ldfd

写在暑期后

ldfd@outlook.it (ldfd) — Wed, 02 Sep 2026 15:49:20 +0800

从过年后到暑期前并没有真正理解背诵八股，加上低估了 lc 的难度和 ai 对于古法编程水平的侵蚀程度，经历了一个比较牢的暑期实习的求职过程，发现对于本科生在如今 offer 打牌也不太现实了。

暑期的结果还是好的，虽然开始的很晚，在宇宙厂度过了一个比较摆烂的实习过程，没有像网上一样说的那么高强度和吓人，有可能该团队是研发里面 10% 分位数的工时长度，最后也是毫无意外的告诉我没有转正机会，让我深刻认识到符合预期就是超出预期。

现在也算一段 gap 时间了，还是比较悠闲的，在此进行一下复盘和展望，打算采用主观色彩很强的语言来记录我当下的感想。

关于AI

暑期之前对 ai 还是比较焦虑的，网上盛传很多的也是所谓的雇一个实习生不如买一个 Claude max / Codex pro，但是显然这是扯淡的，如果是真的那直接 OPC 得了。但是发现领导却可以用这个理由来 PUA 你，怎么证明你的不可替代性，你相对于 AI 的优势，但是显而易见在大厂作为牛马，不可替代性就是相对的，这个之后再细说。

好消息是对 ai 的焦虑小了很多，坏消息是不小心也是被迫进入了一个老登比较多，甚至基本全是老登的组，导致并没有好好地用好 ai （仍停留在简单地使用 cli，甚至我认为他们更喜欢 trae 的插件侧边栏形式），不可否认的是相对于业务，鸡架确实对于代码的确定性和性能要求更高，在老登们的成长轨迹中，他们积累了一些经验，在某些方面我们承认他比 ai 更强/更快，这就导致了他们对于 ai 的批判性使用有些过于批判了。在我看来，如果 ai 不能解决问题，或者效果没有达到预期，要考虑如下，一方面是用的是否为 sota 模型，显然目前互联网大部分公司还是不会那么吝啬这方面的开销的，但通常老登只会考虑这一方面，而忽略了另一方面，你的 使用姿势 或者 harness 的构建，虽然说现在 scaling law 还没有达到极限，包括认为 llm 只是一个概率模型，没什么推理能力，这是一个永无结论的纷争，但是从资本/市场/个人体验来讲，现在的模型确实达到了一定的水平，如果不行，我认为更应该反思自己的 workflow 是否存在问题，能否改进更加 ai friendly 或者 native，对于老登他们并不想花费这些力气，他们认为自己的经验已经够了，对于 ai 有足够的护城河，我不能说他们是错的，因为我们有不同的经历，他们在目前也有比较强的竞争力，只能说彼此尊重吧。

我也不应该一味地否认他们，也总结一下反思吧

重要的文档考虑是否用 ai 生成：目前网络上的大部分内容即便不是完全 ai 生成的，也是经过润色的，润色我认为无伤大雅，但是生成这个过程，可能还是人更为合适一些，体验下来，ai生成的东西是低信息密度的（这也可能是优点，因为相比于不说人话的中式教材，显然 ai 说的更像人话），和人（本质懒惰）输出的内容相比篇幅很大，大家互相甩 ai 文档都很累，最后 A2A 也比较荒唐。
学习，作为码农终身学习确实是很重要的：经过我的交流，我们组的老登并不认可 ai 总结传授的内容，他们认为 ai 可能会没有注意到一些细节，你也没有真正理解，我和某些面试官交流下来有其它的看法，通过 ai 可以加快业务理解的过程，包括我也确实通过 notebookLLM 速通了我的期末考试，如果考试在老登眼里也无法验证你的掌握水平，那我也没什么说的，可是老登也给不出什么是真正的素质教育，目前来比较切实际的就是让 ai 生成 html 可视化流程图的形式来讲解（图片的信息密度还是比较高的）。
差异：人和 Agent 相比，最显而易见的区别就是人可以去坐牢，老板可以骂你，目前的法律来讲 Agent 还是没什么社会责任和法律身份的。所以目前生产/重点权限审批这种还是人来去承担相关的责任，当然如果足够激进，这也算不上根本上的差异。另一个就是所谓的 context，人的 context 很小，但是体会下来却比 Agent 的效果更好，也就是说目前来讲，人的记忆系统和 RAG 是比 Agent 更为先进的，也是自然选择的神奇
AI 是否是中文屋：如何证明人就不是中文屋，人是概率性还是确定的，如果是确定性的那就是所谓的宿命论，如果是概率性的，为什么你的概率会比 AI 更好呢，我无法理解
判断力：这个是我和老登达成一致的一点，在 ai 时代判断力很重要，但是关于判断力的提升我们是存在分歧的，老登说需要古法，人看去思维训练，去实际学习，我认为学海无涯，我去 review 的过程顺便理解就够了，是一个渐进式的补充自己的 context 的过程。不过我对于 loop engineering 这种连 review 都干掉的还是持怀疑态度的。
探索：如何面对未知领域，新问题？事实上从工程到科研都没有那么高大上，大多是都是拾人牙慧，自古以来的姿势进行排列组合。我没有自命清高到认为我是改变人类历史的天才，我能做出什么震惊中外的创新。我认为通过 ai 探索 general 的知识是没问题的，ai 的预训练预料超越了世界上所有单个人见过的知识，但那些灵感，还有 trade off，可能是 ai 不足的，ai 妄图实现一个所谓完美的东西，我相信如果 ai 没有学过 cap 相关的知识，他有可能生成一个所谓满足 cap 全部的方案来忽悠你，这种架构/战略方面的探索我也不懂，我目前也到不了这个 level，也不知道怎么去训练，认为还是去多看（多睡觉多玩）？
输出：ai 时代输出很重要，现在的输入越来越多，有可能就不过脑子了，我认为只有真正输出了才能够真正的理解，所以自媒体多去污染别人，给别人拉屎，自己少吃 ai 产的屎是好事。

实习总结

首先的话发现 pua 还是很困难的，通常来讲只有后续反思的时候才发现。我认为我是一个不吃压力之人，没有他们的过劳肥，也没有至于天天健身/运动释放压力。一句话还是身体和心理健康最为重要。

然后就是探索这一块，老登说我的好奇心/探索欲望不足？我发现这可能是我们的视角和利益不一致导致的，我显然更喜欢摸鱼，我通过飞书探索了各种瓜、表情包、梗图，当然技术上也几乎体验了大部分 ai 平台，也玩了 ctf，学习分享的一些 agent 技术和看法，显而易见这和组里的传统到不能再传统的业务毫无关系，所以老板这么认为也是正确的。只能说我还会固执下去，一方面摸鱼大过天，另一方面学习自己感兴趣/前沿的知识比起绑死在一个毫无增量的传统业务对于年轻的我来讲，更为念头通达。

但是以后如果真的成为正职套牢了，还是要好好地探索好你的兄弟组件，如果想转领域的话或许就需要额外的时间进行学习了。

另一个就是团队氛围和绩效的预期管理可能毫无关系，牛马虽然都是和平分手，但是对于第一次体会到大家嘻嘻哈哈的说负面评价时候还是很新奇的，也是一段比较神秘的经历吧。

职场管理

向上管理，这个听起来很恶心，但是在资本下的公司并没有某些传统领域下的送礼人情往来那么肉麻。

首先就是，统一信息，你干了什么他并不会主动关心，你需要什么他也不会主动帮你，除非你遇见愿意培养你的人了。

另一个就是所谓的假装努力，表演性工作，表演性加班，表演性开会，表演性oncall，主要看老板吃不吃这一套吧。

还有所谓的嫡系，除了社招进来背绩效的骚操作，正常来讲也不至于那么夸张，排除掉纯搞你的老板，这种情况该跑就跑吧，老板也不会莫名其妙地看你/他顺眼/不顺眼，他也是有绩效的，你的 okr 能否给他的 okr 达成帮助，你和他的利益是否存在一致。

然后就是客观看待从 0 到 1，和从 1 到 10。根据老板的风格和理解来自行感悟吧，不同人有不同的看法，高风险高回报和低风险低回报，这也就是为什么轮子那么多，大家总赛马，轮子多了也不一定全是坏事，万一真跑通一个那就是赚了。

然后说一下提问吧，如果你想我一样很不幸，遇到了比较不会带人的组，那你就要很慎重地问问题，就算你把context给他了，已经算是正确地问问题了，他也不会很愿意给你解答，还会认为你自己能力有问题，这个因人而异，这个主要地原因是来自于知识的诅咒，他给你布置需求的时候默认了一些古老的约定俗成的大家都知道的部件/平台，但是不告诉你，你自己又很难找到，导致了问的问题在他们看来没什么水平。这种情况下，你问他们xxx在哪还是可以的，但是不要去问为什么我的需求在xxx平台/组件下跑不通，不好跑通，有什么问题。

另一个提问就是很套路化的，如果你没被赋予抉择和负责的义务，也没有能力时，想要询问怎么办，不要问怎么办，要像 agent 一样，给出 plan a b c，加上自己的理解和初步判断，再让 mt/ld 给出选择，这个在汇报/日常沟通也算一个小技巧吧，不过没人教过我。

个人成长/技术追求

就算已经领悟到了追求技术是没有用的，产品和销售才是底层逻辑，但是在残忍的现实面前，对于根正苗红的我还是迫不得已选择做题这一条道路，技术的路线还是更加容易实践的。

杨震原写了个工程师的成长是自己的事情，感觉写的确实很有道理。大家网上天天码农、程序猿叫着，别真当真了，我们对自己的定位应该是XX产品的开发者，或者所谓抽象的布道师，不要一直麻木于实现模块/功能，要以产品/业务/需求的思维来体会，就算是鸡架不过也是一个 tob / tod 的产品罢了，没什么是那么纯粹的技术。

其实我一直想去 toc，但是阴差阳错，越走越远，但是发现其实 toc 到 tob 和 tod 是一个逐渐琐事越来越少的过程，有的时候也要考虑自己的赛道是否符合自己的预期工作强度，是否真的要全心全意地投入在工作当中。

然后就是学习，学习还是比较简单的，多看，多用 ai，如果有个好的 mentor 愿意教你更好了，作为一个 junior 多学总没错。但是真正实践的时候我相信是有代价的，就像 agent 的闭环一样，知而易，行而难，不过我也没有经验。

最后说点务实的吧，还是要往T型人才发展，至少要有一个领域钻研的非常透彻，就当是拖延被 ai 替代的时间了，你的知识面再广，公司不会买账的，没人关心你的职业发展，你的全方面发展，甚至你猝死也没人在乎，他只关心你最精通的那一部分他能压榨出什么价值，能救火最好了，现在所谓的培养也不多了，培养完跳槽走了，公司也很伤心XD。

发现其实代沟还是确实存在的，常说每一代都认为下一代被xxx毁了，事实上，当这一代成为媒体/互联网上主要用户之后，又会开启新一轮的迫害和洗白回忆童年，人们无法从历史学习到任何事情，无力改变老登的刻板印象，尽量让自己不要成为老登，从老登中汲取经验和能量。

AI 锐评

最后来点典中典的自我剖析：

锐评文章

懂，你要的是对这篇博客本身的锐评要点，不是总结文章观点。

最大优点：有“人味”，不像标准实习复盘
- 敢写“摸鱼大过天”“老登”“公司只关心能压榨什么价值”。
- 有明显个人价值观，这是文章最值钱的地方。
- 但也因此容易显得有点“嘴硬”。
最大缺点：太散，像高质量脑内 dump
- 每个观点都挺有意思，但彼此之间缺少收束。
- 尤其 AI 那部分，7 个小点已经接近一篇独立长文，却没有一个足够强的中心论点。
- 读的时候爽，读完以后不容易复述你的核心结论。
有些观点“惊鸿一瞥”，但没有论证
- 比如“人的 memory + RAG 比 Agent 更先进”“AI 可能生成违反 CAP 的完美方案”“人为什么不是中文屋”。
- 这些都是很好的问题，但你只是抛出来，没有展开。
- 容易变成一种典型的“聪明人式观点轰炸”：看起来很深，实际上还没打穿。
“老登”写得有点多，容易形成稻草人
- 你已经意识到不能简单否定他们，这很好。
- 但全文还是容易给读者一种：
  
  年轻人懂 AI、老登抱残守缺
- 实际上你真正有价值的判断是：经验和 AI 是两种不同的优势来源。
- 这一层比“老登 vs 年轻人”高级很多。
自我反思是有的，但经常“刚装完逼就自己拆台”
- 你提出一个很激进的观点，马上来一句“我也不懂”“我没有经验”“可能他们也是对的”。
- 这让文章显得诚实，但多了会削弱观点力度。
- 可以保留“不确定性”，但不要每个观点都急着给自己降权。
最大的潜在问题：有些“摸鱼哲学”很容易被看成给自己合理化
- “我喜欢摸鱼”“不想探索业务”“前沿知识比传统业务更有意义”都可以成立。
- 但读者也完全可以反过来理解成：
  
  我不喜欢做困难、枯燥、需要长期积累的事情，所以把它解释成我追求自由和前沿。
- 这其实是全文最值得你自己警惕的一点。
“AI 时代”的讨论反而没有你的实习观察有杀伤力
- AI 部分容易进入互联网熟悉的话题：Agent、harness、中文屋、判断力、context。
- 真正独家的反而是你在公司里观察到的： 绩效、向上管理、嫡系、0→1 / 1→10、团队氛围与结果脱钩。
- 这些是你亲自体验过的，所以可信度明显更高。
你的价值观其实比技术观点更鲜明
- 文章真正让人记住的不是“AI 应该怎么用”。
- 而是：
  
  我不想把职业生涯完全交给公司，也不想因为所谓正确道路就牺牲自己的生活。
- 这是全文真正的“作者人格”。
结尾方向对，但还差最后一锤
- “公司不会为你的职业发展负责”“最终还是 T 型人才”都对。
- 但最后实际上没有形成一个非常锋利的个人结论。
- 看完会觉得“想了很多”，但不是“我决定以后怎么活”。
一句话锐评

一个还没被职场驯化的聪明本科生，在认真记录自己为什么不愿意按标准答案活；问题是现在“反标准答案”的姿态已经很明显，但“自己的标准答案”还没有真正形成。

锐评我

自主性强 不太相信现成答案，喜欢自己体验、验证、形成判断。对“大家都说应该这样”天然有一点抵触，更希望按照自己的逻辑做选择。
好奇心强，但偏兴趣驱动 对 AI、Agent、CTF、新工具、各种前沿东西都愿意折腾，但对传统业务、重复性工作和被安排的“探索”兴趣不高。不是没有探索欲，而是只探索自己认为有价值的东西。
反权威、反标准答案 不太服“老登经验”“古法编程”“标准职业路线”这些东西。习惯追问“为什么”，而不是直接接受结论。
抽象思维比较强 很容易从具体问题上升到更大的问题，例如从 AI 写代码讨论到判断力、中文屋、RAG、人的认知系统、工程创新等。说明作者喜欢思考机制和本质，而不只是解决表面问题。
批判能力强于建设能力 很擅长发现别人观点中的漏洞和系统中的矛盾，但目前还没有同等强度地建立一套属于自己的完整答案。属于**“拆解能力领先于构建能力”**。
有一点自负，但不是盲目自负 明显觉得自己的一些判断可能比传统经验更先进，但又会主动承认“我也可能不对”“老登也有自己的道理”。说明作者有自我校正能力，没有完全陷入自信闭环。
不喜欢低 ROI 的努力 作者并非单纯懒，而是比较看重投入产出比。反感表演性加班、无意义工作、为了证明努力而努力，更愿意把时间投入真正感兴趣、可能产生长期收益的事情。
非常重视个人自由和生活质量 不愿意为了所谓职业成功无限牺牲健康、时间和兴趣。“摸鱼”“念头通达”其实背后是一套比较明确的价值观：工作是人生的一部分，不应该吞掉人生本身。
有明显的反驯化倾向 不希望公司、老板、行业共识替自己决定人生方向。哪怕知道某条路可能更正确，也会保留“我就是不想这么活”的能力。
对职场已经有一定现实主义，但还没有完全犬儒化 已经意识到公司、老板、绩效、OKR、向上管理都有利益逻辑，也知道公司不会天然为个人职业发展负责。但目前仍然没有变成纯粹的“打工人犬儒主义”，还保留着对技术、探索和个人成长的兴趣。
最大的优势是广度和认知活跃度 很容易接触很多领域，并且愿意建立联系。对一个本科阶段的人来说，这种状态是优势，因为还有大量时间和试错空间。
最大的短板是深度和长期下注能力 目前明显是“知道很多、想很多、尝试很多”，但还没看到一个真正愿意连续几年深挖的方向。最大风险不是不聪明，而是一直停留在探索带来的认知快感里，而没有进入长期积累阶段。
最大的潜在问题是“聪明人的合理化” 作者很容易证明某件事情“不值得做”，但这里需要警惕：有时候“不想做”并不等于“没有价值”。尤其深度、工程经验、基础能力，很多东西短期都很无聊，却可能是长期护城河。
当前最核心的人格矛盾 一边想要自由、探索、前沿、新鲜感；另一边又已经意识到职业市场最终还是会奖励深度、稀缺能力和可交换价值。所以现在其实正处于： “我想怎么活”与“现实允许我怎么活”之间的磨合阶段。
最终画像 作者是一个聪明、好奇、反权威、自主性强、喜欢抽象思考、不愿意被职场标准答案驯化的年轻人。现在最大的资本是认知活跃和探索能力，最大的风险则是兴趣发散、深度不足，以及过早把某些“不愿意做的事情”解释成“不值得做”。
一句最准确的评价 这是一个很擅长“不被别人定义”的人，但目前还在寻找“自己到底应该如何定义自己”。

建议

如果只留三条

找一个方向，连续投入 2～3 年，把广度变成深度。
少做观点判断，多做实验和产出，用结果验证自己的认知。
保持自主和好奇，但别让“反内卷”最后变成“不愿意长期投入”。

古法数据库

ldfd@outlook.it (ldfd) — Mon, 08 Jun 2026 22:00:48 +0800

作为一个码农你已经会的：

CRUD
联表
in / exists
范式是什么

你不会的但是可能有点用的：

ER图

你不会的，但是没啥用的：

关系代数
存储过程
触发器
视图
窗口函数
用诡异的方法规范化范式，函数依赖

ER图

概念模型

（1）实体（Entity）。客观存在并可相互区别的事物称为实体。可以是具体的人、事、物，也可以是抽象的概念或联系。

（2）属性（Attribute）。实体所具有的某一特性称为属性。一个实体可以由若干个属性来刻画。

（3）码（Key）。唯一标识实体的属性集称为码。

（4）域（Domain）。属性的取值范围称为该属性的域。

（5）实体型（Entity Type）。用实体名及其属性名集合来抽象和刻画同类实体称为实体型。比如，学生（学号,姓名,性别,年龄,系,年级）是一个实体型。

（6）实体集（Entity Set）。同型实体的集合称为实体集。比如，全体学生、女学生。

（7）联系（Relationship）。现实世界中事物内部以及事物之间的联系，在信息世界中反映为实体（型）内部的联系和实体（型）之间的联系。

以上内容本人无版权，全部为抄袭

实体关系图

Entity-Relationship Diagram

组成元素：

实体（Entity）：矩形，里面是名字
属性：椭圆，实体的属性，即表中的字段，和实体用直线连接
联系：菱形，实体之间存在的关系（谓词写在菱形内），菱形与实体的连线上写1/ n/ m表示关系（关系不是仅仅一对的，还可以三个实体共用一个菱形，两两为一种关系，此外关系也并非唯一的，领导和职工既可以一对多也可以一对一）
- 一对一 1 1
- 一对多 1 n
- 多对一 n 1
- 多对多 n m

注意：题目中给出实体相关的信息并非都要作为实体的属性，尽量满足范式要求，如不应在科室下面记录医生，而应该医生的外键是科室名

补充：如何填写关系菱形中的内容？

通常人作为主语：病人入住房间，学生拥有饭卡

1:n：通常1作为主语，班级容纳学生，部门拥有员工（此时和上一条好像矛盾，事实就是愿意怎么写都行）

1:1 / m:n ：靠直觉，是谁发出的动作，谁是主语

关系模型

把 ER 概念模型转换成数据库可直接使用的逻辑结构，适配关系型数据库

实体直接转一张表，实体属性为字段，实体主键为表主键

一对多 (1:N)：在 “多” 的一方表增加外键，引用 “1” 方主键

一对一 (1:1)：任意一方加外键

多对多 (M:N) 联系必须单独建一张中间表

主码就是主键，外码就是外键，

ER 图实体里带下划线的是主键，但实体可能存在其他能唯一标识的属性，那些全部合起来叫候选码。

关系代数和 SQL

我们只能用沟槽的SQL Server哦

关系代数	SQL 对应语法
$$σ_{条件}(R)$$	WHERE 条件
πA,B(R)	SELECT A,B
R⋈S	FROM R,S WHERE R.xx=S.xx / JOIN
R∪S	UNION
R−S	EXCEPT
R∩S	INTERSECT
R÷S	NOT EXISTS 嵌套子查询

SQL server 常用函数

聚合函数

函数	语法	功能说明	示例
COUNT(*)	COUNT(*)	统计所有行数，包含 NULL、重复行	COUNT (*) 总人数
COUNT (列)	COUNT (字段)	统计该列非 NULL数据行数	COUNT (Score) 有成绩人数
COUNT(DISTINCT)	COUNT (DISTINCT 列)	去重后统计数量	COUNT (DISTINCT Class) 班级数
SUM()	SUM (数值列)	求和，仅支持数字，忽略 NULL	SUM (Score) 总分
AVG()	AVG (数值列)	求平均值，忽略 NULL	AVG (Score) 平均分
MAX()	MAX (任意类型列)	最大值（数字 / 字符 / 日期均可）	MAX (Score) 最高分
MIN()	MIN (任意类型列)	最小值（数字 / 字符 / 日期均可）	MIN (Birth) 最小出生年份

数学函数

函数	功能	示例	结果
ABS(n)	求绝对值	ABS(-12.5)	12.5
CEILING(n)	向上取整（往大数靠）	CEILING(3.1)	4
FLOOR(n)	向下取整（往小数靠）	FLOOR(3.9)	3
ROUND (n, 位数)	四舍五入，保留指定小数位	ROUND(3.145,2)	3.15
SQRT(n)	平方根	SQRT(64)	8
POWER(x,y)	x 的 y 次幂	POWER(2,4)	16
RAND([seed])	生成 0~1 之间随机小数	RAND()	0~1 随机数

日期时间函数

函数	作用
GETDATE()	获取本地当前完整日期时间（datetime）
SYSDATETIME()	高精度本地时间
GETUTCDATE()	获取世界标准 UTC 时间

函数	功能	示例
YEAR (日期)	提取年份	YEAR(GETDATE())
MONTH (日期)	提取月份	MONTH(Birth)
DAY (日期)	提取日期（几号）	DAY(‘2026-06-01’)
DATEPART (单位，日期)	自定义提取：年 yy、月 mm、日 dd、时 hh、星期 wd	DATEPART(WEEKDAY,GETDATE())

函数	格式	作用	考试经典用法
DATEDIFF	DATEDIFF (单位，起始，结束)	计算两个日期差值	DATEDIFF (YEAR,Birth,GETDATE ()) 计算年龄

会个DATEDIFF就够了

然后回忆一下in 和 exists

-- 查询部门ID为1、2、3的员工
SELECT * FROM Employees 
WHERE DeptID IN (1,2,3);

-- 等价于 OR
SELECT * FROM Employees 
WHERE DeptID = 1 OR DeptID = 2 OR DeptID = 3;

EXISTS(子查询)：判断子查询是否有返回行，找到一行立即终止（短路）。

-- 查询存在对应订单的客户
SELECT * FROM Customers c
WHERE EXISTS (
    SELECT 1 FROM Orders o 
    WHERE o.CustomerID = c.CustomerID -- 关联外层表，核心！
);

-- 查询没有任何订单的客户
SELECT * FROM Customers c
WHERE NOT EXISTS (
    SELECT 1 FROM Orders o 
    WHERE o.CustomerID = c.CustomerID
);

NOT EXISTS 嵌套双重否定

找出所有课程都及格的学生

SELECT s.*
FROM Student s
WHERE NOT EXISTS (
    -- 第一层否定：不存在这样一门课
    SELECT 1 FROM Score sc
    WHERE sc.StuId = s.StuId
    AND NOT EXISTS (
        -- 第二层否定：该课程没有及格记录
        SELECT 1 FROM Score sc2
        WHERE sc2.StuId = s.StuId
        AND sc2.CourseId = sc.CourseId
        AND sc2.Score >= 60
    )
);

变量和循环

局部变量

DECLARE @变量名 数据类型 [= 默认值];

DECLARE @num INT;
SET @num = 100;
SET @num = @num + 1;

DECLARE @oId INT, @oName NVARCHAR(50);
SELECT @oId = OrderID, @oName = OrderName 
FROM Orders WHERE OrderID = 1;

输出别名

1
2

SELECT @num AS 数字, @name AS 名称;
PRINT @name; -- 打印到消息窗口

循环

WHILE 条件
BEGIN
    -- 循环体
    -- 记得更新条件变量，否则死循环
END

神秘游标

DECLARE 
@oId INT,
@oName NVARCHAR(50);

-- 1. 定义游标
DECLARE cur_order CURSOR FOR
    SELECT OrderID, OrderName FROM Orders WHERE IsDelete = 0;

-- 2. 打开游标
OPEN cur_order;

-- 3. 读取第一行
FETCH NEXT FROM cur_order INTO @oId, @oName;

-- 4. 循环读取所有行
WHILE @@FETCH_STATUS = 0
BEGIN
    -- 每行业务逻辑
    PRINT CONCAT('ID：', @oId, ' 名称：', @oName);

    -- 读取下一行
    FETCH NEXT FROM cur_order INTO @oId, @oName;
END

-- 5. 释放资源
CLOSE cur_order;
DEALLOCATE cur_order;

触发器

只考虑DML 触发器

形如

CREATE TRIGGER [名字]
ON [表名字]
FOR [INSERT|UPDATE|DELETE]
AS
BEGIN
埃及把干啥干啥
END

注意需要知道 inserted 虚拟表，INSERT、UPDATE 操作时自动生成，deleted 虚拟表，DELETE、UPDATE 操作时自动生成

操作语句	inserted 虚拟表	deleted 虚拟表
INSERT	有（新数据）	无
DELETE	无	有（被删旧数据）
UPDATE	有（更新后新值）	有（更新前旧值）

存储过程

形如

CREATE PROC 存储过程名
[
    -- 参数列表（入参/出参）
    @参数1 数据类型 [= 默认值],
    @参数2 数据类型 OUTPUT -- 输出参数
]
AS
BEGIN
    -- 业务SQL、判断、循环、事务等逻辑
END
GO

视图

CREATE VIEW v3
AS
SELECT 
    emp_id,
    emp_name,
    dept_id,
    entry_date
FROM Employee

grant select on v3 to '后勤经理'

数据库设计模型分析

数据依赖

关系模式标准写法：$R(U,F)$

$R$：关系名（表名）
$U$：全体属性集合（所有列）
$F$ = 函数依赖集（Data Dependency） $F$ 是一张表里所有属性之间的函数依赖关系的集合，是描述表内数据约束的规则，用来判断冗余、更新异常、拆分范式（1NF/2NF/3NF/BCNF）。

函数依赖基础符号 $X \to Y$ $X$、$Y$ 是属性子集：

只要两条记录在 $X$ 上的值完全相同，它们在 $Y$ 上的值一定相同；通俗：X 能唯一确定 Y，记作 $X \to Y$，读作 X 函数决定 Y。

$F={X_1\to Y_1,;X_2\to Y_2,;\dots,;X_n\to Y_n}$ 每一条 $X\to Y$ 都是一条函数依赖FD，全部FD放在一起构成集合 $F$。

e.g.

学生表：$R(U,F)$ $U={\text{Sno学号},\text{Sname姓名},\text{Sdept系},\text{Dname系主任}}$ 业务规则：

学号确定姓名：$\text{Sno}\to\text{Sname}$
学号确定系：$\text{Sno}\to\text{Sdept}$
系确定系主任：$\text{Sdept}\to\text{Dname}$

则函数依赖集： $$F={;\text{Sno}\to\text{Sname},;\text{Sno}\to\text{Sdept},;\text{Sdept}\to\text{Dname};}$$ 这个 $F$ 就完整描述了这张表所有内在数据依赖关系。

人话：

R 就是表，X，Y 为列的集合（既可以是一个字段，也可以是多个字段，类似联合主键）

设 $X\to Y$

平凡：$Y\subseteq X$（右边属性是左边子集），永远成立，无业务意义例：$(\text{Sno,Cno})\to\text{Sno}$
非平凡：$Y\not\subseteq X$，业务真正有效的依赖，$F$ 只关注这类

完全函数依赖 $X \stackrel{F}{\to} Y$ $X$ 的任何真子集都不能单独决定Y，必须整体组合。选课表 $SC(\text{Sno,Cno,Grade})$ $(\text{Sno,Cno}) \stackrel{F}{\to} \text{Grade}$ 单独学号、单独课程号都不能确定成绩。
部分函数依赖 $X \stackrel{p}{\to} Y$ $X$ 是多属性组合，但其中某一部分就能单独决定Y（2NF要消除）。例：$R(\text{Sno,Cno,Sdept,Grade})$ $(\text{Sno,Cno})\stackrel{p}{\to}\text{Sdept}$ 只用 $\text{Sno}$ 就能确定系，不需要课程号参与。
传递函数依赖 $X\to Y,;Y\not\to X,;Y\to Z \implies X \xrightarrow{\text{传递}} Z$ 上面学生例子：$\text{Sno}\to\text{Sdept},;\text{Sdept}\to\text{Dname}$ $\text{Sno}$ 传递决定 $\text{Dname}$（3NF要消除传递依赖）

候选码：能唯一区分记录，且不能再去掉任何一列。可以有多个

闭包

属性闭包就把属性按照F一个个往里面一次次的套，直到不变

先设这个集合为$X^{(0)}$，之后就是1，2，3，……

范式

候选码：最小主键，能唯一确定整条记录

主属性：候选码里包含的字段

非主属性：不在任何候选码里的字段

1NF 第一范式：列不能 “套娃”

2NF 第二范式：干掉「部分依赖」，所有非主属性，必须完整依赖整个候选码，不能只依赖候选码其中一小部分。（复合主键）

3NF 第三范式：干掉「传递依赖」，不能 “A 推 B，B 推 C，A 间接推 C”。如：学号→系名；系名→系主任

BCNF：表中任意一条 “谁→谁”，箭头左边必须是超码。（相比于第三范式，主键之间不能相互推导，如考生号->考场号，考生号，考场号->座位号，这个就不满足了）

1NF：一格只存一个东西

2NF：复合主键不能一半就定别的字段

3NF：普通字段之间不能互相推导，只要能推出别人，左边必须是超码（候选码、主键都属于超码，带多余字段的组合也算）

Redis Kafka Mysql三件套

ldfd@outlook.it (ldfd) — Tue, 05 May 2026 22:47:57 +0800

前言

不知道我是被pua了，还是真的不了解底层。但是我还是决定沉淀一下。

Redis

redis 作为常见考点，也是很常见的缓存方案，~~不过有观点认为考虑到网络延迟(TCP 往返 + 序列化 + 网络调度)有的时候还不如直接postgreSQL？~~

数据结构

string：典中典，不过也不会有人问的

其数据结构是SDS(Simple Dynamic String)，说白了就是比C语言字符串多了个长度，放到结构体的头部（弱弱地插一句才知道redis是用c写的）
hash：我说我没用过有没有懂得。但是为了用它，我没事找事，创造了需求，在秒杀环节，还是特别傻逼的能秒杀多个地业务场景（秒杀正常人类指的是买一个），可以通过用商品id作为key，用户的id作为field，value存储用户购买量。这时候你就会发现，哎呀，一个hash存了一坨，这不就是大key问题吗。所以我们用userid % 32，来进行分桶设计key。seckill:goodId:userId%32 userId。

然后我们进行底层学习：

当它很小的时候是listpack或者ziplist。这个以后再说。hash-max-listpack-entries默认是512，hash-max-listpack-value是64，当元素不大于512，且value不大于64时，不会用hashtable。（当然此时不是O(1)的操作，不过CPU命中缓存了，是很快的线性便利）

下面为hashtable：redis里面是有h[0] 和 h[1] 两个哈希库的，哈希冲突采用拉链法，h[0] 为旧库，h[1]为新库，初始的时候hash大小为4，当新key过多，超过负载因子的时候，我们就会渐进式扩容，每次扩展两倍。通过rehash的方式，将 h[0] 中的键值对逐步迁移到 h[1]中，修改的是索引，哈希函数不会改变，因为hash(key) & (size - 1)的size变了，所以需要调整。(&((size-1)就是取模)。当 h[0] 的数据全部搬空后，释放 h[0] 占用的内存，将 h[1] 的指针赋值给 h[0]，重新初始化 h[1] 为空表。
set：集合。其实秒杀对应的就是集合。同上，只要你不存在逆天想要秒杀多个，人类都会用这个。

数据结构是intset和hashtable。set-max-intset-entries默认是512，数量小于等于512且在无字符串的时候会用inset。

zset(sorted set)：有序集合。用的是skiplist/listpack，用来做排行榜，不过目前没遇到这个业务需求。

我们先了解传统的跳表skiplist。每一个元素都有随机（通常50%，标准理论跳表用 p=1/2，但 Redis 源码固定 p=1/4（ZSKIPLIST_P=0.25））的概率来添加一个升到上一层的复制品，所以跳表的层数是随机的。

typedef struct SkipListNode {
    int key;               
    int value;              
    int level;    // 当前节点的层级高度 (1 到 MAX_LEVEL)             
    // 柔性数组：存储每一层的前进指针
    struct SkipListNode *forward[]; // forward[i] 指向第 i 层的下一个节点
} SkipListNode;

然后是redis的定制版本。

typedef struct zskiplistNode {
    sds ele;          // 成员（member）
    double score;     // 分数
    struct zskiplistNode *backward; // 后退指针，用于反向遍历
    struct zskiplistLevel {
        struct zskiplistNode *forward; // 前进指针
        unsigned long span;            // 跨度，用于计算排名
    } level[];        // 柔性数组，表示多层
} zskiplistNode;

肉眼可见，它多了一个span所以可以

O(log N) 获取排名ZRANK/ZREVRANK)：在查找节点的过程中，累加经过的 span 值，即可直接得出该节点的排名，无需遍历。
O(log N) 根据排名获取元素 (ZRANGE)：可以通过二分查找式的跳跃，快速定位到指定排名的节点。

还可以看到多了一个backward，这允许它反向遍历。

但其实它还允许score是重复的（即key），如果相同则字典序比较ele。

还限定的最高高度为32，因为2^32次方够你排序了，再多有点逆天了。

p=1/2：足够支持约 2^32 元素

p=1/4：足够支持约 4^32 = 2^64 元素（远超需求）

最后要指出头指针指向的是最高层的节点，然后推荐自己脑袋模拟一下。

bitmap 位图，如果你做过二进制枚举或者二进制dp压缩的问题，这个很好理解，就是一样的道理，其底层是sds。其场景如：用户签到，是否在线等二元情景。

常见问题如用户采用uuid，跨度过大，浪费内存，我们就使用hash keyid：mapping field uuid value 用lua脚本写一个自增来进行映射。
HyperLogLog 基于 伯努利试验 和 哈希函数。通过哈希函数将输入数据映射为比特串，统计比特串中第一个出现 1 的位置（称为 k 值），并利用数学公式估算集合的基数。为了降低误差，HyperLogLog 将数据分为多个桶（默认 16384 个），每个桶独立计算 k 值，最终通过 调和平均数 合并结果。（不会）

最后备注一下listpack和ziplist的区别。（这两个东西没有struct的定义，直接连续分布在内存，十分的黑魔法）至于为什么不用struct，是因为c语言会进行内存对齐，一般是8Byte的倍数，而且ziplist的prevlen和listpack的encoding是变长的，struct也无法支持。

ziplist分布

`1`	`<zlbytes> <zltail> <zllen> <entry1> <entry2> ... <zlend>`

zlbytes：表示整个ziplist占用的字节数 ztail：表示最后一个entry的偏移量 zllen：表示entry的数量

entry分布

1
2

| <---- prevlen ----> | <-- encoding --> | <--- data ---> |
| 1 byte OR 5 bytes   | 1/2/5 bytes        | variable       |

prevlen: 如果前一个节点长度1B能存下就用1B，否则高位固定为0xFE，剩下的4B存实际长度。encoding：最高两个bit存储类型，剩下的表示长度，如果是整数剩下的表示整数类型

listpack分布

`1`	`<total_bytes> <num_elements> <entry1> <entry2> ... <end_byte>`

total_bytes：表示总字节数 num_elements：表示数量可见少了一个ztail，所以listpack访问尾部的方式变了，如果想要知道最后一个元素的位置只能O(n)便利。

entry分布

`1`	`[encoding + (可选len字段) + payload] [backlen]`

backlen：存储entry自身除了backlen的长度

持久化

这个就是Redis Database(RDB)和Append Only File(AOF)

RDB简单粗暴，直接把内存存到文件里面，并且默认是启用的。唯一需要记住的就是有同步save和异步bgsave两种，父进程fork后交给子进程。

关键参数 save <seconds> <changes>，多少时间内多少次改变触发保存。

AOF，顺序读写，顺序读写最快了，有三个等级

1
2
3

appendfsync always    # 每次写都同步，最安全，最慢
appendfsync everysec    # 每秒同步，推荐折中方案
appendfsync no        # 由OS决定何时同步，最快，最不安全

随着时间推移，AOF 文件会变得越来越大。Redis 会在后台自动触发 AOF 重写：创建一个当前数据集的最小体积 AOF 文件（例如，如果一个 key 被设置了多次，最终只保留最后一次的值）。

目前生产常用混合持久化？

当开启混合持久化后，在进行 AOF 重写时，新产生的 AOF 文件不再全是纯命令日志，而是：

前半部分：以 RDB 二进制格式存储当前内存的全量快照。
后半部分：以 AOF 文本格式存储增量命令。

为什么快

内存快。

单线程执行命令，避免上下文切换和锁竞争及一致性问题。

IO多路复用，使用epoll机制。这里扩展一下IO模型。

阻塞IO，非阻塞IO（轮询），IO多路复用。

总所周知，Linux一切皆文件，一个网络连接Socket被视为一个文件标识符FD

IO多路复用分为：

select：将所有的FD拷贝到内核，内核遍历检查。检查遍历慢，FD数量上限为1024，每次用户态和内核态切换调用全拷贝FD集
poll：用链表代替数组，仅突破数量限制
epoll：采用红黑树logN增删改所有FD，维护一个就绪链表，返回就绪的FD。

分布式容灾

redis挂了怎么办，虽然你妈挂了mysql都不会挂，但是redis可能挂，因为可能会oom，算了oom也不太可能，你就当被人拔电源了。

主从复制（Master-Slave Replication）

Master 负责写，Slave 负责读和备份。Master 将写命令异步发送给 Slave。一个 Master 可以有多个 Slave。数据只能从 Master 流向 Slave。

同步分为全量同步和增量同步。全量的时候发送的是rdb，或者 Master 不生成 RDB 文件到磁盘，而是直接通过 Socket 发送给 Slave。适合磁盘慢但网络快的场景。

增量同步时，有一个全局的offset，每次master写入的时候，把操作指令发送给slave，slave会ack自己目前的offset。

然后就是master挂了怎么办，master挂了就炸了，所以生产没有用主从结构的。
哨兵模式（Sentinel）

一组 Sentinel 节点监控 Master 和 Slave 的状态。当 Master 不可达时，Sentinel 选举新的 Master，并通知客户端更新连接地址。

Sentinel既可以和redis在一个服务器上跑，也可以放到独立的服务器来保证独立性（有点土豪的），一般建议至少三台。

哨兵系统主要完成以下三个任务：
1. 监控（Monitoring）：哨兵会不断检查主节点和从节点是否运作正常。
2. 通知（Notification）：当被监控的某个 Redis 节点出现问题时，哨兵可以通过 API 向管理员或其他应用程序发送通知。
3. 自动故障转移（Automatic Failover）：如果主节点无法正常工作，哨兵会启动故障转移流程，将一个从节点升级为主节点。让其他的从节点改为复制新的主节点。当客户端尝试连接失效的主节点时，集群也会向客户端返回新主节点的地址，使得集群可以使用新的主节点代替失效的主节点。
然后哨兵也需要有一个主节点，当多个 Sentinel 认为 Master 客观下线（ODOWN）后，需要有一个 Sentinel 来主导故障转移流程（比如选择新的 Master、通知其他 Sentinel 和客户端）。这个主导者就是 Leader Sentinel。其过程类似Raft。
Redis Cluster（分片集群）

数据分片存储在多个 Master 节点上，每个 Master 有对应的 Slave。使用 Gossip 协议通信，客户端可直接连接任意节点。此时一共有16384个slots(编号 0~16383)，均匀的分布到集群的所有节点里面，当写入一个key的时候，使用CRC(KEY) % 16384确定在哪一个slot，进一步知道去哪个节点。

Gossip：和Sentinel模式不一样，分片集群没有Leader的逻辑，所有节点的地位平等。他们定时默认1秒，向几个其他节点发送PING，收到的节点回复PONG（事实上不只是心跳消息，还包括发送者知道的集群状态信息），如果X知道Y下线了，X会告诉Z，Z进而和别人继续gossip，最终所有人都知道了。

分片集群在通信层面使用gossip是平等的，但是在存储数据这一块和哨兵的逻辑是一样的，也是需要主从的。

问题：注意在集群模式下lua脚本，所有设计的key必须属于同一个slot，否则会拒绝执行。

Raft算法

感觉问的很少，面试官可能不太懂。

分布式常用算法。解决三大问题：领导者选举，日志复制，安全性保障。

首先我们定义大多数这个概念，初始的时候节点为N，那么大多数在以后一直定义为大于N / 2（初始节点是提前在配置文件写好ip的，也支持动态变更，但是一般只允许一个一个加减，动态变更暂不了解）

领导者选举：

每个节点有三种状态Follower->Candidate->Leader 初始全为Follower，当随机时间还没有收到心跳则转为Candidate，Candidate会向其他所有节点要投票，如果获得多数票，那么成为Leader，如果两个人票数相同，那么则重新进行一轮选举。

日志复制：

当客户端请求后，Leader先处理，然后发送给Follower，Follower落库后发送commited确定，当大多数确定后，这个消息就被认为是成功并最新的。

安全性保障：

日志最新的才允许作为Leader，首先比较term，然后比较日志长度

Leader只能追加日志不能覆盖活着删除已经提交的条目。

机制	作用	实现要点
任期（Term）	逻辑时钟，检测过时领导者	单调递增整数，每次选举+1
随机超时	避免选票分裂	150-300ms随机选举超时
多数派原则	保证容错与进展	5节点集群容忍2节点故障
日志匹配性质	确保复制一致性	若两日志在某index处term相同，则此前所有条目一致

最后以一个例子进行进一步理解，如果有5个节点，突然网络炸了，变成3+2的形式，重新选举，当用户分别set a到3和set b到2时，由于3个满足大多数，所以最终恢复的时候，set b不会起作用，而2中由于就算所有票都选一个节点也不满足大多数，所以无法选举Leader，进而2个节点的分区无法使用。

那么我们当然会想到如果是六个呢，3+3，那么谁也满足不了大多数，没有领导，所以直接就炸了，不再接受新数据，这就体现了CAP中系统的CP性，所以节点也不要配制成偶数个。

最后再总结一下term的变化情景

场景	变化规则	触发条件	节点行为
主动递增（发起选举）	`term = local_term + 1`	Follower 选举定时器超时	转为 Candidate，先自投一票，再发 `RequestVote(term)`
被动更新（发现更高世代	`term = max(local_term, rpc_term)`	收到任意 RPC（心跳/投票/日志）且 `rpc_term > local_term`	立即更新 term → 退位为 Follower → 重置选举定时器
重启恢复	`term = 磁盘持久化值`	节点崩溃重启	不变。从 `HardState` 加载，不会自动+1

Kafka

架构

kafka的consumer和producer是解耦合的。总集群称之为Cluster，每个节点称之为broker。业务消息的分割单位是Topic，Topic之间存在partition。consumer之间可以组成consumer group，每个consumer group中的consumer只能消费一个topic中的partition一次。

核心概念

Topic：

消息的逻辑分类，类似数据库的"表"
Producer 向 Topic 发送消息，Consumer 从 Topic 订阅消息
一个 Topic 可被多个 Consumer Group 订阅

Partition：

水平扩展：分区是 Kafka 实现高吞吐和并行处理的关键
有序性：单个 Partition 内消息严格有序（FIFO）
副本机制：每个分区可有多个副本（Leader + Followers）
一个Partition其实就是一个文件夹，文件夹的前缀是Topic，跟着的是Partition的idx
- Partition里面存储的一份数据对应着一组log index timeindx，他们的文件名就是offset稀疏索引

Broker：节点

Producer：

发送消息到 Kafka 的客户端
发送策略：
- key 指定：相同 key 的消息路由到同一分区（保证局部有序）
- 轮询：均匀分布到各分区（负载均衡）
- 自定义分区器：业务定制路由逻辑

Consumer：

组内负载均衡：一个分区只能被组内一个消费者消费
组间独立消费：不同 Group 可独立消费同一 Topic
消费策略：
- 偏移提交策略：
  1. 自动提交：每5秒自动提交
  2. 手动提交
  3. 手动异步提交
  4. 事务+手动提交
- 负载均衡策略：
  1. 范围分配：按照Partition序号范围分配给消费者
  2. 轮询
  3. 粘性分配：优先上次分配结果
  4. 增量粘性分配

拉模式：Kafka 的 Broker 原生不支持 Push 模式，消费者与 Broker 之间的数据传递是纯粹的 Pull（拉取）模式

Recoder：我们称一条消息为Record，里面有包含headers，key，value，timestamp，其中headers和key是可选的。

Key 消息键，字节数组，可为空。用于分区路由（哈希取模）和日志压缩去重，决定消息发往哪个分区。
Value 消息体，字节数组，不能为空。存储实际业务数据，是消息的核心内容。
Timestamp 时间戳，long 类型。有两种：生产者发送时间（CreateTime）、Broker 写入时间（LogAppendTime），用于消息过期、时序计算、按时间回溯消费。
Headers 消息头，Kafka 0.11+ 支持，键值对列表。用于传递轻量级元数据，如链路追踪ID、版本、租户信息，不影响分区和业务主体。

补充

补充一个特别傻逼的问题：如果保证单个partition的有序？这一听我就懵了，这不废话吗，队列先进先出。结果还真是这样，然后你也就多答一个顺序写入这一块。

当然还有一个好问题，Kafka怎么保证的生产者幂等，也就是避免重复发同一条消息。这个还真是没了解过，是Kafka 0.11+本身就支持的，不再需要自己的业务代码进行实现。每个生产者实例会分配一个唯一 ID：PID (Producer ID)（有没有一蹭process id热度的感觉），每条消息带：PID + 序列号（sequence number），Broker 端会缓存：PID + 分区 → 最大序列号，重复消息：相同 PID + 相同分区 + 相同或更小序列号 → 直接拒绝，不写入。

分布式容灾

Kafka的分布式类似于redis的master-slave模式，但是Kafka是leader负责所有的读写，replica只负责备份，由此我们引出kafka 发消息 ack的三种模式。

ack = 0 生产者只管发消息
ack = 1 leader节点确认落库后认为发送成功
ack = -1 所有的replica都落库后才认为成功

我有一个问题，为什么kafka不像redis那样读写分离呢，这是因为redis读写分离是为了减少读的压力，而kafka本身就可以水平扩展有多个partition，读的问题已经解决了。而且kafka对于一致性的要求更高且是磁盘IO主从数据差距可能较大，所以我们没必要也不应该读写分离。

新版本采用的是Raft算法选取领导，老版本的是zookeeper再说吧。

消费者 Rebalance

这个东西属于是只有专门研究过Kafka的才会问你，因为分布式系统动态更改本身就是一个比较复杂的东西。

首先我们要了解一下心跳线程。消费者需要定期地发送心跳请求（Heartbeat Request）到 Broker 端的协调者，以表明消费者它还存活着。

在0.10.1.0 版本之前，发送心跳请求是在消费者主线程完成的，如果消费时间过长，可能被误认为死亡，但是没死。

自 0.10.1.0 版本开始，社区引入了一个单独的心跳线程来专门执行心跳请求发送，避免了这个问题。社区肯定不傻，为啥最开始就不用这个方案呢，这个方案也不是完美的，**主线程死了，心跳线程依然在跳！**为了解决“拆分线程后产生的僵尸问题”，Kafka 社区又打了个补丁，引入了 max.poll.interval.ms，如果主线程因为处理太慢，超过了这个时间还没进行下一次 poll()（poll 里面包含了向 Coordinator 汇报进度的逻辑），就会被踢出。

然后我们了解一下Rebalance触发场景：

组成员数量发生变化。
订阅主题数量发生变化。
订阅主题的分区数发生变化。

对于2.3版本之前，基于eager 协议，非常的简单粗暴。Coordinator 只知道“现在的状态”和“下一个状态”，转换状态的方式就是全部清空再重填。

过程如下：

触发与心跳发现：当组内成员发生变动（新加入、离开或被认为死亡）或订阅的Topic分区数变化时，再平衡被触发。消费者通过心跳（Heartbeat）通信感知到再平衡开始。
停止消费与提交位移 (Revoke)：收到通知后，消费者需在当前poll()循环结束前完成消息处理，并触发onPartitionsRevoked()回调。在此回调中，必须同步提交Offset以避免消息丢失或重复。随后，消费者将释放所有分区并停止拉取新消息。
加入组 (JoinGroup)：所有消费者重新向协调者发送JoinGroup请求，上报自身订阅信息。协调者会将第一个加入的成员指定为"组领导者"，并将所有成员信息发送给它。
领导者分配 (Leader Assignment)：组领导者根据partition.assignment.strategy（分区分配策略，如Range、RoundRobin、Sticky）计算分区分配方案，并通过SyncGroup请求将结果发送给协调者。
同步分配 (SyncGroup) 并恢复消费：协调者将分配方案下发给所有消费者。消费者收到分区后触发onPartitionsAssigned()回调，开始从各自的分区拉取消息，再平衡过程结束。

其中的重点是停止消费与提交位移这一步，我们要考虑消费者在poll这一轮必须把获取的所有消息在不超过max.poll.interval.ms的时间消费完（默认是5分钟其实绰绰有余），如果真做不到可以考虑调整max.poll.records和max.poll.interval.ms。然后业务这里也要进行幂等操作。

当然，我们很容易就会发现第二个触发场景有问题，明明只需要对新增的topic进行处理，为什么还有STW来重分配呢，所以Kafka2.4+引入了协作式再平衡（Cooperative Rebalance），也称为增量式再均衡（Incremental Rebalance）。其它的场景也有优化，这一块的问题迄今为止应该还在不断优化。

触发场景	是否需要 Revoke	Revoke 范围	核心特点
组成员变化（新增）	✅ 需要	仅部分分区迁移	为了负载均衡，老成员让出一部分分区给新成员（增量迁移，无全停顿）
组成员变化（离开）	❌ 基本不需要	无（只新增分配）	剩余成员直接接管“无人持有”的分区，几乎无迁移成本
订阅 Topic 增加	❌ 不需要	无	旧分区完全不动，只分配新 Topic 的分区
订阅 Topic 删除	✅ 需要	仅被删除 Topic	只释放不再订阅的分区，不影响其他 Topic
Topic 分区数增加	❌ 不需要	无	旧分区不动，仅对新增分区做分配
Topic 分区数减少	✅（理论）	被移除分区	实际很少发生（Kafka 不支持直接缩分区）

注：Revoke 指的是：Coordinator 要求某个 Consumer 放弃它当前持有的分区

MySQL

通识

MySQL为CS架构，有连接层、服务层和存储引擎层。连接层负责身份验证，连接管理。服务层负责解析SQL语句、优化查询SQL和各种运维功能。

存储引擎层负责数据的存储和检索，目前采用InnoDB（支持事务和行级锁），~~5.5之前是MyISAM目前没啥人用，但是了解一下区别也不错，毕竟查询性能还是高一点~~，发现MyISAM仅仅只缓存索引（Index），不缓存数据（Data），所以查询也是一坨。

特性	InnoDB	MyISAM	Memory
事务支持	支持	不支持	不支持
锁粒度	行级锁	表级锁	表级锁
外键约束	支持	不支持	不支持
崩溃恢复	支持	不支持	不支持
全文索引	MySQL 5.6+ 支持	支持	不支持
存储限制	64TB	256TB	受内存限制
适用场景	OLTP 高并发	读多写少	临时缓存

名词解释： 外键约束：通过限制一个表中的字段值必须匹配另一张表的主键值，保证数据的参照完整性，防止出现孤立、无效或不一致的数据关系。 崩溃恢复：能够通过自身的日志机制（如 InnoDB 的 redo/undo log）自动检测并恢复数据到崩溃前的一致状态，避免数据丢失、损坏或不一致，保障数据的持久性和可靠性。 全文索引：针对文本内容的特殊索引类型，用于快速检索字符串类型字段中的关键词，相比传统的LIKE模糊查询，它支持自然语言的分词检索，大幅提升文本搜索的效率和准确性，适用于内容检索类场景。（没啥人用，Elasticsearch爆杀它，除非很轻量化） OLTP（Online Transaction Processing）：大量短小、高频、实时性的事务

SQL vs No SQL

ACID：关系型数据库的事务原则，确保操作要么全做要么全不做，数据时刻保持正确。 e.g. 银行转账：A 向 B 转 100 元。步骤包含“A 扣款”和“B 收款”，这两步必须同时成功或同时失败回滚，绝不能出现 A 钱少了 B 却没收到的情况。 BASE：NoSQL 常用的设计理念，牺牲强一致性换取高可用，允许数据存在中间状态。 e.g. 朋友圈点赞：你点赞后，其他好友可能过几秒才看到红点亮起。系统不保证实时一致，但保证经过一段时间后数据最终同步。适合海量数据、高并发场景。

ACID（关系型数据库事务原则）：

A (Atomicity) 原子性：事务不可分割，操作要么全成功，要么全失败回滚。
C (Consistency) 一致性：事务前后，数据必须符合规则（如余额不能为负），保持合法状态。
I (Isolation) 隔离性：并发事务互不干扰，各干各的，互相看不到中间过程。
D (Durability) 持久性：事务一旦提交，修改永久生效，宕机重启数据也不丢。

BASE（NoSQL / 分布式设计理念）：

BA (Basically Available) 基本可用：系统出故障时，允许损失部分功能（如响应变慢、返回旧数据），但保证核心服务不挂。
S (Soft State) 软状态：允许数据存在中间状态（如副本同步中），不要求实时强一致。
E (Eventually Consistent) 最终一致性：不保证任意时刻数据一致，但承诺经过一段时间后，数据最终会同步到一致状态。

数据库三大范式

NF = Normal Form

数据库三大范式（1NF / 2NF / 3NF）是设计关系表的一套递进规范：

1NF：字段不可再分，每列都是原子值，没有“小表格”、“数组”字段。
2NF：在 1NF 基础上，消除“非主属性对主键的部分依赖”，只与主键整体相关。（针对于联合主键而言）
3NF：在 2NF 基础上，消除“非主属性对非主属性的传递依赖”，避免冗余和更新异常。

e.g.

1NF : 一个列为联系方式是不好的。分为邮件和电话两列更好。 2NF：若主键为（学号，课程号），存在一个列为姓名是不好的，姓名只依赖学号而不依赖课程号；存在一个列存成绩是正常的。所以就把学生表独立出来，原来的表只留成绩。 3NF：若学生表中有“学号、姓名、系名、系主任”，主键是学号。这里“系主任”依赖“系名”，而“系名”又依赖“学号”，构成了传递依赖（学号 -> 系名 -> 系主任）。这会导致数据冗余（同系的学生重复存储系主任）和更新异常（换系主任要改全表）。应将表拆分为：学生表（学号、姓名、系名）和系表（系名、系主任）。

外键

CREATE TABLE students ( 
id INT PRIMARY KEY,
name VARCHAR(50),
course_id INT,
FOREIGN KEY (course_id) REFERENCES courses(id) ON DELETE CASCADE
);

不过其实应用层来控制删除日志记录和控制性更好，只要不疏忽

索引

mindmap
  root((MySQL索引分类体系))
    按数据结构
      B+tree索引
        :最常用，支持范围查询
      Hash索引
        :等值查询极快，不支持范围
      Full-text索引
        :用于全文搜索
    按物理存储
      聚簇索引
        :数据与索引一体
        :叶子存整行数据
      二级索引
        :叶子存主键值
        :需“回表”查询
    按字段特性
      主键索引
        :唯一且非空
      唯一索引
        :允许NULL值
      普通索引
        :基本类型
      前缀索引
        :节省空间
    按字段个数
      单列索引
        :单个字段
      联合索引
        :多个字段
        :遵循最左前缀

最左匹配：

如果创建了一个 (a, b, c) 联合索引。可用

1
2

where a = ? and b = ?;
where a = ?;

失效

1
2

where b = ?;
where b = ? and c = ?;

前缀索引是一种特殊索引类型，它仅对文本字段的前N个字符建立索引，而不是对整个字段进行索引。这种方式特别适用于那些字段值很长，但查询时通常只基于字段值前几个字符进行的情况。

CREATE INDEX idx_name ON table_name (column_name(length));

要注意覆盖率和长度的平衡。

-- 1. 计算完整列的选择性（作为基准）
SELECT COUNT(DISTINCT column_name) / COUNT(*) FROM table_name;

-- 2. 计算不同前缀长度的选择性
SELECT 
    COUNT(DISTINCT LEFT(column_name, 3)) / COUNT(*) AS sel_3,
    COUNT(DISTINCT LEFT(column_name, 4)) / COUNT(*) AS sel_4,
    COUNT(DISTINCT LEFT(column_name, 5)) / COUNT(*) AS sel_5,
    COUNT(DISTINCT LEFT(column_name, 6)) / COUNT(*) AS sel_6
    -- ...继续测试更多长度
FROM table_name;

找到前缀选择性最接近且不低于全列选择性的最小长度。

MySQL事务的ACID特性是其核心，而InnoDB存储引擎通过Redo Log、Undo Log、Binlog以及MVCC和锁机制共同协作来实现这些特性。下面我将为您详细解析其原理与实现。

事务

ACID是数据库事务正确执行的四个关键特性，它们共同保证数据库操作的可靠性。

特性	含义	核心实现机制
原子性 (Atomicity)	事务是不可分割的工作单位，事务中的操作要么全部成功，要么全部失败回滚。	Undo Log (回滚日志)
一致性 (Consistency)	事务必须使数据库从一个一致性状态变换到另一个一致性状态。	由原子性、隔离性、持久性共同保障
隔离性 (Isolation)	多个事务并发执行时，一个事务的执行不应影响其他事务的执行。	锁机制 + MVCC (多版本并发控制)
持久性 (Durability)	一个事务一旦提交，它对数据库中数据的改变就是永久性的，接下来的其他操作和故障不应该对其有任何影响。	Redo Log (重做日志)

核心日志系统

MySQL（InnoDB）通过三类关键日志来实现ACID，它们协同工作，构成了事务可靠性的基石。

flowchart LR
    subgraph A[事务执行流程]
        direction TB
        A1[事务开始] --> A2[记录Undo Log]
        A2 --> A3[修改Buffer Pool<br>生成脏页]
        A3 --> A4[写入Redo Log Buffer]
        A4 --> A5{事务提交?}
        A5 -- 是 --> A6[刷Redo Log到磁盘]
        A6 --> A7[写Binlog]
        A7 --> A8[提交成功]
        A5 -- 否 --> A9[通过Undo Log回滚]
    end
    subgraph B[崩溃恢复流程]
        direction TB
        B1[数据库重启] --> B2{检查Redo Log}
        B2 -- 有已提交事务 --> B3[重放Redo Log<br>前滚]
        B3 --> B4[数据恢复]
        B2 -- 有未提交事务 --> B5[通过Undo Log回滚]
        B5 --> B4
    end

Undo Log（回滚日志）—— 原子性

核心作用：记录数据修改前的旧值，用于事务回滚和实现MVCC的多版本读取。
工作原理：
- 当执行 INSERT、UPDATE、DELETE 等操作时，InnoDB会先将修改前的数据写入Undo Log。
- 例如，对于一条 UPDATE 语句，Undo Log会记录反向的 UPDATE 操作，将数据改回旧值。
- 如果事务需要回滚，InnoDB就会根据Undo Log中的记录执行逆向操作，将数据恢复到事务开始前的状态。
额外作用：Undo Log是InnoDB实现MVCC（多版本并发控制）的关键。它通过版本链将一行数据的历史版本串联起来，使得读操作可以无锁地访问数据的一致性快照。

Redo Log（重做日志）—— 持久性的保障

核心作用：记录事务对数据页的物理修改，确保事务的持久性，实现崩溃恢复。
工作原理：
- 采用WAL (Write-Ahead Logging) 机制。事务提交时，InnoDB会先将修改操作记录到Redo Log并持久化到磁盘，然后再慢慢将Buffer Pool中的脏页刷入数据文件。
- 这将原本的随机写（更新数据文件的不同位置）转化为顺序写（追加日志文件），极大地提升了性能。
- 在系统崩溃重启后，InnoDB会自动检查Redo Log，将已提交但未刷盘的修改重新应用，从而恢复数据。
关键配置：innodb_flush_log_at_trx_commit 参数控制Redo Log的刷盘策略。
- 1：最安全，每次事务提交都刷盘，保证不丢数据（这是默认值）。
- 0：每秒刷盘一次，可能丢失最后一秒的事务。
- 2：提交时写入文件系统缓存，由系统决定何时刷盘，性能好但存在风险。
补充：
- Buffer Pool (缓冲池)：InnoDB 引擎为了弥补内存和磁盘速度的巨大鸿沟，在内存中划分了一块区域。数据库不仅把经常读取的数据放在这里，所有的修改操作也都是优先在这里进行的。
- Clean Page (干净页)：内存里的数据和磁盘里的数据一模一样。
- Dirty Page (脏页)：事务在内存（Buffer Pool）中修改了某个数据页，但这个修改还没来得及写回到磁盘的数据文件中。此时，内存里的数据比磁盘里的新，这个数据页就叫“脏页”。

Binlog（二进制日志）—— 复制与恢复的桥梁

核心作用：记录所有修改数据的SQL语句（逻辑日志），主要用于主从复制和基于时间点的数据恢复。
与Redo Log的区别：
- 产生层级：Redo Log是InnoDB引擎层特有的；Binlog是MySQL Server层实现的。
- 日志内容：Redo Log记录物理修改（对数据页的改动）；Binlog记录逻辑操作（SQL语句或行变更）。
- 写入时机：事务提交时，Redo Log采用循环写，Binlog采用追加写。
两阶段提交：为保持主从数据一致性，InnoDB在事务提交时采用两阶段提交：先写Redo Log，再写Binlog。

隔离性的实现：锁与MVCC

下面是SQL标准的隔离级别，MySQL基本解决幻读问题，到底解决没有这个属于哲学问题。

隔离级别	脏读	不可重复读	幻读
READ UNCOMMITTED	√	√	√
READ COMMITTED	×	√	√
REPEATABLE READ	×	×	√
SERIALIZABLE	×	×	×

隔离性主要解决并发事务之间的干扰问题，InnoDB采用锁机制和MVCC相结合的方式实现。

锁机制 InnoDB支持行级锁，通过给数据加锁来避免并发冲突。

共享锁(S锁)：允许事务读一行数据，其他事务可以读但不能写。
排他锁(X锁)：允许事务删除或更新一行数据，其他事务不能读也不能写。
行锁算法：包括Record Lock（记录锁）、Gap Lock（间隙锁）、Next-Key Lock（临键锁），在可重复读隔离级别下，Next-Key Lock用于防止幻读。

MVCC（多版本并发控制） MVCC是InnoDB实现高并发的关键，它在很多情况下避免了加锁，实现了非阻塞读。

核心思想：为每个事务提供一个数据快照，使得读操作不需要加锁就能看到一致的历史数据。
实现元素：
1. 隐藏字段：每行数据包含 DB_TRX_ID（最近修改事务ID）和 DB_ROLL_PTR（回滚指针）。
2. Undo Log版本链：通过回滚指针将一行数据的多个版本串联起来。
3. Read View（一致性视图）：事务开始时生成，包含“当前活跃事务ID列表”和“最大事务ID”，用于判断数据版本对该事务是否可见。
不同隔离级别的MVCC：
- 读已提交 (READ COMMITTED)：每次查询都会生成一个新的Read View，能看到其他事务已提交的修改。
- 可重复读 (REPEATABLE READ)：事务第一次查询时生成Read View，整个事务期间都使用这个快照，因此能看到事务开始时的一致性状态。

事务执行与崩溃恢复流程

理解ACID特性的实现，关键在于看清楚事务从开始到提交，以及发生崩溃后如何处理。

事务正常提交流程：
- 事务开始，分配事务ID。
- 修改数据前，先写入Undo Log。
- 在Buffer Pool中修改数据页（形成脏页），并将修改记录写入Redo Log Buffer。
- 事务提交时，根据 innodb_flush_log_at_trx_commit 设置将Redo Log Buffer刷盘。
- 写入Binlog（两阶段提交的第二个阶段）。
- 提交完成，返回结果给客户端。
崩溃恢复流程：
- 数据库重启后，检查Redo Log。
- 前滚：对于已提交但未刷盘的事务，重新应用Redo Log，恢复数据。
- 回滚：对于未提交的事务，通过Undo Log撤销所有修改。
- 最终，数据库恢复到一致状态。

总结

MySQL（InnoDB）的事务特性实现是一个精密协作的体系：

原子性：由 Undo Log 实现，提供回滚能力。
持久性：由 Redo Log 实现，采用WAL机制保证崩溃恢复。
隔离性：由 锁机制 和 MVCC 共同实现，平衡了性能与正确性。
一致性：是以上三个特性（A、I、D）共同追求的目标，最终通过数据库的约束机制达成。这套机制使得MySQL能够在高并发环境下，既保证了数据的可靠性和一致性，又提供了良好的性能。理解这些底层原理，对于数据库优化、故障排查以及高可用架构设计都至关重要。

优化

-- 1. 建表
DROP TABLE IF EXISTS employee;
CREATE TABLE employee (
    empid  INTEGER PRIMARY KEY,
    name   TEXT NOT NULL,
    dept   TEXT NOT NULL,
    salary NUMERIC(10,2)
);

-- 2. 批量插入 1000 条数据
INSERT INTO employee (empid, name, dept, salary)
SELECT
    id,
    'User_' || id,
    CASE WHEN id % 5 = 0 THEN 'Sales'
         WHEN id % 5 = 1 THEN 'HR'
         WHEN id % 5 = 2 THEN 'Tech'
         WHEN id % 5 = 3 THEN 'Finance'
         ELSE 'Admin'
    END,
    3000 + random() * 7000
FROM generate_series(1, 1000) AS id;

-- 3. 未加索引：真实执行计划 + 真实耗时
EXPLAIN ANALYZE
SELECT * FROM employee WHERE dept = 'Tech' AND salary > 5000;

-- 4. 创建联合索引
CREATE INDEX idx_employee_dept_salary ON employee(dept, salary);

-- 5. 加索引后：再次真实执行计划对比
EXPLAIN ANALYZE
SELECT * FROM employee WHERE dept = 'Tech' AND salary > 5000;

Output:

117 ms
DROP TABLE
CREATE TABLE
INSERT 0 1000
                                               QUERY PLAN                                                
---------------------------------------------------------------------------------------------------------
 Seq Scan on employee  (cost=0.00..20.80 rows=1 width=84) (actual time=0.009..0.088 rows=137.00 loops=1)
   Filter: ((salary > '5000'::numeric) AND (dept = 'Tech'::text))
   Rows Removed by Filter: 863
   Buffers: shared hit=8
 Planning:
   Buffers: shared hit=11
 Planning Time: 0.069 ms
 Execution Time: 0.098 ms
(8 rows)

CREATE INDEX
                                                              QUERY PLAN                                                              
--------------------------------------------------------------------------------------------------------------------------------------
 Bitmap Heap Scan on employee  (cost=4.30..9.33 rows=2 width=84) (actual time=0.027..0.038 rows=137.00 loops=1)
   Recheck Cond: ((dept = 'Tech'::text) AND (salary > '5000'::numeric))
   Heap Blocks: exact=8
   Buffers: shared hit=8 read=2
   ->  Bitmap Index Scan on idx_employee_dept_salary  (cost=0.00..4.29 rows=2 width=0) (actual time=0.022..0.022 rows=137.00 loops=1)
         Index Cond: ((dept = 'Tech'::text) AND (salary > '5000'::numeric))
         Index Searches: 1
         Buffers: shared read=2
 Planning:
   Buffers: shared hit=23 read=1
 Planning Time: 0.099 ms
 Execution Time: 0.049 ms
(12 rows)

PostgreSQL

这个相对于mysql的烂大街八股，还是新潮一些的。来简单的学习一下事务的实现和mysql有啥区别。

原子性——事务回撤：

做法：当你更新一行数据时，PG 不会修改原有的行（Tuple）。它会插入一行全新的数据，并将旧行标记为“过期”。
MVCC 实现：每行数据有两个隐藏字段：xmin（创建该行的事务 ID）和 xmax（删除/更新该行的事务 ID）。事务根据这两个 ID 和自己的活跃事务快照（Snapshot）进行对比，决定哪一行对自己可见。
优点：回滚（Rollback）极其快！只需要把事务标记为已中断（Aborted），之前的修改由于 xmin 不符合条件，自动就不可见了。不需要像 MySQL 那样去做任何物理上的逆向操作。
代价：那么代价是什么呢？很显然如果不定期清除，历史表就爆炸了。开始吟唱：Vacuum 是 PostgreSQL 独有的数据清理维护功能，它主要负责清理这些废弃数据、回收可用空间，同时更新数据库统计信息来优化查询效率，还能避免事务 ID 异常引发的数据问题。普通的 Vacuum 不会锁表，业务可以正常读写，仅将空间标记为可复用；Vacuum Full 会锁表、彻底收缩表空间并把空闲空间返还给操作系统，生产环境要在低峰期谨慎使用。PG 默认有 autovacuum 自动清理机制，后台会自动运行，大批量增删改数据后，可在业务低峰手动执行 Vacuum Analyze，防止表膨胀、提升查询性能。

持久性——防断电：

只有 WAL (Write Ahead Log)。PG 的 WAL 承担了 Redo 的功能，用于宕机恢复。由于新旧版本都在主表里，回滚时不需要 Undo 信息，所以 WAL 不需要记录复杂的撤销逻辑。

隔离级别：

幻读（Phantom Read）：
- MySQL RR：通过 Next-Key Locks（锁）和 MVCC（快照读）共同解决。
- PostgreSQL RR：由于其天然的多版本机制，PG 的 Repeatable Read 级别本身就不允许幻读。
- 人话补充：MySQL的read view 是语句级别的，使用当前读后就会破坏掉。而PG在一个事务里面的一直就是最开始哪个read view。
可串行化（Serializable）：
- MySQL：通过强制加锁（Locking-based）实现。
- PostgreSQL：使用的是 SSI (Serializable Snapshot Isolation)。它不阻塞读写，而是通过监控事务间的“读写冲突”来发现可能的串行化异常，如果发现风险，直接报错让事务重试。这是一种更现代、学术界公认更优的做法。

索引：

MySQL：主键是聚簇索引，数据就在索引上。

PostgreSQL：表数据存储在 Heap（堆） 中，索引（如 B-Tree）存储的是指向堆中物理位置的 TID（页号+偏移量）。

写放大隐患：在 PG 中，即使你更新的是一个非索引字段，由于产生了新行，物理位置变了，该表所有的索引都得更新指向新的位置。
HOT 优化 (Heap Only Tuple)：为了解决这个问题，PG 引入了 HOT 技术。如果新行和旧行在同一个 Page 里，索引可以继续指向旧行，通过旧行的“指路牌”找到新行，从而避免更新所有索引。

注意此堆非彼堆，是硬盘的概念，堆由页组成。

一个标准 Heap Page 的内部构造从低地址到高地址依次为：

Page Header（页头）：24字节，记录页的元数据，如校验和（Checksum）、空闲空间起始与结束位置等。
Line Pointers (ItemId / Linp)：一个 4 字节的数组。每当插入一行数据，这里就增加一个元素。它充当了页内索引，存储了该行数据在页内的物理偏移量。
Free Space（空闲空间）：新数据插入时，从此处分配空间。
Tuples（元组/行数据）：实际的数据行。它是从页的尾部向上增长的。

每一行数据（Tuple）由两部分组成：

HeapTupleHeader：包含 MVCC 控制字段。
- xmin：插入该行的事务 ID。
- xmax：删除或更新该行的事务 ID。
- t_ctid：物理指针，指向自身或新版本（用于 HOT 链）。
- t_infomask：状态位（如该行是否已提交、是否有 OID 等）。
User Data：实际的列数据。

RabbitMQ

学这个东西有一种命苦的感觉，虽然没啥用，也得背一点。

这个按照AMQP实现非常的好啊，非常的规范。

AMQP 模型的三大组件：

`1`	`生产者(Producer) → 交换机(Exchange) → 队列(Queue) → 消费者(Consumer)`

交换机类型	路由规则	适用场景	具体匹配示例
Direct	精确匹配：消息 routing-key 与绑定键完全一致	一对一通信（任务分发）	绑定键 `order.pay`，仅路由键为 `order.pay` 的消息进入该队列
Fanout	广播模式：忽略 routing-key，发送到所有绑定队列	一对多通知（如事件广播）	无论路由键是什么，消息都会发给所有绑定到此交换机的队列
Topic	模糊匹配：支持`*`(单级) 和`#`(多级) 通配符	多条件路由（如新闻分类订阅）	绑定键 `log.*` 匹配 `log.error`；`log.#` 可匹配 `log.error.mysql`、`log`
Headers	基于消息 headers 属性匹配，不依赖 routing-key	复杂属性过滤场景	消息头 `{"type":"order"}`，绑定 `x-match=any` 时，只要包含该键值对即可匹配

操作系统和计网

ldfd@outlook.it (ldfd) — Tue, 05 May 2026 16:11:27 +0800

内存屏障

有两个东西会指令重排编译器（Compiler)和CPU 硬件，当然在单线程的时候，根据我们学过的流水线，这样可以提高吞吐量。

但是在多线程下可能导致乱序。

编译屏障（Compiler Barrier）

**只喊停编译器，不管 CPU。**如果确定CPU 本身不会乱序，那么它就够了。
CPU 内存屏障（Hardware Memory Barrier）

同时喊停编译器和 CPU 硬件。 不但让编译器不许重排，还插入一条特殊指令，强制 CPU 在执行到这里时，把之前乱序执行的尾巴收干净，后续指令必须严格等在后面。

四种乱序：

写-写重排：后一个写，跑到前一个写的前面去。
读-读重排：后一个读，跑到前一个读的前面去。
读-写重排：一个读，跑到后面一个写的后面；或者一个写跑到后面一个读的前面。
写-读重排：一个写之后的读，跑到写完成之前就执行了。

进而有下列屏障：

写屏障（Store Barrier / Write Barrier）：只有写操作之间不能换顺序。
读屏障（Load Barrier / Read Barrier）：只有读操作之间不能换顺序。
全屏障（Full Barrier）：所有四种乱序都禁止
Release 和 Acquire
Release（发布）：写操作。保证在它之前的所有读写，都完成之后，才轮到它执行
Acquire（获取）：读操作。保证在它之后的所有读写，必须等它完成之后才能开始。

用户态线程

用户态线程，就是完全在用户程序自己手里管理的线程，操作系统内核根本不知道它的存在。

优点：

极低开销：创建只需分配用户空间数据结构（通常 2~8 KB 栈），切换仅涉及少量寄存器的保存/恢复，无特权级切换。
超高并发：可在单个进程中容纳数十万甚至百万级并发单元，非常适合 I/O 密集型高并发场景（如网络服务器）。
灵活调度：应用可自定义调度策略，例如带优先级的协作调度、工作窃取（work-stealing）等，无需受限于内核通用调度器。

缺点：

阻塞隐患（N:1 模型下或 M:N 阻塞处理不当）：任何直接的系统阻塞调用都可能阻塞整个调度域。
多核利用需显式设计：需要与应用层调度器配合，分配足够的内核线程并将就绪的 ULT 调度上去。
抢占困难：内核线程可依赖时钟中断强制抢占，用户态线程若缺乏语言/运行时支持（如 Go 的协作抢占基于栈扫描和抢占点），只能依赖显式让出（yield），容易因死循环导致其他线程饥饿。
资源隔离和公平性问题：用户态调度器通常对 CPU 时间无硬性保障，也难以与内核全局调度策略协调。
与现有同步原语的交互：用户态线程切换不提供任何内存屏障语义，对可见性的保证需由开发者通过并发原语显式声明。

模型：

一对一模型（1:1 Model）：每一个用户线程都映射到一个内核线程。说白了，就是给内核态套了个用户态的皮。

多对一模型（M:1 Model）：多个用户线程映射到一个内核线程。

一个线程阻塞 → 全部阻塞
系统调用会卡死整个进程

多对多模型（M:N Model）：多个用户线程映射到多个内核线程（数量可不同）。

用户态负责“线程调度”，内核负责“线程执行”。
实现复杂

计算机系统结构

ldfd@outlook.it (ldfd) — Tue, 28 Apr 2026 21:07:26 +0800

第一章

阿姆达尔定律（Amdahl’s Law）

$$ S_{n}=\frac{T_{0}}{T_{n}}=\frac{1}{(1-F e)+\frac{F e}{S e}} $$

符号	含义
Sn	整体系统加速比：优化后系统性能与优化前的比值，也等于优化前执行时间与优化后执行时间的比值
T0	优化前的执行时间：没有任何优化措施时，完成整个任务需要的时间
Tn	优化后的执行时间：对部分组件进行优化后，完成整个任务需要的时间
Fe	可优化部分的占比：任务中可以被优化 / 加速的部分，占原始执行时间的比例（取值范围：0≤Fe≤1）
Se	可优化部分的加速比：优化措施给可优化部分带来的性能提升倍数（例如，优化后这部分运行速度是原来的 3 倍，则Se=3）

公式的推导逻辑是：

任务中不可优化部分的执行时间：$T_0 \times (1-Fe)$
任务中可优化部分优化后的执行时间：$T_0 \times Fe / Se$
优化后的总执行时间：$T_n = T_0(1-Fe) + \frac{T_0 Fe}{Se}$
加速比：$S_n = \frac{T_0}{T_n} = \frac{1}{(1-Fe) + \frac{Fe}{Se}}$

这个定律揭示了一个重要的工程规律：系统的整体加速比受限于不可优化部分。即使可优化部分的加速比$Se$趋近于无穷大，系统整体加速比的上限也只是$\frac{1}{1-Fe}$。 $$ CPU时间 = \text{IC} \times \text{CPI} \times \text{时钟周期时间} \ = \sum_{i=1}^{n} (\text{CPI}_i \times \text{IC}i) \times \text{时钟周期时间} \[1em] \text{CPI} = \frac{\text{时钟周期数}}{\text{IC}} = \frac{\sum{i=1}^{n} (\text{CPI}_i \times \text{IC}i)}{\text{IC}} = \sum{i=1}^{n} \left( \text{CPI}_i \times \frac{\text{IC}_i}{\text{IC}} \right) \[1em] \text{MIPS速率} = \frac{f}{\text{CPI} \times 10^6} $$ CPU 时间：程序实际执行花费的总时间（秒）

IC (Instruction Count)：指令总数，程序一共执行多少条指令

CPI (Cycles Per Instruction)：每条指令平均时钟周期数

时钟周期时间：一个时钟周期持续的时间（秒）

时钟周期数：程序执行总共用了多少个时钟周期

f：CPU 主频 / 时钟频率（Hz）

MIPS 速率：每秒执行多少百万条指令

i：指令类型编号（如加法、乘法、访存等）

n：指令类型总数

CPIᵢ：第 i 种指令的 CPI

ICᵢ：第 i 种指令的执行条数

第二章

MIPS（Microprocessor without interlocked pipelined stages）:这个和第一章缩写一样，但是不是一个东西，是一种RISC处理器架构。

哈夫曼编码（Huffman Coding）

核心思想：按频率分配变长码，高频指令用短码、低频用长码，保证前缀性质（任一码字不是其他码字的前缀）。

扩展操作码

指令操作码不等长，短码给高频指令，长码给低频指令；

例子： ① 2 - 7 扩展操作码

数字含义：

第一个数 2：短指令最多 2 条
第二个数 7：长指令最多 7 条

② 3 - 3 - 3 扩展操作码

三个 3 依次代表三层：

第 1 个3：2 位短指令层，预留 3 个码做扩展
第 2 个3：4 位中指令层，预留 3 个码做扩展
第 3 个3：6 位长指令层，不再扩展

指令	使用频度	哈弗曼编码1	哈弗曼编码2	3-3-3扩展编码	2-7扩展编码
ADD	0.43	0	0	00	00
CLA	0.22	10	100	01	01
SUB	0.13	110	101	10	1000
JMP	0.07	11100	1100	1100	1001
JOM	0.06	11101	1101	1101	1010
STO	0.05	11110	1110	1110	1011
CIL	0.02	111110	11110	111100	1100
SHR	0.01	1111110	111110	111101	1101
STP	0.01	1111111	111111	111110	1110

第三章

流水线

第一种流水线时空图：格子里填数字 i，代表第 i 条指令 / 第 i 次运算在对应时间、对应流水段执行，用来直观看指令重叠、冲突、吞吐率。

第二种流水线时空图：时空图方框里面是MIPS流水段指令，主要就是 IF ID EX MEM WB

IF：Instruction Fetch 取指段 从指令存储器中取出当前指令

ID：Instruction Decode 译码 / 取数段 解析指令 + 从寄存器堆读源操作数

EX：Execute 执行 / 运算段 ALU 进行运算、地址计算、分支比较

MEM：Memory 访存段 访问数据存储器

WB：Write Back 写回段 把运算 / 访存结果写回寄存器堆

STALL：因为数据冒险、控制冒险，当前指令不能继续往下走，空出一个周期。

下面是常用公式： $$ % 流水线四大性能指标公式总执行时间

T_k = (k + n - 1)\Delta t \

吞吐量（单位时间完成指令数）

TP = \frac{完成运算数}{总执行时间} = \frac{n}{(k + n - 1)\Delta t} \

最大吞吐量

TP_{\text{max}} = \frac{1}{\Delta t} \

流水线效率

E =\frac{串行时间运算次数}{段数总执行时间} =\frac{n}{k + n - 1} \

加速比

S = \frac{nk}{k + n - 1},\quad S_{\text{max}} = k \ $$ k：流水线段数（MIPS 5 级流水 k=5）

n：任务 / 指令条数

Δt：流水线每段时钟周期（时钟周期 T=Δt）

Tk：流水线执行 n 条指令总时间

T0：非流水线顺序执行总时间

对于不等长时钟周期还有一个公式，核心是第一条走完要所有段，后面每条只占一个时钟周期 $$ T_k = \sum_{i=1}^k \Delta t_i + (n-1)T_{max} $$

第五章

标量流水处理机：就是之前学的每条指令分多段（取指 / 译码 / 执行 / 写回），每周期仅发射 1 条指令，流水线深度固定。

超标量处理机（Superscalar）：复制多套流水线与执行单元（ALU、访存端口），每周期动态发射多条独立指令。

超长指令字处理机（VLIW，Very Long Instruction Word）：编译器在编译期静态挖掘并行性，将多条无依赖指令打包成一条超长指令（数百位），含多个独立操作字段。

超流水线处理机（Superpipeline）：将标量流水线的每一级再细分为更小的子阶段（如 4 级→8/16 级），缩短周期（原周期 Δt→Δt/m，m 为流水度）。

重要参数ILP（Instruction-Level Parallelism），指令级并行：

超标量：ILP套流水线 并行挖

VLIW：一条长指令内含 ILP个操作 即EX

超流水线：拆分流水级、单周期吞吐 ILP条

第六章

GCD 循环依赖：

规范化循环：确保循环索引从 1 开始，步长为 1
提取数组下标表达式：对于两个数组引用，分别提取系数 a, b 和 c, d（写操作 a, b 读操作c, d）
计算最大公约数：计算 g = GCD(a, c)
判断整除性：检查 (d - b) 是否能被 g 整除：（d-b）% gcd(c, a) == 0
- 如果不能整除：一定没有循环携带依赖
- 如果能整除：可能存在循环携带依赖，需要进一步测试（如 Banerjee 不等式、Omega 测试等）

依赖类型	读写顺序	本质	是否可消除	对并行化的影响	典型例子
流依赖（真依赖，RAW）	先写后读	数据的 “生产 - 消费” 关系，后序语句依赖前序语句产生的数据	不可消除（硬依赖）	最大，必须严格保证顺序	循环无关：`c[i]=2c[i-1]; b[i+1]=c[i]+d[i];`循环携带：`c[i]=2c[i-1];`（第`i`次读依赖第`i-1`次写）
反依赖（WAR）	先读后写	避免后序写操作覆盖前序读操作需要的值	可通过变量重命名消除（伪依赖）	中等，消除后可并行	`c a = b + c; // 先读b b = d + e; // 后写b` 重命名后：`a = b + c; b_new = d + e;`
输出依赖（WAW）	先写后写	保证最终内存值是最后一个写操作的结果	可通过变量重命名消除（伪依赖）	中等，消除后可并行	`c a = 1; // 先写a a = 2; // 后写a` 重命名后：`a1=1; a2=2;`

第七章

cache

复习计组三种形态：

全相联
直接映像
组相联

见八股文.md文件

#### 全相联映射

相当于随机存储，只要cache没满就往里面存，但是需要并行比较导致电路复杂，一多了设计难度就炸了。

主存地址 = 块号(s) + 块内字节号(w位) 

#### 直接映射方式

相当于分组，给主存按照每r行分为一组，然后每组的第i块只能存在cache的第i行中。

主存地址 = 组号 (s-r)+ 组内号数(r) + 块内字节号(w)

此时第i行的cache存的就是每组主存第i块的内容，可以省略cache中对于行数的存储

#### 组相联映射方式

是全相联和直接映射的折中。Cache被分成若干个**组**，每个组内包含多个**块**。

**映射规则**：主存中的一个块可以映射到**指定组**内的**任意一个空闲块**。

命名：cache每组行数v时，我们通常称这种方式为**v路组相联映射**，v通常为2、4、8、16。

对于主存每$2^v$分成一组，对于每个组中的第i块，可以存到cache中第i组的任意一行。

d = log2(cache组数)

主存地址=主存组号（s-d）+ 组内块号（d）+块内字节号（w）

#### 举例

我们以一个地址线为16的64KB主存为例。其地址形如`1001 0000 0000 0001`，字长为`1B`，假设块大小为`16B`。（由此我们可以理解一点：cache中存的不是一个主存地址的内容，而是主存中相邻的几个内容组成的一个块。进一步，我们可以知道，在此例子下，一个块有16个，对应着4位二进制，所以主存的后四位**对于命中cache的判断就没有用了**，只是用来确定块内偏移的。）

1. **全相联映射**：这种情况，主存的前12位就是用来定位cache的tag，每次cpu访问的时候和tag进行比较。

2. **直接映射**：这种情况与cache的行数有关，假如cache一共有32行，那么主存就是每32块视作一组。每一组的第i块，对应着cache的第i行。

   ~~64KB / 16B = 4K，可以求出主存有4K块。4K / 32 = 128，可以求出每一行cache被128行主存抢着用(我们可以视作把主存划分成128坨，但不能叫组，为了和下一种方式区分开)，log2(128) = 7~~。log2(32) = 5，定位cache的行需要5位。剩下的12 - 5 = 7 ，所以主存的地址就是 `7(tag) + 5(index) + 4(offset)`。

3. **组相联映射**：依旧和cache有关，我们假设cache有32行，设每组有4行，一共有32 / 4 = 8组。log2(8) = 3，需要3位来定位是哪一组cache。剩下的 12 - 3 = 9 位作为tag，用于和这一组的4行并行比较，判断是否命中缓存。所以主存的地址就是`9(tag) + 3(set index) + 4(offset)`

> [!WARNING]
>
> 直接映射中删除线部分求出log2(128) = 7来表示tag当且仅当主存填满地址空间时结果与减出来的结果一致，所以用地址线数减去 index和 offset 更加稳妥。tag就是剩下多少位都用作tag，就算超了也是未命中，没有任何风险。

写策略：

写直达法：不仅写入Cache，也写入下一级存储器。
写回法：只写入Cache，不写入下一级存储器，设置修改位，仅当Cache中相应的块被替换时，才写回主存，当一个块被替换时，若没有被修改过，则不必写回到下一级存储器

当发生写不命中时，是否需要调入相应的块：

按写分配（Write Allocate）（写时取）：写不命中时，先把所写单元所在的块调入Cache，再进行写入。

不按写分配（No-Write Allocate）（绕写法）：写不命中时，直接写入下一级存储器而不调块入Cache。

第八章

RAID

RAID 0（条带阵列，无冗余）

原理：数据分块并行分散到所有磁盘，纯条带化，无校验/备份
盘数：≥2块
容量：所有硬盘容量总和
性能：读写速度全系最高，IO并行优势极强
容错：零容错，任意一块盘损坏，全部数据丢失
适用：临时高速存储、非重要数据，严禁存核心资料

RAID 1（镜像阵列，全冗余）

原理：磁盘两两完全镜像，数据双向同步备份
盘数：≥2块（标准2块）
容量：仅等于单块硬盘容量（一半空间用于镜像备份）
性能：读速度快（双盘并行读），写略有损耗（双盘同步写入）
容错：单盘绝对容错，任意一块盘故障不丢数据
适用：系统盘、核心机密数据、高可靠低容量场景

RAID 2（位级条带+汉明校验，已淘汰）

原理：按比特位拆分数据，搭配多块专用校验盘做错误纠错
盘数：需多块数据盘+多校验盘，架构复杂
特点：早期技术、成本极高、硬件依赖强，目前彻底淘汰，无商用场景

RAID 3（字节条带+独立校验盘，小众淘汰）

原理：数据按字节条带分布，单独一块固定校验盘存奇偶校验
盘数：≥3块（N数据盘+1校验盘）
容量：(总盘数−1)×单盘容量
性能：连续读写强，随机读写极差，校验盘成为性能瓶颈
容错：仅容忍单盘故障
现状：基本被RAID5替代，极少使用

补充：RAID3 只支持整组读写，也数据一次性必须写N个数据盘

RAID 4（块条带+独立校验盘，基本弃用）

原理：数据按数据块条带，同RAID3，校验盘独立固定
盘数：≥3块
容量：(总盘数−1)×单盘容量
致命缺陷：所有写入操作争抢同一校验盘，IO瓶颈严重
容错：单盘容错
现状：商用几乎绝迹

RAID 5（分布式奇偶校验，主流通用）

原理：数据块条带化，奇偶校验码分散在所有磁盘，无独立校验盘
盘数：≥3块
容量：(总盘数−1)×单盘容量
性能：读写均衡，随机IO表现优秀；硬盘故障后重建开销大
容错：仅支持任意单盘故障，第二块盘损坏则数据丢失
适用：企业文件存储、普通业务数据，最经典通用型RAID

RAID 6（双分布式奇偶校验，高容错）

原理：搭载两套独立奇偶校验，校验信息分布式存储
盘数：≥4块
容量：(总盘数−2)×单盘容量
性能：读性能接近RAID5，写性能偏弱（双重校验计算开销大）
容错：全系常规RAID里容错最强，可同时容忍两块硬盘故障
适用：大容量硬盘阵列、长期运行、高可靠性要求场景

RAID 10（RAID1+RAID0 镜像条带，高性能高可靠）

原理：先做RAID1镜像组，再对镜像组做RAID0条带（先镜像、后条带，区别于RAID01）
盘数：≥4块，必须为偶数盘
容量：(总盘数÷2)×单盘容量
性能：继承RAID0高速+RAID1稳定，读写性能优异，高IO首选
容错：同一镜像组内单盘损坏无影响；不同镜像组可同时坏多块盘，仅同一镜像对双盘同时损坏才丢数据
成本：硬件成本高
适用：数据库、虚拟化、核心业务等高IO+高可靠场景

还需要会画系统的可靠性框图

第九章

互联函数

互连函数是用于描述互连网络中输入端号与输出端号之间连接关系的数学表达式。在拥有 $N$ 个输入端和 $N$ 个输出端的网络中，互连函数 $f(x)$ 表示输入端 $x$ 连接到输出端 $f(x)$。

1. 交换函数（Exchange/Cube Function）

定义：对 n 位二进制地址的第 k 位单独取反，其余所有位保持不变。。
表达式：$Cube_k(x_{n-1}\dots x_k\dots x_0) = x_{n-1}\dots \bar{x}_k\dots x_0$。
特点：常用于构造立方体网络。当 $N=8$ 时，有 $Cube_0$、$Cube_1$、$Cube_2$ 三种。（补充一下，这个N请看开头的输入端输出端定义，所以就是3个二进制可以表示十进制8）

2. 均匀洗牌函数（Shuffle Function）

定义：将输入端的二进制编号循环左移一位。
表达式：$\sigma(x_{n-1}x_{n-2}\dots x_1x_0) = x_{n-2}\dots x_1x_0x_{n-1}$。
逆洗牌函数：$\sigma^{-1}$ 为循环右移一位。
应用：Omega 网络级间互连采用均匀洗牌连接方式。

3. 蝶式函数（Butterfly Function）

定义：将输入端二进制编号的最高位与最低位互换位置。
表达式：$\beta(x_{n-1}x_{n-2}\dots x_1x_0) = x_0x_{n-2}\dots x_1x_{n-1}$。

4. 反位序函数（Bit-reversal Function）

定义：将输入端二进制编号的位序完全颠倒。
表达式：$\rho(x_{n-1}x_{n-2}\dots x_1x_0) = x_0x_1\dots x_{n-2}x_{n-1}$。

5. PM2I 函数（Plus-Minus $2^i$ Function） 又被叫做移数网络

定义：一种移数函数，将输入端号加或减 $2^i$ 后取模 $N$。
表达式：
- $PM2_{+i}(x) = (x + 2^i) \pmod N$
- $PM2_{-i}(x) = (x - 2^i) \pmod N$
范围：$0 \le i \le n-1$，$n = \log_2 N$。

互连网络（Interconnection Network）的主要特性参数用于描述其拓扑结构和性能表现。根据源文件，这些参数主要分为结构参数和性能指标两大类：

一、结构参数 这些参数主要从图论的角度描述网络的物理布局：

网络规模 ($N$)：指互连网络中结点的个数。它代表了该网络所能连接的部件（如处理器、存储模块等）的数量。
结点度 ($d$)：指与结点相连接的边数（通道数）。具体分为入度（进入结点的边数）和出度（从结点出来的边数）。
距离：指网络中任意两个结点之间通信时需要跨越的最少边数。
网络直径 ($D$)：指网络中任意两个结点之间距离的最大值。网络设计中通常希望直径越小越好，以减少通信延迟。
等分宽度 ($b$)：指将拥有 $N$ 个结点的网络切成结点数相同的两半时，在各种切法中沿切口边数的最小值。对应的线等分宽度 $B = b \times w$（$w$ 为通道宽度）。
对称性：指从网络中任何一个结点看去，其拓扑结构都是相同的。对称网络在实现和编程上通常更加容易。

2^n = N

混洗交换网：直径 2n-1 节点度2

移数网络：直径 n/2 节点度 2n-1

编译原理

ldfd@outlook.it (ldfd) — Sat, 18 Apr 2026 13:19:22 +0800

本文档由notebookLM独家指导，尝试新时代速通路线。

词法分析

核心概念

词法单元 (Token)：由一个词法单元名和一个可选的属性值组成，通常用 <token name, token value> 的形式表示。它是词法分析器输出给语法分析器的逻辑符号。

模式 (Pattern)：描述了源语言中特定记号的构成规则。在编译器设计中，模式通常使用正则表达式来刻画，例如变量名的命名规则就是一个模式。(事实上翻译成模板你就理解是什么意思了，就是一堆东西应该长成什么样子)

词素 (Lexeme)：是源程序中的一个具体的字符序列。它与某个词法单元的模式相匹配，并被词法分析器识别为该词法单元的一个实例。

词法分析器根据模式（规则），在源代码中识别出词素（字符序列），并将其转化为词法单元（逻辑单元）传递给后续阶段

DFA：确定有穷自动机 NFA：不确定有穷自动机二者区别在于NFA允许有多个出边，DFA所有状态、所有字符都必须有唯一转移，并不至少单纯的唯一输入唯一转移就可以，如果一个节点接受一个输入但是即不能终结也没有去处，那就还是NFA，满足不了DFA，

正则表达式

ϵ：匹配空串

字符 a：匹配字母表中的单个符号 a

选择 (r|s)：匹配 r 或 s 定义的语言。例如 a|b 匹配集合 {a,b}。

连接 (rs)：匹配 r 后面紧跟 s 的字符串。例如 ab 匹配 {ab}。

Kleene 闭包 ($r^*$)：匹配 r 出现 0 次或多次的情况。例如 a* 匹配 {ϵ,a,aa,…}。

优先级：闭包（*）优先级最高，其次是连接，最后是选择（|）。所有算符均为左结合

还有一些扩展语法我们通常在题目中不用，如正闭包 (r+)这种，因为做题不方便。不方便写状态机。但是是可以等价转换的。

$r^+$ 还原为 $rr^*$
$r?$ 还原为 $r | \epsilon$

RE转NFA

正则表达式 Regular Expression

非确定性有穷自动机 Non-Deterministic Finite Automata

选择 ($s|t$)：创建一个新起点和新终点。从起点画两条 $\epsilon$ 弧分别指向 $s$ 和 $t$ 的开始，再从 $s$ 和 $t$ 的结束各画一条 $\epsilon$ 弧指向新终点, 。

连接 ($st$)：将 $s$ 的接受状态与 $t$ 的开始状态合并（或者用一条 $\epsilon$ 弧连接）。

闭包 ($s^*$)：增加新起点和新终点。新起点可直接跳到新终点（匹配空串），也可进入 $s$；$s$ 的终点画 $\epsilon$ 弧回跳到其起点（实现循环），同时也指向新终点。

唯一性：整个 NFA 只能有一个开始状态（用 start 箭头标出）和一个接受状态（用双圈表示）。

出口限制：接受状态不能有向外的转换弧。

弧的限制：每个状态要么发出一条字母表符号弧，要么最多发出两条 $\epsilon$ 弧。

推荐步骤：

先画出单个字母（如 $a, b$）的基础 NFA。
按照括号 > 闭包 > 连接 > 选择的优先级顺序逐步合并。
最后检查是否只有一个双圈状态，且该状态没有发出的弧。

NFA转DFA

子集构造法 (Subset Construction)，其核心思想是让 DFA 的每一个状态对应 NFA 的一个状态集合。

我们通过一个为Dtran的表格来实现，假设我们的语言只有ab两个字母。

NFA 状态	DFA状态	a	b
{0,1,2,3,4,…..}	A	B	C
{1,2,6,8,10,…}	E	B	D

以上数据均为瞎编构造，仅用于说明NFA状态填入集合，DFA状态填入一个字母表示这个集合，当不存在新的集合出现时，证明已经转换完毕。

在填充表格之前，必须定义两个操作：

$\epsilon\text{-closure}(S)$：从状态集 $S$ 中的每个状态开始，只通过 $\epsilon$ 边（空移动）能够到达的所有状态的集合。
$move(S, c)$：从状态集 $S$ 中的每个状态开始，通过消耗一个输入字符 $c$ 能够直接到达的状态集合。

初始的时候第一个NFA状态是start通过不限量个ε可达的节点。然后这个集合通过一个a/b进行状态转移，能到达什么地方，再计算这个几个通过不限量个ε可达的节点，也就是求$\epsilon_{closure}({T}) $（T为集合, T = move(A, a)）。

DFA最小化

DFA 最小化（通常采用 Hopcroft 算法）的核心是通过划分等价状态组，将行为完全一致的状态合并，从而得到状态数最少的等价 DFA。

核心步骤：

初始划分：将 DFA 的所有状态分为两个初始组：接受状态组（终态）和非接受状态组。检查可区分性：对于同一组内的状态，检查它们在输入相同符号 a 后，是否跳转到了不同的组。如果跳转目标不在同一个组，说明这些状态是“可区分”的，必须将它们拆分。
迭代与合并：重复上述拆分过程，直到所有组都不能再划分为止。最后，将每个组内的状态合并为一个代表状态。
区分标准：如果从状态 s 出发经路径 w 到达接受状态，而从 t 出发经相同路径 w 到达非接受状态，则 s 和 t 是不可合并的。

终态也叫接受状态就是完事了，非终态通常指自动机中的初始状态或中间状态。等价类就是对于任意输入他们跳转到同一个等价类并且它们两个本身必须同为“终态”或同为“非终态”。

语法分析

核心概念

语法分析的基础是上下文无关文法 (CFG)，它的任务是根据词法分析提供的记号（Token）流，构造出具有层次结构的语法分析树。

上下文无关文法（CFG）是用于描述程序设计语言语法的核心工具，它比正则表达式更强大，能够表达递归和嵌套结构（如配对的括号 (( ))）,。

它由一个四元组定义：

非终结符 ($V_N$)：表示语法范畴的逻辑符号，如“语句”或“表达式”。
终结符 ($V_T$)：语言的基本单元，即词法分析传来的记号（如 id, +, if）。
开始符号 ($S$)：文法中指定的唯一起始非终结符。
产生式 ($P$)：重写规则，形式为 $A \rightarrow \alpha$，表示左边的符号可以被右边的序列替换。

推导 (Derivation)：这是分析的核心过程。通过不断地用产生式的右部替换左部的非终结符，最终生成只包含终结符的字符串。

文法设计

线性文法 (正则文法)：用于描述简单的重复或顺序结构。其产生式形式受限：
- 右线性：$A \rightarrow aB$ 或 $A \rightarrow a$（非终结符只能在最右边）。
- 左线性：$A \rightarrow Ba$ 或 $A \rightarrow a$。
- 考试技巧：设计生成“被 3 除余 1 的二进制串”这类题目时，通常使用右线性文法，通过状态转换的思想来写。
上下文无关文法 (CFG)：比线性文法更强大，左部只有一个非终结符，右部可以是任意符号串。
- 应用：处理配对（如 $a^n b^n$）或嵌套结构（如括号匹配）时必须使用 CFG。

二义性与语法树

定义：如果一个文法能为同一个句子构造出两棵不同的语法分析树（或两个不同的最左推导），它就是二义性的。
证明方法：找一个简单的输入串（如真题中的 a+a+a 或 id*id+id），尝试画出两棵结构不同的树：一棵左结合，一棵右结合。
消除方法：通过改写产生式来引入优先级和结合性。例如，先处理乘法再处理加法，从而强制生成的树只有一种形态。

构造等价无二义文法的核心在于引入运算符的优先级和结合性，通过将产生式分层来强制唯一的推导路径。

以真题文法 $S \rightarrow a \mid S+S \mid SS \mid S^* \mid (S)$ 为例，构造步骤如下：

确定优先级：通常顺序为括号 $(S)$ 和原子 $a$ > 闭包 $S^*$ > 连接 $SS$ > 选择 /运算符$S+S$。
处理结合性：
- 左结合（如 $+$ 和连接）：采用左递归形式（$A \rightarrow A\alpha \mid \beta$）。
- 右结合：采用右递归形式。
分层改写：
- $S \rightarrow S + A \mid A$ （处理优先级最低的 $+$，左结合）
- $A \rightarrow AB \mid B$ （处理连接，左结合）
- $B \rightarrow B^ \mid C$* （处理闭包）
- $C \rightarrow (S) \mid a$ （处理最高优先级的括号和原子）

补充：引入的东西在于不同层级的非终结符只能推导出一种优先级的运算，每一级非终结符，只能包含它自己这一级以及比它优先级更高的运算，严格排斥更低优先级的运算。

引入的非终结符	代表含义	负责的运算符	关键特征
`F` (Factor)	原子/因子	`( )` , `id`	不可分割的最小单元，不包含任何二元运算符
`T` (Term)	项	`*`	只能生成连乘的结构，不允许在此层直接生成 `+`
`E` (Expr)	表达式	`+`	最外层，只能生成连加的结构，加法的右侧必须是 `T`

左递归消除

为什么要消除：自顶向下的 LL(1) 分析器不能处理左递归（如 $A \rightarrow A\alpha$），否则会陷入死循环。
固定公式 (直接左递归)：
若有 $A \rightarrow A\alpha \mid \beta$，改写为：

$A \rightarrow \beta A'$
$A’ \rightarrow \alpha A’ \mid \epsilon$

进一步还有隐式左递归消除

隐式左递归（间接左递归）是指文法产生式中没有直接的 $A \rightarrow A\alpha$，但经过两步或多步推导后，会出现以自身开头的符号串（例如 $S \Rightarrow Aa \Rightarrow Sda$）。

消除步骤（算法 4.1）：

非终结符排序：将文法中的所有非终结符按一定顺序排列，如 $A_1, A_2, \dots, A_n$。
代入转化：按照排序依次检查每一个 $A_i$。如果 $A_i$ 的产生式右部以排在它前面的非终结符 $A_j$ ($j < i$) 开头，则将 $A_j$ 的所有定义代入到 $A_i$ 的产生式中。
消除直接左递归：完成代入后，若 $A_i$ 出现了直接左递归，则应用标准公式：$A \rightarrow \beta A’, A’ \rightarrow \alpha A’ \mid \epsilon$ 进行消除。实例演示

已知文法：$B \rightarrow Sa \mid a$，$A \rightarrow Bb \mid b$，$S \rightarrow Ac \mid c$。

代入：将 $B$ 的定义代入 $A$，得到 $A \rightarrow Sab \mid ab \mid b$。
再代入：将 $A$ 的新定义代入 $S$，得到 $S \rightarrow Sabc \mid abc \mid bc \mid c$。
消除：此时 $S$ 变为了直接左递归，应用公式改写为 $S \rightarrow (abc \mid bc \mid c) S’$ 和 $S’ \rightarrow abc S’ \mid \epsilon$ 即可。

LL（1）分析

LL(1) 分析是考试中分值最高的大题（约 20-30 分），它代表：L（从左向右扫描）、L（产生最左推导）、1（每步只向前看一个输入符号）。

掌握这个专题需要按以下三个核心步骤走：

第一步：计算 First 集和 Follow 集

这是构造分析表的依据。

First(X)：从 $X$ 推导出的字符串中第一个终结符的集合。
Follow(A)：可能紧跟在非终结符 $A$ 后面的终结符集合。
必考点：开始符号 $S$ 的 Follow 集初始必包含 $。

这三条规则的核心逻辑是：找出在所有可能的推导序列中，哪些终结符可能紧跟在非终结符 $B$ 的右边。

1. 开始符号规则：若 $A$ 是开始符号，则 $$ \in FOLLOW(A)$

总结：文法的起始目标是匹配整个输入串，而输入串的逻辑终点由 $$$ 标记。
证明：根据句法分析的设计，完整的推导序列表现为 $S$ \Rightarrow w$$，因此 $$$ 必然存在于起始符号的后继集合中。

2. 右邻居规则：若 $A \rightarrow \alpha B \beta$，则 $FIRST(\beta) - {\epsilon} \subseteq FOLLOW(B)$

总结：$B$ 的“右手边邻居”能推导出的所有开头字符，都是 $B$ 的追随者。
证明：在推导序列 $A \Rightarrow \alpha B \beta$ 中，如果 $\beta$ 推导出的字符串以终结符 $a$ 开头（即 $a \in FIRST(\beta)$），则序列变为 $\dots \alpha B a \dots$，证明 $a$ 可以紧跟在 $B$ 之后。

3. 左部继承规则：若 $A \rightarrow \alpha B$ 或 $A \rightarrow \alpha B \beta$（且 $\beta \Rightarrow \epsilon$），则 $FOLLOW(A) \subseteq FOLLOW(B)$

总结：如果 $B$ 位于产生式末尾，或者它后面的所有符号都能消失（推导出空串），那么凡是能跟在左部符号 $A$ 后面的，也一定能跟在 $B$ 后面。
证明：
- 针对 $A \rightarrow \alpha B$：假设 $a$ 跟在 $A$ 后面，推导为 $Aa \Rightarrow \alpha Ba$，此时 $a$ 显然也跟在 $B$ 后。
- 针对 $\beta \Rightarrow \epsilon$：若 $Aa \Rightarrow \alpha B \beta a$，由于 $\beta$ 可以变为空，推导最终变为 $\alpha B a$，证明 $a$ 也是 $B$ 的追随者。

第二步：构造预测分析表 $M$

根据产生式 $A \rightarrow \alpha$ 填表：

对 $First(\alpha)$ 中的每个终结符 $a$，把 $A \rightarrow \alpha$ 放入 $M[A, a]$。
若 $\epsilon \in First(\alpha)$，则对 $Follow(A)$ 中的每个终结符 $b$，把 $A \rightarrow \alpha$ 放入 $M[A, b]$。
判定：如果表中任何单元格都没有重定义（即一个格子里只有一条产生式），该文法就是 LL(1) 文法。

第三步：显式栈模拟句法分析

在考试中，通常要求你演示对输入串（如 babbb 或 adccd）的分析过程：

初始化：栈底为 $，栈顶为开始符号 $S$；输入串末尾加 $。
操作：
- 若栈顶是终结符且与输入匹配，则弹出并前进。
- 若栈顶是非终结符，查表 $M$，将栈顶替换为对应产生式的右部逆序入栈。
- 若栈顶与输入都是 $，则分析成功。

恍若隔世

此时已经忘了期中考了什么，之前学了什么。

所以先回忆正则和NFA和DFA的转来转去还有最小化这一块

最左/右推导，是从S->SS* 这个视角看的，把S这个串的最左侧/右侧的非终结符替换掉，而不是看串的最终形态。

然后就是左递归、语法树和 LL(1)，然后就没了

自底向上分析

归约：推导的逆过程，把串逐步还原成起始推导式子的过程。

移进：把输入的串压入分析栈的过程

句柄：归约时候的栈里面的与产生式匹配的那一段内容。也就是最有推导到这一步产生的内容

LR(0) / SLR(1)

LR(0) 分析法是自底向上（Bottom-up）语法分析家族的基础。“L”代表自左向右（Left-to-right）扫描输入串，“R”代表最右推导的逆过程（Rightmost derivation in reverse），“0”则表示在做分析决策时不参考任何向前看符号。

LR(0) 项目是在文法产生式的右部某个位置标有“·”的产生式。

“·”的含义： 表示分析过程中的状态。“·”之前的子串表示已经出现在分析栈顶的部分，“·”之后则是下一步希望看到的符号。
项目分类：
- 归约项目： 如 $A \to \alpha\cdot$，表示产生式右部已全部识别，可以进行归约。
- 待约项目（基本项目）： 如 $A \to \alpha\cdot B\beta$，表示后面紧跟的是非终结符。
- 移进项目： 如 $A \to \alpha\cdot a\beta$，点后面紧跟的是终结符。
特殊情况： 对于 $\epsilon$ 产生式（如 $A \to \epsilon$），其对应的项目仅有一个，即 $A \to \cdot$。

增广文法（Augmented Grammar）

为了让分析器能明确知道何时成功接受输入串，通常会对文法 $G[S]$ 增加一个产生式 $S’ \to S$。

初始项： $S’ \to \cdot S$。
接受状态： 当状态中包含 $S’ \to S\cdot$ 且输入符号为 $ 时，执行 accept。

闭包（Closure）与转向（Goto）

闭包运算 (closure)： 如果项目集 $I$ 中包含 $A \to \alpha\cdot B\beta$，且文法中有产生式 $B \to \gamma$，则必须将 $B \to \cdot\gamma$ 加入到项目集中，直到不再增加为止。
转向函数 (goto)： 定义了状态之间的转换。$goto(I, X)$ 表示当前状态为 $I$，当吃进文法符号 $X$（可以是终结符或非终结符）后，转到的新状态是所有 $A \to \alpha X \cdot\beta$ 项目及其闭包的集合。

LR(0) 的局限性：冲突

LR(0) 分析法功能较弱，容易在分析表中产生冲突，导致文法不是 LR(0) 文法：

移进-归约冲突： 某个状态既包含移进项目（如 $S \to d\cdot c$），又包含归约项目（如 $A \to d\cdot$），且无法仅凭栈顶状态决定动作。
归约-归约冲突： 某个状态包含两个及以上的归约项目，分析器无法决定用哪条产生式进行归约。

LR0总结构造过程：

先增广一个初始产生式，然后把所有的或都拆开成单独的推导，把所有的产生式编号为0,1,2,3…
先把S‘->S 写入作为状态 0，注意，如果点后面是非终结符那么需要把这个非终结符的所有初始项目（推导式最开始的状态）写在这个状态里面，这也就是闭包运算
下一步就是如何转移到其它状态，可以看前面的goto运算，就是吃进了终结符或者非终结符后的下一个状态，把点向右移动（移进），注意也要进行闭包操作
整体状态的编号类似bfs的顺序
最后画表格，列分别为状态、ACTION（终结符和$）、GOTO（非终结符），ACTION 下面表中sn表示状态，rn表示规约（n = 0,1,2,3…），acc表示接受，然后对于处于归约的状态，需要把这一行全部写上r，n就是产生式的编号，GOTO 下面只有数字表示状态，因为ACTION表示规约/移进动作，GOTO不执行只跳转

将LR0扩展为SLR1：

把所有非终结符的Follow集合列出来
对于LR0表格中的rn，如果相应推导式的Follow集合里面没有 ACTION 上面的终结符，那么就把它删掉，相当于不规约

LR(1) / LALR(1)

LR(k) 就相当于, A->ab, x1,x2,x3..,xk 这个推导式逗号后面有k个终结符

LR(1) 解决的是LR(0)中Follow集合可能过大的问题，即在某些前缀下Follow集合中的符号根本不可能出现。

前置处理：和之前完全一样，先增广一个初始产生式 S'→S，把所有 “或” 拆开成单独推导，所有产生式编号为 0,1,2,3…（增广产生式必须是 0 号）
核心差异：LR (1) 项目

格式：A→α·β, a（a 是单个终结符或 $，叫展望符）
含义：我已经识别了 α，接下来要识别 β；等我把 β 也识别完（圆点到末尾），只有当下一个输入符号正好是 a 时，我才用 A→αβ 归约
对比：LR (0) 项目没有展望符，相当于对所有符号都归约；SLR (1) 用全局 Follow (A) 当展望符；LR (1) 每个项目有自己的专属展望符

闭包运算（重点）

初始：把给定的 LR (1) 项目全部加入状态
规则：如果状态里有项目 A→α·Bβ, a（B 是非终结符）（α和β是什么都无所谓）
- 把 B 的所有产生式的初始项目 B→·γ 全部加进来（γ是什么也无所谓）
- 关键：给这些新项目计算展望符 = First (βa)：这个相当于如果β推不出空就是First(β) 可以推出空就是First(β) + a
递归：直到没有新项目可以加入为止
注意：为什么LR(1)这么傻逼就是因为这个First可能算出多个展望符，由于是LR(1)，逗号后面只能有一个，所以它竟然每一个展望符都要写到新的一行里面，这就是所谓的分裂出一坨，但是作业解析中的写法是展望符之间用/分割开就可以，这样看起来没那么占地方

goto 转移运算

第一步：和 LR (0) 完全一样，找到状态中所有圆点后是 X 的项目，把圆点向右移动一位
关键：移动后，原来的展望符原封不动保留
第二步：对移动后的所有项目，做上面的 LR (1) 闭包运算
结果就是转移后的新状态

构造所有状态

初始状态 0 = closure ({S'→·S, $})（注意初始展望符必须是 $！）
整体状态编号完全按照 BFS 顺序，和之前一模一样
去重规则：只有当两个状态的所有项目（包括展望符）都完全相同时，才认为是同一个状态

表格（只有归约规则变了）

表格结构完全不变：列是状态、ACTION（终结符和 $）、GOTO（非终结符）
ACTION 表符号含义完全不变：sn= 移进，rn= 归约，acc= 接受
移进规则：和 LR (0)/SLR (1) 完全一样
归约规则）：
- 如果状态里有归约项目 A→α·, a（产生式编号 k）
只在 ACTION [i,a] 这一个格子里写 rk，其他格子什么都不写（对比：LR (0) 整行写 r；SLR (1) 给 Follow (A) 里的所有符号写 r）

显然LR(1)太繁琐了，所以LALR(1)诞生了：

项目核心：LR (1) 项目去掉其展望符部分后剩余的 LR (0) 项目

同心集：LR (1) 项目集规范族中，项目核心完全相同，仅展望符集合不同的项目集。

合并规则：

核心合并规则：同心集的项目核心集完全一致，合并后新的项目核心集与原核心集相等，无新增核心项目。
展望符合并规则：对同一核心项目在各同心集中的展望符集合取并集，作为合并后该核心项目的展望符集合。
GOTO 函数合并规则：若状态 I、J 合并为 I’，则对任意文法符号 X，goto(I', X) 为 goto(I, X) 与 goto(J, X) 的合并结果（由同心集的同态性保证其目标必为同心集）。

总结

特性	LR(0)	SLR(1)	LR(1)	LALR(1)
项目格式	`A→α·β`	`A→α·β`	`A→α·β, a`	`A→α·β, {a1,a2,...}`
状态数量	少	和 LR (0) 相同	多（通常是 LR (0) 的 2-3 倍）	和 LR (0) 相同
归约依据	全局归约	全局 Follow (A)	局部单个展望符	局部展望符集合
冲突解决能力	无	解决大部分移进 - 归约冲突	解决所有合理冲突	解决大部分冲突，可能引入归约 - 归约冲突

语法制导翻译

这一块的内容就是语法分析后，加上语义操作

语法制导定义(Syntax-Directed Definitions, SDD)

语法制导翻译方案(Syntax-Directed Translation schemes， SDT)：

综合属性：结点 N 的属性值由其子结点或其自身的属性计算得出

继承属性：结点 N 的属性值由其父结点、兄弟结点或其自身的属性计算得出

lexval: 它是一个关联在终结符号（Terminals）上的综合属性。其具体数值是由**词法分析器（Lexical Analyzer）**在扫描源程序并识别出Token时提供的，类似字符串转实际的值

如果一个SDD的每个属性都是综合属性，则它是S属性的。可以按照分析树的自底向上顺序来计算各属性值

一个语法制导定义是L属性定义，如果任意一条产生式A → X1X2 … Xj… Xn，其右部符号Xj的继承属性仅依赖于

产生式中Xj的左边的符号X1, X2 ,… Xj-1的属性；
A的继承属性。

L属性定义对综合属性没有限制。显然，所有的S属性定义都是L属性定义

SDD 的语义规则是无顺序的，需要你自己画注释语法分析树来找拓扑排序

SDT 则是把{xxxx}这种代码插入产生式中间，这样就自带顺序，SDD转SDT要注意，插入的式子中所有用到的的属性一定要已经得出。

中间代码生成

DAG：相比于注释语法分析树更加化简，体现在如果有相同的元素被用到那就用之前的而不是新建一个

后缀表示：如 a + b -> a b +

三地址码：

L 为行号或者标记

x = y op z        // arithmetic and logical (算术与逻辑运算)
x = op y         // negation and conversion (一元运算与类型转换)
x = y            // copy (复制赋值)

goto L           // unconditional jump (无条件跳转)
if x goto L      // conditional jump (条件为真跳转)
ifFalse x goto L // conditional jump (条件为假跳转)
if x op y goto L // relational operation (关系运算条件跳转)

param x1         // parameter passing (参数传递)
param x2
...
param xn
call p, n        // procedure call (过程调用，无返回值)
y = call p, n    // function call (函数调用，有返回值)
return y         // return a value (返回值)


x = y[i]         // indexed copy, i is the offset (数组元素读取，i为偏移量)
x[i] = y         // 数组元素写入

x = &y           // address and pointer assignment (取地址与指针赋值)
x = *y           // 指针解引用读取
*x = y           // 指针解引用写入

三地址码的具体表现存储形式：

四元式：(op, arg1, arg2, result)

序号	op	arg1	arg2	result
0	*	b	c	t1
1	+	a	t1	t2
2	/	d	e	t3
3	-	t2	t3	t4
4	=	t4	null	x

三元式：每条指令由3 个字段组成，没有专门的 result 字段 (op, arg1, arg2)

序号	op	arg1	arg2
0	*	b	c
1	+	a	(0)	// (0) 表示引用序号为 0 的三元式的结果
2	/	d	e
3	-	(1)	(2)
4	=	x	(3)	// 赋值运算的 arg1 是目标变量，arg2 是源

间接三元式：为了解决三元式的位置相关性问题，增加了一个间接码表

如果代码中出现两次b * c，三元式表中只需要存储一次：

序号	三元式序号
0	0	// 第一次计算 b*c
1	1
2	0	// 第二次直接引用已有的三元式 0
3	2

序号	op	arg1	arg2
0	*	b	c	// 只存一次
1	+	a	(0)
2	+	d	(0)

回填：是一种在中间代码生成过程中，用于处理跳转地址未知的指令的技术。它主要为了实现一遍扫描（One-pass）翻译。

“回填”不使用继承属性，只使用综合属性！

回填技术依赖于三个核心操作：

makelist(i)：创建一个新列表，其中只包含指令序号 i。返回指向该列表的指针。

merge(p1, p2)：将两个回填列表 p1 和 p2 合并为一个，返回合并后的列表指针。

backpatch(p, i)：核心回填操作。将具体的语句地址 i 填入列表 p 中所有指令的跳转目标域。

关键属性与变量truelist 和 falselist：布尔表达式 B 的两个综合属性，分别记录当 B 为真或为假时，需要回填的跳转指令列表。

nextlist：语句 S 的综合属性，记录在该语句执行完后，需要跳过后续代码的跳转指令列表。

nextinstr：全局变量，记录下一条即将生成的四元式指令序号。

标记非终结符 M：用于在产生式中捕获当前指令序号。规则为M→ϵ{M.instr=nextinstr;}。

分布式事务

ldfd@outlook.it (ldfd) — Mon, 13 Apr 2026 20:43:32 +0800

前言

我说分布式事务是屎有没有懂得。就不该存在这种东西。

一个业务操作涉及多个独立系统/数据库，需要保证数据一致。

强一致

2PC（Two-Phase Commit）：直译两阶段提交

阶段1：Prepare

协调者问所有参与者：能不能提交？
每个节点锁资源并返回 yes/no

阶段2：Commit

如果全部 yes → 提交
如果有一个 no → 回滚

这个可以保证强一致性，不过在没有commit之前的时候，事务会把所有的资源锁住，有着阻塞的性能差的问题。而且如果出现了单点故障，其它的服务也会白白地浪费一次。

3PC：多加了一个看参与者挂没挂地操作

阶段1：CanCommit（询问阶段）

参与者只做检查（不执行、不锁资源）

阶段2：PreCommit（预提交）

执行事务
写 undo/redo 日志
锁资源
但不提交

阶段3：DoCommit 真正提交

最终一致

TCC（Try-Confirm-Cancel）：主要体现在不依靠数据库的事务

三阶段：

Try：预留资源（不真正提交）
Confirm：真正执行
Cancel：回滚

特点：

业务侵入强
可控性高

这个就时相当于完全地业务写回滚代码了。

本地消息表 + 异步补偿：

这个应该就是outbox模式，先落库再发消息，不过落库就已经影响性能了。

RocketMQ事务消息：

Producer → Broker：发送 Half Message

Producer：执行 DB 操作（下单）

Producer → Broker：commit / rollback

Consumer → 消费消息（扣库存）

Saga模式：把一个大事务拆成多个本地事务，如果失败就执行补偿

TCC示例

库存表（stock）
- sku_id
- total_stock
- available_stock
- reserved_stock

预留记录表（reservation）
- tx_id            // 全局事务ID（幂等键）
- sku_id
- user_id
- quantity
- status           // TRYING / CONFIRMED / CANCELED
- expire_at        // 预留过期时间（兜底释放）
- created_at
- updated_at

interface SeckillTccService {
    boolean tryReserve(String txId, Long userId, Long skuId, int qty);
    boolean confirm(String txId);
    boolean cancel(String txId);
}

try

@Transactional
boolean tryReserve(String txId, Long userId, Long skuId, int qty) {
    // 1. 幂等控制：如果已存在记录，直接返回（避免重复Try）
    Reservation r = reservationDao.findByTxId(txId);
    if (r != null) {
        if (r.status == CONFIRMED) return true;     // 已完成
        if (r.status == CANCELED) return false;     // 已取消（反悬挂保护）
        return true;                                // TRYING 重入
    }

    // 2. 反悬挂：若已经被Cancel标记过（比如先到Cancel后到Try）
    if (reservationDao.existsCanceled(txId)) {
        return false;
    }

    // 3. 扣减可用库存、增加预留库存（原子更新，防超卖）
    int updated = stockDao.tryReserve(skuId, qty);
    // SQL 示意：
    // UPDATE stock
    // SET available_stock = available_stock - ?, reserved_stock = reserved_stock + ?
    // WHERE sku_id = ? AND available_stock >= ?

    if (updated == 0) {
        return false; // 库存不足
    }

    // 4. 写预留记录（状态：TRYING）
    reservationDao.insert(new Reservation(
        txId, userId, skuId, qty, TRYING, now()+TTL
    ));

    return true;
}

confirm

@Transactional
boolean confirm(String txId) {
    Reservation r = reservationDao.findByTxId(txId);
    if (r == null) {
        // 允许空Confirm：可能Try未执行成功（幂等设计）
        return true;
    }

    if (r.status == CONFIRMED) return true;   // 幂等
    if (r.status == CANCELED) return false;   // 已取消

    // 1. 从预留转已售（减少 reserved，不回加 available）
    stockDao.confirm(r.skuId, r.quantity);
    // SQL 示意：
    // UPDATE stock
    // SET reserved_stock = reserved_stock - ?
    // WHERE sku_id = ? AND reserved_stock >= ?

    // 2. 更新状态
    reservationDao.updateStatus(txId, CONFIRMED);

    return true;
}

cancel

@Transactional
boolean cancel(String txId) {
    Reservation r = reservationDao.findByTxId(txId);

    // 1. 空回滚（Try 还没执行或失败）
    if (r == null) {
        // 记录一个“已取消占位”，防止后续Try（反悬挂）
        reservationDao.insertCanceledMarker(txId);
        return true;
    }

    if (r.status == CANCELED) return true;     // 幂等
    if (r.status == CONFIRMED) return true;    // 已确认，不再回滚

    // 2. 释放预留库存
    stockDao.release(r.skuId, r.quantity);
    // SQL 示意：
    // UPDATE stock
    // SET available_stock = available_stock + ?, reserved_stock = reserved_stock - ?
    // WHERE sku_id = ? AND reserved_stock >= ?

    // 3. 更新状态
    reservationDao.updateStatus(txId, CANCELED);

    return true;
}

Ai相关

ldfd@outlook.it (ldfd) — Mon, 13 Apr 2026 20:19:32 +0800

上下文限制

此处主要讨论coding情境下的上下文。

首先最粗暴的就是换一个大上下文的模型。

分块处理，将超长输入分割成多个chunk，每次调用模型时只输入一个块及必要上下文前后文，有时还会对前后块生成内容进行合并或摘要。在代码场景则为采用 AST（抽象语法树）感知分块。

摘要，就是用llm对上下文进行总结，这种只适合文档这一类的。具体的code如果摘要应该会失真。可以用来作为索引，生成一个md指示哪些文件是干什么的。

RAG。通过向量数据库，进行检索。当然代码向量检索肯定是不准确的，所以可以：

代码符号必须走精确匹配（BM25），只有自然语言注释走向量检索。
把代码的 AST 和调用关系存进图数据库，直接在图上遍历边。
使用IDE的LSP（Language Server Protocol），类似于传统的方法。
认为llm很聪明，可以通过grep自己来搜索关键词并反思。

增量编译/差分补丁。使用git diff，仅分析变更部分。当然这个肯定需要知道整个函数长啥样

最佳实践（Diff + Context）：

拿到当前文件的 Diff。
自动向上追溯：找到 Diff 所在的函数签名、所在的类定义。
自动向外追溯：如果 Diff 里调用了外部接口，把接口的类型定义也捞进来。
将【小范围原始代码 + Diff + 追溯的必要上下文】打包发给模型。

Harness

Harness其实就是限制agent的实现路径，不过工程实践百花齐放，所以众说纷坛，根本看不懂。

这里我们跟随万恶的Claude博客分析一波。

Effective harnesses for long-running agents

这个是最早的一篇文章，甚至是2025年的。文章主要讨论了，agent面对长期大任务的问题。总结如下

问题	初始化代理行为	编码代理行为
过早宣布胜利	建立结构化的 JSON 功能列表文件。	会话开始时读取列表，仅选择一个未完成的功能点。
环境混乱/进度不明	初始化 Git 仓库和进度记录文件。	读取 Git 日志和进度文件；结束后提交 Git 记录并更新进度。
功能标记草率	设定明确的功能验收标准。	必须通过自动化工具进行自验证，通过测试后方可标记“完成”。
启动应用困难	编写 `init.sh` 脚本用于启动开发服务器。	会话开始首先运行脚本。

简而言之就是给agent一个todo list，然后用git控制版本，明确通过测试验收，还要保证能够轻松跑起来（类似人类配置环境的痛苦）。(注意此时的需求拆解是人写的，下一篇文章提出用ai写，即planner)

拆解可以像传统软件工程一样拆解成feature story task，随着模型能力增强，拆解的颗粒度可以越来越粗。

Harness design for long-running application development

本文虽然也是Harness但是解决的问题不同，主要是上下文焦虑（临近限制时降低质量），自我评价偏差（自恋写生成的内容）。但是自恋这一块主要是前端的问题，也就是现在的ai前端同质化的情况。

上下文部分：

自动压缩 (Compaction)： 像是在同一个大脑里不断梳理记忆，减掉细枝末节，但身份和连续性不变。它更简单、延迟低，但在旧模型上可能无法彻底消除“接近上限时的焦虑感”。

上下文重置 (Context Resets)： 像是“换班”。旧 Agent 把工作写成**交接文档（Handoff Artifact）**交给新 Agent，然后旧窗口彻底清空。这能提供最干净的逻辑起点，但增加了编排的复杂性和 Token 开销。

自我评价部分：

模拟 GAN 的“生成者-评估者”循环

借鉴生成对抗网络 (GAN) 的思路，作者设计了一个双智能体结构：

生成者 (Generator)： 负责编写代码。
评估者 (Evaluator)： 使用 Playwright MCP 实际运行页面、进行交互和截图，并根据预设的客观标准（如：设计质量、原创性、工艺、功能性）进行无情的批判。
效果： 这种循环迫使模型跳出“AI 样板风”的舒适区。在实验中，模型甚至能从普通的网页设计飞跃到极具创意的 3D 空间交互体验。

全栈开发的“三剑客”模式

针对更复杂的全栈任务（如开发一个复古游戏制作工具或数字音频工作站 DAW），系统演进为三个角色：

规划者 (Planner)： 将简短的需求扩展为详细的产品规格书，并主动加入 AI 功能建议。
执行者 (Generator)： 按功能模块进行“冲刺阶段 (Sprints)”开发，并使用版本控制。
质量保证 (Evaluator/QA)： 模拟用户操作，查找 API 匹配错误、UI 逻辑漏洞等细节。

技术选型

ldfd@outlook.it (ldfd) — Sat, 11 Apr 2026 21:38:20 +0800

前言

做个demo愿意用啥用啥呗，非得问我怎么选择，说白了我直接让ai不到一天就能换一个中间件，我也没啥历史的重担。但是我们以长远的眼光来看，万一你成架构师了呢。

DDD

DDD作为一个比较新，又没那么新的东西。首先就是老生常谈的高内聚和低耦合，通过充血对象，把一堆repository注入到bo，来让bo自己去实现校验、状态转移、业务行为等。

我们先来看一下它的目录长什么样（虽然这然很直观，但是事实上正确理解DDD应该从业务作为起点）

适配器层

adapter/
├─ controller/          # 接口控制器（RESTful，适配前端请求）
│  ├─ OrderController.java       # 订单核心接口（创建、支付、取消等）
│  └─ OrderQueryController.java  # 订单查询接口（单独拆分，区分命令/查询）
├─ dto/                 # 数据传输对象（入参，适配外部入参格式）
│  ├─ OrderCreateDto.java
│  └─ OrderPayDto.java
├─ vo/                  # 视图对象（出参，专门给前端展示使用）
│  ├─ OrderDetailVo.java
│  └─ OrderPageVo.java
└─ converter/           # DTO/Vo <-> 领域模型
   └─ OrderConverter.java

应用层

application/
├─ service/             # 应用服务（对外提供可调用的业务能力）
│  ├─ OrderApplicationService.java  # 订单核心流程（创建订单、支付订单等）
│  └─ OrderQueryApplicationService.java # 订单查询流程（分页、详情）
├─ command/             # 命令对象（封装“执行操作”的请求，对应领域命令）
│  ├─ CreateOrderCommand.java
│  └─ PayOrderCommand.java
└─ event/               # 应用层事件相关（订阅领域事件，触发跨上下文/跨聚合逻辑）
   └─ listener/         # 领域事件监听器
      ├─ OrderPaidEventListener.java  # 监听订单支付事件，触发库存、积分逻辑
      └─ OrderCanceledEventListener.java

领域层

domain/
├─ bo/                  # 业务对象（封装业务逻辑、业务属性，核心业务载体）
│  ├─ OrderBo.java      # 订单BO（包含订单业务逻辑、属性，如取消、支付判断）
│  ├─ OrderItemBo.java  # 订单明细BO
│  └─ CouponBo.java     # 优惠券BO（业务相关实体）
├─ service/             # 领域服务（封装核心业务逻辑，操作BO）
│  └─ OrderDomainService.java  # 订单领域服务（如：订单履约校验、取消规则判断）
├─ event/               # 领域事件（业务事实，由BO触发发布）
│  ├─ OrderCreatedEvent.java   # 订单创建事件
│  ├─ OrderPaidEvent.java      # 订单支付事件
│  └─ OrderCanceledEvent.java  # 订单取消事件
├─ repository/          # 仓储接口（抽象，定义BO/PO的持久化操作，不关心实现）
│  └─ OrderRepository.java     # 订单仓储接口（增删改查、BO与PO转换）
└─ specification/       # 领域规格（封装复杂查询/校验规则，如：订单可取消规格）
   └─ OrderCancelSpecification.java

设施层

infrastructure/
├─ repository/          # JPA仓储实现（实现领域层仓储接口，基于JPA完成持久化）
│  └─ impl/
│     └─ OrderRepositoryImpl.java  # 订单JPA仓储实现（继承JpaRepository，操作PO）
├─ po/                  # 数据库实体（与领域层PO一致，添加JPA注解，用于ORM映射）
│  ├─ OrderPo.java      # 订单PO（添加@Entity、@Id等JPA注解）
│  └─ OrderItemPo.java  # 订单明细PO（添加JPA注解）
└─ config/              # 基础设施配置（JPA配置、数据库配置等全局配置）
   ├─ JpaConfig.java    # JPA核心配置（指定实体扫描、方言等）
   └─ DataSourceConfig.java  # 数据源配置

最后还可以加个common

common/
├─ constant/            # 全局常量
│  ├─ OrderConstant.java
│  └─ EventConstant.java
├─ exception/           # 全局异常（区分业务异常、系统异常）
│  ├─ BusinessException.java  # 业务异常（如：订单不可取消）
│  └─ GlobalExceptionHandler.java  # 全局异常处理器
├─ util/                # 通用工具

最后，我没用过纯的DDD架构，事实上也没人知道DDD架构是什么样子的，准确的来讲DDD风味架构更适合大家。

最后用一个订单支付来体验一下纯的ddd流程。

接口层请求(PayDTO) 
→ 应用层服务(OrderPayService)
  → 调用OrderRepository（领域接口）加载聚合Order
    → Order(BO/聚合根).pay()：校验规则 + 改状态 + 生成OrderPaid领域事件
  → 应用层保存Order（通过Repository）
  → 发布领域事件OrderPaid
→ 事件监听器监听事件
  → 执行后续业务（扣库存/发通知/积分等）

其中最关键的就是bo的pay没有真的pay，而是生成了一个cmd到service层来让它再去调用支付。

这就体现出来依赖倒置：接口层 → 应用层 → 领域层 ← 基础设施层

消息队列

先来一个酣畅淋漓的AI表格总结一手。

指标	RabbitMQ	Kafka	RocketMQ
吞吐量	中等（10K-50K TPS）	极高（100K+ TPS，单机百万级）	高（50K-100K TPS）
延迟	低（微秒级，最佳约 50μs）	较高（毫秒级，批处理设计）	低（毫秒级，平衡吞吐与延迟）
消息堆积能力	强（适合中小规模堆积）	极强（海量日志 / 数据，分层存储）	强（支持百亿级消息堆积）
顺序消息	单队列严格顺序	分区内顺序	全局顺序 / 分区顺序

如果简而言之给出一个爆论那就是 Java 就用 rocketmq 大数据就用kafka。可是悲剧的是当时我一懒，用的rabbitmq，那如果问我技术选型怎么回答呢。

RabbitMQ 部署简单、API 友好，开发效率高，适合快速搭建项目原型，消息确认、持久化、死信队列这些功能开箱即用，足够支撑秒杀业务。然我也了解，在真实生产环境里，Java 电商 / 金融类业务更常用 RocketMQ，它在事务消息、顺序消息、大规模堆积上更有优势；如果是日志采集、流计算场景会用 Kafka。

当然这就给自己挖坑了，就该问你这仨架构，然后分布式事务，幂等，然后就寄了。

数据库

MySQL vs PostgreSQL 你们知道吗，但是好像Oracle牛逼。

但是如果问你为啥用PostgreSQL呢？如果你干巴巴地说你觉得PostgreSQL牛逼，性能屌，他又开始说你瞎选没有理解了。

所以我们跟他扯一点东西，让他觉得我好像真懂点。

JSON/JSONB 这个绝对可以把，直接把mongodb的市场抢占了
uuid_generate_v4()：这就可以扯到为什么PG可以用uuid作为主键了
原本想说开窗函数啥的，后来发现这个高版本MySQL也支持了
依旧秒杀：FOR UPDATE SKIP LOCKED，然后主键id不同，goodId相同，这样的话相当于把good拆成几分，然后跳过锁上的。
UNLOGGED TABLE：这个抽象吧，直接当缓存用了，就是不用WAL日志

JVM

ldfd@outlook.it (ldfd) — Sun, 01 Feb 2026 11:49:20 +0800

JVM（Java Virtual Machine，Java虚拟机）是Java程序“一次编写，到处运行”这一特性的实现者。

JVM 主要由四个子系统组成。

类加载子系统 (Class Loader Subsystem): 负责将硬盘上的 .class 文件加载到内存中。
运行时数据区 (Runtime Data Areas): 也就是我们常说的“JVM 内存”，用于存储数据和中间结果。
执行引擎 (Execution Engine): 负责解释命令，提交给操作系统执行。包含解释器、 JIT 编译器和垃圾回收器(GC) 。
本地库接口 (Native Interface): 融合不同编程语言为 Java 所用（通常是 C/C++）。那我为啥不用python？

类加载子系统

流程

它的核心职责包括：

加载（Loading）：查找并读取类的二进制数据(.class)
连接（Linking）：验证、准备、解析类
初始化（Initialization）：执行类初始化逻辑

.class文件为二进制文件，里面包含0xCAFEBABE这个魔数，版本号，常量池，访问标志，代码等等。经过一番研究发现.class虽然与汇编代码样似，但是实际上根本不一样，因为class根本不是让人看的，汇编人类还是可以编写的，但不会有正常人编写class。所以了解即可，除非你干的是逆向。我们最多用到javap -c xxx.class看一些编译器的优化操作，而java -c -v xxx.class则是过于繁琐。

类的完整生命周期（注意所有的类都会连接，但是只有被触发的类才会走到初始化这一步）

`1`	`加载 → 连接 (验证 → 准备 → 解析) → 初始化 → 使用 → 卸载`

从加载到初始化归类加载子系统负责，

加载就是将字节码形态的.class装载到JVM内存里面，字节码可以既可以来自本地，也可以来自网络和动态代理。

连接分为验证安全性，为静态变量分配内存并附上默认值（并非类自定义的值），将符号引用(字符串形态)解析为直接引用(内存地址、偏移量)。

初始化：

<clinit>（class initialization method）：

由 javac 编译器自动生成
用于完成 类级别初始化
只负责：
- static 变量的显式赋值
- static {} 静态代码块
在 类初始化（Initialization）阶段由 JVM 调用
一个类最多只有一个 <clinit> 方法

初始化触发条件：

new 创建对象
访问 static 非 final 变量
调用静态方法
反射调用
JVM 启动主类
子类初始化，父类先初始化

实现

JVM 内置类加载器：

Bootstrap ClassLoader: 祖宗级。用 C++ 写的，加载核心库（rt.jar，如 String, System）。Java 代码无法直接获取它。
Extension/Platform ClassLoader: 父级。加载扩展库。（属于历史遗留问题，现在的maven和gradle已经很好地管理第三方库了）在Java8中ExtClassLoader加载JAVA_HOME/lib/ext所有的库，而Java9+中则变为PlatformClassLoader加载<JAVA_HOME>/jmods，但是仅限 JDK 内置模块和仅加载官方签名模块。
Application ClassLoader: 应用级。加载 classpath 下你自己写的类。

双亲委派模型 (Parent Delegation Model)：

注意这个双亲和数据结构一个问题，都是政治正确导致的中性词语，本质上仍为上下级、父子这种一一相对的关系，parent也并未parents，双亲只是一个很烂容易误导初学者理解的翻译。

总结起来这个就是为了安全，防止篡改核心库的类加载设计，一切加载先交给父加载器，失败再回退到当前加载器。

运行时数据区

也就是我们常说的JVM内存，OOM警告！

┌──────────────────────┐
│   程序计数器（PC）      │ 线程私有
├──────────────────────┤
│   虚拟机栈             │ 线程私有
├──────────────────────┤
│   本地方法栈           │ 线程私有
├──────────────────────┤
│   Java 堆            │ 线程共享
├──────────────────────┤
│   方法区              │ 线程共享
└──────────────────────┘

关键划分原则：是否线程私有 (感谢ai大人的古法ascii画图)

想必都学过计组，PC就是那个PC：执行 Java 方法 → 存字节码行号执行 Native 方法 → 值为 Undefined

虚拟机栈就是类似汇编的PROC区域 本地方法栈也是个傻逼翻译，native method，就是非java语言的，c，cpp写的方法在 HotSpot 虚拟机中，直接就把本地方法栈和虚拟机栈合二为一了。

Java堆，就是最大的一坨内存，用来存放对象实例。 分代架构（经典版）：为了高效回收，堆被划分为：

新生代 (Young Generation)：
- Eden 区：大部分对象出生的地儿。
- Survivor 区 (S0/S1)：经历过 GC 幸存下来的对象存放地。
老年代 (Old Generation)：存放生命周期长、大的对象。

方法区:它用于存储已被虚拟机加载的类型信息、常量、静态变量、即时编译器编译后的代码缓存等数据。（JDK7-为“永久代 (Permanent Generation)”使用堆内存，JDK8+为“元空间 (Metaspace)”，直接使用本地物理内存）

最后补充一下Java堆和物理内存的区别，JVM只是内存的“二房东”。提前划分好一块，然后自己搞GC，不让操作系统参与。

执行引擎

解释/编译

解释器：将字节码转换为机器码，启动快，无需编译

JIT 编译器 (Just-In-Time Compiler)：A. 热点探测 (Hot Spot Detection)

JVM 会监控代码的运行情况。如果某段代码（一个方法或一个循环体）运行频率非常高，就会被标记为**“热点代码”**。
编译优化 JIT 会把这些“热点代码”直接编译成本地机器指令，并存在内存的 Code Cache （就是在内存里面的一块，不是在java堆里面）中。下次执行时，CPU 直接跑机器码，速度接近 C/C++。
C1 与 C2 编译器现代 JVM（HotSpot）内置了两个 JIT 编译器：

C1 (Client Compiler): 优化简单，耗时短。追求启动速度和基本的优化。
C2 (Server Compiler): 耗时长，但优化极深。它会根据代码运行的统计信息进行激进优化（如逃逸分析）。

逃逸分析：如果一个对象只在当前方法内部使用，且没有返回，也没有赋值给外部变量，那它就是“不逃逸”的。

如果不逃逸会优化：

栈上分配 (Stack Allocation)

优化： 既然对象只在方法里用，执行引擎直接在**栈（Stack）**上分配内存。
好处： 方法执行完，栈帧弹出，对象直接消失。完全不需要 GC 介入，性能极大提升。

标量替换 (Scalar Replacement)

概念： “标量”是指不可再拆分的数据（如 int, long 等基本类型）。“聚合量”是指可以拆分的对象（如包含 x, y 坐标的 Point 对象）。
优化： 如果一个对象不会逃逸，执行引擎可能根本不创建这个对象，而是把这个对象拆解掉，将其成员变量恢复成原始的局部变量存放在栈上。
好处： 节省了对象头（Object Header）的内存消耗（通常 12-16 字节），且基本类型的操作效率比对象高得多。

同步消除 (Lock Elision / Lock Coarsening)

优化： 如果执行引擎发现一个同步锁对象（synchronized）只会在当前线程内被访问，不可能被其他线程竞争。
好处： 执行引擎会直接把锁删掉。因为单线程环境下的加锁、解锁是纯粹的性能浪费。

垃圾回收

最常被问到的GC。垃圾回收（GC）主要回收 JVM 堆（Heap），元空间也有很小概率会被回收，废弃常量和无用的类会被回收，但是无用的类很难被满足（不如好好想想加大元空间大小）。

JVM 不使用引用计数法（引用为0则删除），而是使用 可达性分析算法

基本原理：从一系列被称为 “GC Roots” 的根对象开始，像走迷宫一样向下搜索。如果一个对象到 GC Roots 没有任何引用链相连，就说明这个对象是不可达的，即为垃圾。

哪些可以作为 GC Roots？

虚拟机栈（栈帧中的局部变量表）引用的对象。
方法区中类静态属性、常量引用的对象。
本地方法栈中 JNI（Native方法）引用的对象。
所有被同步锁（synchronized）持有的对象。

清理垃圾策略：

标记 - 清除 (Mark-Sweep)：把垃圾标记出来，直接原地抹掉。缺点：会产生大量的内存碎片。
标记 - 复制 (Mark-Copying)：把内存分成两块，每次只用一块。清理时，把活着的对象全部“搬家”到另一块，剩下的全清空。优点：没有碎片，速度极快。缺点：浪费空间，始终有一半内存是空着的。
标记 - 整理 (Mark-Compact)：标记后，让所有存活对象都向内存的一端移动，然后直接清理掉边界以外的内存。优点：没有碎片，也不浪费空间。缺点：移动对象很费劲，需要更新所有指向这些对象的指针，效率较低。

分代回收：

JVM 发现，绝大多数 Java 对象都是“短命鬼”（比如方法里的临时变量），而极少数对象（如连接池、Spring Bean）能活很久。

于是，堆内存被划分为 新生代 和 老年代，采用不同的策略：

新生代 (Young Generation) —— “高频清理”

特点：对象死得快，存活率低。
结构：Eden 区 + 两个 Survivor 区 (S0, S1)，默认比例 8:1:1。
策略：采用 复制算法。
- 新对象在 Eden 出生。
- Minor GC 时，把 Eden 和 S0 里的活口扔进 S1，清空 Eden 和 S0。
- 对象每横跳一次，年龄 +1。
- 当S0空的时候，Minor GC就会把活口扔进 S1，清空 Eden 和 S1，实现左右横条

注：Eden为伊甸园的意思 Minor GC在Eden满的时候触发

老年代 (Old Generation)

特点：对象生命周期长，空间大。
策略：采用 标记-整理 或 标记-清除 算法。
晋升机制：对象年龄达到阈值（默认 15）或者对象太大（大数组），直接进入老年代。当老年代满了，触发 Major GC / Full GC。

Full GC 触发（整堆回收，含新生代 + 老年代 + 元空间）：老年代/元空间空间不够，新生代晋升老年代失败等

Major GC 触发（仅老年代回收）：老年代占用达到阈值，大对象 / 大量对象直接进入老年代导致空间紧张，多次 Minor GC 后对象持续晋升，老年代逼近上限

注：元空间虽然不在java堆，但是满了也会触发Full GC是想通过类卸载来释放元空间

垃圾回收器

Parallel GC：追求最高吞吐量

Minor GC（新生代回收）：

STW 暂停应用程序线程。
从根节点（GC Roots，包括线程栈、静态变量等）开始，多线程并发标记存活对象。
使用复制算法，将存活对象从 Eden 区复制到 Survivor 区。
清空 Eden 区和已使用的 Survivor 区。
恢复应用程序线程。

Full GC（老年代回收，通常伴随 Minor GC）：

STW 暂停应用程序线程（暂停时间较长，可能数百毫秒至秒级）。
多线程并发标记所有存活对象（标记 - 整理 算法）。
标记阶段：从 GC Roots 追踪存活对象。
整理阶段：将存活对象压缩到内存一端，消除碎片。
清空剩余空间。
恢复应用程序线程。

CMS（Concurrent Mark Sweep）针对老年代设计，旨在减少暂停时间。

Minor GC（新生代回收，使用 ParNew）：

STW 暂停应用程序线程。
多线程从 GC Roots 标记存活对象。
使用复制算法，将存活对象从 Eden 区复制到 Survivor 区。
清空 Eden 区和已使用的 Survivor 区。
恢复应用程序线程。

Major GC（老年代回收）：

初始标记（STW）：短暂暂停，标记 GC Roots 直接引用的对象。
并发标记：应用程序继续执行，多线程从初始标记的对象追踪所有存活对象。
重新标记（STW）：短暂暂停，修正并发标记期间的引用变化（使用增量更新机制）。
并发清除：应用程序继续执行，清除标记为垃圾的对象（不进行内存整理，导致碎片）。
如果碎片过多，可能触发 Full GC（退化为 Serial Old 的单线程 标记 - 整理 算法）。

当然如果你一想就会发现CMS很逆天，Full GC既然已经STW了，为什么还要用Serial Old呢，明明这个也会STW为什么不并行整理呢，事实上这就是没人原因维护这个屎坑了， ParOld在JDK1.6+才有。其设计哲学就是低停顿，但是都已经沦落到Full GC就证明设计失败了，所以就直接摆烂了，这种设计被弃用还是普大喜奔的。

注意：CMS 已于 JDK 14 移除，不推荐新项目使用。

G1 GC 执行过程

G1（Garbage-First）将堆分为多个 Region（通常 1-32MB），逻辑上分代（Eden、Survivor、Old），回收优先处理垃圾最多的 Region。过程包括年轻代回收和混合回收，支持暂停时间目标控制。

Young GC（年轻代回收）：

STW 暂停应用程序线程（通常数十至数百毫秒）。
多线程从 GC Roots 标记存活对象。
使用复制算法，将存活对象从 Eden 和 Survivor Region 复制到新的 Survivor 或 Old Region。
清空原 Eden 和 Survivor Region。
恢复应用程序线程。

Concurrent Marking Cycle（并发标记周期，用于老年代准备）：

初始标记（STW，通常借用 Young GC 完成）：标记 GC Roots 直接引用的对象。
根区域扫描（并发）：扫描 Survivor Region 中的根引用。
并发标记：应用程序继续执行，多线程追踪所有存活对象，记录跨 Region 引用（使用 Remembered Set）。
重新标记（STW）：修正并发标记期间的引用变化（使用 Snapshot-At-The-Beginning）。
清理（STW）：计算每个 Region 的存活率，更新统计信息。

Mixed GC（混合回收，包含年轻代和部分老年代 Region）：

STW 暂停应用程序线程。
选择垃圾最多的 Region（基于优先级）。
多线程复制存活对象到新 Region（整理碎片）。
清空原 Region。
恢复应用程序线程（可能分多次 Mixed GC 以控制单次暂停）。

ZGC 执行过程（分代模式，JDK 21+ 默认）

ZGC（Z Garbage Collector）设计为低暂停收集器，使用着色指针（Colored Pointers）和读屏障（Load Barriers）实现并发回收。JDK 21 后引入分代，支持年轻代和老年代独立回收，暂停时间通常 <10ms。

Generational Minor GC（年轻代回收）：

STW 暂停（通常 <1ms）：根扫描，标记 GC Roots 引用的年轻代对象。
并发标记和重定位：应用程序继续执行，使用读屏障追踪和更新引用，将存活对象重定位到新地址（多视图内存映射）。
STW 最终标记（<1ms）：修正根引用。
清空原年轻代空间。

Generational Major GC（老年代/全局回收）：

STW 初始标记（<1ms）：标记 GC Roots 直接引用的对象。
并发标记：应用程序继续执行，使用读屏障和着色指针标记存活对象。
并发重定位准备：计算重定位集。
并发重定位：应用程序继续执行，重定位存活对象到新地址（读屏障确保引用更新）。
STW 最终重映射（<1ms）：更新根引用。
清空原空间。

ZGC有一些黑话术语听不懂，我也懒得听懂了，我还年轻

TODO

汇编

ldfd@outlook.it (ldfd) — Mon, 10 Nov 2025 10:00:23 +0800

前言

汇编是个干黑客的好东西，可惜我已经没时间好好学了😭，本文以8086典中典cpu，MASM和王爽经典教材进行学习。

环境配置

古老的是通过dosbox，然后从网上找到古老的并非自带的MASM的工具，然后挂载，通过外部编辑器来写代码，dosbox只负责编译和运行。（但是dosbox明明是用来玩dos游戏的）

现在也可以使用vscode配置对应的环境，但是我还不会。TODO

引入

8086是16位处理器，一共只有14个寄存器虽然还是记不住，但是比64位的那么多寄存器好记多了。

字(word)代表着处理器一次性处理数据的能力，在16位中 1个字=2个字节(Byte)=16位(Bit)，而在常见的64位中 1个字 = 8个字节 = 64位

通用寄存器

8086提供四个16位通用寄存器：AX、BX、CX 和 DX。每个寄存器可拆分为两个8位部分：高字节（H）和低字节（L），例如 AX = AH + AL（其中+表示拼接）。 8086采用小端（little-endian）字节序：当将16位值存入内存时，低字节（如 AL）存储在较低的内存地址，高字节（如 AH）存储在相邻的较高地址。但是说是通用其实还是有一定特定的用处的（约定俗成那种）只不过是还可以随便用，详见英文名字。

AX = AH + AL ：Accumulator
BX = BH + BL：Base
CX = CH + CL：Count
DX = DH + DL：Data

简单的指令

mov ax, 18
mov ah, 18
add ax, 8
mov ax, bx
add ax, bx

在汇编中，预留关键词不区分大小写，但是用户自定义的是区分的。

例题：四条指令计算2的4次方

mov ax, 2 ; ax = 2
add ax, ax ; ax = 4
add ax, ax ; ax = 8
add ax, ax ; ax = 16

寻址

不巧8086的地址总线是20位，cpu却只有16位，那么怎么办呢。当我们学这个的时候有一种先射箭后画靶的感觉，当初设计师肯定是先设计的寻址再让地址总线是20位。而20位支持1MiB的内存大小，当年还是很🐮的。至于为什么不直接把地址总线设置成32位，那鬼才知道他脑袋一热怎么想的。

以上是废话，我们只需要知道在8086中，地址 = 段地址 x 16 + 偏移地址，段地址 x 16 又称之为基础地址。（注意，如果逆向过植物大战僵尸的修改阳光，肯定会遇到过基址这个东西，但是其实并不是一个东西，现代的基址是用来内存保护的。）

寄存器（寻址）

使用CS和IP，作为上面提到的段地址和偏移地址。即地址 = CS x 16 + IP。(由于IP是16位，所以我们可知一个地址有很多种表示方式)

至于怎么修改这个这两个的值呢，不巧还真不能用mov，而是使用jmp CS:IP来修改，想要只修改IP，那就jmp 地址，至于只修改CS正常人类好像是没这个需求。

小于等于64KiB的一组代码可以视作一个代码段，如123B0H~123B9H，可以视作段地址位123BH的一个代码段，我们通过jmp 123BH:0就是可以实现开始执行这一堆，注意如果一个指令执行完了，IP会自动跳转到下一条指令的位置（相当于IP ← IP + 当前指令长度），但是指令既可以是2个字节，也可以是三个3字节

寄存器（内存访问）

对于两个连续的内存字节，我们既可以视作两个独立的字节，也可以视作一个字，但是要注意由于是小端，所以如果内存是12H 34H，对应的字其实是3412H。

想要内存访问，也是需要通过16位的CPU来访问20位的地址总线，不过此时我们用DS寄存器来表示段地址，再加[偏移]，来表示。

mov bx, 0100H     ; 将0100H加载到BX寄存器
mov ds, bx        ; 将BX的值赋给数据段寄存器DS
mov ax, [10H]     ; 从DS:10H地址读取字数据到AX
mov [0H], cx      ; 将CX寄存器的值写入到DS:00H地址

注意：ds不能直接用数字赋值，必须通过寄存器来间接赋值，就是这么设计的。

类似于之前的代码段，我们称从ds开始这64KiB位为数据段

补充：

MASM的逆天设计，导致上面的mov ax, [10H]其实是错误的，在debug中该语句时按照预期执行的，但是在MASM中实际上它是ax = 10H。（早期简单汇编器（如 Intel ASM）中，[100h] 本就是 “带括号的立即数” 写法（括号仅为视觉区分，无内存含义），MASM 作为商用汇编器，必须兼容这种行业惯例，否则开发者迁移成本极高。？？？）

如果想要实现这个功能

使用寄存器中转
显式加上段前缀

; 假设ds已经赋值
mov bx, 1234H      
mov ax, [bx]      ; 等价于 ds:[1234H]，取DS:1234H处的字值

mov ax, ds:[0]    ; 明确指定从DS段偏移0处取字，赋值给ax
mov ax, cs:[0]    ; 从CS段偏移0处取字

内存访问补充（段前缀）

在指令前，你可以使用以下四个段前缀之一来覆盖默认的段寄存器：

CS: （代码段前缀）
DS: （数据段前缀）
ES: （附加段前缀）
SS: （堆栈段前缀）

我们先暂时了解：在 8086/8085 实模式下，内存地址 0:0200h到 0:02FFh（对应的物理地址是 00200h到 002FFh）这段 256 字节的空间，通常被 DOS 和其他合法程序刻意避开，主要是因为它是 BIOS 数据区 的重要组成部分，用于存储系统关键的运行时数据。

寄存器（栈）

在栈中，数据的操作单元是字，同样的小端存储。通过SS:SP来确定哪个地址是栈顶，注意在8086中是没有栈底这个概念的，处理器不会进行是否越界的判断，你需要自己保证SP不会超出SS段边界。

需要记住并理解的一件事情是8086中栈是从高地址到低地址的，所以初始化的时候SP应当为FFFEH(因为这个段最大是FFFFH，但是由于一次是移动两个字节，所以说要凑成偶数地址从而字对齐)(注意dosbox中经测试，sp在自动初始化的时候为0)

pop ax
mov ax, ss:[sp]
add sp, 2

push bx
sub sp, 2
mov ss:[sp], bx

上面是等价写法，助于我们理解其实际操作过程，和ds不一样，ss和sp是可以直接赋值的。(备注mov ax, [sp] 在汇编中默认是 DS:[SP]，这是常见陷阱。必须显式写 ss:[sp] 或依赖 pop/push 自动用 SS。)

然后需要注意的一点，当你的SP为0000H的时候，你再次压入数据，会变成FFFEH，但是这不是循环栈或者地址回绕，这只是单纯的硬件无符号加减法导致的溢出，导致的环形相接。

程序

很不幸，学汇编的时候并不能很轻松的写出第一个hello，world。

但是我们要先背诵记住这个框架

DATA segment
    msg db 'Hello, World!', 0Dh, 0Ah, '$'
DATA ends

STACK SEGMENT PARA STACK 'STACK'
    db 1024 dup(?)
    STACK_TOP label word
STACK ENDS


CODE segment
    assume cs:CODE, ds:DATA
START:
    mov ax, DATA
    mov ds, ax

    mov ax, STACK
    mov ss, ax
    mov sp, offset STACK_TOP


    mov dx, offset msg
    mov ah, 09h
    int 21h
    mov ah, 4Ch
    int 21h
CODE ends
end START

或者使用伪指令.STACK [大小]来定义栈大小

`1`	`.STACK 100h`

在 8086 + MASM 的 EXE 程序中，使用 .STACK 时不需要手动初始化 SS 和 SP

伪指令

汇编语言中的指令分为伪指令和汇编指令，伪指令的作用和Java中的注解类似，并非是直接用来编译的，但是编译器可以根据其做出一些处理，而汇编指令则被编译成机器码。

对于不同的编译器伪指令也是不同的，我们只学习MASM的。

1
2
3

XXX segment

XXX ends

段是用来存储数据、代码或者当成栈的。一个汇编语言至少有一个代码段。

结束

end写所有的最后，表示程序的结束，注意和ends的区分

assume

关联，将自己定义的段和系统的寄存器关联

; 假设数据段 DATA 由 DS 指向
ASSUME DS:DATA

; 假设代码段 CODE 由 CS 指向（通常可省略，CS 默认指向当前代码段）
ASSUME CS:CODE

; 假设堆栈段 STACK 由 SS 指向
ASSUME SS:STACK

; 如果不再使用某段寄存器与段的关联，可设为 NOTHING
ASSUME DS:NOTHING

在8086中，MASM 汇编器需要明确知道自定义的变量或者段应该用那哪个寄存器访问他，没有智能推断

就像C语言中的return 0;一样（古老的标准中也是需要显式返回的，虽然现在可以不写），汇编需要对程序进行显式返回。

1
2

mov ax, 4c00H
int 21H

这个先记下来，可以先知道这是调用中断，至于中断如果接触过单片机的话会有所了解。

LOOP循环

其格式为

mov cx, 循环次数
标号: 指令
		 指令
		 ...
		 loop 标号

当走到loop这一行时，先执行cx–，然后再判断cx是否为0，如果不为0，再跳转到标号。用起来像C语言当中的goto一样。

我们以计算3*16为例

; 目标：计算 3 × 16 = 48，结果存放在 AX 中
mov cx, 16   ; 1. 设置循环次数：CX = 16（需要加16次3）
mov ax, 0    ; 2. 初始化累加器：AX = 0（乘法本质是累加）
chao:        ; 循环标号（类似C语言的goto标记）
add ax, 3    ; 3. 核心操作：AX = AX + 3（每次加3）
loop chao    ; 4. LOOP指令：CX-- → 判断CX是否为0 → 非0则跳回chao

跳转

在汇编中，我们相当于使用goto来实现一切的if语句种种，没想到啊，判断语句比循环语句还复杂。

8086 的条件跳转指令（Jcc）依赖 CPU 标志寄存器 FLAGS 中的 6 个关键标志位：

标志位	名称	含义
`CF`	Carry Flag	进位/借位（无符号数运算）
`ZF`	Zero Flag	结果为零
`SF`	Sign Flag	结果符号位（最高位），负数则 SF=1
`OF`	Overflow Flag	有符号数溢出
`PF`	Parity Flag	结果低8位中 1 的个数为偶数则 PF=1
`AF`	Auxiliary Flag	辅助进位（BCD 运算用）

跳转表格如下

类型	指令	条件	适用场景
无符号大于	`JA`	CF=0, ZF=0	A > B (unsigned)
无符号小于	`JB`	CF=1	A < B (unsigned)
有符号大于	`JG`	(SF XOR OF)=0, ZF=0	A > B (signed)
有符号小于	`JL`	(SF XOR OF)=1	A < B (signed)
等于	`JE`/`JZ`	ZF=1	A == B
不等于	`JNE`/`JNZ`	ZF=0	A != B
为负	`JS`	SF=1	A < 0
为正	`JNS`	SF=0	A >= 0
进位	`JC`	CF=1	加法进位/减法借位
溢出	`JO`	OF=1	有符号数溢出
等于0	`JCXZ`	CX=0	循环前检查计数器是否为0，或字符串/数组边界处理

程序框架如下

MOV AL, 7   
MOV BL, 5 

CMP AL, BL       ; 核心：AL - BL，仅更新 FLAGS，不改变 AL/BL
                 ; 根据结果，FLAGS 变化如下：
                 ;   AL > BL → ZF=0, (SF XOR OF)=0 → JG/JA 成立
                 ;   AL = BL → ZF=1               → JE 成立
                 ;   AL < BL → ZF=0, (SF XOR OF)=1 → JL/JB 成立

JE  equal        ; if (AL == BL)
JG  greater      ; if (AL >  BL)  ← 有符号
JL  less         ; if (AL <  BL)

**注意，汇编中的数字存储本身不分有无符号，只是在读取和运算的时候按照规则看待的，有符号的按照补码的方式存储。**这有助于我们理解溢出

标记位。

函数

指令	作用
`PROC`	定义一个过程（子程序），类似高级语言的函数/方法
`CALL`	调用一个过程（近调用或远调用）
`RET`	从过程返回到调用点（必须与 `CALL` 成对）

形如

函数名 PROC [距离属性]
; 函数实现
	RET
函数名 ENDP

距离属性：默认为NEAR段内调用，也可为FAR段见调用

调用 CALL 函数名

NEAR CALL：PUSH IP
FAR CALL：PUSH CS 和PUSH IP

返回RET

从栈顶弹出返回地址到 IP
- NEAR RET：POP IP
- FAR RET：POP IP → POP CS
继续执行 CALL 之后的指令

代码示例：

无参数，段内调用

DATA SEGMENT
    MSG1 DB 'Calling sub1...', 0DH, 0AH, '$'
    MSG2 DB 'Inside sub1!', 0DH, 0AH, '$'
DATA ENDS

CODE SEGMENT
    assume DS:DATA

; 子程序定义：NEAR（默认）
SUB1 PROC
    PUSH DX      ; 保护调用者寄存器（良好习惯）
    PUSH AX

    MOV DX, OFFSET MSG2
    MOV AH, 09h
    INT 21h

    POP AX
    POP DX
    RET          ; NEAR 返回
SUB1 ENDP

MAIN PROC
    MOV AX, DATA
    MOV DS, AX

    ; 显示调用前消息
    MOV DX, OFFSET MSG1
    MOV AH, 09h
    INT 21h

    ; 调用子程序
    CALL SUB1

    ; 程序结束
    MOV AH, 4Ch
    INT 21h
MAIN ENDP


CODE ENDS
END MAIN

从这个程序要学到以下内容：

END后面标签指明了程序开始的地方，若无标签则从代码段第一行开始执行
保护调用者寄存器，在子程序用到的寄存器需要备份一下，防止在子程序中被更改，进而有可能对主程序造成影响（子程序中 修改了哪些寄存器，就保护哪些）

寄存器传参

这种比较简便和方便，但是传参数目收到限制

; 计算 AX + BX → 返回结果在 AX
ADD_TWO PROC
ADD AX, BX
RET
ADD_TWO ENDP

; 调用：
MOV AX, 5
MOV BX, 7
CALL ADD_TWO   ; AX = 12

栈传参

我们要回忆一下，压栈的时候SP是减去对应的参数大小的。

; 调用前压栈（右→左）
    PUSH 10
    PUSH 20
    CALL ADD_STACK
    ADD SP, 4   ; 清理栈（调用者清理，C 规约）

ADD_STACK PROC
    PUSH BP
    MOV BP, SP
    MOV AX, [BP+4]   ; 第1个参数（20）
    ADD AX, [BP+6]   ; 第2个参数（10）
    ; 结果在 AX
    POP BP
    RET
ADD_STACK ENDP

也可以 RET 4为：stdcall / Pascal / Windows API → 被调用者清理

当然MASM有相应的语法糖

但是要标好语言约定格式

DATA segment
DATA ends

CODE segment
    assume cs:CODE, ds:DATA

ADD_TWO PROC C a:word, b:word
    mov ax, b
    add ax, a
    ret
ADD_TWO ENDP

START:
    mov ax, DATA
    mov ds, ax

    mov ax, 10
    push ax
    mov ax, 20
    push ax
    call ADD_TWO
    add sp, 4      ; clean up the stack

    ; result is now in ax
    mov ax, 4C00h
    int 21h

CODE ends
end START

或者采用STDCALL，连ret几都自动帮你算好(就是proc后面的参数个数)，缺点就是无法实现变长参数，但是都已经用参数了其实也无所谓。

DATA segment
DATA ends

CODE segment
    assume cs:CODE, ds:DATA

ADD_TWO PROC stdcall a:word, b:word
    mov ax, b
    add ax, a
    ret
ADD_TWO ENDP

START:
    mov ax, DATA
    mov ds, ax

    mov ax, 10
    push ax
    mov ax, 20
    push ax
    call ADD_TWO

    ; result is now in ax
    mov ax, 4C00h
    int 21h

CODE ends
end START

需要注意一下参数的顺序

; C/STDCALL调用：func(a, b, c) → 压栈顺序：c, b, a
PUSH 3      ; 参数 c
PUSH 2      ; 参数 b
PUSH 1      ; 参数 a
CALL FUNC
ADD SP, 6   ; 调用者清栈（C 规约）

最后要注意访问值的时候的规则

寻址模式	默认段寄存器	示例
`[BX]`, `[SI]`, `[DI]`	`DS`	`mov ax, [bx]` → `DS:BX`
`[BP]`, `[BP+偏移]`	`SS`	`mov ax, [bp+6]` → `SS:BP+6`
直接寻址	`DS`	`mov ax, [1234h]` → `DS:1234h`

对于如ADD_TWO PROC stdcall a:word, b:word的参数，其实是相当于bp这一种，所以想要修改外部的值的时候，记住通过中间寄存器来修改，否则修改的是栈上的值。

远调用

简单了解一下

STACK_SEG SEGMENT
    DW 128 DUP(?)          ; 256 字节堆栈（128 words）
STACK_TOP LABEL WORD       ; 堆栈顶指针（初始化用）
STACK_SEG ENDS

DATA_SEG SEGMENT PARA 'DATA'
MSG_BEFORE  DB 'Calling FAR subroutine...$'
MSG_IN_SUB  DB 13,10,'>> Inside FAR subroutine!$'
MSG_AFTER   DB 13,10,'Returned from FAR call.$'
DATA_SEG ENDS

CODE_MAIN SEGMENT PARA 'CODE'
    ASSUME CS:CODE_MAIN, DS:DATA_SEG, SS:STACK_SEG

START:
    ; 初始化 DS 和 SS:SP
    MOV AX, DATA_SEG
    MOV DS, AX

    MOV AX, STACK_SEG
    MOV SS, AX
    MOV SP, OFFSET STACK_TOP   ; SP 指向栈顶（空栈时为最高地址）

    ; 显示调用前消息
    MOV DX, OFFSET MSG_BEFORE
    MOV AH, 09h
    INT 21h

    ; ★★★ 远调用子程序（跨段）★★★
    CALL FAR_SUB               ; 此处汇编成：CALL FAR PTR FAR_SUB

    ; 显示调用后消息
    MOV DX, OFFSET MSG_AFTER
    MOV AH, 09h
    INT 21h

    ; 正常退出
    MOV AH, 4Ch
    INT 21h

CODE_MAIN ENDS

; ────────────────────────────────────────
; ★ 子程序代码段（独立段！CS 将切换至此）★
; ────────────────────────────────────────
CODE_SUB SEGMENT PARA 'CODE'
    ASSUME CS:CODE_SUB, DS:DATA_SEG, SS:STACK_SEG

; ★ 必须声明为 FAR 过程！
FAR_SUB PROC FAR
    ; 标准 FAR 过程入口：保存 BP，建立栈帧
    PUSH BP
    MOV BP, SP             ; BP = 当前堆栈帧基址

    ; 保存调用者寄存器（调用约定要求）
    PUSH AX
    PUSH DX

    ; 显示进入子程序消息
    MOV DX, OFFSET MSG_IN_SUB
    MOV AH, 09h
    INT 21h

    ; 恢复寄存器（逆序）
    POP DX
    POP AX
    POP BP

    ; ★ RET FAR：弹出 IP + CS，返回主程序 ★
    RET                    ; 在 FAR PROC 中自动汇编为 RETF (CBh)
FAR_SUB ENDP

CODE_SUB ENDS

; ★ 指定程序入口点
END START

中断

中断（Interrupt） 是一种软硬件机制，用于响应事件（如 I/O 操作、定时器、异常等）。我们在 DOS 或 BIOS 编程中，会用 INT n 来调用系统提供的服务。

DOS系统调用中断

INT 21H

注意是AH，看的是高8位

功能类别	AX 功能号 / 说明	说明/用途
字符输出	AH = 02h	输出字符到标准输出（DL = 字符）
字符输入	AH = 01h	从标准输入读取字符（回显到屏幕）读到AL里面
直接输入	AH = 08h	从标准输入读取字符（不回显）
输出字符串	AH = 09h	输出以 `$` 结尾的字符串，DX = 地址
读磁盘文件	AH = 3Fh	DX = 缓冲区, BX = 文件句柄, CX = 字节数
写磁盘文件	AH = 40h	DX = 缓冲区, BX = 文件句柄, CX = 字节数
打开文件	AH = 3Dh	DX = 文件名, AL = 0（只读）、1（写）
关闭文件	AH = 3Eh	BX = 文件句柄
创建文件	AH = 3Ch	DX = 文件名, CX = 属性
程序退出	AH = 4Ch	AL = 返回码, 退出程序

常用到的换行是0Ah，回车是0Dh

还有一个是常用但是比较复杂的，从键盘输入字符串AH = 0Ah

需要先准备一个 输入缓冲区，代码示例如下：

DATA SEGMENT
buffer DB 100        ; 最大输入长度 100
       DB ?         ; DOS 返回实际长度
       DB 100 DUP(?) ; 字符存储区
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
    MOV AX, DATA
    MOV DS, AX

    ; 调用 DOS 功能 0Ah 输入字符串
    MOV AH, 0Ah
    LEA DX, buffer   ; DX = 缓冲区地址
    INT 21h

    ; 处理字符串结尾，添加 '$'
    LEA BX, buffer
    MOV AL, [BX+1]   ; 获取实际输入长度
    MOV AH, 0
    MOV SI, AX
    MOV BYTE PTR [BX+SI+2], '$' ; 在字符串末尾添加 '$'

    ; 输出换行 (可选，为了美观)
    MOV DL, 0Ah
    MOV AH, 02h
    INT 21h

    ; 输出输入的字符串
    MOV AH, 09h
    LEA DX, buffer + 2 ; DX 指向实际字符开始处
    INT 21h

    ; 退出程序
    MOV AH, 4Ch
    INT 21h
CODE ENDS
END START

BIOS中断

用于 硬件底层操作，如显示、键盘、磁盘操作。略

INT 10H - 视频服务

AH 功能号	功能说明
00h	设置显示模式
01h	设置光标属性
02h	设置光标位置
06h	向屏幕滚动
0Eh	TTY 输出字符（带滚动）

INT 16H - 键盘服务

AH 功能号	功能说明
00h	等待键盘按键，返回 ASCII + 扫描码
01h	检测按键（非阻塞）
02h	获取键盘状态

IINT 13H - 磁盘服务

AH 功能号	功能说明
00h	重置磁盘
02h	读扇区
03h	写扇区
08h	获取磁盘参数

寄存器一览

一、通用寄存器（8 个 16 位寄存器）

通用寄存器用于临时存储数据和地址，支持 16 位整体操作或拆分为两个 8 位寄存器独立操作，是编程中最常用的寄存器组。

数据寄存器（4 个）
- AX (Accumulator)：累加器，多用于算术运算（加减乘除）、数据传输，是汇编指令的默认操作数寄存器。
  - 拆分：AH（高 8 位）、AL（低 8 位）
- BX (Base)：基址寄存器，常与段寄存器配合存放内存地址（基址寻址）。
  - 拆分：BH（高 8 位）、BL（低 8 位）
- CX (Count)：计数寄存器，用于循环（LOOP 指令）、字符串操作的计数器。
  - 拆分：CH（高 8 位）、CL（低 8 位）
- DX (Data)：数据寄存器，用于存放乘法运算的高位结果、除法运算的余数，或扩展地址总线宽度。
  - 拆分：DH（高 8 位）、DL（低 8 位）
指针与变址寄存器（4 个）这类寄存器不能拆分为 8 位，专门用于内存寻址，存放偏移地址。
- SP (Stack Pointer)：栈指针寄存器，指向栈顶的偏移地址，配合 SS 段寄存器使用，用于栈操作（PUSH/POP）。
- BP (Base Pointer)：基址指针寄存器，指向栈底或栈内某位置的偏移地址，配合 SS 段寄存器访问栈内数据。
- SI (Source Index)：源变址寄存器，字符串操作中存放源数据的偏移地址，配合 DS 段寄存器使用。
- DI (Destination Index)：目的变址寄存器，字符串操作中存放目的数据的偏移地址，配合 ES 段寄存器使用。

二、段寄存器（4 个 16 位寄存器）

8086 是 16 位处理器、20 位地址总线，通过段地址 + 偏移地址的方式生成 20 位物理地址（物理地址 = 段地址 × 16 + 偏移地址）。段寄存器专门存放段的起始地址（高 16 位）。

CS (Code Segment)：代码段寄存器，存放程序指令所在段的段地址，配合 IP 寄存器定位下一条要执行的指令。
DS (Data Segment)：数据段寄存器，存放程序数据所在段的段地址，默认用于访问内存数据。
SS (Stack Segment)：栈段寄存器，存放栈空间所在段的段地址，配合 SP/BP 寄存器访问栈数据。
ES (Extra Segment)：附加段寄存器，额外的数据段寄存器，常用于字符串操作的目的段地址。

三、控制寄存器（2 个 16 位寄存器）

控制寄存器用于控制 CPU 的运行状态和指令执行顺序，程序员只能间接修改，不能直接赋值。

IP (Instruction Pointer)：指令指针寄存器，存放当前代码段中下一条要执行指令的偏移地址，与CS配合确定指令的物理地址。
- CPU 执行完一条指令后，会自动修改 IP 的值，指向下一条指令，程序员无法通过 MOV 指令直接修改。
FLAGS

：标志寄存器（也叫程序状态字寄存器 PSW），存放 CPU 执行指令后的状态标志和控制标志，共 16 位，仅 9 位有效（6 个状态标志 + 3 个控制标志）。
- 状态标志（反映运算结果特征）：
  - CF（进位标志）：无符号数运算进位 / 借位时置 1。
  - PF（奇偶标志）：运算结果低 8 位中 1 的个数为偶数时置 1。
  - AF（辅助进位标志）：低 4 位向高 4 位进位 / 借位时置 1（用于 BCD 码运算）。
  - ZF（零标志）：运算结果为 0 时置 1。
  - SF（符号标志）：运算结果最高位为 1 时置 1（对应有符号数的负数）。
  - OF（溢出标志）：有符号数运算溢出时置 1。
- 控制标志（控制 CPU 运行方式）：
  - TF（陷阱标志）：置 1 时 CPU 进入单步执行模式（调试用）。
  - IF（中断允许标志）：置 1 时允许 CPU 响应可屏蔽中断，置 0 时禁止。
  - DF（方向标志）：字符串操作的方向控制，置 0 时正向（地址递增），置 1 时反向（地址递减）。

栈补充

栈和字符串结合起来就容易晕头转向。

首先要搞清楚OFFSET的用途，它的核心作用是：在汇编时获取某个标号（label）、变量或过程（procedure）在它所在段内的偏移地址（offset address），即段内偏移量（以字节为单位）。

而与其功能类似的是LEA(Load Effective Address)： LEA reg16, mem 目标操作数 reg16：只能是 16 位通用寄存器：AX, BX, CX, DX, SI, DI, BP, SP 源操作数 mem：必须是内存寻址表达式（即含 [...] 的地址表达式），如：

[BX]
[SI+4]
[BX+SI+10h]
[BP+DI-2]
[DI]

注：可是明明有lea后面跟着标号的写法，但这其实只是MASM将label隐含成[label]了，对于lea的[]，这个并非是取内存的值，只是对于框里面的表达式进行运算来求值而已。

然后我们就考虑如何处理栈必须是word为单位，而字符串确实用byte存储的问题。解决方式就是尽量不用，或者用八位的凑合用一下。

debug

MASM 的 debug 指令用于在 DOS 下调试可执行文件。常用指令如下：

d：显示内存内容（dump），如 d 100。
u：反汇编（unassemble），如 u 100。
e：编辑内存（enter），如 e 100。
g：运行程序（go），如 g。
t：单步执行（trace），如 t。
r：显示/修改寄存器（register），如 r。
q：退出 debug（quit）。

对于下断点：

在 DOS debug 里这样做：

载入程序
反汇编找到该指令偏移（例：u 100，记下 lea ax,[buffer+2] 前的偏移，如 0123）。
设断点并运行

到达断点后用 r 看寄存器，t 单步继续

或者可以在那行前插入软件断点 int 3，重新运行，使用g即可在此处停下。

停下后你就会发现确实是停下了，但也动不了了，此时需要R IP → 输入 当前IP+1；2. G

MASM 6.11邪教

.IF、.WHILE、.REPEAT 是 MASM（Microsoft Macro Assembler） 从 **v6.0+**开始支持的伪代码

.IF condition
    ; 代码块 A
[.ELSEIF condition2
    ; 代码块 B]
[.ELSE
    ; 代码块 C]
.ENDIF

1
2
3

.WHILE condition
    ; 循环体（可含 .BREAK / .CONTINUE）
.ENDW

.REPEAT
    ; 循环体（可含 .BREAK/.CONTINUE）
.UNTIL condition       ; 条件为真时退出
; 或
.UNTILCXZ              ; 等价于 .UNTIL cx == 0（常用于 string 操作）

大小写不敏感：.if, .If, .IF 均可（但推荐大写保持风格统一）。
运算符空格：eax==0 必须写成 eax == 0 （MASM 6.11 要求空格）。
寄存器 vs 内存：条件中尽量用寄存器，内存操作（如 [var] == 5）可能效率低或需 mov 中转。
嵌套支持：可任意嵌套（.IF 里套 .WHILE 等），但注意 .ENDIF/.ENDW 配对。
现代替代：
- 在 x64 MASM（ml64.exe） 中，这些指令仍支持（Visual Studio 自带）。
- 但纯汇编项目更倾向手写 cmp/jcc 以精确控制性能。
坑爹：默认是无符号的比较，想要有符号还是老老实实的cmp吧

八股取士补充

寻址

立即寻址 mov ax, 3064h
寄存器寻址 mov ax, bx
直接寻址 mov ax, [1234h] 注意：在 MASM 中，mov ax, [1234h] 默认被解释为 mov ax, 1234h（立即数寻址）
寄存器间接寻址 mov ax, [bx]
寄存器相对寻址 mov ax, count[SI] 等价于mov ax, [count + SI] count为提前定义好的符号地址
1 2

.data count dw 1111h, 2222h, 3333h, 4444h
基址变址寻址方式 mov ax, [bx][di] 等价于 mov ax, [BX + DI]
相对基址变址寻址方式相当于二维数组 mov ax, MASK[bx][si]等价于mov ax, MASK[bx+si] 等价于 mov ax, [MASK + bx + si]

然后是8086不支持的比例变址寻址方式，就是允许在寻址的时候进行乘法运算

1
2
3

mov eax, count[esi * 4]
mov ecx, [eax][edx * 8]
mov eax, table[ebp][edi*4]

跳转

近跳转只改 IP

JMP NEAR PTR PROGIA ; 16位
JMP SHORT QUESR ; 8位

JMP BX
JMP TABLE[BX]

段间跳转 = 修改 CS（代码段） 和 IP（指令指针）

1
2

JMP FAR PTR NEXTROUTINY
JMP DWORD PTR[INTERS+BX]

NEXTROUTINE在同模块内，形如

.code
start:
    jmp far ptr NEXTROUTINE   ; 段间跳转

; 假设 NEXTROUTINE 在另一个段
NEW_CODE_SEG segment
    assume cs:NEW_CODE_SEG
NEXTROUTINE:
    mov ax, 1234h
    ; ...
NEW_CODE_SEG ends

INTERS 必须是一个内存变量（标号），指向一个 FAR 指针表（每个元素 4 字节：IP + CS）。

.data
; 定义一个远指针（CS:IP）
INTERS  dd  ROUTINE1      ; dd = define double word (4 bytes)
        dd  ROUTINE2

.code
    mov bx, 0             ; 选第 1 个指针（偏移 0）
    jmp dword ptr [INTERS + bx]   ; 跳转到 ROUTINE1

    mov bx, 4             ; 第 2 个指针（偏移 4）
    jmp dword ptr [INTERS + bx]   ; 跳转到 ROUTINE2
    
OTHER_SEG segment
    assume cs:OTHER_SEG
ROUTINE1 proc far         ; 必须是 FAR 过程！
    ; ...
    retf                  ; 段间返回用 RETF（非 RET）
ROUTINE1 endp
OTHER_SEG ends

冷门指令

冷门且无用

8086有都没有的

movsx 带符号扩展的数据传送。将小尺寸有符号整数扩展为大尺寸（高位用符号位填充：正数补 0，负数补 1）。

movzx带零扩展的数据传送。将小尺寸无符号整数扩展为大尺寸（高位补 0）。

mov al, 0xFE      ; AL = 1111 1110₂ = -2（有符号）
movsx ax, al      ; AX = 1111 1111 1111 1110₂ = 0xFFFE = -2
movsx eax, al     ; EAX = 0xFFFFFFFE = -2
movsx rax, al     ; RAX = 0xFFFFFFFFFFFFFFFE = -2（64 位）

mov al, 0xFE      ; AL = 254（无符号）
movzx ax, al      ; AX = 0x00FE = 254
movzx eax, al     ; EAX = 0x000000FE = 254
movzx rax, al     ; RAX = 0x00000000000000FE = 254

没人用过的

XCHG ax, bx交换

考试有用的

累加器专用传送指令

IN AL, PORT(Btye)
IN AX, PORT(Word)

OUT PORT(Byte), AL
OUT PORT(Byte), AX

8086中I/O端口与CPU通信使用IN和OUT指令，端口的范围为0~FFFFH，当端口号小于256时（0~255），可以使用立即数

eg对于读取时间

时间在CMOS RAM 中的地址偏移量分别是：
秒 → 地址 00H
分 → 地址 01H
时 → 地址 04H
日 → 地址 07H
月 → 地址 08H
年 → 地址 09H

MOV AL, 04H        ; 要读取的地址是 04H（小时）
OUT 70H, AL        ; 写入地址到索引端口
IN  AL, 71H        ; 从数据端口读取数据
; AL 中现在包含 BCD 编码的小时值，比如 0x14 表示 14 点

``:用 AL 作为索引，从一张字节表中取出对应字节，放回 AL

.MODEL SMALL
.STACK 100h

.DATA
    hex_table DB '0123456789ABCDEF'   ; 16字节查表
    prompt    DB 'Input hex digit (0-F): $'
    result    DB ' -> $'

.CODE
MAIN PROC
    MOV AX, @DATA
    MOV DS, AX          ; 初始化 DS

    ; 显示提示
    MOV DX, OFFSET prompt
    MOV AH, 09h
    INT 21h

    ; 读取一个字符（假设用户输入 0~F）
    MOV AH, 01h         ; DOS 读字符（回显）
    INT 21h             ; AL = 输入字符（如 'A' = 41h）

    ; 转换为索引：'0'~'9'→0~9, 'A'~'F'→10~15
    CMP AL, '9'
    JBE is_digit
    SUB AL, 'A' - 10    ; 'A'→10, 'B'→11...
    JMP done_convert
is_digit:
    SUB AL, '0'         ; '0'→0, '1'→1...

done_convert:
    ; ★ 关键：设置 BX 指向表，AL 为索引，执行 XLAT
    MOV BX, OFFSET hex_table
    XLAT                ; AL = [BX + AL]

    ; 显示转换结果
    PUSH AX             ; 保存 AL（结果字符）
    MOV DX, OFFSET result
    MOV AH, 09h
    INT 21h
    POP AX

    MOV DL, AL          ; 显示查表得到的字符
    MOV AH, 02h         ; DOS 输出字符
    INT 21h

    ; 退出
    MOV AH, 4Ch
    INT 21h
MAIN ENDP

END MAIN

地址传送指令

LEA

LEA reg16, memory_operand

⚠️ reg16 只能是 16 位通用寄存器（AX/BX/CX/DX/SI/DI/BP/SP） ⚠️ memory_operand 必须是内存操作数（不能是立即数或寄存器）

LDS、LES、LFS、LGS、LSS

8086 只支持 LDS 和 LES

标志寄存器

LAHF: AH <- 标志低字节送到AH SAHF: AH -> 标志 PUSHF: 标志进栈 POPF: 标志出栈

CBW: 字节转为字 AL → AX 符号扩展 CWD: 字转为双字 AX → DX:AX 符号扩展可视作负数扩展全为1，正数扩展全为0，这样维持了补码形式的大小不变和符号的正负注意上述操作对象只能是AL和AX，这是无参数的指令

加法带进位、减法带借位

ADC dst, src : dst <- dst + src + cf

SBB dest, src: dst -< dst - src - cf

这个是用来进行32位加减法的

; 输入：A = DX:AX,  B = CX:BX
; 输出：A = DX:AX ← A + B
;       CF = 最终进位（33 位结果的第 33 位）
    ADD  AX, BX      ; 低 16 位相加，CF = 低字进位
    ADC  DX, CX      ; 高 16 位 + 进位

; 输入：A = DX:AX,  B = CX:BX
; 输出：A = DX:AX ← A - B
;       CF = 1 表示 A < B（无符号），即借位发生
    SUB  AX, BX      ; 低 16 位相减，CF = 1 当且仅当 AX < BX（需借位）
    SBB  DX, CX      ; 高 16 位 - 借位

乘除法符号

imul bx AX * BX → DX:AX idiv bx DX:AX（32 位）/ bx -> 商AX 余数 DX

1
2

mov ax,被乘数      ;16 位
imul 乘数          ;16 位 → 结果在 DX:AX

1
2
3

add ax,低常数
adc dx,高常数    ;带进位加高 16 位
idiv 除数        ;最终商在 AX，余数在 DX

必考之加减乘除 $$ \text{Result} = \left\lfloor \frac{A \times B + 2026}{C} \right\rfloor + D \times E $$

mov ax, A
mov bx, B
imul bx ; dx:ax = ax * bx = A * B
add ax, 2026
adc dx, 0
mov bx, C
idiv bx ; ax ... dx 
push ax
mov ax, D
mov cx, E
imul cx ; dx:ax = D * E
mov bx, ax
mov cx, dx
pop ax
cwd
add ax, bx
adc dx, cx

最终 Result 存放在：DX:AX （32 位有符号整数）

中断

中断 = 外部/内部事件“打断”CPU当前工作，让它去处理更紧急的事。

中断分为可屏蔽中断和非屏蔽中断。

CPU通过IF位（Interrupt Flag，中断允许标志位）

IF = 1 → 允许响应可屏蔽中断
IF = 0 → 屏蔽（忽略）可屏蔽中断

1
2

STI ; IF = 1
CLI ; IF = 0

所以 IF位和中断屏蔽寄存器用来实现两级控制是否允许中断。

非屏蔽中断（NMI） = 不能被忽略的超级紧急事件NMI 。无视IF位，CPU一定会响应。

中断屏蔽寄存器的IO端口是21H，通过八位来对应控制八个外部设备的是否允许中断，1表示禁止，0表示允许

7	6	5	4	3	2	1	0
打印机	软盘	硬盘	串行通信口1	串行通信口2	保留	键盘	定时器

编写中断程序时，需要在主程序配置好中断屏蔽寄存器和IF并设置中断向量，所以需要先知道什么是中断向量表

每个中断都有一个编号，叫 中断号（Interrupt Vector Number） 中断向量表（IVT） 就是一个数组，有 256 个中断向量。当触发中断时可以高效地跳转到对应的中断程序地址。

; 设置中断向量
ah = 25h
al = 中断类型号
ds : dx = 用于赋值中断向量

; 读取中断向量
ah = 35h
al = 中断类型号
es : bx = 返回的中断向量

以覆写定时中断为例(假设已经有一个countdown proc)

; 首先备份原先的中断地址
mov ah, 35h ; 35h 表示读取中断
mov al, 1ch
int 21h
push es
push bx
; 然后修改成自己的中断程序
push ds ; 备份ds
mov ax, seg countdown
mov ds, ax ; 段地址
mov dx, offset countdown ; 偏移地址
mov ah, 25h ; 25h 表示设置中断
mov al, 1ch ; 
int 21h
pop ds ; 恢复ds
; 确保中断启用
cli
mov al, 11111110B
out 21H, al
sti

注意中断的函数返回是iret

通过1CH中断进行定时操作

串子

方向标志 DF（Direction Flag）：

DF = 0：正向（递增） —— 字符串操作时，SI/DI 自动 +1（字节）或 +2（字）
DF = 1：反向（递减） —— SI/DI 自动 –1（字节）或 –2（字）

1
2
3

CLD          ; 设置 DF=0，SI/DI 递增（最常用）
; 或
STD          ; 设置 DF=1，SI/DI 递减（如从高地址向低地址复制）

8086 提供 5 条隐式操作寄存器的字符串指令：

指令	操作	源地址	目标地址	说明
`MOVSB` / `MOVSW`	移动字节/字	`[DS:SI]` → `[ES:DI]`	自动更新 SI/DI	内存复制（需 DS→ES）
`CMPSB` / `CMPSW`	比较字节/字 (SI-DI )	`[DS:SI]` vs `[ES:DI]`	更新 SI/DI，影响 FLAGS（ZF, CF 等）	可用于 `repe CMPSB` 实现 `memcmp`
`SCASB` / `SCASW`	扫描（搜索）字节/字	`AL/AX` vs `[ES:DI]`	更新 DI，影响 FLAGS	常用于 `repne SCASB` 搜索字符（如 strlen）
`STOSB` / `STOSW`	存储字节/字	`AL/AX` → `[ES:DI]`	更新 DI	常用于 `rep STOSB` 填充内存（如 memset）
`LODSB` / `LODSW`	加载字节/字	`[DS:SI]` → `AL/AX`	更新 SI	较少与 `REP` 连用（因无目标存储）

这些是重复前缀，作用于带 CX 计数的字符串指令，相当于“硬件循环”。

前缀	全称	条件	常用于
`REP`	Repeat	`CX ≠ 0`	无条件重复（`MOVSB`, `STOSB`）
`REPE` / `REPZ`	Repeat while Equal / Zero	`CX ≠ 0` 且 `ZF = 1`	`CMPSB`, `SCASB`（如比较相等时继续）
`REPNE` / `REPNZ`	Repeat while Not Equal / Not Zero	`CX ≠ 0` 且 `ZF = 0`	`SCASB`, `CMPSB`（如搜索不等时继续）

Java Memo

ldfd@outlook.it (ldfd) — Mon, 11 Aug 2025 17:03:07 +0800

业务

SQL卡住了怎么办

`1`	`SELECT * FROM information_schema.innodb_trx;`

查看运行中的事务（重点关注长时间运行的事务）

然后KILL 线程id(trx_mysql_thread_id)即可

新建SQL

拥抱 docker desktop 的gui

（MySQL 5.7+ 引入的 X Protocol (X Plugin)，提供了一个33060的端口，采用protobuf标准）

去images下一个MySQL
配置端口，采用3306，33060相同对应MySQL的端口，本地也没有占用这两个
然后持久化，挂载目录，如果删除容器后数据不需要了也无所谓，但是如果数据有转移到其它容易的打算的话还是挂载一下。Host path是自己的电脑目录，Container path是/var/lib/mysql（默认存储位置，可以通过*–datadir*来更改）
然后MySQL必须要有一个初始密码才行，通过在下面的环境变量设置MYSQL_ROOT_PASSWORD即可。

下面使用DBeaver，一个开源的Java数据库管理软件来进行操作。

添加管理员用户

-- 先创建用户(% 表示允许任意主机登录)
CREATE USER 'USERNAME'@'%' IDENTIFIED BY 'PASSWORD';

-- 再授予权限(WITH GRANT OPTION 用于允许它授予别人权限可选)
GRANT ALL PRIVILEGES ON *.* TO 'USERNAME'@'%' (WITH GRANT OPTION);

-- 刷新权限
FLUSH PRIVILEGES;

1
2
3

会发现提示
'FLUSH PRIVILEGES' is deprecated and will be removed in a future release.
MySQL 8.0+ 创建用户、授权 → 不需要 FLUSH PRIVILEGES

然后创建一个数据库

`1`	`CREATE DATABASE mydb CHARACTER SET utf8mb4 COLLATE utf8mb4_general_ci;`

字符集，和字符串比较规则。

vo getter

原本以为没什么用，结果序列化的时候是用getter来序列化的，悲

outdated

用于与先进生产力不符的落后面试的刷题知识点。（其实是离开ide补全java一长串谁能背下来）

获取原始数组的长度（不是cpp的size）

int [] nums;
int n = nums.length;
str.length(); // 字符串
list.size(); // 集合 (List/Map/Set)

遍历字符串

1
2

for (char c : str.toCharArray()) {
}

字符串访问

`1`	`str.charAt(i)`

对数组哈希

`1`	`Arrays.hashCode(array);`

排序

1
2
3

Arrays.sort(nums);
Arrays.sort(nums, (a, b) -> b - a);
Collections.sort(list);

map经典操作

map.computeIfAbsent(key, value);
mp.merge(key, 1, Integer::sum); // 如果 key 不存在，存入 1；如果存在，将旧值与 1 相加。
mp.getOrDefault(c, 0);
mp.put(c, 1);
mp.containsKey(key);

大小

1
2

Math.max(a, b);
Math.min(a, b);

自定义类的大小，compareTo 负数为小于，零是等于，正数是大于

class P implements Comparable<P> {
    Integer val;
    Integer idx;

    P (Integer a, Integer b) {
        this.val = a;
        this.idx = b;
    }

    @Override
    public int compareTo(P b) {
        if (val == b. val) return b.idx - idx;
        return  b.val - val;
    }

集合的增删改查：add, remove, set, get, indexOf

队列特殊：

入队： offer(e) (常用) / add(e)

出队： poll() (常用，空时返回 null) / remove()

看队首： peek() (常用) / element()

八股文

ldfd@outlook.it (ldfd) — Mon, 28 Jul 2025 13:00:23 +0800

计组

小数

定点

定点就是最高位是符号位，形如x.xxxxxx(x = 0 or 1)，当以补码的形式存储时范围是[-1, 1)

例：

十进制数	二进制真值	原码（8位纯小数）	补码（8位纯小数）	说明
+0.6875	+0.1011	0.1011000 → `01011000`	0.1011000 → `01011000`	正数原码 = 补码
-0.6875	-0.1011	1.1011000 → `11011000`	1.0101000 → `10101000`	补码 = 数值部分取反加1

当然，我们也可以添加整数位，用.来分割整数位和小数位，现在二进制由符号位+整数位+小数位构成

十进制数	二进制真值	原码（8位定点）	补码（8位定点）	说明
+3.625	+11.101	0011.1010	0011.1010	正数原码 = 补码
-3.625	-11.101	1011.1010	1100.0110	负数补码 = 原码数值部分取反+1

注：表格中“.”仅为视觉分隔，实际存储为连续8位：如 00111010、10111010、11000110

变形补码

这里补充双符号位补码，用来防止溢出

我们用00和11表示正数和负数，01和10分别表示着正溢出和负溢出，我们可以通过第一位永远是其符号位来记忆。

规格化

下文中的M,S,E为mantissa，significand，coefficient的缩写。

规格化就是二进制的科学计数法表示，第一个数不能为0。现在二进制由阶码(E)+尾数(M)构成。阶码的符号位为阶符，尾数的符号位为数符。

由于规格化的限制，所以我们可知尾数用原码表示的时候$\frac{1}{2}\leq M\lt 1$用补码表示的时候规定 $\frac{1}{2} \leq M < 1$ 或 $-1 \leq M < -\frac{1}{2}$，补码的时候尾数只能是1.0XXX或者0.1XXX

例：

十进制数	二进制表示（非规格化）	规格化形式（M × 2^E）	尾数 M（二进制）	阶码 E
5.0	101.0	0.101 × 2³	0.101	3
-3.5	-11.1	-0.111 × 2²	0.111	2
0.75	0.11	0.11 × 2⁰	0.11	0
0.375	0.011	0.11 × 2⁻¹	0.11	-1
10.0	1010.0	0.1010 × 2⁴	0.1010	4
-0.625	-0.101	-0.101 × 2⁰	0.101	0
0.1875	0.0011	0.11 × 2⁻²	0.11	-2

IEEE754

这是一个标准，我们只学习单浮点数的情况。二进制现在同样由E+M构成，但是这里的E会加上偏移(2^n-1)。对于单浮点，一共有32位，S为一位E为8位M为23位，这里当$E >= 1000 0000$代表阶码为正，小于的时候是负的，它的正负由于加了偏移所以和补码是不一样的，相当于基于2^9的偏移。M则是在规格化的基础上，略去第一个1，相当于增加表示的尾数提高了精度，此处的M就是单纯的无符号数，其正负由其S符号位表示。

加减法

这里考虑补码的加减法，加法很简单，减法需要转换一下。

$[x-y]_补 = [x]_补 - [y]_补 = [x]_补 + [-y]_补 $

对于$[-y]_补$我们的求法是对$[y]_补$求补，但是是在符号位也需要变的情况下求补码。对 $Y_补$按位取反，末位加 1（包括符号位）

十进制数	原码 (8位)	补码 (8位)	$[-x]_{补}$
7	0000 0111	0000 0111	1111 1001
-7	1000 0111	1111 1001	0000 0111

乘法

原码阵列乘法器

符号位用小学二年级老师教的判断

乘积采用小学三年级的乘法竖式计算，但是我们要按照绝对值后的乘法来计算。

补码阵列乘法器

按照原码算还是太拟人了。显然机器完全不是人。

如果给你两个补码让你算乘法，我们可以先换成原码，再将运算结果变成补码，符号位单独去算，这个也是要知道的，但是机器显然不能这么算，这太慢了。

所以直接补码阵列运算器出现了。

直接补码阵列乘法器

相当于带着补码的符号位一起进行运算，在人肉运算时，我们将符号位的1写为(1)，用来表示-1，在常规的运算完成后相加时，这里的(1)相当于减去1，如果不够减的话，那么就需要借位，当借位到最高位的时候并且还是0，没有可借的，那么就把这个（1）写下去到最终结果。

除法

除法作为人类我们可以按照十进制数的写法来计算，但是呢，比较大小对于机器并非是看出来的，而是需要进行比较运算的，所以对于机器还不如直接被除数减去除数来判断正负，所以这就引出了下面两种方法。

注：这里所以的计算都采用定点小数和双位补码来进行。

当被除数为负数时，变成绝对值进行处理

恢复余数法

这个只是用来帮助理解下一个方法的。

每一次我们将余数左移

加减交替法

先减，正的接着减，负的加回来

规格化浮点数加减法

判断是否有0
比较阶码，小阶码看齐大阶码（精度更高）
尾数求和（采用双符号位补码运算）
结果规格化

判断符号位：
1. 若为00.1，11.0则证明无溢出，已经符合规格化
2. 若为00.0，11.1，也无溢出，只需要左移至0.1，1.0的规格化形式即可（左规）
3. 若为01，10则出现了溢出，这时候我们进入第五步进行舍入处理
舍入处理：在对阶和溢出摄入的时候均按照这个原则处理
1. IEE754
  1. 就近舍入：类似与四舍五入，尾数后面被舍去的数字，若比10000….大，则最低位+1，反之舍去，若恰好为1000…000…，那么如果现在最低位是0就舍去，是1就+1
  2. 去尾/正无穷/负无穷
2. 尾数补码规格化：均采用0舍1入的方法，类似于754标准的就近舍入，但是X > 10000的时候才最低为+1，<=的情况统一舍去
阶码的溢出：阶码若正溢出视作正或负无穷，负溢出视作0

cache

基本概念：

cache：cache的数据块大小叫做行（所以行是大小），但是cache不仅是行，cache包含标记位和cache的数据块
主存：以块（B）为单位，主存的地址由不同的映射方式定义
cache的行和主存的块是等长的

对于缓存一个主存的块，cache需要多存一个tag，主存->纯数据，cache-> 数据 + 元数据

全相联映射

相当于随机存储，只要cache没满就往里面存，但是需要并行比较导致电路复杂，一多了设计难度就炸了。

主存地址 = 块号(s) + 块内字节号(w位)

直接映射方式

相当于分组，给主存按照每r行分为一组，然后每组的第i块只能存在cache的第i行中。

主存地址 = 组号 (s-r)+ 组内号数(r) + 块内字节号(w)

此时第i行的cache存的就是每组主存第i块的内容，可以省略cache中对于行数的存储

组相联映射方式

是全相联和直接映射的折中。Cache被分成若干个组，每个组内包含多个块。

映射规则：主存中的一个块可以映射到指定组内的任意一个空闲块。

命名：cache每组行数v时，我们通常称这种方式为v路组相联映射，v通常为2、4、8、16。

对于主存每$2^v$分成一组，对于每个组中的第i块，可以存到cache中第i组的任意一行。

d = log2(cache组数)

主存地址=主存组号（s-d）+ 组内块号（d）+块内字节号（w）

举例

我们以一个地址线为16的64KB主存为例。其地址形如1001 0000 0000 0001，字长为1B，假设块大小为16B。（由此我们可以理解一点：cache中存的不是一个主存地址的内容，而是主存中相邻的几个内容组成的一个块。进一步，我们可以知道，在此例子下，一个块有16个，对应着4位二进制，所以主存的后四位对于命中cache的判断就没有用了，只是用来确定块内偏移的。）

全相联映射：这种情况，主存的前12位就是用来定位cache的tag，每次cpu访问的时候和tag进行比较。
直接映射：这种情况与cache的行数有关，假如cache一共有32行，那么主存就是每32块视作一组。每一组的第i块，对应着cache的第i行。

64KB / 16B = 4K，可以求出主存有4K块。4K / 32 = 128，可以求出每一行cache被128行主存抢着用(我们可以视作把主存划分成128坨，但不能叫组，为了和下一种方式区分开)，log2(128) = 7。log2(32) = 5，定位cache的行需要5位。剩下的12 - 5 = 7 ，所以主存的地址就是 7(tag) + 5(index) + 4(offset)。
组相联映射：依旧和cache有关，我们假设cache有32行，设每组有4行，一共有32 / 4 = 8组。log2(8) = 3，需要3位来定位是哪一组cache。剩下的 12 - 3 = 9 位作为tag，用于和这一组的4行并行比较，判断是否命中缓存。所以主存的地址就是9(tag) + 3(set index) + 4(offset)

[!WARNING]

直接映射中删除线部分求出log2(128) = 7来表示tag当且仅当主存填满地址空间时结果与减出来的结果一致，所以用地址线数减去 index和 offset 更加稳妥。tag就是剩下多少位都用作tag，就算超了也是未命中，没有任何风险。

虚拟内存

仅学习页式存储管理

地址位数：存储容量 = 2地址位数，物理地址位数由主存容量定，虚地址位数由虚存容量定；单位换算：1KB=210B、1MB=220B、1GB=230B

页内偏移位数：由页面大小决定，即 log2(页面大小)

总页数 = 存储容量 ÷ 页面大小；页表长度 = 虚存总页数

逻辑地址位数 = 页号位数（log2(逻辑总页数)） + 页内偏移位数

主存物理空间 = 物理总页数 × 页面大小

虚地址转物理地址：拆分虚地址得虚页号（商）和偏移（余）→ 查页表找物理页号 → 物理地址 = 物理页号 × 页长 + 偏移；无映射则缺页中断

主存容量为 4MB，虚存容量为 1GB，则虚地址和物理地址各为多少位？如页面大小为 4KB，则页表长度是多少？ 30 22 1GB/4KB = 256K
某页式存储管理，页大小为 2KB。逻辑地址空间包含 16 页，物理地址空间共有 8 页。逻辑地址应有多少位？主存物理空间有多大？

页面大小 2 KB=2^11 B，因此页内偏移量为 11 位。逻辑地址空间含 16 页，16=2^4，因此页号为 4 位 逻辑地址位数 = 页号位数 + 页内偏移量位数 = 4+11=15 位。物理空间 = 物理页数 × 页面大小 = 16KB
在一个分页虚存系统中，用户虚地址空间为 32 页，页长 1KB，主存物理空间为 16KB。已知用户程序有 10 页长，若虚页 0、 1、 2、 3 已经被分别调入主存 8、 7、 4、 10 页中，请问虚地址 0AC5 和 1AC5(十六进制)对应的物理地址是多少页长 1 KB=2^10 B，因此页内偏移量为 10 位 虚地址空间 32 页，32=25，虚页号占 5 位二进制。物理空间 16 KB=16 页，物理页号范围 0∼15 映射关系：虚页 0→物理页 8、虚页 1→物理页 7、虚页 2→物理页 4、虚页 3→物理页 10。虚地址格式：虚页号（高位 5） + 页内偏移（低位 10)

0AC5H=00010，1011000101B，页面号为2，已被调入到主存页4，所以，物理地址中的页面号为4，页内地址与虚地址的页内地址相同，所以是：0100，1011000101=12C5H

1AC5H=00110，1011000101B，页面号为6，未被调入到主存页中，所以无物理地址，会发生缺页中断。

指令系统

指令格式

指令格式形如：

操作码字段 OP	地址码字段A

根据一条指令有几个操作数，分为零、一、二、三操作数地址。（如汇编中的 NOP、INC、ADD、和arm架构下的add x0, x1, x2）

零地址指令

操作码 OP

一地址指令

操作码 OP	地址码 A

二地址指令

操作码 OP	地址码 A₁	地址码 A₂

A1为兼作存放操作结果的地址

三地址指令

操作码 OP	地址码 A₁	地址码 A₂	地址码 A₃

A1为被操作地址、A2为操作数地址、A3为存放操作结果的地址。

对于二地址指令可以进一步划分：令S代表存储器，R代表寄存器

SS型
RR型
RS型

按照指令子长度划分，分为单字长、半字长、双字长指令

例题：

机器字长为 16 位，其中 OP 为操作码字段，Ms 和 Md 分别为寻址方式，Rs 和 Rd 为通用寄存器，Ms 和 Rs 组成了源操作数，Md 和 Rd 组成了目的操作数。指令格式：15 OP 10 Ms Rs Md Rd

（1）指令格式是何种指令格式？单字长二地址指令

（2）请解释说明：该指令可以指定多少种操作？6位OP，2⁶=64

（3）若源操作数和目的操作数各有 8 种寻址方式，则该系统可以具有多少个通用寄存器？2³ = 8，所以寻址方式占了3位，(16 - 6) / 2 - 3 = 2，剩下两位是用来存地址的，即为4个

寻址

方式	算法	主要优点
隐含寻址	操作数在专用寄存器	无存储器访问
立即寻址	操作数=A	无存储器访问
直接寻址	EA=A	简单
间接寻址	EA=(A)	大的地址范围
寄存器寻址	EA=R	无存储器访问
寄存器间接寻址	EA=(R)	大的地址范围
偏移寻址	EA=A+(R)	灵活
段寻址	EA=A+(R)	灵活
堆栈寻址	EA=栈顶	无需给出存储器地址

偏移寻址包含：相对寻址、基址寻址、变址寻址 也是最容易考的

指令

指令流程

**指令寄存器(**IR)：保存当前正在执行的一条指令 Instruction Register **程序计数器(**PC)：用于存放下一条指令所在的单元地址 Program Counter 数据地址寄存器(AR)：保存当前CPU所访问的数据存储器（简称数存）单元的地址 Address Register 数据缓冲寄存器(DR)：用来暂时存放ALU的运算结果或者内存的内容 Data Register 通用寄存器：当算术逻辑元(ALU)执行算术或逻辑运算时，为ALU提供一个工作区通用的取指流程

graph TD
    A[开始] --> B[PC → AR]
    B --> C["M → DR (信号 R/Ŵ = R)"] 
    C --> D[DR → IR]
    D --> E{ }

然后是经典操作读取：地址存到AR，输出存到DR，$R/\overline{W} = R$ 写入：地址存到AR，输入存到DR，$R/\overline{W} = W$

微指令格式

微指令的格式大体分成两类：水平型微指令和垂直型微指令

水平型微指令。一次能定义并执行多个并行操作微命令的微指令，叫做水平型微指令。其一般格式如下

控制字段	判别测试字段	下地址字段

e.g.:

已知某机采用微程序控制方式，控存容量为 512× 48 位。微程序可在整个控存中实现转移，控制微程序转移的条件共 4 个，微指令采用水平型格式，后继微指令地址采用断定方式。请问： (1)微指令的三个字段分别应为多少位?

控存地址位数 = 下地址字段 log2 512=9 位；有 n 个转移条件，需要 n 位来分别表示 “是否按该条件转移”；本题有 4 个转移条件，因此判别测试字段 = 4 位。微操作控制字段位数 = 微指令字长 - 判别测试字段位数 - 下地址字段位数 = 32 - 4 - 9 = 35位

AI的一坨

好的，这是对您提供的四份计算机组成原理/体系结构简答题的完整解答。

第一份试卷（七、简答题 10分）

RISC 含义： RISC 是 精简指令集计算机 (Reduced Instruction Set Computer) 的缩写。其核心思想是通过简化指令系统，使每条指令执行周期短、硬件实现简单，从而提高处理器的执行效率和性能。
“存储总线”连接部件： 在双总线结构中，“存储总线”主要用于连接 CPU 和主存储器 (内存)。有时也用于连接高速缓存 (Cache)，但其主要作用是实现 CPU 与主存之间的数据交换。
浮点数加减运算对阶原则： 对阶操作应采用 “小阶向大阶看齐”的原则。即，将阶码较小的那个数的小数点右移，使其阶码与较大的那个数相等。这样做可以保证数值精度损失最小（因为右移时丢失的是低位有效数字）。
“控制存储器”存放内容： “控制存储器”（Control Memory, CM）用来存放 微程序。微程序是由一系列微指令组成的，每条微指令对应一个或多个控制信号，用于控制数据通路中的各个部件完成一条机器指令的操作。
采用“虚拟存储器”的目的： 采用“虚拟存储器”的主要目的是 扩大程序可使用的地址空间，使其不受物理内存容量的限制。它通过将部分不常用的数据暂时存放到外存（如硬盘），在需要时再调入内存，从而让程序感觉拥有一个比实际物理内存大得多的连续地址空间，同时提高内存利用率和多道程序并发能力。

第二份试卷（七、简答题 12分）

内部总线连接部件： 内部总线（也称片内总线或芯片内总线）主要用来连接 CPU 芯片内部的各个功能部件，例如：寄存器堆、算术逻辑单元 (ALU)、控制器、指令译码器、地址生成器等。
计数器定时查询方式优先级设置： 若要使得每个设备使用总线的优先级相等，应该将 计数器的初始值每次都从0开始计数，并且每次查询结束后，计数器清零或重置为0。这样，所有设备都有均等的机会被轮询到，实现了公平的“轮询”机制。
先行进位加法器优点： 先行进位加法器（Carry Lookahead Adder, CLA）的优点是 大大缩短了进位传递的时间，提高了加法运算的速度。它通过并行计算每一位的进位产生（Generate）和进位传播（Propagate）信号，避免了串行进位加法器中进位逐位传递造成的延迟。
双译码方式优点： 在存储器芯片中，地址译码采用双译码方式（行译码 + 列译码）的优点是 显著减少了译码器的输出线数量，降低了芯片引脚数和内部布线复杂度，节省了芯片面积，提高了集成度。例如，对于 64K×1 位的芯片，单译码需 65536 条字线，而双译码只需 256 条行线 + 256 条列线 = 512 条线。
CPU区分指令和数据： CPU 区分指令和数据主要依靠 不同的时间周期和指令执行阶段：
- 取指周期：CPU 从存储器取出的内容被视为指令。
- 执行周期：根据指令的操作码，CPU 可能会再次访问存储器，此时取出的内容被视为数据。此外，指令和数据在存储器中的位置、格式以及由控制单元根据指令流自动判断。
流水线资源相关冲突解决： 当流水线中出现资源相关（如两个指令同时争用同一个功能部件，如 ALU 或乘法器）时，通常采用以下方法解决：
- 插入气泡 (Bubble/Stall)：暂停后续指令的执行，等待当前指令释放资源。
- 增加功能部件：复制有冲突的功能部件（如增加多个 ALU）。
- 资源重命名：在支持乱序执行的处理器中，通过寄存器重命名技术，将不同指令的操作数映射到不同的物理寄存器，减少资源竞争。

第三份试卷（六、简答题 12分）

求 [-y]补的方法： 已知 [y]补，求 [-y]补的方法是：对 [y]补连同符号位一起按位取反，然后末位加1。（公式：[-y]补 = ~[y]补 + 1）
解决 CPU 与主存速度差异的方法： 一种常用方法是 在 CPU 和主存之间设置高速缓冲存储器 (Cache)。Cache 存储最近频繁访问的数据和指令，利用程序访问的局部性原理，使 CPU 大部分时间能从高速的 Cache 中获取数据，从而缓解速度差异。
程序计数器 (PC) 内容修改情况： PC 的内容在以下情况下会被修改：
- 执行顺序指令后，PC 自动加1（或加指令长度）。
- 执行 转移指令（如 JMP、CALL、BRANCH）时，PC 被载入目标地址。
- 执行 中断或异常 时，PC 被保存，并载入中断服务程序的入口地址。
- 执行 子程序调用指令 (CALL) 时，PC 被压栈，然后载入子程序入口地址。
- 执行 返回指令 (RET) 时，PC 从栈中弹出。
流水线“数据相关”冲突解决： 解决数据相关（Data Hazard）冲突的主要方法有：
- 前递 (Forwarding/Bypassing)：将前一条指令的运算结果直接从 ALU 输出端或寄存器文件写回端“转发”给后一条指令的输入端，避免等待写回。
- 插入气泡 (Stall)：暂停流水线，插入空闲周期，直到数据准备好。
- 编译器调度：在编译时调整指令顺序，尽量避免数据相关。
- 乱序执行：允许后序指令在数据准备好时提前执行。
快速和慢速模块共用总线的定时方式： 应采用 同步定时方式。同步定时以统一的时钟信号作为基准，所有设备都按固定节拍工作。虽然慢速设备会降低整体效率，但为了确保系统稳定性和兼容性，必须选择最慢设备能跟上的时钟频率。异步定时虽然灵活，但在此场景下管理复杂，不如同步定时可靠。
总线仲裁目的： 总线仲裁是为了 解决多个主设备（如 CPU、DMA 控制器、I/O 处理器）同时请求使用总线时的冲突问题，决定哪个设备在当前时刻获得总线使用权，从而保证总线通信有序、高效地进行。

第四份试卷（无标题，共6题）

二进制全加器公式： 设 A、B 为两个输入位，C_in 为进位输入，则：
- 和输出 S = A ⊕ B ⊕ C_in
- 进位输出 C_out = (A ∧ B) ∨ ( (A ⊕ B) ∧ C_in )
DRAM 需要“刷新”的原因： DRAM 的存储单元是基于电容存储电荷的，而电容会随着时间推移自然漏电，导致存储的信息（0或1）丢失。因此，必须定期对 DRAM 进行“刷新”操作——即读取每一行的数据并重新写入，以恢复电容上的电荷，保持数据不丢失。
链式查询方式设备优先级确定： 在“链式查询”方式中，设备的优先级由它们在总线上的 物理连接位置决定。离总线仲裁器（或总线控制器）最近的设备具有最高优先级，越远的设备优先级越低。仲裁信号沿链依次传递，只有当高优先级设备未请求总线时，低优先级设备才有机会获得授权。
按仲裁电路位置分类的仲裁方式： 按照总线仲裁电路的位置不同，仲裁方式分为两类：
- 集中式仲裁：所有仲裁逻辑集中在单一的总线仲裁器（Bus Arbiter）中。
- 分布式仲裁：仲裁逻辑分散在各个主设备上，各设备通过某种协议（如自举、竞争）自行协商决定谁获得总线使用权。
RISC 最主要特点： RISC 最主要的特点是 指令集简单、规整，指令条数少，指令长度固定，寻址方式少，大部分指令在一个机器周期内完成。这使得硬件设计简化，易于采用流水线、超标量等高性能技术，从而获得更高的执行效率。
程序“时间局部性”含义： 程序的“时间局部性”（Temporal Locality）是指：如果一个信息项（如数据或指令）被访问过，那么在不久的将来它很可能再次被访问。这是缓存（Cache）和预取技术能够有效工作的理论基础之一。

以上答案力求简洁准确，符合“简答即可”的要求。希望对您的学习或备考有所帮助！

六、简答题（12分）

1.传统的CPU包括哪两部分？运算器和控制器

2.用双符号位补码（变形补码）表示数据。当两个符号位为10时，此时该数的数值大小范围是多少？负溢出 -2ⁿ⁺¹~-2ⁿ-1 若非符号位有n个 10中， 1表示1×-2ⁿ⁺¹ 0表示0×-2ⁿ 剩下数据部分的范围为0~2ⁿ-1

3.采用行、列双译码结构进行地址译码，有什么优点？

减少线的数目

4.微程序控制器由哪三部分组成？

控制存储器微指令寄存器地址转移逻辑

5.总线带宽与总线位宽二者有什么关系？

带宽=位宽*工作频率

6.采用“链式查询方式”进行总线总裁时，设备的优先级如何确定？

越靠近中央仲裁器的优先级越高

简答

以下是将您提供的内容整理为 问答（QA）形式 的完整版，按章节组织，问题与答案一一对应，语言简洁准确，便于复习或教学使用：

第一章计算机系统概论

Q1：冯·诺依曼结构计算机的主要特点是什么？
A：采用“存储程序”方式；指令与数据以二进制形式统一存储于同一存储器中；按顺序执行（取指→译码→执行）；以 CPU 为核心，通过总线连接存储器和 I/O 设备。

Q2：冯·诺依曼结构的核心思想是什么？
A：将程序当作数据一样存入存储器，由硬件自动按顺序取出并执行，实现“程序控制”。

Q3：为什么说指令和数据在冯·诺依曼计算机中地位相同？
A：因为二者均以二进制形式存储在同一地址空间，通过同一总线传输，可被同等读写——程序本身也可作为数据被修改或生成（如自修改代码、编译器等）。

Q4：计算机系统为什么要采用分层结构？
A：为了降低系统复杂度，通过抽象隔离各层功能，使接口清晰、便于设计、移植、复用和维护。

Q5：简述计算机系统的层次结构及各层的作用。
A：典型层次从上到下为：

应用程序层：解决用户问题；
高级语言/库：提供编程抽象；
操作系统：管理资源、提供系统调用接口；
指令系统/汇编层：软硬件接口，定义机器指令；
微程序层：生成控制信号序列（部分 CPU 使用）；
数字逻辑/电路层：物理硬件实现。

Q6：什么是软件和硬件的逻辑等价性？举例说明。
A：指同一功能既可用软件实现，也可用硬件实现。例如：浮点运算可用 FPU（硬件）或数学库（软件）；AES 加密可用专用指令（如 AES-NI）或软件算法实现。

Q7：软件实现与硬件实现各有什么特点？
A：

软件：灵活、开发快、成本低，但速度慢、效率较低；
硬件：速度快、并行性强、能效高，但成本高、修改困难、灵活性差。

第二章数的表示与运算

一、数的表示

Q1：原码、反码、补码、移码各自的表示方法是什么？
A：

原码：最高位为符号位（0正1负），其余为绝对值；
反码：正数同原码；负数符号位不变，数值位按位取反；
补码：正数同原码；负数 = 反码 + 1；
移码：真值 + 偏置常数（如 2^(n−1)），主要用于浮点阶码。

Q2：原码、反码、补码中 0 的表示有何不同？
A：原码和反码有 +0（00…0）和 −0（10…0 或 11…1）两种表示；补码中 0 唯一（全 0）。

Q3：n 位补码所能表示的数值范围是多少？为什么没有 −2ⁿ？
A：范围为 [−2^(n−1), 2^(n−1)−1]。−2ⁿ 需要 n+1 位才能表示（如 8 位无法表示 −256），故不在 n 位补码范围内。

Q4：什么是移码？移码的主要用途是什么？
A：移码 = 真值 + 偏置（通常为 2^(k−1)）。主要用于浮点数的阶码表示，便于比较大小和硬件实现。

二、浮点数表示

Q5：浮点数由哪几部分组成？数符和阶符分别表示什么？
A：由数符 S（表示数值正负）、阶码 E（指数部分）、尾数 M（有效数字）组成。IEEE 754 中无显式“阶符”，阶码采用偏置表示，隐含符号信息。

Q6：为什么浮点数需要规格化表示？
A：避免同一数值有多种表示（如 0.1×2³ 与 0.01×2⁴），提高精度和有效位利用率。

Q7：什么是规格化浮点数？规格化的目的是什么？
A：规格化浮点数的尾数满足 1 ≤ |M| < 2（二进制下即形如 1.xxxxx…）。目的：唯一表示、最大化有效数字位数、提升计算精度。

Q8：IEEE 754 单精度浮点数的格式是怎样的？
A：共 32 位：1 位符号 S + 8 位阶码 E（偏置 127）+ 23 位尾数小数 f。值为 (−1)^S × 1.f × 2^(E−127)（正规数）；E=0 或 255 用于表示非正规数、零、无穷大或 NaN。

Q9：IEEE 754 中为什么要隐藏尾数的最高位 1？
A：因规格化尾数必为 1.xxxx…，故可隐含最高位 1，节省 1 位存储空间，相当于获得 24 位精度。

Q10：IEEE 754 中阶码为什么要加偏置（127）？
A：将有符号阶码转为无符号整数，便于硬件直接比较大小、排序和进行加减运算。

三、算术运算与运算器

Q11：补码加法的运算规则是什么？
A：按模 2ⁿ 相加，丢弃最高位进位；溢出可通过符号位进位异或判断。

Q12：补码减法如何转换为加法实现？
A：A − B = A + (−B) = A + [B 的补码] = A + (~B + 1)。

Q13：什么是算术溢出？如何检测溢出（单符号位 / 双符号位）？
A：结果超出机器数表示范围即为溢出。

单符号位：若两同号数相加得异号结果，或符号位进位 ⊕ 最高数值位进位 = 1，则溢出；
双符号位（变形补码）：若结果最高两位不一致（如 01 或 10），则溢出。

Q14：全加器的逻辑表达式是什么？其进位延迟如何产生？
A：Sum = A ⊕ B ⊕ Cin；Cout = AB + (A⊕B)Cin。进位需逐级传递，前一级 Cout 作为后一级 Cin，导致传播延迟。

Q15：行波进位加法器的工作原理及其缺点是什么？
A：多个全加器串联，低位进位依次传递至高位。缺点：进位链延迟随位数线性增长（O(n)），速度慢。

Q16：先行进位的基本思想是什么？为什么能提高速度？
A：预先计算每位的“进位生成”Gi = Ai·Bi 和“进位传递”Pi = Ai⊕Bi，通过并行逻辑直接计算各级进位，减少进位传播深度，显著加速。

Q17：原码阵列乘法器的基本工作原理是什么？
A：根据乘数每一位生成部分积（0 或被乘数），通过阵列加法器逐层累加，符号位单独处理。

Q18：什么是间接补码阵列乘法器？
A：先将补码操作数转换为绝对值（原码），进行原码乘法，再根据符号和补码规则修正最终结果。

Q19：直接补码阵列乘法器与间接补码阵列乘法器的区别？
A：

直接：在阵列内部处理符号和补码补偿（如末尾加一行），速度快但结构复杂；
间接：先取绝对值做原码乘，再外部修正，结构简单但需额外步骤。

Q20：原码除法的“恢复余数法”和“加减交替法”有何区别？
A：

恢复余数法：试减后若余数为负，需加回除数“恢复”，再记商 0；
加减交替法（非恢复）：余数为负时不恢复，下步改做加法，末尾一次性修正，效率更高。

Q21：阵列除法器的基本思想是什么？
A：将除法的逐次加/减与移位操作固化为硬连线阵列结构，实现并行或流水化除法。

Q22：ALU 的功能由什么决定？如何根据功能表使用 ALU？
A：由控制信号（功能码）决定。根据功能表设置选择信号（如 S3~S0），即可输出对应运算结果（如加、减、与、或等）。

Q23：浮点加减运算的主要步骤有哪些？
A：① 对阶（小阶向大阶对齐，尾数右移）；② 尾数加减；③ 规格化；④ 舍入处理；⑤ 溢出/下溢检查。

Q24：浮点乘除运算中，阶码和尾数分别如何处理？
A：

阶码：乘法时相加（再减偏置），除法时相减（再加偏置）；
尾数：相乘或相除；
结果需规格化、舍入，并设置符号位 S = SA ⊕ SB。

第三章存储系统

Q1：存储器按层次如何分类？各层次的特点是什么？
A：寄存器 → Cache → 主存（DRAM）→ 外存（SSD/HDD）→ 离线存储。越上层速度越快、容量越小、成本越高；越下层反之。

Q2：简述存储系统的层次结构及其设计依据。
A：基于局部性原理（时间/空间局部性），通过多级缓存、块传送、替换策略（如 LRU）和写策略（Write-through/Back），在成本与性能间取得平衡。

Q3：主存储器的主要技术指标有哪些？
A：容量、字长、访问时间/周期、带宽、命中率、功耗、成本/位。

Q4：SRAM 和 DRAM 在结构和性能上有何区别？
A：

SRAM：用触发器存储，无需刷新，速度快，但密度低、成本高；
DRAM：用电容存储，需定期刷新，速度较慢，但密度高、成本低。

Q5：为什么 DRAM 需要刷新？刷新有哪几种方式？
A：电容会漏电导致数据丢失。刷新方式包括：集中刷新、分散刷新（行刷新）、CAS-before-RAS（CBR）刷新、自刷新。

Q6：存储器容量扩展的常见方法有哪些？
A：位扩展（增加数据宽度）、字扩展（增加地址空间）、多模块交叉/银行化（提高并行性）。

Q7：什么是位扩展和字扩展？
A：

位扩展：多个芯片并联，扩展数据位宽（如 8 片 1M×1 扩展为 1M×8）；
字扩展：通过地址高位选片，扩展存储单元数量（如 2 片 1M×8 扩展为 2M×8）。

Q8：新型 DRAM 芯片（如 SDRAM）的主要特点是什么？
A：同步时钟控制、支持突发（Burst）传输、多 Bank 并行、命令驱动、高带宽。

Q9：ROM 有哪几种类型？各自的特点是什么？
A：

Mask ROM：出厂固化，不可改；
PROM：一次可编程；
EPROM：紫外光擦除；
EEPROM/Flash：电擦除、可重写，Flash 支持块擦除。

Q10：什么是双端口存储器？有什么优点？
A：具有两个独立访问端口，可同时读/写，提升带宽和并行性，常用于高速缓存或图形处理。

Q11：什么是相联存储器？其主要用途是什么？
A：按内容而非地址寻址（Content-Addressable Memory, CAM）。用于 TLB、Cache 标记查找等需快速匹配的场景。

Q12：多模块交叉存储器的基本原理是什么？
A：将地址低位用于选择存储模块，连续地址分布在不同模块，实现交叉访问，隐藏存储周期，提高吞吐。

Q13：Cache 的基本工作原理是什么？
A：利用局部性，将主存中近期可能访问的数据块复制到高速 Cache 中；命中则快速访问，未命中则从主存调入。

Q14：Cache 与主存之间有哪些地址映射方式？
A：直接映射、全相联映射、组相联映射。

Q15：直接映射、全相联映射、组相联映射各有什么特点？
A：

直接：实现简单、速度快，但冲突率高；
全相联：命中率高，但硬件复杂、成本高；
组相联：折中方案，兼顾性能与复杂度。

Q16：什么是虚拟存储器？其核心思想是什么？
A：以磁盘为后备，将程序按页/段动态调入主存，提供远大于物理内存的虚拟地址空间。核心：按需调页 + 局部性原理。

Q17：存储保护的主要实现方法有哪些？
A：基址-界限寄存器、页表中的 R/W/X 权限位、特权级/保护环、段表权限、内存保护键（MPK）等。

第四章指令系统

Q1：一条指令通常由哪几部分组成？
A：操作码（Opcode）、寻址方式标识、源/目的操作数字段（寄存器、立即数、地址偏移等）、条件码、长度信息等。

Q2：常见的指令格式有哪些？
A：0/1/2/3 地址指令；R/I/J 型（如 MIPS）；定长（RISC）与变长（CISC）格式。

Q3：什么是操作码定长？有什么优缺点？
A：操作码固定位数。优点：解码简单快速；缺点：编码空间受限，难以支持大量指令或灵活操作数。

Q4：什么是扩展操作码？其设计思想是什么？
A：高频指令用短操作码，低频指令用前缀+长操作码。思想：层次化编码，提升编码效率和指令密度。

Q5：常见的寻址方式有哪些？
A：立即、寄存器、直接、间接、寄存器间接、基址、变址（索引）、位移、PC 相对、堆栈等。

Q6：如何计算有效地址 EA？
A：依寻址方式而定，例如：

基址+变址：EA = Base + Index×Scale + Disp；
PC 相对：EA = PC + offset；
寄存器间接：EA = (R)。

Q7：立即寻址和直接寻址的区别是什么？
A：立即寻址的操作数直接包含在指令中；直接寻址的操作数地址在指令中，需访存一次获取数据。

Q8：变址寻址和基址寻址各自的应用场景是什么？
A：

变址（Index）：用于数组/循环遍历（Index 递增）；
基址（Base）：用于程序重定位、多任务隔离、栈帧访问（Base 固定，Disp 变化）。

Q9：CISC 指令系统的主要特点是什么？
A：指令多且复杂、寻址方式丰富、变长指令、微程序控制、寄存器少、代码密度高。

Q10：RISC 指令系统的主要特点是什么？
A：指令简单定长、Load/Store 架构、寄存器多、寻址方式少、硬连线控制、流水线友好。

Q11：RISC 与 CISC 在设计思想上的根本区别？
A：CISC 依靠复杂指令减少程序条数，靠硬件实现功能；RISC 简化指令，靠编译器优化和流水线提升吞吐。

Q12：设计指令结构时需要考虑哪些因素？
A：性能（流水线兼容性）、编码空间与密度、正交性、兼容性、实现复杂度、能耗/面积、调试与安全性。

第五章中央处理器（CPU）

Q1：CPU 的基本组成包括哪些部件？
A：ALU、寄存器组、控制器（硬连线/微程序）、PC、IR、状态寄存器、内部总线，部分含 Cache。

Q2：程序计数器（PC）的作用是什么？
A：保存下一条待取指令的地址，执行后自动更新（顺序+4 或跳转目标）。

Q3：指令周期和 CPU 周期的区别是什么？
A：指令周期 = 完成一条指令所需全过程；CPU 周期（时钟周期）是基本时间单位，一个指令周期包含多个 CPU 周期。

Q4：一条指令的执行过程通常分为哪几个阶段？
A：取指 → 译码 → 取操作数/地址计算 → 执行 → 访存（如 Load/Store）→ 写回。

Q5：如何用方框图语言描述指令执行过程？
A：用寄存器传输语言（RTL）表示，如：MAR←PC；IR←Mem[MAR]；PC←PC+4；Reg[rd]←ALUout。

Q6：控制器有哪些控制方式？各有什么特点？
A：

硬连线：速度快，但修改困难；
微程序：灵活易改，但稍慢；
混合式：结合两者优势。

Q7：什么是微程序控制？
A：将每条机器指令的执行分解为一系列微指令，存储在控制存储器中，顺序执行以生成控制信号。

Q8：微命令、微指令和微程序之间的关系是什么？
A：微命令 = 单个控制信号；微指令 = 一个时钟周期内所有微命令的集合；微程序 = 实现一条机器指令的微指令序列。

Q9：微地址是如何形成的？
A：由微地址字段、顺序器、条件分支（根据标志位）、操作码映射入口等共同决定下一微地址。

Q10：什么是并行性？CPU 中体现在哪些方面？
A：并行性指同时处理多个任务。CPU 中包括：

指令级（流水线、超标量）；
数据级（SIMD/向量）；
线程级（多核、SMT）；
存储并行（多 Bank Cache）。

Q11：流水线中的三种相关冲突分别是什么？
A：数据相关、结构相关、控制相关（分支相关）。

Q12：数据相关、结构相关、控制相关的解决方法有哪些？
A：

数据相关：转发（旁路）、停顿、寄存器重命名、调度；
结构相关：增加资源（如多 ALU）、调度；
控制相关：分支预测、延迟槽、投机执行+回滚。

Q13：RISC 技术在 CPU 设计中的体现是什么？
A：定长指令利于流水线；Load/Store 架构简化访存；丰富寄存器减少访存；硬连线控制提速；支持快速分支与数据转发。

Q14：指令与微指令的区别是什么？
A：指令是 ISA 层对软件可见的操作；微指令是硬件内部控制单元使用的底层信号序列，软件不可见。

第六章总线系统

Q1：总线按功能可分为哪几类？
A：地址总线、数据总线、控制总线；按范围：片内总线、系统总线、I/O 总线、存储总线等。

Q2：总线的主要性能指标有哪些？
A：带宽（GB/s）、位宽、时钟频率、传输率、延迟、仲裁延时、利用率、负载能力、电气特性。

Q3：总线的数据传送方式有哪些？
A：程序查询 I/O、中断 I/O、DMA、总线主控（Bus Mastering）。

Q4：常见的总线仲裁方式有哪些？
A：链式查询（菊花链）、集中并行仲裁、分布式仲裁（如令牌、CAN）、轮询。

Q5：链式查询仲裁方式的工作原理是什么？
A：总线请求信号沿设备链传递，优先级由物理位置决定，最先响应者获得总线。

Q6：集中式仲裁和分布式仲裁有何区别？
A：集中式由单一仲裁器裁决；分布式由各节点自主协商（如比较优先级或传递令牌），无单点故障。

Q7：分布式仲裁电路的基本思想是什么？
A：各节点将自己的优先级编码放到总线上，通过“线与”或“线或”比较，最高优先级者胜出；或通过令牌在节点间传递。

Q8：总线的同步定时和异步定时有何区别？
A：

同步：依赖全局时钟，时序固定，简单但受时钟 skew 限制；
异步：采用握手协议（Req/Ack），适应不同延迟，更灵活但控制复杂。

Q9：总线的数据传送模式有哪些？
A：单次传送、突发（Burst）传送、分离事务（Split Transaction）、循环窃取（DMA）。

Q10：多总线结构的优点是什么？
A：提高并行度、减少冲突、模块化设计、易于扩展、隔离不同类型流量（如 CPU-内存 vs I/O），提升整体吞吐与可靠性。

✅ 此 QA 整理可用于复习提纲、教学讲义或面试准备。如需 PDF 或 Markdown 格式，可进一步告知。

计网

模型概念

OSI模型：

物理层：在物理介质（如电缆、光纤）上传输和接收原始比特流。
数据链路层：将从物理层获得的二进制流拆分为分离的帧。
网络层：将分组从源机一路送到目的机。
传输层
会话层
表示层
应用层

信道复用

时分复用：将时间分成一个个极短的间隔，并为每个用户分配专属的时间间隔，用户在属于自己的时间间隔使用整条共享信道。
频分复用：将共享的物理带宽分成若干间隔的频率范围，每个频宽可以全时、同时使用，各个频宽上传输的信号互不干扰。
波分复用：本质上是频分复用，波分复用是一种共享光纤信道的技术，不同用户的数据搭载到不同波长的光波信号上，复用在一起共享信道
码分复用：不会太难了

数据链路层(DLL)协议

HDLC协议

帧的头部和尾部，以01111110的序列作为分界标志。

HDLC协议使用比特填充（bit stuffing）来避免在数据中出现与标志字段相同的比特模式。HDLC的标志字段是01111110，因此当数据中出现连续5个1时，需要在第5个1后面插入一个0。（这样数据中永远无法出现连续的6个1，避免出现帧标志分界符）

PPP

PPP同样以01111110作为分帧的边界符。

PPP协议在进行异步传输时，使用字节填充的法而在同步传输时，PPP协议使用与HDLC协议类似的位填充法

PPP使用异步传输时，我们使用0x7D（01111101）作为转义符，想要在里面输入特殊字节，就在前面加个转义符。类似c语言字符串中的"\\"行为

PPPoE

PPPoE技术(PPP over Ethernet)，“在以太网上的PPP协议”

调制

波特率（baud）和比特率（bit）的关系：

波特率：每秒钟信号变化的次数，也称调制速率

比特率：每秒钟传送的二进制位数

校验

奇偶校验

通过校验码字里面的1的个数是奇数或者偶数来判断是否出错。

CRC

给出一个生成多项式G(x)为r阶，原数据M(x)

在M(x)后面添加r个0，用得到的这个使用模2除法（即不借位）除以G(x)求出余数，用余数替换原先的r个0

模2除法它既不向上位借位，也不比较除数和被除数的相同位数值的大小，只要以相同位数进行相除即可。余数首位是1，商就是1，余数首位是0，商就是0。

海明码

用2^n位(n = 0, 1, 2 …)作为校验位，然后中间是原先的数据位

对于第i个校验位(i = n + 1)，从该位开始计算连续i的异或，跳过i个，再计算连续i个的异或，一直循环到末尾。

通常使用偶校验（即校验位使得其负责的所有位的总异或和为0）。

校验位数 r 需要满足不等式: 2^r >= k + r + 1

算法

ldfd@outlook.it (ldfd) — Thu, 05 Jun 2025 22:05:17 +0800

循环不变量

循环不变量不是编程意义上的常量，它是一个在一次循环前后都不变的性质、属性。用来证明算法正确性。

其证明过程类似数学归纳法，数学归纳法分为两种，第一类（普通）归纳法和第二类（强）归纳法。

第一类：假设 P(k) 成立，能推出 P(k+1) 成立；则P成立。

第二类：假设对所有 1≤m≤k，P(m) 成立，能推出 P(k+1) 成立；则P成立。

相对于数学上，算法是有终止条件的，要显式的终止假设。

证明过程写成：初始化，归纳，终止三部分。

以插入排序为例。

循环不变量：每次迭代开始时，子数组 arr[1..i-1] 是已排序的，且包含原数组前 i-1 个元素。

初始化

当 i=1 时，子数组 arr[1..0] 为空，默认有序。

归纳

假设：第 i 次迭代前，arr[1..i-1] 已排序。
动作：将 arr[i] 插入到 arr[1..i-1] 的正确位置（通过内层 while 循环）。
结果：arr[1..i] 变为有序。

终止

当 i = n+1 时，子数组 arr[1..n] 是整个数组，且已排序。

时间复杂度符号

符号	定义	数学表达	含义	示例
大O (O)	渐进上界（最坏情况）	$$f(n)≤c⋅g(n)$$	复杂度不超过 g(n)	$$3n^2+2n+1=O(n^2)$$
大Ω (Ω)	渐进下界（最好情况）	$$f(n)≥c⋅g(n)$$	复杂度至少是 g(n)	$$3n^2+2n+1=Ω(n^2)$$
大Θ (Θ)	渐进紧确界（精确阶数）	$$c1⋅g(n)≤f(n)≤c2⋅g(n)$$	复杂度等于 g(n)	$$3n^2+2n+1=Θ(n^2)$$

然后需要记住主定理。

算法主定理（Master Theorem）是用于分析分治算法时间复杂度的一个重要工具，特别是适用于形如以下递归关系式的算法：

$$ T(n) = a \cdot T\left(\frac{n}{b}\right) + f(n) $$

其中：

$ n $ 是问题的规模；
$ a \geq 1 $ 是子问题的数量；
$ b > 1 $ 是每个子问题相对于原问题的规模缩小因子；
$ f(n) $ 是划分子问题和合并解所需的时间（即非递归部分的时间复杂度）。

设： $$ T(n) = a \cdot T\left(\frac{n}{b}\right) + f(n) $$

我们比较 $ f(n) $ 和 $ n^{\log_b a} $ 的大小关系（注意：$ \log_b a $ 是一个常数，由 $ a, b $ 决定），可以分为以下三种主要情况：

情况一：
如果
$$ f(n) = O(n^{\log_b a - \varepsilon}) \quad \text{对于某个 } \varepsilon > 0 $$ 也就是说，$ f(n) $ 增长得比 $ n^{\log_b a} $ 慢一些。

那么： $$ T(n) = \Theta(n^{\log_b a}) $$

情况二：
如果
$$ f(n) = \Theta(n^{\log_b a}) $$ 也就是说，$ f(n) $ 与 $ n^{\log_b a} $ 同阶。

那么： $$ T(n) = \Theta(n^{\log_b a} \log n) $$

情况三：
如果
$$ f(n) = \Omega(n^{\log_b a + \varepsilon}) \quad \text{对于某个 } \varepsilon > 0 $$ 并且满足正则条件（regularity condition）： $$ a \cdot f\left(\frac{n}{b}\right) \leq c \cdot f(n) \quad \text{对于某个 } c < 1 \text{ 且足够大的 } n $$ 也就是说，$ f(n) $ 增长得比 $ n^{\log_b a} $ 快一些，并且这个增长是“规则”的。

那么： $$ T(n) = \Theta(f(n)) $$

总结：

如果 $ f(n) $ 较小（多项式意义上），就取主项 $ n^{\log_b a} $，对应情况一。
如果 $ f(n) $ 和 $ n^{\log_b a} $ 差不多大，就多出一个 log，对应情况二。
如果 $ f(n) $ 较大，并且满足正则条件，那它主导整个运行时间，对应情况三。

示例1：归并排序 $$ T(n) = 2T\left(\frac{n}{2}\right) + \Theta(n) $$ 这里 $ a=2, b=2, f(n)=n $

计算： $$ n^{\log_b a} = n^{\log_2 2} = n^1 = n $$

因为 $ f(n) = \Theta(n) $，符合情况二，所以：

$$ T(n) = \Theta(n \log n) $$

示例2：二分查找 $$ T(n) = T\left(\frac{n}{2}\right) + \Theta(1) $$ 这里 $ a=1, b=2, f(n)=1 $

计算： $$ n^{\log_b a} = n^{\log_2 1} = n^0 = 1 $$

因为 $ f(n) = \Theta(1) = \Theta(n^0) $，所以也是情况二：

$$ T(n) = \Theta(\log n) $$

注意事项

主定理不适用于所有递归形式。例如，像：
- $ T(n) = T(n - 1) + f(n) $
- $ T(n) = T(n/2) + T(n/3) + f(n) $ 这类无法直接使用主定理求解。

一类题目是求两个函数之间的关系，既可以用上面的定义，也可以使用下面极限的方法（可以洛它！） $$ \lim_{n \to \infty} \frac{f(n)}{g(n)} \begin{cases} = c & \text{implies } f(n) = \Theta(g(n)) \quad \text{if } 0 < c < \infty \ = 0 & \text{implies } f(n) = O(g(n)) \ = \infty & \text{implies } f(n) = \Omega(g(n)) \end{cases} $$

分摊分析时间复杂度

合计方法（Aggregate Method）

通过计算n个操作构成序列的最坏总成本，然后平摊到n个操作上。

下面我们以一个栈（Stack）支持三种操作为例进行说明：

Push(S, x)：将元素 x 压入栈 S。
Pop(S)：弹出栈顶元素。
MultiPop(S, k)：从栈 S 中最多弹出 k 个元素（如果栈中元素不足 k，则弹出所有元素）。

最坏情况下的单操作成本

Push(S, x) 的最坏成本为 O(1)。
Pop(S) 的最坏成本为 O(1)。
MultiPop(S, k) 最坏成本为 O(k)。

假设我们总共执行了 n 次操作，包括任意数量的 Push、Pop 和 MultiPop。

关键观察：

每次 Push 往栈中加入一个元素；
而每个元素至多只能被 Pop（或 MultiPop）弹出一次。

也就是说：不管我们使用 Pop 还是 MultiPop，在 n 个操作中，最多只能弹出 n 个由 Push 操作压入的元素。

总成本估计：

每个 Push 成本是 O(1)，最多 n 次 → O(n)
每个元素最多被弹出一次 → 所有 Pop 和 MultiPop 总共最多执行 n 次弹出操作 → O(n)

所以：

n 个操作的总成本是 O(n)，每个操作的 平均摊还成本为 O(1)。

替换法/递归树求时间复杂度

一、替换法（Substitution Method）

原理替换法的思路是：假设递归式的解为某个函数形式（如 T(n) = O(n log n)），然后用数学归纳法来验证这个假设是否成立。步骤

猜一个解 T(n) = O(f(n))。
用归纳法证明这个猜测对所有较小的 n 成立。
替换回递推式，验证是否成立。示例：

递归式： $T(n) = 2T(n/2) + n$ 我们猜测解为： $T(n) = O(n \log n)$ 用归纳法验证： 归纳假设：假设对所有小于 n 的输入，成立，即 $T(n/2) \leq c(n/2)\log(n/2)$ 代入原式：

$$ \begin{aligned} T(n) &= 2T(n/2) + n \ &\leq 2 \cdot c(n/2)\log(n/2) + n \ &= c n \log(n/2) + n \ &= c n [\log n - \log 2] + n \ &= c n \log n - c n + n \ &= c n \log n - (c n - n) \end{aligned} $$

只要 $c \geq 1$，上式说明 $T(n) \leq c n \log n$，即猜测成立。

二、递归树法（Recursion Tree Method）

原理

递归树法通过画出递归的结构图，直观地看到每一层的计算开销，并将所有层加总，从而求出总的时间复杂度。

示例：

还是这个递归式：

$$ T(n) = 2T(n/2) + n $$

我们用递归树表示如下：

第一层：

工作量 = $n$

第二层：

两个子问题，每个大小为 $n/2$，每个消耗 $n/2$，总共 $2 \cdot (n/2) = n$

第三层：

四个子问题，每个大小 $n/4$，每个消耗 $n/4$，总共 $4 \cdot (n/4) = n$

……

继续下去，每一层的工作量都是 n，而层数是：

$$ \log_2 n $$

然后求和总时间为：

$$ T(n) = n \cdot \log n $$

归并/快排

void quick_sort(int a[], int l, int r) {
    if(l >= r) return;

    int pivot = a[(l + r) >> 1];
    int i = l, j = r;

    while(i <= j) {
        while(a[i] < pivot) i++;//找到左边比pivot大的数
        while(a[j] > pivot) j--;//找到右边比pivot小的数
        if(i <= j) {//此处分为两种情况理解，小于的时候正常交换，等于的时候i和j都是pivot的下标，所以i++，j--，退出循环。
            swap(a[i], a[j]);
            i++;
            j--;
        }
    }

    if(l < j) quick_sort(a, l, j);//只要理解上面<=的意思，这里就很好理解为什么是l到j和i到r了。
    if(i < r) quick_sort(a, i, r);//此时i - 1和 j + 1是pivot的下标，所以不用再次排序。
}

void merge_sort(int a[], int l, int r) {
    if(l >= r) return;

    int mid = (l + r) >> 1;
    merge_sort(a, l, mid);
    merge_sort(a, mid + 1, r);//注意好地板除mid，划分好范围
    
    int i = l, j = mid + 1, k = 0;
    while(i <= mid && j <= r) {
        if(a[i] < a[j]) {
            tmp[k++] = a[i++];
        }else {
            tmp[k++] = a[j++];
        }
    }
    while(i <= mid) tmp[k++] = a[i++];
    while(j <= r) tmp[k++] = a[j++];
    for(i = l, j = 0; i <= r; i++, j++) {
        a[i] = tmp[j];
    }
}

然后快排变形成找前k小的元素

void quick_select(int a[], int l, int r, int k) {
    if (l >= r) return;

    int pivot = a[(l + r) >> 1];
    int i = l, j = r;

    while (i <= j) {
        while (a[i] < pivot) i++;
        while (a[j] > pivot) j--;
        if (i <= j) {
            std::swap(a[i], a[j]);
            i++;
            j--;
        }
    }

    int leftCount = j - l + 1; // 左边元素个数

    if (k <= leftCount) {
        // 前k小元素都在左边
        quick_select(a, l, j, k);
    } else if (k > leftCount + (i - j - 1)) {
        // 需要左边 + pivot重复个数 + 部分右边
        quick_select(a, i, r, k - (i - l));
    }
    // 否则刚好包含左边 + pivot重复的部分，不需要再处理
}

动态规划

考试既可以用伪代码，也可以用正常的，所以下面全都用c++写

装配线调度

定义：

对于 i = 0 or 1，一共n个工序

$S_i[j]$：第i个流水线的j个工序 $a_i[j]$：第i个流水线的j个工序的加工时间 $e_i$：进入第i个流水线的时间 $x_i$：退出第i个流水线的时间

目的：使得总加工时间最少

方程：(1-index) $$ f^* = \min{f_1[n] + x_1 , f_2[n] + x_2} \

f_1[j] = \begin{cases} a_1[1] + e_1, & j = 1 \ \min(f_1[j - 1] + a_1[j],; f_2[j - 1] + t_2[j - 1] + a_1[j]), & j > 1 \end{cases} \ f_2[j] = \begin{cases} a_2[1] + e_2, & j = 1 \ \min(f_2[j - 1] + a_2[j],; f_1[j - 1] + t_1[j - 1] + a_2[j]), & j > 1 \end{cases} $$ 代码：

// 0-index
int assemble() {
    int f1[N], f2[N];
    // 初始化
    f1[0] = e[0] + a[0][0];
    f2[0] = e[1] + a[1][0];
    
    // 动态规划转移
    for (int j = 1; j < n; ++j) {
        f1[j] = min(f1[j - 1] + a[0][j], f2[j - 1] + t[1][j - 1] + a[0][j]);
        f2[j] = min(f2[j - 1] + a[1][j], f1[j - 1] + t[0][j - 1] + a[1][j]);
    }
    // 最优解
    return min(f1[n - 1] + x[0], f2[n - 1] + x[1]);
}

然后可能会涉及到构造答案，我们开个辅助数组L[]便于我们反向递归搜索。

int assemble() {
    int f1[N], f2[N];
    // 初始化
    f1[0] = e[0] + a[0][0];
    f2[0] = e[1] + a[1][0];
    l[0] = (f1[0] <= f2[0]) ? 0 : 1;

    // 动态规划转移 + 记录路径
    for (int j = 1; j < n; ++j) {
        if (f1[j - 1] + a[0][j] <= f2[j - 1] + t[1][j - 1] + a[0][j]) {
            f1[j] = f1[j - 1] + a[0][j];
            l[j] = 0;
        } else {
            f1[j] = f2[j - 1] + t[1][j - 1] + a[0][j];
            l[j] = 1;
        }

        if (f2[j - 1] + a[1][j] <= f1[j - 1] + t[0][j - 1] + a[1][j]) {
            f2[j] = f2[j - 1] + a[1][j];
            // 可选：记录每个点来源
        } else {
            f2[j] = f1[j - 1] + t[0][j - 1] + a[1][j];
        }
    }

    // 返回最终结果，并决定最后从哪条线出来
    int res;
    if (f1[n - 1] + x[0] <= f2[n - 1] + x[1]) {
        res = f1[n - 1] + x[0];
        l[n] = 0; // 最后从 line 0 出口
    } else {
        res = f2[n - 1] + x[1];
        l[n] = 1; // 最后从 line 1 出口
    }

    return res;
}

然后打印路径

void printPath(int l[], int n) {
    cout << "最优路径：" << endl;
    int line = l[n]; // 最后从哪条线出
    cout << "Line " << line << ", Station " << n - 1 << endl;

    for (int i = n - 1; i > 0; --i) {
        line = l[i];
        cout << "Line " << line << ", Station " << i - 1 << endl;
    }
}

矩阵链乘法

A的列数等于B的行数就可以$A \times B$

定义：

$A_i$表示矩阵i，一共n个

$p_{i-1} \times p_i$表示第i个矩阵的维度

目的：求出最小连乘运算量

方程：m[i,j]为$A_i$乘到$A_j$的最小运算量 $$ m[i,j] = \begin{cases} 0, &i=j, \ \min_{i \leq k < j} {m[i,k] + m[k+1,j]+p_{i-1}p_kp_j}, &i < j.

\end{cases} $$ 注：$p_{i-1}$即为$A_i$的行数，$p_j$即$A_j$的列数，

当你将两个矩阵 $ X: a \times b $ 和 $ Y: b \times c $ 相乘时，所需的标量乘法次数为： $$ a \cdot b \cdot c $$

所以，将上述两部分的结果矩阵相乘时，所需的乘法次数就是： $$ p_{i-1} \cdot p_k \cdot p_j $$ 代码：

DpMatrix() {
    // 长度为 1
    for (int i = 0; i < n; i++)
        m[i][i] = 0;
    // 枚举长度
    for (int len = 2; len <= n; len++) {
        for (int i = 0; i < n - len; i++) {
            int j = i + len - 1;
            for (int k = i; k < j; k++) {
                int tmp = m[i][k] + m[k+1][j] + p[i-1]*p[k]*p[j];
                if (tmp < m[i][j]) {
                    m[i][j] = tmp;
                    s[i][j] = k; // 溯源存储
                }
            }
        }
    }
    return m and s;
}

void printOptimalParens(int s[][MAX], int i, int j) {
    if (i == j)
        cout << "A" << i;
    else {
        cout << "(";
        printOptimalParens(s, i, s[i][j]);
        printOptimalParens(s, s[i][j]+1, j);
        cout << ")";
    }
}

最长公共子序列

序列不需要连续

定义：字符串$X$长度为m和$Y$长度为n

目的：求出最长公共子序列

方程： $$ c[i,j] = \begin{cases} 0, &i=0 \space or\space j =0,\ c[i-1,j-1]+1,& i,j>0 \space and \space x_i == y_i,\ max{c[i-1,j],c[i,j-1]}, & i,j>0 \space and \space x_i \neq y_i. \end{cases} $$

代码：b[i][j]用来存是从哪里转移

表格i为行，j为列，填表。

LCS() {
    for (int i = 0; i < m; i++) c[i, 0] = 0;
    for (int i = 0; i < n; i++) c[0, i] = 0;
    
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < n; j++) {
			if (X[i] == Y[j]) {
                c[i][j] = c[i-1]][j-1] + 1;
                b[i][j] = "左上";
            } else if (c[i-1][j] > c[i][j-1]) {
                c[i][j] = c[i-1][j];
                b[i][j] = "上";
            } else {
                c[i][j] = c[i][j-1];
                b[i][j] = "左";
            }
        }
    }
    return c[m-1][n-1];
}

void print_LCS(int i, int j) {
    if (i == 0 || j == 0) return;

    if (b[i][j] == "左上") {
        print_LCS(i - 1, j - 1;
        cout << X[i - 1]; // 因为 X 是从 0 开始索引的
    }
    else if (b[i][j] == "上") {
        print_LCS(i - 1, j);
    }
    else { // "左"
        print_LCS(i, j - 1);
    }
}

答案不唯一

0/1背包

dp[i][j]：表示前 i 个物品，背包容量为 j 时，可以获得的最大价值。
dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weights[i]] + values[i])：选择第 i 个物品，从 i-1 的状态转移过来（因为每个物品只能选一次）。

贪心

任务选择问题：

找最先结束的

证明：一个是最优子结构性质，另一个是贪心选择性质。

只证贪心选择：

问题描述：

给定一组活动 S={a1,a2,…,an} ，每个活动 ai 有一个开始时间 si 和结束时间 fi 。
活动之间互不重叠时是兼容的。目标是选出一个最大兼容活动集合。

贪心策略：

每次选择最早结束 的活动 ak ，然后递归地处理与该活动兼容的剩余活动。

证明思路：

假设存在一个最优解 A 包含某个活动 aj ，而不是最早结束的活动 ak 。
由于 ak 是最早结束的活动，那么它的结束时间 fk≤fj 。
将 aj 替换为 ak 后，新的解 A′=(A−{aj})∪{ak} 仍然是一个有效解，并且大小与原解相同。
因此，A′ 也是一个最优解，并且包含 ak 。
这表明，选择最早结束的活动 不会影响最终得到一个最优解，即贪心选择是安全的。

完全背包

排序

霍夫曼

小根堆

图

会写代码即可

拓扑排序

const int N = 100010;
vector<int> adj[N];   // 邻接表
int indegree[N];      // 入度
vector<int> topo;     // 拓扑排序结果

int main() {
    int n, m; // n个点，m条边
    cin >> n >> m;
    while (m--) {
        int u, v;
        cin >> u >> v;  // u -> v
        adj[u].push_back(v);
        indegree[v]++;
    }

    queue<int> q;
    for (int i = 1; i <= n; i++)
        if (indegree[i] == 0)
            q.push(i);

    while (!q.empty()) {
        int u = q.front(); q.pop();
        topo.push_back(u);
        for (int v : adj[u]) {
            if (--indegree[v] == 0)
                q.push(v);
        }
    }

    if (topo.size() == n) {
        for (int x : topo) cout << x << " ";
    } else {
        cout << "有环，无法拓扑排序";
    }
    return 0;
}

Prim

const int INF = 1e9;
int n, g[100][100]; // 邻接矩阵存图
int dis[100];       // 每个点到生成树的最小边权
bool vis[100];      // 是否已加入生成树

int prim() {
    fill(dis, dis + n, INF);
    dis[0] = 0;
    int res = 0;
    for (int i = 0; i < n; ++i) {
        int u = -1;
        for (int j = 0; j < n; ++j)
            if (!vis[j] && (u == -1 || dis[j] < dis[u]))
                u = j;
        vis[u] = true;
        res += dis[u];
        for (int v = 0; v < n; ++v)
            if (!vis[v])
                dis[v] = std::min(dis[v], g[u][v]);
    }
    return res;
}

Kruskal

struct Edge {
    int u, v, w;
    bool operator<(const Edge& e) const {
        return w < e.w;
    }
};

int fa[100];
int find(int x) { return x == fa[x] ? x : fa[x] = find(fa[x]); }

int kruskal(int n, vector<Edge>& edges) {
    iota(fa, fa + n, 0);
    sort(edges.begin(), edges.end());
    int res = 0, cnt = 0;
    for (auto& e : edges) {
        int fu = find(e.u), fv = find(e.v);
        if (fu != fv) {
            fa[fu] = fv;
            res += e.w;
            if (++cnt == n - 1) break;
        }
    }
    return res;
}

Dijkstra

typedef pair<int, int> PII;
vector<PII> g[100]; // g[u] = {{v1, w1}, {v2, w2}, ...}
int dis[100];
bool vis[100];

void dijkstra(int s) {
    priority_queue<PII, vector<PII>, greater<>> pq;
    fill(dis, dis + 100, INF);
    dis[s] = 0;
    pq.emplace(0, s);
    while (!pq.empty()) {
        auto [d, u] = pq.top(); pq.pop();
        if (vis[u]) continue;
        vis[u] = true;
        for (auto [v, w] : g[u]) {
            if (dis[v] > d + w) {
                dis[v] = d + w;
                pq.emplace(dis[v], v);
            }
        }
    }
}

Floyd

const int INF = 1e9;
int n, d[100][100]; // d[i][j] 表示 i 到 j 的最短路径长度

void floyd() {
    for (int k = 0; k < n; ++k)
        for (int i = 0; i < n; ++i)
            for (int j = 0; j < n; ++j)
                d[i][j] = std::min(d[i][j], d[i][k] + d[k][j]);
}

网络流

网络流的图由一个源点s，一个汇点t和一个有向图组成，s只有出边，t只有入边。

主要的目的是为了求最大流，相当于一个水管网络单位时间从s到t的最大流量。

每个边要么带权$w$表示其容量（capacity），要么用$u/v$来表示，u为流量(flow)，v为容量，u <= v。我们再称v-u为余量（residual）

流的性质：用$(u,v)$表示一条有向边，f是流量，c是容量

容量约束 $f(u,v) \leq c(u,v)$
反对称性 $f(u,v) = -f(v,u)$
流守恒，除了源点和汇点外，每个顶点的流入量等于流出量。 $\sum_{u \in V} f(u, v) = 0$

流量定义：从源点到该点的总流量。$ |f|= \sum_{u} f(s, u)$

先给出一个最简单的方法，但是不一定能求出最大值。

先画出一个余量图（初始和原图相同），对于余量图图，我们找到一个简单路径从s到t（无环），然后将容量均减去所有边中最小的容量，如果出现容量变成0了，那么就视作删去这条边，然后重复上述操作，直到没有s到t的简单路径存在。

然后用原图减去余量图就可以得到一个新图，以u/v的格式表示，就可以得到一个流。

这个方法的局限性在于如果选择的路径顺序不同，结果也可能不同，你无法保证你选择的路径顺序是最优的，而枚举所有的路径也是相当复杂的，所以我们需要下面的算法。

FordFulkerson 算法

该算法和上面的朴素算法基本一样。

画出余量图
进行下述循环直到找不到从s到t的简单路径
- 找到s到t的简单路径
- 路径所有边减去最小的容量
- 给所有的路径加上减去容量的反向边（用另一种方式颜色/虚线表示便于区分），如果存在相同方向的可以进行合并

该方法弥补了之前方法无法反悔的缺陷，这使得它一定能找到最大流。

当然它也有缺陷，当它路径选择不当时每轮只能使其得到的流+1，所以它的最坏复杂度是O(f*m)，f是最大流，m是边数。

最大流最小割

这个是对找不到增广路径就是最大流情况的证明。

在流网络 G=(V,E) 中，设 s 为源点，t 为汇点，f 为 G 中的一个可行流。以下三个条件是等价的：

(1) f 是 G 中的最大流。

(2) 残量网络 Gf 中不存在增广路径。

(3) 存在某个割 (S,T)，使得 ∣f∣=c(S,T)（即流的值等于该割的容量）。

1->2:反证，存在增广路径就可以增加流，就不是最大流

3->1:根据最大流最小割定理，任意流的流量不超过任意割的容量。若 ∣f∣=c(S,T)，则 f 已达到理论最大值，故为最大流。

2->3：不存在到t的增广路径，我们让S为s能到的点，T为V-S，所以（S,T)划分是一个割，对于所有S到T的边都是饱和的，所以f(S,T)=c(S,T)，又由于f(S,T)=|f|所以可证。

最短路径增广SPA（Edmond-Karp ）

这个只是将Ford-Fulkerson的简单路径改成最短路径(使用BFS找到边数最小的，相当于权为1)，这样使得复杂度变成了O(n*m^2)。

备注一下：上面所有的简单路径也就是增广路径，路径上的最小容量也就是瓶颈容量。

二分图匹配

只掌握二分图转最大流求解。

构造流网络：
- 添加一个源点 s 和一个汇点 t。
- 从源点 s 向 U 中的每一个顶点 u 添加一条有向边，容量为 1。
- 对于原二分图中的每一条边 (u,v)（其中 u∈U, v∈V），添加一条从 u 到 v 的有向边，容量为 1。
- 从 V 中的每一个顶点 v 向汇点 t 添加一条有向边，容量为 1。
求解最大流：
- 使用最大流算法计算从 s 到 t 的最大流。
- 最大流的值即为二分图的最大匹配的大小。
- 流网络中流量为 1 的 U 到 V 的边对应于匹配中的边。

P NP问题

P （Polynomial ）问题：能在多项式时间内解决的问题。 NP（Nondeterministic Polynomial ）问题：解的正确性能在多项式时间内被验证。

判定问题：回答是否存在一个满足问题要求的解。

NPC (Completeness) 问题：

属于NP问题
所有NP问题可在多项式时间归约到它

NP-Hard问题：如果所有NP问题都可以多项式时间归约到某个问题，则称该问题为NP困难。因此NP困难问题“至少与NP完全问题一样难”。

归约：将问题 A 的实例 x 转换成问题 B 的实例 f(x)，使得：

如果 x 是 A 的“是”实例，则 f(x) 也是 B 的“是”实例。
如果 x 是 A 的“否”实例，则 f(x) 也是 B 的“否”实例。

在NP证明中我们要求归约函数 f 必须在多项式时间内计算完成。

回溯法

就是dfs

约束函数：判断当前部分解是否满足问题的约束条件。

示例：在n皇后问题中，约束函数判断当前皇后是否和前面已放置的皇后冲突（同列/对角线等）。

限界函数：用于估计从当前部分解出发最优情况下也不可能超过当前已知最优解，从而剪枝。

装载问题

n个箱子，重量分别为$w_i$，最多装W，求出能装出最接近W的装法。

约束函数：$C(i) = cw(i-1) + w_i$

C(i)含义是：尝试加入第 i 个箱子后的总重量。

cw：当前累计重量（current weight）

限界函数：$B(i) = C(i) + r(i)$

r(i) 是从第 i+1 箱子开始，剩余还没尝试的所有箱子中可能加入的最大重量之和

剪枝的两种情况：

约束剪枝（可行性剪枝）：$C(i) > W$

限界剪枝（最优性剪枝）:$B(i) \leq bestw$

01背包

想要剪枝需要按照性价比先排序。

约束函数：$C(i) = cw(i-1) + w_i$

cw：当前累计重量（current weight）

限界函数：$B(i) = cv(i) + r(i)$

cv：当前累计价值（current value）

r(i)：剩余物品（从i+1）开始的最大总价值。

r(i)的计算：如果能装下去就装，装不下去就拆开装，因为最终的结果一定是小于等于这个贪心得到的值的，上界都不如目前的bestw就没必要继续搜索了。

约束剪枝（可行性剪枝）：$C(i) > W$

限界剪枝（最优性剪枝）:$B(i) \leq bestw$

分支限界

就是bfs剪枝+（优先）队列

01背包

约束函数：$C(i) = cw(i-1) + w_i$

cw：当前累计重量（current weight）

限界函数：$B(i) = cv(i) + r(i)$

cv：当前累计价值（current value）

r(i)：剩余物品（从i+1）开始的最大总价值。

解空间树的画法：

每个节点旁边是C(i)/B(i)，如果C(i)>W那么就似了，如果叶子节点的cv大于剩下的所有的B那么就结束了，每次从目前B(i)最高的值开始继续搜。

可满足性问题

歪果选修课

ldfd@outlook.it (ldfd) — Sun, 06 Apr 2025 13:26:55 +0800

假设检验超详细基础教程（贝叶斯决策、MAP、ML规则与错误概率）

0. 从生活例子理解假设检验

场景：医生判断患者是否患病（假设检验简化版） • 假设： • $H_0$（原假设）：患者健康 • $H_1$（备择假设）：患者患病 • 数据：检测结果 $X$（如血液指标） • 目标：根据 $X$ 选择接受 $H_0$ 或 $H_1$，尽量少犯错。

1. 核心概念与符号

1.1 基本定义

• 条件概率分布： • $f_X(x \mid H_0)$：健康时检测结果的分布（如正态分布）。 • $f_X(x \mid H_1)$：患病时检测结果的分布。 • 先验概率： • $P(H_0) = P_0$（人群中健康者的比例）。 • $P(H_1) = P_1 = 1 - P_0$（患病的比例）。

1.2 两类错误

错误类型	定义	概率符号	生活例子
第一类错误（假阳性）	$H_0$ 为真时错误拒绝 $H_0$	$P_{FA}$	健康人被误诊为患病
第二类错误（假阴性）	$H_1$ 为真时错误接受 $H_0$	$P_M$	患病者被漏诊

1.3 总错误概率

$$ P(\text{error}) = \underbrace{P(\text{误诊} \mid H_0)}{P{FA}} \cdot P_0 + \underbrace{P(\text{漏诊} \mid H_1)}_{P_M} \cdot P_1 $$ 目标：找到决策规则，使 $P(\text{error})$ 最小。

2. 决策规则：从直觉到公式

2.1 最大似然（ML）规则

• 思想：只相信数据，忽略人群患病率。 • 判决条件： • 如果 $f_X(x \mid H_1) > f_X(x \mid H_0)$，选 $H_1$；否则选 $H_0$。 • 公式： $$ L(x) = \frac{f_X(x \mid H_1)}{f_X(x \mid H_0)} \gtrless 1 \quad \text{（似然比）} $$ • 适用场景：无先验信息（如 $P_0 = P_1 = 0.5$）。

2.2 最大后验概率（MAP）规则

• 思想：结合数据与先验知识（如人群患病率）。 • 判决条件： • 如果 $P(H_1 \mid x) > P(H_0 \mid x)$，选 $H_1$；否则选 $H_0$。 • 公式（利用贝叶斯定理）： $$ \frac{P(H_1 \mid x)}{P(H_0 \mid x)} = \frac{f_X(x \mid H_1)P_1}{f_X(x \mid H_0)P_0} \gtrless 1 $$ 简化为： $$ L(x) \gtrless \frac{P_0}{P_1} $$ • 意义：如果疾病罕见（$P_1$ 小），需要更强的数据证据才能诊断患病。

2.3 贝叶斯决策规则

• 思想：考虑不同错误的代价（如误诊健康人 vs. 漏诊患者）。 • 成本矩阵：

	决策选 $H_0$	决策选 $H_1$
真实 $H_0$	$C_{00} = 0$	$C_{10} = 1$
真实 $H_1$	$C_{01} = 5$	$C_{11} = 0$

例：漏诊患者（C01=5）比误诊健康人（C10=1）更严重。

判决条件： $$ L(x) \gtrless \frac{(C_{10} - C_{00})P_0}{(C_{01} - C_{11})P_1} $$

特殊情形（均匀成本）：

当 C00=C11=0，C10=C01=1 时，退化为 MAP 规则。

3. 逐步推导：为什么MAP最小化错误概率？

3.1 后验概率与错误的关系

• 后验概率：$P(H_0 \mid x)$ 和 $P(H_1 \mid x)$ 是给定数据后的修正信念。 • 直觉：选择后验概率大的假设，犯错概率自然最小。

3.2 数学证明

• 总错误概率： $$ P(\text{error} \mid x) = \min{P(H_0 \mid x), P(H_1 \mid x)} $$ • MAP选择：若 $P(H_1 \mid x) > P(H_0 \mid x)$，则错误概率为 $P(H_0 \mid x)$，这是可能的最小值。

3.3 均匀成本下的贝叶斯规则

• 当所有错误成本相等时，最小化 $E[\text{cost}]$ = 最小化 $P(\text{error})$。 • 公式推导： $$ E[\text{cost}] = P_{FA} \cdot C_{10} \cdot P_0 + P_M \cdot C_{01} \cdot P_1 $$ 若 $C_{10}=C_{01}=1$，则 $E[\text{cost}] = P(\text{error})$。

4. 对比表格：三大规则核心差异

规则	输入	阈值公式	优化目标	生活例子类比
ML规则	数据似然度	$L(x) \gtrless 1$	仅依赖数据	抛硬币10次8次正面，认为硬币不均匀
MAP规则	数据+先验概率	$L(x) \gtrless P_0/P_1$	最小化错误概率	结合新冠流行率判断检测结果
贝叶斯规则	数据+先验+成本矩阵	$L(x) \gtrless \frac{(C_{10}-C_{00})P_0}{(C_{01}-C_{11})P_1}$	最小化期望损失	医疗决策中权衡误诊和漏诊代价

5. 实际应用步骤

案例：工厂质检（判断产品合格 $H_0$ vs. 不合格 $H_1$）

步骤1：建立模型 • 测量数据 $X$（如零件尺寸），假设： ◦ $X \mid H_0 \sim N(\mu_0, \sigma^2)$（合格产品尺寸分布） ◦ $X \mid H_1 \sim N(\mu_1, \sigma^2)$（不合格产品尺寸分布） • 先验概率：$P_0 = 0.95$（合格率95%），$P_1 = 0.05$。
步骤2：选择决策规则 • 若只考虑数据：ML规则，阈值 $L(x) = 1$。 • 若考虑先验：MAP规则，阈值 $L(x) > 0.95/0.05 = 19$。 • 若考虑成本（如误判合格损失100元，误判不合格损失10元）： $$ \text{阈值} = \frac{(100 - 0) \cdot 0.95}{(10 - 0) \cdot 0.05} = 190 $$
步骤3：计算与决策 • 假设某零件测得 $x = 12.1$，计算似然比 $L(x) = \frac{f_X(12.1 \mid H_1)}{f_X(12.1 \mid H_0)}$。 • 比较阈值，决定是否拒收零件。

6. 常见问题解答

Q1：先验概率未知怎么办？ • 使用ML规则，或假设均匀先验（$P_0 = P_1 = 0.5$）。

Q2：如何确定成本参数？ • 依赖领域知识（如医学中漏诊成本远高于误诊）。

Q3：非高斯分布如何处理？ • 原理相同，只需替换 $f_X(x \mid H_i)$ 的具体分布形式（如泊松分布、指数分布）。

7. 总结

• 核心逻辑链： $$ \text{数据} + \text{先验} + \text{成本} \xrightarrow{\text{贝叶斯框架}} \text{决策规则} \rightarrow \text{最小化损失} $$ • 关键记忆点：

ML规则：纯数据驱动，阈值=1。
MAP规则：数据+先验，阈值=$P_0/P_1$。
贝叶斯规则：广义形式，可调成本参数。
最小化错误概率：当成本均匀时，MAP=贝叶斯最优。

假设检验的判决规则通常基于统计量（如似然比 L(x)）与阈值 τ 的比较：

若 L(x)>τ→拒绝 H0（选 H1）,若 L(x)<τ→接受 H0.

第二堂课

第一部分：假设检验（Hypothesis Testing）

一、基本概念

原假设（H₀）：我们先默认它是真的
备择假设（H₁）：我们想证明它是真的
从样本数据出发，决定是否拒绝 H₀

二、四种决策结果

实际情况 / 决策	选择 H₀	选择 H₁
H₀ 为真	正确（True Negative）	第一类错误 Type I Error (α)
H₁ 为真	第二类错误 Type II Error (β)	正确（True Positive）

显著性水平 α：错误拒绝 H₀ 的概率
检验功效 Power = 1 - β

三、最优检验准则（Neyman-Pearson）

似然比检验： [ \Lambda(x) = \frac{f(x|H_1)}{f(x|H_0)} ]
如果 ( \Lambda(x) > \eta ) 则拒绝 H₀，接受 H₁

四、p 值

定义：在 H₀ 成立的条件下，观察到比当前数据更极端的概率
越小，越不支持 H₀

p 值解释规则：

p < 0.01：非常强证据反对 H₀
0.01 < p < 0.05：强证据
0.05 < p < 0.1：弱证据
p > 0.1：几乎无证据反对 H₀

例子：

抛 5 次硬币全为正面，假设 H₀：p=0.5，则 [ p = (0.5)^5 = 0.03125 < 0.05 \Rightarrow \text{拒绝 H₀} ]

第二部分：参数估计（Parametric Estimation）

一、点估计（Point Estimation）

目标：使用样本估计未知参数 (\theta)

性质：

无偏性： [ \mathbb{E}[\hat{\theta}] = \theta ]
方差： [ \text{Var}(\hat{\theta}) ]
均方误差（MSE）： [ \text{MSE} = \text{Bias}^2 + \text{Var} ]
一致性：( \hat{\theta}_n \xrightarrow{p} \theta )

二、最大似然估计（MLE）

定义： [ \hat{\theta}{\text{MLE}} = \arg\max{\theta} L(\theta) = \arg\max_{\theta} f(x_1, …, x_n | \theta) ]

例子：抛硬币

设观察到正面次数为 S，总次数为 n： [ L(\theta) = \theta^S (1 - \theta)^{n - S} \ \log L(\theta) = S \log \theta + (n - S) \log (1 - \theta) ] 求导得： [ \hat{\theta} = \frac{S}{n} ]

三、贝叶斯估计（Bayesian Estimation）

给定先验分布 ( p(\theta) )
后验分布： [ p(\theta | x) = \frac{f(x|\theta)p(\theta)}{p(x)} ]

估计方法：

MAP：最大后验概率估计： [ \hat{\theta}_{\text{MAP}} = \arg\max p(\theta|x) ]
MMSE：最小均方误差估计： [ \hat{\theta}_{\text{MMSE}} = \mathbb{E}[\theta | x] ]

第三部分：置信区间（Confidence Interval）

Hoeffding 不等式（用于构造置信区间）

若 (X_1, \dots, X_n\in[a,b])，独立同分布，记样本均值为： [ \bar{X}_n = \frac{1}{n}\sum X_i ] 则有： [ P(|\bar{X}_n - \mathbb{E}[X]| \geq \varepsilon) \leq 2 \exp\left(-\frac{2n\varepsilon^2}{(b - a)^2}\right) ]

例子：

抛 100 次硬币观察到 60 次正面，样本比例 ( \bar{X} = 0.6 )

设 ( \delta = 0.05 )，则 [ \varepsilon = \sqrt{\frac{\log(2/\delta)}{2n}} \approx 0.135 ] 置信区间为： [ [0.465, 0.735] ] 表示我们有 95% 的把握，认为正面概率落在这个区间内。

总结表格

内容	关键公式	举例
假设检验	( \Lambda(x) = \frac{f(x	H_1)}{f(x
点估计	MLE: ( \hat{\theta} = \arg\max L(\theta) )	硬币正面比例 ( \hat{\theta} = \frac{S}{n} )
贝叶斯估计	后验：( p(\theta	x) )，MAP、MMSE
置信区间	Hoeffding: ( \varepsilon = \sqrt{\frac{\log(2/\delta)}{2n}} )	[0.465, 0.735]

如果需要图示或例题演练，也可以继续加！

以下是将标题降级后的版本，所有标题都调整为更小的层级（例如将 # 改为 ##，## 改为 ### 等），以便在文档中更好地组织内容：

（四）一、基础设定

• 有 $k$ 个操作选择，或称 “arms” • 每轮 $t = 1, 2, \dots, n$： ◦ 选择一个 arm: $A_t \in A$ ◦ 获得奖励: $X_t \sim P_{A_t}$

目标: 最大化累计奖励 $$ S_n = \sum_{t=1}^{n} X_t $$

二、核心概念

• Mean reward: $$ \mu_a = \mathbb{E}[X \mid A = a] $$ 例如 Bernoulli 奖励： $\mu_a = \theta_a$

• Best Arm: $$ a^* = \arg\max_a \mu_a $$ • Regret (懵悔): $$ R_n = n \cdot \mu^* - \mathbb{E}\left[\sum_{t=1}^{n} X_t \right] $$ • 分解公式: ◦ $T_a(n)$: arm $a$ 被选的次数 ◦ $\Delta_a = \mu^* - \mu_a$ ◦ $$ R_n = \sum_{a \in A} \mathbb{E}[T_a(n)] \cdot \Delta_a $$

三、Explore-Then-Commit (ETC) 算法

思路:

每个 arm 先游玩 $m$ 次
选择平均奖励最大的 arm，一直选它

Regret 分析:

$$ R_n = m \cdot \sum_{i eq a^} \Delta_i + (n - km) \cdot \sum_{i eq a^} P(\text{commit to } i) \cdot \Delta_i $$

优化选择 $m$ 可以让 regret 约为 $\mathcal{O}(\log n)$

四、UCB (Upper Confidence Bound) 算法

思路: 基于 “optimism under uncertainty” 原则，给每个 arm 一个置信上界值

$$ \text{UCB}_i(t) = \hat{\mu}_i(t) + \sqrt{\frac{2 \log t}{T_i(t)}} $$

• $\hat{\mu}_i(t)$: arm $i$ 当前平均奖励 • $T_i(t)$: arm $i$ 被选次数 • 选择 UCB 最大的 arm

Regret 界:

$$ R_n \leq \sum_{i eq a^*} \left( \frac{8 \log n}{\Delta_i} + \text{const} \right) $$

五、ETC 和 UCB 对比

算法	是否需知 $\Delta$	是否均衡探索/利用	Regret	特点
ETC	需要	不均衡	$\mathcal{O}(\log n)$	简单，需控 $m$
UCB	不需要	动态均衡	$\mathcal{O}(\log n)$	实际效果好

六、示例：UCB 在广告点击率优化中的应用

场景:

你需要在两个广告位之间选择一个显示，每次显示都会记录点击，点击=1，未点击=0。

• Arm A: $\theta_A = 0.7$ 点击率 (unknown) • Arm B: $\theta_B = 0.5$ 点击率 (unknown)

前 4 轮操作:

轮 $t$	选择	点击 $X$	$\hat{\mu}$	$T_i(t)$	UCB
1	A	1	1.0	1	$\infty$
2	B	0	0.0	1	$\infty$
3	A	1	1.0	2	2.18
4	A	0	0.66	3	1.78

分析:

• UCB 算法初始会对每个 arm 进行基本探索，然后根据置信区间的上界进行利用 • 随着时间探索增加，正确的 arm 会被选中的次数增加，接近真实均值 • UCB 会自动抑制对次优 arm 的过度探索

第四堂课

以下是课程知识点的详细总结，包含公式和示例：

1. 多臂老虎机问题 (Multi-Armed Bandit Problem)

核心目标：在探索（Exploration）与利用（Exploitation）之间平衡，最大化累积奖励。

关键指标

• Regret（遗憾）：长期累积奖励与最优策略的差距
$$ R_n = n \cdot \mu^* - \sum_{t=1}^n \mu_{A_t} $$
其中 $\mu^*$ 是最优臂的期望奖励，$\mu_{A_t}$ 是第$t$步选择的臂的期望奖励。

2. UCB 算法 (Upper Confidence Bound)

思想：通过置信区间选择潜在收益最高的臂。

公式

$$ UCB_i(t) = \hat{\mu}_i + \sqrt{\frac{2 \ln t}{T_i(t)}} $$
• $\hat{\mu}_i$：臂$i$的历史平均奖励
• $T_i(t)$：臂$i$被拉取的次数
• $\sqrt{\frac{2 \ln t}{T_i(t)}}$：置信区间宽度（随时间减少）

示例

假设有两臂： • 臂1：平均奖励 $\hat{\mu}_1 = 0.8$，被拉取10次
• 臂2：平均奖励 $\hat{\mu}_2 = 0.7$，被拉取100次
则： $$ UCB_1 = 0.8 + \sqrt{\frac{2 \ln 100}{10}} \approx 0.8 + 0.9 = 1.7 $$ $$ UCB_2 = 0.7 + \sqrt{\frac{2 \ln 100}{100}} \approx 0.7 + 0.45 = 1.15 $$ 此时选择臂1。

3. ETC 算法 (Exploit-Then-Commit)

思想：先探索所有臂固定次数$m$，再选择平均奖励最高的臂持续利用。

性能

• 若$m$选择合理，性能接近UCB，但通常略差。 • 变种UCB（如汤普森采样）通常表现更优。

4. 贝叶斯方法

核心思想：通过概率模型（先验分布）动态更新对环境的认知（后验分布）。

公式

$$ q(u) = P(\text{环境为} u) $$ 最优策略为最小化期望损失： $$ \pi^* = \arg\min_\pi \sum_{u \in \mathcal{E}} q(u) \cdot \mathbb{E}[L(\pi, u)] $$

示例

假设环境有两种可能：

两白球（WW），奖励1
一白一黑（WB），奖励0.5

初始先验：$P(WW) = P(WB) = 0.5$

观察数据：随机抽取一球为黑色。 • 后验概率： $$ P(WW | \text{黑球}) = 0 $$ $$ P(WB | \text{黑球}) = 1 $$

5. 汤普森采样 (Thompson Sampling)

思想：从每个臂的奖励分布中随机抽样一个值，选择抽样值最高的臂。

关键步骤

为每个臂$i$维护一个后验分布（如Beta分布）。
抽样$\theta_i \sim \text{Beta}(\alpha_i, \beta_i)$。
选择$\theta_i$最大的臂$i$。
根据奖励更新后验参数。

示例

假设奖励服从伯努利分布（0或1）： • 初始参数：$\alpha_1 = 1, \beta_1 = 1$（均匀先验） • 拉取臂1，获得奖励1 → 更新为$\alpha_1=2, \beta_1=1$ • 下次抽样时，$\theta_1 \sim \text{Beta}(2,1)$ 更可能偏高。

6. 算法对比

算法	优点	缺点
UCB	理论保证强，方差小	探索效率可能低
ETC	实现简单	需要预定义探索次数$m$
汤普森采样	实际表现优异，适应性强	方差较大，理论分析困难

7. 数学工具

• Sub-Gaussian 分布：若随机变量$X$满足$P(|X - \mu| \geq t) \leq e^{-t^2/(2\sigma^2)}$，则称$X$是$\sigma$-sub-Gaussian。 • 例如：奖励范围$[a,b]$时，$\sigma = \frac{b-a}{2}$。

总结

UCB和汤普森采样是解决多臂老虎机问题的经典算法。
贝叶斯方法通过动态更新信念优化决策。
ETC适合探索次数明确的场景，但灵活性较低。

建议结合具体代码实现（如Python的numpy和scipy库）加深理解。

第五堂

以下是本节课的核心知识点总结，我会尽量用通俗的语言和例子帮助你理解：

一、在线学习（Online Learning）

核心思想：数据逐个到达，模型实时更新，无需完整训练集。

1. 关键概念

• 累积后悔（Regret）：模型当前损失与事后最优模型的累计差距
公式：
$$R(T)=\sum_{t=1}^{T}\left[I\left(x_{t}, y_{t},\beta_{t}\right)-I\left(x_{t}, y_{t},\beta^{*}\right)\right]$$
目标：让后悔随时间次线性增长（即最终接近最优模型）。

• 应用场景：
处理大数据流、适应数据分布变化（如房价预测）。

2. 典型算法

• 随机梯度下降（SGD）：每次用单个样本更新模型参数。 • 多臂老虎机（Multi-armed Bandits）：在探索（尝试新动作）与利用（选择已知最优动作）间权衡。

二、强化学习（Reinforcement Learning, RL）

核心思想：智能体通过与环境的交互学习最优策略，最大化长期奖励。

1. 基本要素

• 状态（State, (s)）：环境的描述（如机器人位置、游戏画面）。
例：机器人当前坐标 [3,3]。

• 动作（Action, (a)）：智能体可执行的操作（如移动方向）。
例：机器人可选 UP/DOWN/LEFT/RIGHT。

• 奖励（Reward, (r)）：执行动作后的反馈（正/负/零）。
例：抓取物体得+1分，撞墙得-1分，移动扣-0.04分。

• 策略（Policy, (\pi)）：状态到动作的映射。
确定性策略：(\pi(s) = a)（直接指定动作）。
随机策略：(\pi(a|s))（给出动作的概率分布）。

2. 目标函数

• 无限时域折扣奖励：
$$R(\infty)=\sum_{t=0}^{\infty} \gamma^{t} r(a(t), s(t))$$
(\gamma \in [0,1)) 是贴现因子（平衡短期与长期奖励）。

3. 马尔可夫决策过程（MDP）

核心假设：未来状态仅依赖当前状态和动作（无记忆性）。

• 组成： • 状态空间 (S)（如网格世界的所有坐标）。 • 动作空间 (A)（如四个移动方向）。 • 转移概率 (P(s’|s,a))（从状态 (s) 执行动作 (a) 后转移到 (s’) 的概率）。 • 奖励函数 (r(s,a))（执行动作 (a) 在状态 (s) 时的即时奖励）。

• 示例：
下图展示一个简单的网格世界，智能体需通过上下左右移动到达目标位置 [4,3]（奖励+1）或避免 [4,2]（奖励-1）。

4. 贝尔曼方程（Bellman Equation）

作用：将长期奖励分解为即时奖励和未来奖励的加权和。

• 状态值函数（State-Value Function）：
$$V_{\pi}(s) = E\left[\sum_{t=0}^{\infty} \gamma^{t} r(a(t), s(t)) \mid s(0)=s\right]$$
表示从状态 (s) 出发，遵循策略 (\pi) 的期望总奖励。

• 动作值函数（Action-Value Function）：
$$Q_{\pi}(a,s) = E\left[r(a,s) + \gamma \sum_{s’} P(s’|s,a) V_{\pi}(s’) \right]$$
表示在状态 (s) 执行动作 (a) 后，遵循 (\pi) 的期望总奖励。

• 最优策略：
通过贪心选择动作最大化 (Q^(a,s))：
$$\pi^(s) = \arg\max_a Q^*(a,s)$$

5. 挑战与解决方案

• 未知动态：需通过试错学习状态转移规律。 • 部分可观测：需推断隐藏状态（如自动驾驶中仅通过摄像头观察环境）。 • 延迟奖励：需平衡短期收益与长期目标（如围棋中牺牲局部利益换取全局胜利）。

三、经典案例：机器人导航

目标：从起点 [START] 移动到目标 [4,3]（奖励+1），避开 [4,2]（奖励-1），每步扣除-0.04分。

1. 策略分析

• 状态：机器人当前位置（如 [3,3]）。 • 动作：上/下/左/右移动。 • 奖励：根据是否到达目标或执行动作计算。

2. 值函数计算

假设折扣因子 (\gamma=0.9)，使用贝尔曼方程迭代更新各状态的值函数，最终找到最优路径。

四、总结

在线学习：处理动态数据流，关注累积后悔的最小化。
强化学习：通过与环境交互学习策略，核心是贝尔曼方程和马尔可夫决策过程。
关键挑战：探索与利用的平衡、延迟奖励的处理。

学习建议：
• 从简单环境（如网格世界）开始实践，理解状态、动作、奖励的关系。
• 尝试推导贝尔曼方程，理解其递归分解的思想。
• 对比监督学习（有标注数据）与强化学习（通过试错学习）的差异。

如果有具体问题（如公式推导或代码实现），可以进一步讨论！ 🚀

算法上机

ldfd@outlook.it (ldfd) — Thu, 13 Mar 2025 19:48:43 +0800

Expt2(递归/分治)

王牌游戏

数据范围一给就知道是cf的原题，但是左半部分是什么傻逼翻译，请强调一下左面的一半。

彩球归位

Python 卡常+1

总体时间复杂度为 O(N + Q)，其中N是球的总数，Q是桶的数量。对于最坏情况，每个桶都有球，且所有球都能配对移除，我们需要处理每个球，因此是线性的。

#include <bits/stdc++.h>

using namespace std;

int main() {
    int N, Q;
    cin >> N >> Q;

    // 读取所有桶的数据
    vector<vector<int>> buckets(Q);
    for (int i = 0; i < Q; ++i) {
        int k;
        cin >> k;
        buckets[i].resize(k);
        for (int j = 0; j < k; ++j) {
            cin >> buckets[i][j];
        }
        // 从顶部取球，符合题意，需要反转
        reverse(buckets[i].begin(), buckets[i].end());
    }

    // 球 -> 桶的映射
    vector<vector<int>> color_to_buckets(N + 1);
    
    // BFS队列，存储可以配对的颜色
    queue<int> matching_colors;

    // 初始化：检查每个桶顶部的球，建立颜色到桶的映射
    for (int i = 0; i < Q; ++i) {
        if (!buckets[i].empty()) {
            int top_color = buckets[i].back();
            color_to_buckets[top_color].push_back(i);
            
            // 如果某种颜色刚好有两个球在不同桶的顶部，加入队列
            if (color_to_buckets[top_color].size() == 2) {
                matching_colors.push(top_color);
            }
        }
    }

    // BFS处理能够配对的球
    while (!matching_colors.empty()) {
        int current_color = matching_colors.front();
        matching_colors.pop();

        // 如果当前颜色的球少于2个（可能在之前的操作中已被处理），跳过
        if (color_to_buckets[current_color].size() < 2) {
            continue;
        }

        // 获取两个包含当前颜色球的桶
        int bucket1 = color_to_buckets[current_color].back();
        color_to_buckets[current_color].pop_back();
        int bucket2 = color_to_buckets[current_color].back();
        color_to_buckets[current_color].pop_back();

        // 从两个桶中移除顶部的球
        buckets[bucket1].pop_back();
        buckets[bucket2].pop_back();

        // 检查移除球后，两个桶的新顶部球
        for (int bucket_idx : {bucket1, bucket2}) {
            if (!buckets[bucket_idx].empty()) {
                int new_top_color = buckets[bucket_idx].back();
                color_to_buckets[new_top_color].push_back(bucket_idx);
                
                // 如果新顶部颜色刚好有两个，加入队列
                if (color_to_buckets[new_top_color].size() == 2) {
                    matching_colors.push(new_top_color);
                }
            }
        }
    }

    // 检查是否所有桶都为空
    bool all_empty = true;
    for (const auto& bucket : buckets) {
        if (!bucket.empty()) {
            all_empty = false;
            break;
        }
    }

    cout << (all_empty ? "Yes" : "No") << endl;

    return 0;
}

异或游戏

Python被卡常了，差评。

#include <bits/stdc++.h>

using namespace std;

/**
 * @brief 通过对位的二进制搜索计算最小可能的异或(XOR)值
 * 
 * 这个函数实现了一种分治方法来寻找最小异或值:
 * 1. 对于每个位置(从最高有效位到最低有效位)，将数字分成两组
 * 2. 一组在当前位置有1，另一组在当前位置有0
 * 3. 递归处理导致最小异或值的那个组
 * 
 * @param bit 当前处理的位位置(从最高有效位开始)
 * @param candidates 当前递归级别要处理的整数数组
 * @return 给定位置和候选数字可能的最小异或值
 * 
 * 时间复杂度: O(N * log(max(candidates)))
 * 空间复杂度: O(N) 用于存储分离的组
 * 
 * 注意: 假设输入向量非空且包含非负整数
 */

int dfs(int bit, vector<int>& candidates) {
    if (bit < 0) {
        return 0;
    }
    int mask = 1 << bit;
    vector<int> zeros, ones;
    for (int num : candidates) {
        if (num & mask) {
            ones.push_back(num);
        } else {
            zeros.push_back(num);
        }
    }
    if (zeros.empty()) {
        return dfs(bit - 1, ones);
    } else if (ones.empty()) {
        return dfs(bit - 1, zeros);
    } else {
        int val1 = dfs(bit - 1, ones);
        int val2 = dfs(bit - 1, zeros);
        return (1 << bit) + min(val1, val2);
    }
}

int find_min_max_xor(vector<int>& arr) {
    // 找到最大的数，然后调用抽象函数实现O(1)计算最高位是哪一位，不过只算一次其实复杂点也无所谓（
    if (arr.empty()) {
        return 0;
    }
    int max_val = *max_element(arr.begin(), arr.end());
    int max_bit = max_val ? __builtin_clz(1) - __builtin_clz(max_val) : 0;
    return dfs(max_bit, arr);
}

int main() {
    int n;
    cin >> n;
    vector<int> arr(n);
    for (int i = 0; i < n; ++i) {
        cin >> arr[i];
    }
    cout << find_min_max_xor(arr) << endl;
    return 0;
}

魔法符文分形

原题 USACO17JAN

def solve(a, n, i):
    """
    递归函数，用于查找序列中数字的位置。
    此函数通过递归二分法计算序列中数字的位置，
    在每个递归层级将序列分成两半。
    参数：
        a (int): 当前考虑的序列长度
        n (int): 要在当前序列中查找的位置（基于1的索引）
        i (int): 变换的次数
    返回：
        int: 原始序列s中目标位置的值
    注意：
        - 函数假设存在包含原始序列的全局列表/数组's'
        - 当i=1时达到基本情况，返回原始序列s的第(n-1)个元素
        - 对于每个递归层级，长度为'a'的序列被分成两半
        - 根据目标位置在哪一半中重新计算位置n
    """

    if i == 1:
        return s[n-1]

    x = a // 2
    # 下面所有的目的都是把n映射到左侧的位置
    if n <= x:
        # 在左面
        return solve(x, n, i-1)
    else:
        # 恰好在右面的第一个 等价于 找左面的最后一个
        if n == (x + 1):
            return solve(x, n-1, i-1)
        # 其他右面情况 仅考虑最简情况理解 举例理解
        """
        ABCD
        ABCD DABC
        """
        # 此时n-x为右侧的第几个，是由左侧尾巴移动到头构造得到的，所以比在左侧的对应的位置大1。
        else:
            return solve(x, n-x-1, i-1)


s, n = input().split()
n = int(n)
a = len(s)
i = 1
# a变换i次后，满足第n个字符在这个变形后的串里面
while a < n:
    i += 1
    a *= 2

print(solve(a, n, i))

为运算表达式设计优先级

和表达式递归求值想法相同。一个表达式可以分成：运算符、数字、更小的表达式。

当遇到运算符时进行左右切片，左右是表达式进而递归调用函数。当表达式不再存在运算符时等价于它就是数字，所以返回整数。

注意对于一个表达式返回的是一个列表，这样代码中的两种循环就可以理解了。

def f(input):
    res = []
    for i in range(len(input)):
        if input[i] in {'+', '-', '*'}:
            left = f(input[:i])
            right = f(input[i+1:])
            for l in left:
                for r in right:
                    if input[i] == '+':
                        res.append(l + r)
                    elif input[i] == '-':
                        res.append(l - r)
                    elif input[i] == '*':
                        res.append(l * r)
    if not res:
        res.append(int(input))
    return res
print('\n'.join(map(str,sorted(f(input())))))

石子游戏

记忆化搜索

Expt3(DP)

调制四果汤

原题 CF1042B Vitamins 现在加强完不能暴力了（

由题目可知，四果汤的特征n = 15为一个较小的值，又没那么小的值，所以可以采用状压dp来做。

状态定义 : dp[mask] 表示获得当前集合所需的最小成本
mask : 第(i-1)为表示第i种元素, ABCD... -> 第0123二进制位
初始状态 : dp[0] = 0 无集合成本视作空
状态转移: dp[mask] 由 dp[mask | current] 转移而来， current表示当前配料的元素的mask

所以预处理出所有配料的mask, 然后进行dp即可。

vector<int> ingredient_bits(T, 0);
for (int i = 0; i < T; ++i) {
    const string& elem = elements[i];
    for (char c : elem) {
        if (c >= 'A' && c < 'A' + n) {
            int bit = c - 'A';
            ingredient_bits[i] |= (1 << bit);
        }
    }
}

vector<long long> dp(1 << n, LLONG_MAX);
dp[0] = 0;

for (int i = 0; i < T; ++i) {
    int current_mask = ingredient_bits[i];
    long long price = prices[i];

    for (int mask = (1 << n) - 1; mask >= 0; --mask) {
        if (dp[mask] != LLONG_MAX) {
            // 不等于LLONG_MAX说明当前mask是可达的，进而可以转移到mask | current
            int new_mask = mask | current_mask;
            if (dp[new_mask] > dp[mask] + price) {
                dp[new_mask] = dp[mask] + price;
            }
        }
    }
}

上课别摸鱼

原题统计打字方案数 - 力扣（LeetCode）

由leetcode可知常数非常宽松（

这道题的dp不是对于总方案而言的，而是对于每一个按键来说的。

状态定义 : dp[i]表示i个相同数字可以产生的序列数量 1-index
初始状态 : dp[0] = 1 空串视作一种方案
状态转移 : 对于dp[i]，我们假设最后一个字母消耗了k个按键，但是这k个按键最终形成的是一个字母，所以说对于方案数不是乘法的关系，只是单纯的追加上去，和dp[i-k]的方案数是相同的，而k的取值是变化的,即[1, (1, min(i, mp[c])]，最终构成了dp[i]
mp[c] : 表示c按键有几个字母

然后进行下一步，我们只需要将不同连续的数字视作一个整体（不停地查相同数字个数即可），然后将它们的方案数相乘即可。当然预处理dp数组效率更高，一共就两个，但是下面的能过没被卡。

mp = {
        2: 3,
        3: 3,
        4: 3,
        5: 3,
        6: 3,
        7: 4,
        8: 3,
        9: 4
    }

def calc(n, c):
    dp = [0] * (n + 1)
    dp[0] = 1
    
    for i in range(1, n + 1):
        for j in range(1, min(i, mp[c]) + 1):
            dp[i] += dp[i - j]
    return dp[n]

ans = 1
cnt = 0
MOD = 10**9 + 7
pressedKeys = input()
n = len(pressedKeys)
for i in range(n):
    cnt += 1
    if i == n - 1 or pressedKeys[i] != pressedKeys[i+1]:
        ans = ans *  calc(cnt, ord(pressedKeys[i]) - ord('0'))% MOD
        cnt = 0
        
print(ans)

共享单车

原来这就是传说中的刷表法。由当前点的状态，更新后面点的状态。但是有反转填表法也行。所以两种代码都可以。

1
2
3

状态定义 : dp[i] 表示第i天的总花费的最小值
状态转移 : dp[i] 一共有两类, 一种是 dp[i-1] + 单价 * 当日次数 
         另一种是dp[i - k] +k 天套票的价格

dp = [float('inf')] * (len(d) + 1)
dp[0] = 0

for i in range(1, len(d) + 1):
    dp[i] = min(dp[i-1] + d[i-1] * m, dp[i])
    
    for j in range(k):
        valid_days = min(i + t[j] - 1, len(d))
        cost_before_pass = dp[i-1]
        dp[valid_days] = min(dp[valid_days], cost_before_pass + c[j])

dp = [float('inf')] * (len(d) + 1)
dp[0] = 0

for i in range(1, len(d) + 1):
    dp[i] = dp[i-1] + d[i-1] * m
    for j in range(k):
        if i - t[j] >= 0: 
            dp[i] = min(dp[i], dp[i - t[j]] + c[j])
        else:
            dp[i] = min(dp[i], dp[0] + c[j])

print(dp[len(d)])

小s的游戏

python又卡常了，乐。和上一道题一样，填表刷表均可，ai明显喜欢刷表，所以我决定填表。

1
2

状态定义 : dp[i][j] 表示走i次，到达第j个格子的最大欢乐值 注意数据是从第0个格子开始的 根据数据范围应该不会爆！
状态转移 : dp[i][j] 由 dp[i-1][j-k] 构成, k∈[1, 6]

dp[0][0] = 0;
for (int move = 1; move <= k; ++move) {
    for (int pos = 0; pos <= n; ++pos) {
        for (int step = 1; step <= 6; ++step) {
            // 来时路
            int npos = pos - step;
            // 越界
            if (npos < 0) break;
            // 前路未曾到过
            if (dp[move-1][npos] == MINF) continue;      
            ll new_val = dp[move-1][npos] + a[pos];           
            if (new_val > dp[move][pos]) {
                dp[move][pos] = new_val;
            }
        }
    }
}
int best_pos = max_element(dp[k].begin(), dp[k].end()) - dp[k].begin();
cout << dp[k][best_pos] << "\n";

以上是动态规划的代码，如果会的话还是不难的，甚至如果没有第二位还可以去掉一维数组。

为了知道我们的路线，还需要一个二维数组

`1`	`par[i][j] : 表示第i步在j位置的时候并且是最优解的情况，是从哪一个格子走来的`

这样更新一下上面的代码即可

 if (new_val > dp[move][pos] || 
    (new_val == dp[move][pos] && npos < par[move][pos])) {
     // 如果npos 即来自的那个格子比当前更靠近起点 则符合题意要求 也需要更新
    dp[move][pos] = new_val;
    par[move][pos] = npos;
}

然后逆序寻找路径即可

 vector<int> path;
for (int move = k, pos = best_pos; move > 0; --move) {
    path.push_back(pos);
    pos = par[move][pos];
}
reverse(path.begin(), path.end());

签到码生成

原题: ABC344_D 太好啦是abc我们的常数有救了原来是分组背包同样填表刷表均可

1
2

状态表示 : dp[i][j] 考虑前i组字符串构成S[0:j]签到码的最小资源 此处为python的左闭右开切片
状态转移 : dp[i][j] 由dp[i-1][j - k]构成, k∈[min(len(a[i])), max(len(a[i]))]

dp = [[INF] * (m + 1) for _ in range(n + 1)]
dp[0][0] = 0  # 空字符串不需要任何包

for i in range(1, n + 1):
    parts = input().split()
    count = int(parts[0])    # 当前包的字符串数量
    package = parts[1:]      # 当前包的字符串列表

    # 初始状态：不选当前包，继承前i-1个包的结果
    for j in range(m + 1):
        dp[i][j] = dp[i - 1][j]

    # 尝试用当前包的字符串更新状态 刷表
    for j in range(m + 1):
        if dp[i - 1][j] != INF:  # 如果前i-1个包能组成S[0:j]
            for s in package:
                ls = len(s)
                # 伟大的python切片 如此简洁
                if j + ls <= m and S[j:j + ls] == s:
                    # 更新dp[i][j + ls]，取最小值
                    if dp[i][j + ls] > dp[i - 1][j] + 1:
                        dp[i][j + ls] = dp[i - 1][j] + 1
	# 填表
    for j in range(m+1):
        for s in package:
            if j - len(s) >= 0 and S[j - len(s):j] == s:
                dp[i][j] = min(dp[i][j], dp[i - 1][j - len(s)] + 1)

下面考虑压缩一维，这道题虽然dp[i]仅有dp[i-1]层决定，但是由于每组字符串的长度没什么规律，所以至少需要两个dp数组，拷贝一份原来的才行。

for _ in range(n):
    parts = input().split()
    count = int(parts[0])    # 第一个数是当前包的字符串数量
    package = parts[1:]      # 剩下的部分是当前包的字符串列表

    new_dp = dp.copy()  # 初始化为不选当前包的情况

    for j in range(m + 1):
        if dp[j] != INF:
            for s in package:
                ls = len(s)
                if j + ls <= m and S[j:j+ls] == s:
                    if new_dp[j + ls] > dp[j] + 1:
                        new_dp[j + ls] = dp[j] + 1

    dp = new_dp  # 更新dp数组

print(dp[m] if dp[m] != INF else -1)

突击学习

首先你需要朴素地猜测一下忘得越快越后学

n天 m门课程

1
2
3

状态定义 : dp[i][j] 表示前i门课程, 从头开始学习了j天的最高分
状态转移 : dp[i][j] 假如我厌学了，那就不学！最起码能考dp[i-1][j]的分数
			我又悔改了，今天如果学了那么是另一类情况 dp[i-1][j-1] + 最终分数 j ∈ [1, n]

std::vector<int> xs(m);
std::vector<int> ds(m);

for (int i = 0; i < m; ++i) {
    std::cin >> xs[i];
}

for (int i = 0; i < m; ++i) {
    std::cin >> ds[i];
}

std::vector<std::pair<int, int>> courses(m);
for (int i = 0; i < m; ++i) {
    courses[i] = {xs[i], ds[i]};
}

std::sort(courses.begin(), courses.end(), 
         [](const std::pair<int, int>& a, const std::pair<int, int>& b) {
             return a.second < b.second;
         });

std::vector<std::vector<int>> dp(m + 1, std::vector<int>(n + 1, 0));

for (int i = 1; i <= m; ++i) {
    int x = courses[i-1].first;
    int d = courses[i-1].second;

    for (int j = 0; j <= n; ++j) {
        dp[i][j] = dp[i-1][j];

        if (j > 0) {
            int score = x - d * ((n+1) - j);
            // 罪不至此 考负分
            if (score < 0)  score = 0;
            dp[i][j] = std::max(dp[i][j], dp[i-1][j-1] + score);

        }
    }
}


std::cout << dp[m][n] << std::endl;

电梯问题

这是贪心？

#include <bits/stdc++.h>
using namespace std;
 
struct Student {
    int from, to;
};
 
int main(){
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, s;
    cin >> n >> s;
    vector<Student> stu(n);
    for (int i = 0; i < n; i++){
        cin >> stu[i].from>> stu[i].to;
    }
    // 按上电梯楼层升序排序
    sort(stu.begin(), stu.end(), [](const Student &a, const Student &b){
        return a.from < b.from;
    });
    // 优先队列按照目标楼层r降序排列（r大的优先）大根堆

    priority_queue<pair<int,int>> pq; // pair<r, l>
    long long totalCost = 0;
    int current = s; // 电梯当前楼层
    int idx = 0; 

    // 注意回忆一下，乘客上电梯的楼层是升序的
    // 并且电梯下来的时候一定空载的
    while(idx < n || !pq.empty()){
        // 把所有当前可以接的人加入优先队列
        while(idx < n && stu[idx].from <= current){
            pq.push({stu[idx].to, stu[idx].from});
            idx++;
        }
 
        if(!pq.empty()){
            auto top = pq.top();
            pq.pop();
            int pickup = top.second, drop = top.first;
            // 下来的时候没有人在电梯里
            // 乘客上电梯时，电梯可以先下行（免费）到达pickup
            // 再上行到达drop，消耗(drop - pickup)单位电量
            totalCost += (drop - pickup);
            current = drop;
        } else {
            // 当前没有可接的人，说明下一个乘客的 pickup 高于当前楼层，
            // 电梯必须上行（消耗电量）前往该楼层
            totalCost += (stu[idx].to - current);
            current = stu[idx].to;
        }
    }
    cout << totalCost << "\n";
    return 0;
}

Expt4(???)

树状数组求逆序对

def lowbit(x):
    return x & (-x)

def update(bit, index, val, n):
    while index <= n:
        bit[index] += val
        index += lowbit(index)

def query(bit, index):
    res = 0
    while index > 0:
        res += bit[index]
        index -= lowbit(index)
    return res

"""
计算逆序对数量
"""
def count_inversions(arr):
    # 将原数组离散化
    sorted_arr = sorted(list(set(arr)), reverse=True)
    rank = {}
    for i, num in enumerate(sorted_arr):
        rank[num] = i + 1
    
    n = len(sorted_arr)
    bit = [0] * (n + 1)
    
    inversions = 0
    for num in arr:
        index = rank[num]
        inversions += query(bit, index - 1)
        update(bit, index, 1, n)
    
    
    return inversions

离散化，压缩数据是的树状数组的数组空间不会爆
逆序排序
树状数组的含义：遍历过元素的个数
从左到右遍历数组，并动态统计每个元素与其左侧已处理元素形成的逆序对数量。

query(bit, index - 1)查询的是排名小于index的元素数量，因为我们是从大到小排序，所以这实际上是查询比当前元素大的已处理元素数量
树状数组在这里维护的是"每个排名的元素数量"，通过前缀和可以快速查询"排名小于某个值的元素总数"
由于我们是从左向右遍历，所以inversions += query(bit, index - 1)就是在统计左侧已处理元素中比当前元素大的个数，这正是当前元素参与的逆序对数量

ABC391

ldfd@outlook.it (ldfd) — Sat, 01 Feb 2025 19:53:44 +0800

ABC390

ldfd@outlook.it (ldfd) — Sun, 26 Jan 2025 13:12:55 +0800

D

🦐头题。本质就是划分子集，纯暴力。但其实没那么暴力，你得想到加来加去就相当于分成几堆，因为0^X=X，所以零对异或没影响。

N = int(input())                        # 袋子数量
A = list(map(int, input().split()))     # 每个石头的数量

ans = set()                             # 存储所有可能的异或和

def dfs(pos, B):
    # 所有石头都处理完毕时
    if pos == N:
        x = 0
        for b in B:
            x ^= b                      # 计算当前状态的异或和
        ans.add(x)
        return
    
    # 方案1: 将当前石头放入已有的袋子
    for i in range(len(B)):
        B[i] += A[pos]                  # 加入当前石头
        dfs(pos + 1, B)                 # 递归处理下一个石头
        B[i] -= A[pos]                  # 回溯还原
    
    # 方案2: 放入新袋子
    dfs(pos + 1, B + [A[pos]])         # 创建新袋子存放当前石头

dfs(0, [])                             # 从空状态开始搜索
print(len(ans))                        # 输出不同异或和的数量

E

一眼dp。题解的背包什么玩意看不明白为啥又来了一个遍max，还是记录一下自己的。就是三个01背包，然后再枚举等于k的情况，复杂度完全够用。

# dp[c] = 在热量 c 内能获得的最大维生素值
def build_dp(arr):
    dp = [0]*(X+1)
    for (val, cal) in arr:
        for c in range(X, cal-1, -1):
            dp[c] = max(dp[c], dp[c-cal] + val)
    return dp

然后我们就得到了三个背包的dp数组。X最大是5000，两层循环暴力直接过！

ans = 0
for i in range(1, X+1):
    for j in range(1, X+1):
        k = X - i - j
        if k < 0:
            break
        ans = max(ans, min(dp1[i], dp2[j], dp3[k]))

Python

ldfd@outlook.it (ldfd) — Fri, 24 Jan 2025 13:41:23 +0800

数组

python没有严格意义上的数组，一般用list。但是开二维数组还是需要简单注意一下的。

首先是需要了解一下python的list的*运算符，列表重复（List Repetition）。

1
2
3

lst = [1, 2, 3]
result = lst * 3
print(result)  # 输出: [1, 2, 3, 1, 2, 3, 1, 2, 3]

注意：如果 n 是 0 或负数，结果会是一个空列表。

如果列表中的元素是可变对象（如列表、字典等），重复操作会导致共享引用问题。（备注一下，此时被复制的元素是整个list脱去一层后的那一层，比如[0]->0,[[0]] 才是 [0]）

例如：

lst = [[0]] * 3
print(lst)  # 输出: [[0], [0], [0]]
lst[0][0] = 1
print(lst)  # 输出: [[1], [1], [1]]，所有子列表都被修改了
# 这是因为 * 复制的是引用，而不是创建新的对象。

然后二维数组就有两种写法。

# 一维数组
a = [0] * 10086
# 二维数组
f = [[0] * cols for _ in range(rows)]
f = [[0 for _ in range(cols)] for _ in range(rows)

求n!中质数的出现次数

质数 $ p $ 在 $ n! $ 中的出现次数可以通过以下步骤计算：

初始化总和：设次数 $ v_p(n!) = 0 $。
逐次除以 $ p $ 的幂：从 $ k = 1 $ 开始，依次计算 $ \left\lfloor \frac{n}{p^k} \right\rfloor $（即 $ n $ 除以 $ p^k $ 的商向下取整），并将结果累加到总和 $ v_p(n!) $ 中。
终止条件：当 $ p^k > n $ 时，后续项均为 0，停止计算。

公式表示：

$$ v_p(n!) = \sum_{k=1}^{\infty} \left\lfloor \frac{n}{p^k} \right\rfloor $$

原理：

$ \left\lfloor \frac{n}{p} \right\rfloor $ 统计了 $ 1 \sim n $ 中至少含有一个 $ p $ 因子的数的个数。
$ \left\lfloor \frac{n}{p^2} \right\rfloor $ 统计了至少含两个 $ p $ 因子的数的个数（每个额外贡献一次）。
以此类推，每次累加更高幂次的贡献，最终总和即为 $ p $ 在 $ n! $ 中的总次数。

示例：
$$ ( n = 10 )，质数 ( p = 3 ) 时:

\left\lfloor \frac{10}{3} \right\rfloor + \left\lfloor \frac{10}{9} \right\rfloor = 3 + 1 = 4 $$ 验证：$ 10! = 3628800 = 2^8 \times 3^4 \times 5^2 \times 7 $，确实 $ 3$出现 4 次。

结论：通过逐次除以 $ p $ 的幂并求和，即可准确计算质数 $ p $ 在 $ n! $ 中的次数。

二维矩阵相等

n, m = map(int, input().split())
a = [input() for _ in range(n)]
b = [input() for _ in range(m)]
for i in range(n - m + 1):
    for j in range(n - m + 1):
        if all(a[i + k][j:j + m] == b[k] for k in range(m)):
            print('Yes')
            exit()
print('No')

sequence[start : end : step] # step 默认为 1 规则

start: 起始索引（包含）
end: 结束索引（不包含）
索引可以是负数，表示从末尾开始计数
省略规则：
- [:] - 复制整个序列
- [start:] - 从start到末尾
- [:end] - 从开始到end-1
- [:-1] - 除了最后一个元素的所有元素

all() 函数用于判断给定的可迭代参数 iterable 中的所有元素是否都为 True，如果是返回 True，否则返回 False。

堆

python只有小根堆，大根堆用负数实现，但是注意python的地板除的cpp的区别（//表示“地板除”（floor division），即两个数相除后向下取整（取不大于结果的最大整数）而cpp的/当操作数为整数时，执行的是截断除法（truncation division），即直接舍去小数部分（向零靠拢））

import heapq

# 1. 基本操作
heap = []  # 创建一个空堆

# 添加元素
heapq.heappush(heap, 4)
heapq.heappush(heap, 1)
heapq.heappush(heap, 7)
heapq.heappush(heap, 3)

print("堆的内容:", heap)  # [1, 3, 7, 4]

# 弹出最小元素
smallest = heapq.heappop(heap)
print("弹出的最小元素:", smallest)  # 1
print("弹出后的堆:", heap)  # [3, 4, 7]

# 查看堆顶元素但不删除
peek = heap[0]
print("堆顶元素:", peek)  # 3

# 2. 高级用法
numbers = [10, 4, 8, 3, 5, 9]

# 将列表转换为堆
heapq.heapify(numbers)
print("转换后的堆:", numbers)  # [3, 4, 8, 10, 5, 9]

# 获取最小的3个元素
smallest_three = heapq.nsmallest(3, numbers)
print("最小的三个元素:", smallest_three)  # [3, 4, 5]

# 获取最大的3个元素
largest_three = heapq.nlargest(3, numbers)
print("最大的三个元素:", largest_three)  # [10, 9, 8]

ABC385

ldfd@outlook.it (ldfd) — Tue, 21 Jan 2025 15:01:07 +0800

A

排完序就可知道大小了，有效减少代码量

C

一种是动态规划

def solve2():
    n = int(input())
    h = list(map(int, input().split()))

    # 初始化 dp 数组
    # dp[i][j] 以i开头区间距离是j的最多个数
    dp = [[1] * n for _ in range(n)]
    ans = 1

    # 动态规划
    for i in range(n):
        for j in range(1, n - i):
            if h[i + j] == h[i]:
                dp[i + j][j] = dp[i][j] + 1
                ans = max(ans, dp[i + j][j])
    print(ans)

另一种是没那么暴力的暴力。看似是三重循环实则是$O(n^2logn)$

def solve1():
    N=int(input())
    H=list(map(int,input().split()))
    ans=1
    # 从第i个开始
    for i in range(N):
        # 枚举区间距离
        for w in range(1,N-i):
            cnt=1
            # 没到末尾并且高度相同
            while i+cnt*w<N and H[i]==H[i+cnt*w]:
                cnt+=1
            ans=max(ans,cnt)

    print(ans)

D

orderset呜呜呜，所以我们用c++！

解决思路

数据结构：
- 使用两个字典来存储房子的位置：
  - Ypos[x]：存储所有 x 坐标为 x 的房子的 y 坐标，按升序排序。
  - Xpos[y]：存储所有 y 坐标为 y 的房子的 x 坐标，按升序排序。
- 这些有序列表可以通过二分查找快速查询和更新。
Santa 的移动：
- 当 Santa 水平移动（例如从 (X, Y) 移动到 (X, Y + C)），在 Ypos[X] 中查找所有 y 坐标在 [Y, Y + C] 范围内的房子。
- 当 Santa 垂直移动（例如从 (X, Y) 移动到 (X + C, Y)），在 Xpos[Y] 中查找所有 x 坐标在 [X, X + C] 范围内的房子。
更新房子状态：
- Santa 经过的房子需要从 Ypos 和 Xpos 中移除，避免重复计算。

#include<bits/stdc++.h>
using namespace std;
using ll=long long;

int main(){
	int n,m;
	ll x,y;
	cin >> n >> m >> x >> y;
	
	map<ll,set<ll>>xy;//xy[i]={j s.t. (i,j) に家}
	map<ll,set<ll>>yx;//yx[j]={i s.t. (i,j) に家}
	
	for(int i=0;i<n;i++){
		int xx,yy;
		cin >> xx >> yy;
		xy[xx].insert(yy);
		yx[yy].insert(xx);
	}
	
	int ans=0;
	for(int i=0;i<m;i++){
		char c;
		int d;
		cin >> c >> d;
		if(c=='U'){
			ll new_y=y+d;
			auto it=xy[x].lower_bound(y);
			while(it!=xy[x].end()&&*it<=new_y){
				ans++;
				yx[*it].erase(x);
				it=xy[x].erase(it);
			}
			y=new_y;
		}else if(c=='D'){
			ll new_y=y-d;
			auto it=xy[x].lower_bound(new_y);
			while(it!=xy[x].end()&&*it<=y){
				ans++;
				yx[*it].erase(x);
				it=xy[x].erase(it);
			}
			y=new_y;
		}else if(c=='L'){
			ll new_x=x-d;
			auto it=yx[y].lower_bound(new_x);
			while(it!=yx[y].end()&&*it<=x){
				ans++;
				xy[*it].erase(y);
				it=yx[y].erase(it);
			}
			x=new_x;
		}else if(c=='R'){
			ll new_x=x+d;
			auto it=yx[y].lower_bound(x);
			while(it!=yx[y].end()&&*it<=new_x){
				ans++;
				xy[*it].erase(y);
				it=yx[y].erase(it);
			}
			x=new_x;
		}
	}
	
	cout << x << ' ' << y << ' ' << ans << endl;
}

ldfd

写在暑期后

关于AI

实习总结

职场管理

个人成长/技术追求

AI 锐评

锐评文章

锐评我

建议

古法数据库

ER图

概念模型

实体关系图

关系模型

关系代数 和 SQL

变量 和 循环

触发器

存储过程

视图

数据库设计模型分析

数据依赖

闭包

范式

Redis Kafka Mysql三件套

前言

Redis

数据结构

持久化

为什么快

分布式容灾

Raft算法

Kafka

架构

核心概念

补充

分布式容灾

消费者 Rebalance

MySQL

通识

数据库三大范式

外键

索引

事务

核心日志系统

隔离性的实现：锁与MVCC

事务执行与崩溃恢复流程

总结

优化

PostgreSQL

RabbitMQ

操作系统和计网

内存屏障

用户态线程

计算机系统结构

第一章

第二章

第三章

第五章

第六章

第七章

第八章

第九章

编译原理

词法分析

核心概念

正则表达式

RE转NFA

NFA转DFA

DFA最小化

语法分析

核心概念

文法设计

二义性与语法树

左递归消除

LL（1）分析

恍若隔世

自底向上分析

LR(0) / SLR(1)

LR(1) / LALR(1)

关系代数和 SQL

变量和循环