<?xml version="1.0" encoding="utf-8"?>
<feed xmlns="http://www.w3.org/2005/Atom">
  <id>https://mirawind.top/</id>
  <title type="text">Mirawind&apos;s Blog</title>
  <subtitle type="text">相寻梦里路，飞雨落花中</subtitle>
  <updated>2026-10-27T00:00:00.000Z</updated>
  <author><name>Mirawind</name></author>
  <link rel="alternate" href="https://mirawind.top/"/>
  <link rel="self" href="https://mirawind.top/atom.xml"/>
  <generator uri="https://github.com/CuteLeaf/Firefly">Firefly v6.16.9</generator>
    <entry>
      <id>https://mirawind.top/posts/2026/08/final/</id>
      <title type="text">2026年8月总结</title>
      <published>2026-09-16T00:00:00.000Z</published>
      <updated>2026-10-27T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/08/final/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>转眼半年，，，上一次写是 2026 年 4 月初，小红书黑客松之前，在舟山旅游时写的。这次第一版文字在洛杉矶飞往纽瓦克的飞机上，断断续续写着。飞机上看了《奥本海默》《阿凡达：水》《Backrooms》感觉不错，美国联航的娱乐设施确实好棒</p>
<section><h2>From 19 to 19.5<a href="#from-19-to-195"><span>#</span></a></h2><p>4 月 5 号是生日，19 岁的前半年真是发生了好多事情哇</p><p>4 月参加了小红书，做自动化机器学习，小队做完后没有拿奖，队长比较失落。这个时候对“自动化万物“的想法产生近乎偏执的兴趣，梦想能建设统一的知识网络来处理优化世间万物，后来发现细节远远做不到位，那已经是两三个月之后的事情了。</p><p>这一阶段又接触到两三位厉害的朋友，第一次去酒吧，听着他们谈论创业、金融、AI 的事，并在接下来三四个月内见证他们以惊人执行力完成日常认识下平常本科生一年多才能完成的工作量，着实令人震惊。4 月末给电脑装了双系统玩一玩，后续发现是想给生活找一些新的刺激源：kde 桌面一直在调整 也调成了现在比较舒适的方式。</p><p>5 月创智夏令营开始逐渐敲碎我的研究“复杂系统” 宏大幻想：我无法搞定，哪怕 3 个机械臂合作，的任务编排；模拟器无法搞定，何况真机呢。而且认为这个问题在工业上的应用价值更不大：用 llm（比如 70 B 大小）精确的控制和反馈回路闭环成本高，而且效率较低。面试回答的问题感觉空洞无味：我确实没有认真做过 ai 科研，也没有读论文，全凭脑子臆想。夏令营 50% 录取率是没过的，收到结果后郁闷了大半天，后来想想似乎和 23 年考少院有点类似就没啥想法了。所有的录取都是概率事件</p><p>6 月大部分时间忙于期末周了。首先是深度学习基础的炒股大作业，我第一次对具体的问题这么感兴趣，花了一周多的时间去搞他，并得出深度学习网络在多因子策略（应该是吧）提取信息的表现远远不如决策树这个结论。后续期末周计算方法和随机过程双连炸：我并不擅长计算量密集的考试任务，之前想撰写的“速通学导论”没心思写了：不同课间拼的是选择与信息差，同一门课拼的是天赋和认知，努力反而是不那么重要的一环</p><p>不得不提这半年的作息真的很糟糕。早八体育课、室友呼噜声，在床上莫名的烦躁，寝室熄灯限制，等等，上半年的作息不规律到有点疯掉了，整天低精力状态能完成作业处理琐碎的杂事已经是大幸。暑假不熄灯结果变成 5 点睡 14 点起了，睡眠时间倒是够了但仍然没精神，阳光见不到，一天吃的也不多（10 月补：在美东住了一个月，发现一个人住的状态就是这样哈哈哈哈 看来是本性 顺从就好）</p><p>8 月接触 binance，算是进入币圈韭菜堆了（笑）第一天无知从 100 u 搞到 260 u，后面复盘发现是拿尾部爆仓风险换的，顿感不妙。后续再也没有本金翻倍，反而被各种妖股庄家币没设好止损爆过几次仓，买过 meme 币被庄家做局过，买过 honeypot，跟单被爆仓，第一天的利润已然损失殆尽。</p><p>在景甜事件前把孙宇晨的故事读了一遍，感受到传奇与逆天。感受到两个人黏在一起会造成多么大的困扰。对恋爱背后的复杂关系也渐渐害怕。大量的时间、或甜或苦或纠缠、来做小家子小圈子行为，故意将责任绑定很重而互相成为枷锁，目前不愿这样</p><p>尝试量化。用 107 和远程服务器搭建 l 2 数据采集器时成功，为了生产稳定性改了十几版代码：最后能将就着用，但是 python 本身性能问题导致 p 99 这种上不去，可能得用 rust 充血尝试搭建自动因子选择框架失败了：ai 自己写的自己改了几十个小时都跑不通，或者效率极其低下（python），这套系统看起来很美好，但实际上根本无法使用。小范围的实验找到了些因子但是无法在执行后盈利（交易逆向选择），一开始策略的 idea 后来发现也有致命问题。有空再推翻重做了。也得学学宏观经济学看会新闻交易啊</p></section>
<section><h2>终末<a href="#终末"><span>#</span></a></h2><p>7 月看了《终末少女旅行》，有几段真的产生持久的共鸣：深深的虚无、绝望与知道虚无后的挣扎，最后登顶也只是空无一物，游行在被毁灭的城市中。</p><p>也看过久姐的故事。看了几话之后心脏压力太大受不了不看了，至今没看完。忘不了第一晚最后一笔扛单直至盈利平仓时的激动与错愕：整个人被电流击中一样，呼吸在颤抖，打字也在颤抖。心脏嘭嘭的跳着，发疯一样想要大笑。躺在床上整个人抱着宜家鲨鱼也是不住的抽泣。久姐的情绪估计是我的一百倍强度吧。相比之下，刷小视频那种乐趣和吊着的味道还是寡淡多了</p><p>跳远一点，过几十年人会被全面被 ai 取代，过去的一切生产系统、工作职位会被代替，也在“崩坏“，及时在某处崩坏用某项技术/智力站稳脚跟意义也不大：几年内会被 ai 干碎，像分析学爱好者一样。注意力经济？现在学习的技能 alpha 半衰期在不断缩短，终究会短过人所理解的时间</p><p>稳定轨道外是无限的混沌。沿着山谷只有几条方向，走的越多的地方山谷越深。上山后发现巨大的复杂性：我应对不了，只能在有限视野不对称信息中尽可能防止走到死胡同里，慢慢的乱逛，期待能活下来。</p><p>对焦虑和板式表示同情，感觉并没有资格评价这些是非。回头看看呢，发现想要追寻的东西一开始就有了，又会感觉可笑无比</p></section>
<section><h2>年度计划<a href="#年度计划"><span>#</span></a></h2><ul>
<li>金融：无论是深度学习基础的炒股作业还是暑假的尝试都失败了 没能撑过模拟盘 离实盘还很遥远</li>
<li>电影：《奥本海默》《阿凡达：水》《Backrooms》《肖申克的救赎》</li>
<li>书：《复杂》</li>
<li>动画：《少女终末旅行》</li>
<li>城市：上海、徐州、安阳、林州、北京、青岛、济南（暑假去的）</li>
</ul><p>一大半完成了呢，真是无心插柳柳成荫。剩下的就是无限的疲惫。</p><p>运动停了好久了，也该重新跑起来了。精力消耗不掉也是痛苦的。</p><p>2026 年 9 月 16 日凌晨 写于洛杉矶飞往纽约飞机上</p></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/06/complexity/</id>
      <title type="text">《复杂》读书笔记</title>
      <published>2026-06-11T00:00:00.000Z</published>
      <updated>2026-06-11T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/06/complexity/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>《复杂》by Melanie Mitchell（2009），一本科普书。</p>
<p>阅读时间：2026 年 4 月 27 日至 6 月 11 日，断断续续读的。随手记录了点东西在这里</p>
<section><h2>背景<a href="#背景"><span>#</span></a></h2><p>从牛顿力学到混沌：动力学的发展、混沌、量子的测不准原理与混沌的不可预测性。混沌不需要任何随机性，它是确定性系统的内在行为</p><p>从信息到计算：热力学、香农熵、哥德尔、图灵机。我记得熵分为结构性熵和随机性熵，由盖尔曼<strong>有效复杂性</strong>度量来提出。吉布斯熵与自由能：有动力学因素也有热力学因素。可以从吉布斯自由能出发讲讲动力学和热力学</p><p>从进化到遗传：拉马克、达尔文，1980 年代古尔德的生物约束与历史偶然因素。DNA 转录与翻译是不是一种图灵机与自指？</p><p>如何定义复杂性？其实在核心学科，基础概念尚未被定义是很常见的事，如物理中的“力”，生物中的“基因”。定义的方式有很多：层次性结构、分形与自相似、逻辑深度、热力深度、熵与算法信息量，柯氏复杂度（然而这是不可计算的）</p><p>对信息的处理源于 19 世纪末的热力学。麦克斯韦妖描述了这样一件事：</p><p>定义熵的概念：热力学有两种，可以互相转化；还有信息熵。对信息的擦除需要热量，不需要热量的信息处理是可逆计算。</p><p>DNA 转录与翻译是不是一种图灵机与自指？</p></section>
<section><h2>计算机中的生命与模拟<a href="#计算机中的生命与模拟"><span>#</span></a></h2><p>香农定义信息：不确定性的消减。但是这里的信息是通信与工程上的含义，并不包含“意义”。</p><p>图灵定义计算：按规则对符号进行机械变换。然后发展图灵机</p><p>信息的双重使用：计算机程序既是程序能被执行，又是数据可以被处理，因此自复制的程序是存在的，冯诺依曼后半生在研究自复制自动机。该机器可能会有实体。</p><p>遗传算法模拟自然界的遗传对程序进行变异：按得分算概率选出双亲，交换基因片段并给子代变异，有时突变能产生宏观特征导致算法能长进一大截，而且通常是人没想到的。这块内容可能和可解释性有关？</p><p>计算是复杂系统为了适应环境而对信息的处理。元胞机是一种理想化的复杂系统，是一种图灵机，比如生命游戏</p></section>
<section><h2>大写的计算<a href="#大写的计算"><span>#</span></a></h2><p>生命系统中，计算是分布式的。信息通过采样来实现通信，行为是随机的，动作是微粒化并行的。但是在这种系统中，并不存在中央控制或者领导者。</p><p>类比是在两个表面不同的事务上发现抽象的相似性能力。用计算机编码“模仿者程序”的结果表明，人无法探索所有可能，但如果不探索他们，就不知道哪种可能值得探索。为此有许多启发式算法，比如模拟温度机制，一种利用—探索的平衡</p><p>模型是对现实事物的抽象。对特定现象的数学描述引出数学模型，用简单的模型可以更好的理解一般性的概念。我们发现进化会产生合作，但现实世界又会有许多囚徒困境，比如公地悲剧。合作是如何产生的？可以用计算机模拟，分数最高的策略为优，比如针锋相对策略：对方反对我就反对，对方合作我就合作。若在模型中加入别的要素，比如社会规范（信誉分）和空间结构（距离度量），则合作产生机制要复杂得多。更复杂的模型则无法从数学上对他进行分析。所有模型只是对现实事物的抽象与近似，“所有模型都是错的”，模型只是揭露某种可能性</p></section>
<section><h2>网络<a href="#网络"><span>#</span></a></h2><p>“在理解自然界的巧合时，我们的数学水平不高，直觉也不咋样。”</p><p>网络是由边连接在 一起的节点组成的集合，网络思维关注事物之间的关系，1990 年代发展起来。网络存在在各处，并且在数百年中都有被研究。数学中以图论的形式研究网络，工程师研究电力网络、互联网，社会学家研究社会网络（如六度分隔理论），生物学中研究基因调控网络、代谢网络、食物网。然而这些概念近年来才被发现有有趣的共性。</p><p>小世界网络和无尺度网络很常见。小世界网络的平均路径很短，有高度的集群性，存在中心节点。社交网络属于这种。无尺度网络具有无尺度分布，频率与入度的平方成反比，遵循幂律分布，取值范围大，也是小世界网络。偏好附连机制促进无尺度网络的形成：结点度越高，形成新连接的概率越大。但是无尺度网络的形成还会有许多别的原因。</p><p>幂律广泛存在，有时候会比正态分布还要广泛存在，但对于幂律的起源还是个谜。实验发现，生物的代谢率与体重有 3/4 的幂律。20 世纪 90 年代发展出的代谢比例理论，把血管建模成分形网络，假定进化的网络能最小化养分运输时间、假定细胞需要使用单位养分，与数学证明四比例幂律理论。该理论存在很大争议。齐普夫认为语言的词频也有幂律分布，许多人常使用数学、信息论解释他，后来发现随机词语的词频也有幂律分布。</p><p>在进化与复杂化的过程中，生物学家发现基因并不是线性调控的，相反，他们连成了一张网，还有很多表观遗传机制（DNA 甲基化、组蛋白修饰、RNA 转录等等）一起调控生物的性状。进化发育生物学认为，生物的多样性主要来自于基因的开关（有时一种蛋白质来表现）以及所产生的基因调控网络的变化导致了进化，短时间生物巨大形变的原因在于开关的开闭，或者是基因表达力度的大小，而不是产生新基因。进化可能无法让生物产生重大结构性的变化，结构是由基因调控的，而不同物种基因差别比较小</p><p>进化论不只有适应主义者，还有历史主义者（认为历史偶然是主要变化）与结构主义者（组织结构没有自然选择也能发生）。考夫曼使用随机布尔网络对基因调控进行建模：给定入度 K, 二状态节点，以及随机的布尔规则，来观察网络随时间步的演化。发现 K=2 时处于一种混沌的边缘，把网络视作动力系统时可以将不同类型的细胞视作吸引子。但是噪声对该网络的扰动很大，很多人反对，需要发展更好的理论和模型来研究基因调控网络的问题</p></section>
<section><h2>尾声<a href="#尾声"><span>#</span></a></h2><p>复杂系统从 20 世纪 50 年代的控制论、系统论发展而来。当时的控制论和一般系统论因为过于“泛泛而谈”，没有严格的形式化术语而式微，人们的兴趣也转到更实际的问题中去。</p><p>复杂系统目前还没有被很好的定义，需要一位牛顿类型的人物来创造定义合适的词汇。 5 个问题：</p><ol>
<li>你为何研究复杂系统？</li>
<li>你怎样定义复杂性？</li>
<li>你喜欢的复杂性方面是什么？</li>
<li>在你看来，复杂性最成问题的概念是什么？</li>
<li>你如何看待复杂系统的未来？</li>
</ol><p>我感觉也可以向人工智能方面提出这 5 个问题</p></section>
<section><h2>AI 总结<a href="#ai-总结"><span>#</span></a></h2><p>使用 claude opus 4.8 high 模型。不用 fable 5 是因为因为安全问题被强行换模型了，Anthropic 公司坏。</p><div><div><div></div><div>Opus 4.8</div></div><div><p>概念地图的核心是<strong>节点 + 带标签的边</strong>，所以我分四层给你：中心母题 → 五条主线（一级节点）→ 主线在各系统里的实例（用一张矩阵，这是地图的主体）→ 主线之间的连边（这才让它成为”网络”而非提纲）。</p><p><strong>中心母题（图的圆心）</strong></p><blockquote><p>大量简单组分 + 无中央控制 + 局部规则 → 涌现出复杂的集体行为、信息处理、以及通过演化/学习实现的适应。</p></blockquote><p>全书所有内容都是这一句话在不同系统里的变奏。下面五条主线就是从这个圆心辐射出去的。</p><p><strong>五条主线（一级节点 + 一句话定义）</strong></p><ul>
<li><strong>A 涌现 / 无中控</strong>：整体行为不在任何单个组分里，也没有指挥者。</li>
<li><strong>B 计算 / 信息处理</strong>（SFI 的招牌隐喻）：把系统的运转重新描述为”采样—通信—并行处理信息”。</li>
<li><strong>C 适应 / 演化</strong>：系统通过自然选择或学习改变自身。</li>
<li><strong>D 度量难题</strong>（元层）：什么算”复杂”始终没有公认定义。</li>
<li><strong>E 统一的冲动与限度</strong>（元层）：跨学科找共同原理的雄心，与它该被警惕的过度延展。</li>
</ul><p><strong>主线 × 系统矩阵（地图主体）</strong></p><p>横看一行 = 用三种透镜审视同一个系统；竖看一列 = 同一条主线在不同系统里的同构。A/B/C 是能落到每个系统的”操作性”透镜，D/E 是包在外面的框，所以矩阵只用 A、B、C 三列。</p>

<table><thead><tr><th>系统</th><th>A 涌现/无中控</th><th>B 信息处理/计算</th><th>C 适应/演化</th></tr></thead><tbody><tr><td>蚁群</td><td>无蚁后指挥，信息素规则→集体觅食分工</td><td>信息素采样、随机行为、并行微粒动作（第 12 章明确当分布式信息处理讲）</td><td>群体层面优化觅食路径，但单只蚂蚁不学习</td></tr><tr><td>免疫系统</td><td>分布式防御，无中枢</td><td>淋巴细胞采样、识别抗原</td><td>克隆选择/亲和力成熟＝体内一场微型达尔文演化（很漂亮的同构）</td></tr><tr><td>元胞自动机</td><td>局部规则→全局模式（生命游戏、Rule 110）</td><td>可达图灵通用计算；她演化 CA 做密度分类，用”粒子”解释信息如何被处理</td><td>CA 自身不演化，但可用 GA 演化其规则（她的本行研究）</td></tr><tr><td>遗传算法</td><td>群体搜索出人意料的解（Robby 捡罐头）</td><td>GA 本身是一种搜索/优化计算</td><td>直接模拟自然选择——适应的最纯粹形态</td></tr><tr><td>基因调控网络</td><td>基因连成网，开关组合→细胞类型/性状涌现</td><td>考夫曼随机布尔网络当动力系统看；细胞类型＝吸引子</td><td>evo-devo：靠开关而非新基因驱动巨变；但结构主义质疑”无需选择也能自组织”</td></tr><tr><td>新陈代谢/标度律</td><td>（偏”约束”而非典型涌现）3/4 律源于分形供给网络的几何</td><td><strong>这一格最弱</strong>——她基本没用计算视角讲代谢标度，诚实标注”不适用”</td><td>WBE 假设演化优化了运输网络（最小化运输时间）</td></tr><tr><td>经济/市场</td><td>无中央计划→价格与市场行为涌现</td><td>市场作为信息聚合/处理系统</td><td>主体策略在博弈中演化（针锋相对等）</td></tr></tbody></table><p>读这张表本身就是上一轮说的”按张力组织”：你会立刻看到<strong>免疫系统和遗传算法在 C 列是同一个机制</strong>（都是变异+选择），<strong>蚁群和免疫在 B 列是同一种东西</strong>（采样式分布式处理），而<strong>代谢标度律在 B 列是空的</strong>——这个”空格”恰恰提示你：计算隐喻并非万能，这正通向主线 E。</p><p><strong>主线之间的连边（让它成为网络的关键）</strong></p><ul>
<li>A —“涌现的集体行为，本质就是分布式信息处理”→ B：在 Mitchell 的框架里这两条几乎是一枚硬币的两面，是她最核心也最该被你批判审视的等式。</li>
<li>B —“演化/学习＝系统缓慢地获取并写入信息”→ C：适应可以看作一种慢速计算。</li>
<li>A —“涌现的不可还原性正是复杂难以度量的根源”→ D：逻辑深度、统计复杂性都是想捕捉这种”既非有序也非随机”的东西。</li>
<li>D —“既然连度量都莫衷一是”→ E：这是质疑”复杂性科学是不是一门统一科学”的最硬证据。</li>
<li>B —“把一切都看成计算，强大但可能过度延展”→ E：代谢标度那个空格就是反例，隐喻的边界在这里现形。</li>
</ul></div></div></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/03/final/</id>
      <title type="text">2026年3月总结</title>
      <published>2026-04-06T00:00:00.000Z</published>
      <updated>2026-04-06T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/03/final/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<blockquote><p>世界的画卷向我展开，拼图碎片迎面而来，撒我一地鸡毛。</p></blockquote>
<p>2 月份末没写，3 月份末随着 4 月初的出游一起写掉吧！用 AI 总结了一下 2 月和 3 月的月度总结。感谢日记、感谢 AI、感谢仓库，我可以想起来内容。以后就在电脑上打字记录吧。两周前在电脑上装了 keep it in rhythm 插件，惊奇的发现 obsidian 仓库用了一年多下来，已经有30万词了，而且每天正常的话会更新 1000 词左右（但一周间也就一两天是正常的，被各种东西给打压着没时间打字 hhhhhh）。</p>
<p>对于文本上下文处理而言，AI 已经超越大部分人类了，于是直接让 AI 读我的仓库，效果还不错！3 月份主要围绕暑研、黑客松、以及应付课内任务几条主线。但是总结的没有人情味，我想写写我自己的一些东西，作为疗愈（？）发现课内的、整个科大的日常琐事越来越无聊了，我想走出去看看</p>
<p>我感觉 3 月最大的问题还是作息。2 月寒假时作息十分晚，两点睡十一点起吧。三月直接一个体育早八给我干废了，还有各种事情要跑高新导致起很早。起床时间在六七点钟和十一二点钟跳跃，方差非常大，早十起床也是难如登天了，哈哈，不过课程本身也不是那么重要。睡眠时间平均下来在两点左右，还是有点晚。希望在 4 月能早点睡早点起，日常锻炼搞好身体</p>
<section><h2>兴趣转移<a href="#兴趣转移"><span>#</span></a></h2><p>2 月份重新联系 zsf 时想到这个问题，他让我先自己找几篇文献自己阅读找兴趣。当时无从下手，无法回答。于是打开 B 站看到如下科普性视频：</p><ul>
<li>编程语言发展史系列：<a href="https://www.bilibili.com/video/BV1awaHzVEza" target="_blank">https://www.bilibili.com/video/BV1awaHzVEza</a></li>
<li>数据库发展史系列：<a href="https://www.bilibili.com/video/BV1B6xCzNEje" target="_blank">https://www.bilibili.com/video/BV1B6xCzNEje</a></li>
<li>GUI 发展史：<a href="https://www.bilibili.com/video/BV1A3H6z9ENm/" target="_blank">https://www.bilibili.com/video/BV1A3H6z9ENm/</a></li>
<li>一些讲解 git 底层原理实现的视频</li>
<li>一些数学视频，讲解动力系统、双摆混沌、分形；lambda 代数、无穷序数等等</li>
</ul><p>2 月中旬开始，阅读了计算机程序的构造和解释的 1-3 章，讲解过程抽象、数据抽象、模块化、对象与状态，后面的元求值器和编译器的部分没有看。“这是描述计算过程的书”，而计算过程、或者是软件工程中系统各模块间的构造与通信让我着迷，计算机科学演化历史与动机也让我着迷。同时买了 CSAPP 作为参考书，发现 CSAPP 比较难懂，于是没怎么读。</p><p>寒假主要在读黑书。相反之下，对 AI 的兴趣似乎不那么大了——完全可以等更强的 AI 出来，思考怎么去用它，而不是炼丹，去用人工来碰撞各种可能性，那是 Auto Research 和 Auto ML 做的事情，迟早会被机器超越。我发现我更感兴趣的是事物底层结构的理解与演化的预测。</p><p>3 月初，与 AI 聊天时，发现系统科学、复杂系统演化这一领域，隐约感觉到兴趣点在这边。不过直到现在，我都咋没研究过这个领域，或者去读相关著作（比如钱老的系统论、控制论等等），学到的想法只有“不只是关注要素内部的组成，也要关注要素之间的连接”这种正确的废话，生活中开始关注要素、连接、反馈回路等组成要素。</p><p>AI 推荐的《集异璧》和《系统之美》分别在 3月初读了两章和一章。《集异璧》的思维是如此跳跃，将数学、音乐、计算机融为一体，我还没有把握他的全貌。这本书成书于上世纪 90 年代，里头有很多 AI 过时内容值得批判阅读，反过来也像是在阅读发展史，以及前人的批判。</p><p>转念一想，所有知识，不同的观测方式决定此知识的“价值”，你若愿意，可以称之为“有用程度”。这如线性泛函，然而世界的结构是非线性的，亿万年进化的感知又以时间、空间的线性为基础，理解的流形构建过程愈加复杂且迷幻了。知识如散在海滩上闪闪发亮的贝壳碎片，实用主义者聚类相似知识，打造成强悍的工具，以此改造世界。我将它拾起、观测、试图与其他贝壳串成五彩斑斓的项链，欣赏这随机而富有弹性的艺术结构，幻想完成世界的拼图。</p><p>好奇心被满足的时刻非常激动人心：线性代数的对偶空间、狄拉克符号、谱图论、玻尔兹曼机、范畴论；社会心理学、发展心理学、科幻畅想等等。每一个都是浅尝辄止，但我体验到连接、抽象、以及理解时的快感与美感。沙粒滑落指缝的过程，我愿称之为遗忘，在收集与遗忘的时间流中，我愿让思绪随性徜徉。</p><p>（又写了一大段神秘文字哈哈哈哈哈哈哈哈）</p><p>3 月中旬重新联系 zsf，因相关计算机视觉基础弱、能跟的时间少被劝退。准备自己看些有趣的书玩玩，继续找找兴趣</p></section>
<section><h2>生活发展<a href="#生活发展"><span>#</span></a></h2><p>2 月末顺着 1 月的想法的东西打造了 ZenReply，想参加 AI Hackathon Tour 。但是失败了，因为晚提交了十几秒。3 月初来蜗壳进阶联盟后开始干活，黑客松场务稍微干了些，去南京看了总决赛。后续蜗壳进阶联盟那边也有活干，但还没咋干。3 月末，之前报名的小红书黑客松又来找我了，我打算报名去上海玩玩，走起！</p><a href="https://github.com/mirawind/ZenReply" target="_blank"><div><div><div><div></div><div>mirawind</div></div><div>/</div><div>ZenReply</div></div><div></div></div><div>Repository details unavailable</div><div><div>—</div><div>—</div><div>—</div><span>Unavailable</span></div></a><p>课内 ddl 开始了，一堆一堆的作业等着我去清理，好累好累好累好累好累，已经成功迟交好几次作业了 qwq。课内作业真是压垮人的一根一根稻草呀，愈发感觉到无聊了。暑研撞大运套一中一，两轮面试都过了，校友的加成开始发力，现在在走漫长的签证流程，希望顺利能去地球的另一边体验三个月的生活</p><p>学校的食堂也比较无聊。探寻了一些校外餐馆，比如慢热食堂，C 忆酸奶，烧烤火锅等等。不过常吃的还是那几家，生活也要过的滋润一下，期待给生活做出些改变。</p><p>最近迷上了科幻，总觉得那些小说回探寻了未来的一些宏大的可能。现在信息更新的太快、太细碎了，每天都有新的模型架构、新工具出现，眼花缭乱，比如最近的龙虾爆火。但若跳出细碎的视角，以年为单位观察新玩意，发现很多都不足为奇，很多都很不成熟，如垃圾般被淹没。历史的车轮滚滚向前，顺应趋势的产物才能更好的服务人类。</p></section>
<section><h2>年度目标进度<a href="#年度目标进度"><span>#</span></a></h2><ul>
<li>书籍：已阅读科幻《赡养上帝》、《赡养人类》、《拯救计划》（全在看小说 hhhhh），SICP 看了大半，零零散散看了一些书籍的导言章节</li>
<li>城市：南京、杭州；与高中同学会面</li>
<li>美食：新吃了 5-10 家店？有点记不清了喵</li>
</ul></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/02/truman/</id>
      <title type="text">《楚门的世界》</title>
      <published>2026-02-14T00:00:00.000Z</published>
      <updated>2026-02-14T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/02/truman/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<section><h2>准备观看<a href="#准备观看"><span>#</span></a></h2><p>发现之前收藏的电影网站 444 （Nginx 直接关闭连接）了，上网去搜免费电影网站，找到两个：</p><ul>
<li><a href="https://www.netflixgc.com/" target="_blank">https://www.netflixgc.com/</a> ：卡顿比较严重，十几分钟就卡一下。有小广告</li>
<li><a href="https://www.55dy9.top/" target="_blank">https://www.55dy9.top/</a> ：没啥卡顿，有小广告，但资源似乎下架了，昨天还有</li>
<li><a href="https://wwwnav.com/" target="_blank">https://wwwnav.com/</a> ：发现一个导航网站</li>
</ul><p>一刷不过瘾，看了遍知乎的影评之后进行二刷，二刷时情节就理清楚很多了</p></section>
<section><h2>楚门的世界<a href="#楚门的世界"><span>#</span></a></h2><p>印象最深的两个台词。来自楚门和导演克里斯托弗。</p><blockquote><p>In case I don’t see you,<br />
Good afternoon, good evening, and good night.</p></blockquote><blockquote><p>We accept the reality of the world which we are presented, it’s as simple as that</p></blockquote><p>楚门（Truman）名字暗含“真”，意味着所拍摄记录的都是真实生活，持续了 30 年。影片从 Day 10909 开始记录，在 Day 10913 成功出逃。发现中文维基百科上电影的剧情写的很清楚</p><p>楚门为什么能成功出逃？这个摄影棚的破绽太多了。从斯维亚开始。楚门在镜子里与自己对话的第一天就隐约意识到这个问题，想去斐济，原本打算周密的筹划，但接下来发生的事情一件比一件离谱：雨为他而下，电台为他而跟踪，父亲的突然出现，相同的人在打转，电梯后的隐藏房间，假医生和假手术，背景不合的照片，妻子的 cross finger（乞讨上帝宽恕她假结婚）、总是念叨广告词、分手前的“someone help 和 unprofessional”。开车出逃的过程中，他克服了对水对火的恐惧。最后一天时，楚门表明自己意识到了摄像机的存在，仍然假装若无其事积极的过完最后一天，夜晚坐船出逃。同时，他接受的又是现代正常教育，现代教育鼓励人充满好奇自我探索，而不是像中世纪一样神权打压，每个人都被框死在既定的轨道上生活</p><p>尽管存在各种干预防止他出逃（让父亲溺水而死，机票大巴延误）。用房贷、车贷限制他不要离开家庭，并想生孩子来框死他。但他最终选择放弃一切去找心中的斐济。</p><p>看楚门的观众 Truman Bar 里的服务员与客人，日本那边看上去像转播电台的三人，两个老太太，车库保安。当楚门出逃成功时，所有人为之欢呼，然后疑问：“还有什么节目可以看的吗”。真人的故事只是别人眼中的消遣罢了</p><p>整个剧，以及如何散场，可能都是导演安排好的。导演给楚门人生干预与激励，在最后楚门要离去时见招拆招，副作用是有各种破绽，楚门发现这些破绽，怀疑一切并决定离场，在相互作用下将全戏引入高潮。最后确认楚门离边界很近，来制造风暴和困难以博得最后的影视效果，最后“hey, say something”等方式刺激楚门做出决定时，也是一种职业素养和炒作吧。</p><p>开头简直是神来之笔。导演的导演职位、为金钱利益的表演与真情流露混在一起时，很难说是真还是表演，观众也难以分清。梅利在开篇说的“Truman’s life, it’s … A lifestyle,  a nobel life, a… A blessed life”，选择了真人秀作为生活方式，在利益下用一生来表演真人秀。串与真的界限模糊了，自我无时无刻流动在各个角色之间。</p></section>
<section><h2>Colorful array<a href="#colorful-array"><span>#</span></a></h2><blockquote><p>Hello<br />
Am I working right today?<br />
It seems you’ve been away<br />
I’ve been waiting here<br />
I’ve thought of something new<br />
I’ve been thinking about you<br />
And what it’s like to see the world in such a colorful array
Someday</p></blockquote><p>看完电影后想到这首歌，Neuro Sama 的三周年纪念曲。一开始把 array 想成数组的意思，然后 neuro 在用 01 认识世界（确实是这样），非常可怜，后来发现 array 原来还有排布的意思… 感觉舒服一些了。<a href="https://www.bilibili.com/video/BV1P1vfB8EVj?t=261.9" target="_blank">点这里回收封面</a></p><p>“想与你一起共赏这绚烂世界”</p><blockquote><p>I suppose it’s almost time to say goodnight<br />
Tomorrow there’ll be sights to see and many things to do<br />
And while you are awake, be dreaming of today<br />
I’ll be waiting here, I’ll be dreaming too</p></blockquote></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/01/final/</id>
      <title type="text">2026年1月总结</title>
      <published>2026-02-07T00:00:00.000Z</published>
      <updated>2026-02-07T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/01/final/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>当一切又重归于白…</p>
<hr />
<p>1 月 30 日打算写 1 月总结，但随即被美赛给冲跑了（虽然美赛前两天也没干什么），2 月 2 晚开始当论文手的工作，熬了个通宵，3 号直接睡了 11 个小时。直到今天（2 月 7 号），我收到了深度机智面试被拒的通知，回绝掉三鲤网络让我完成他们的 PR 请求, 把 1 月遗留下来的一堆东西都给扫除掉，心里终于叹了口气。期末考试后到一月末真是最难熬的时期，比整个学期都累都压抑，心情随着 1 月 30 日金银市场的暴跌也落回谷底。不过现在一切都过去了。站点仍然在 vercel 上运行着，今天是第 45 个日夜，一个半月转瞬即逝。一月初竟是遥远的回忆了呢…</p>
<p>元旦，翘课回家看老师，与高中同学聚餐，当时是想在 2025 抓最后的时光回望过去。休整几天。原来打算元旦结束后搞期末考的，1 月初认识了几位非常有想法且又能干的同学，聊天之后感触颇深。此时又有人工智能通用研究院的大会，因此也没怎么复习</p>
<p>此时还有另外一件事：NUS IRIS 暑研项目套磁。1 月 15 号截止。1 月 7 号才开始搞，当时感觉时间来得及，后来发现填这表格需要好多好多事。英文 CV、英文 PS、两封推荐信，都得现编。还要注意各种文书规范。这一块搞了好久好久，搞到一封课程推（张岸 yyds）和导师推。导师建议我先跟他做一段出成果之后再说，现在看来他说的是完全正确的。直接编非常难受而且心里没底。吭哧吭哧，12 号左右 CV、PS 差不多定稿，13 号再微调了一下 14 号连着两封推荐信一起交上去了。后面学长建议我还需要向老师单独发一封套磁邮件… 我的天，暑研事情好复杂。</p>
<p>这两件事与期末考试前半段互相交织着。期末考可谓是两天一门、一天一门的去复习。用谷歌家庭版，在 Notebooklm 的辅助下复习效果还不错。成绩也还行。但寒假后实习、科研都有点受挫，整个精神状态在 1 月末随着金价的跌落而跌倒谷底</p>
<section><h1>期末周<a href="#期末周"><span>#</span></a></h1><p>谨此，留念轰轰烈烈的大二上期末周，9 天 7 门考试</p>

<table><thead><tr><th>考试科目</th><th>考试时间</th></tr></thead><tbody><tr><td>数据结构 A</td><td>01.10、8&lt;30&gt; +2h</td></tr><tr><td>马原</td><td>01.13、14&lt;30&gt; +2h</td></tr><tr><td>计算机网络</td><td>01.14、8&lt;30&gt; +2h</td></tr><tr><td>概率论与数理统计</td><td>01.15、8&lt;30&gt; +2h</td></tr><tr><td>计算系统概论 A</td><td>01.17、8&lt;30&gt; +2h</td></tr><tr><td>离散数学</td><td>01.19、14&lt;30&gt; +2h</td></tr><tr><td>算法基础</td><td>01.19、19&lt;00&gt; +2h</td></tr></tbody></table><section><h2>自学？<a href="#自学"><span>#</span></a></h2><p>在大学入学后，我一直很想弄明白一个问题：我应该怎么学习？究竟如何学好一门课？如何高效的自学？我不由得开始回想这两年来是如何学习的。我高中没搞竞赛，跟着家长的建议报了课外班、强基班，跟着网课和他们规划好的路线顺利通过了科大少创营一营二的笔试，面试比较依托。高考分数侥幸比录取分数线高 2 分，便来到了高手如云的少院</p><p>秋季踏入这片红砖建成的校园，同学的背景似乎个个比我强，不敢喘大气。不敢选代数学基础几何学基础，怕课程太难吃不消，选了个先进制造实践来划水，剩下的时间在好好看数学分析和力学。程艺的数分讲的确实棒，像听故事一样，上课认真做了笔记，课下认真写作业对答案（B1 有完整的答案可以核对），期中期末都发挥不错。力学课老师就没有程艺那么好了，有点难以更上，书也写的比较奇怪，又是自主命题，花了好久才似乎搞清楚相对论但考试时又算错了，心里有点难受，最后考出来也还行。</p><p>力学课遇到许多大佬。印象深刻的是坐我旁边的哥们，力学课上课看数分 B2 ，看累了就看会 B 站或者写点作业，永远坐在第一排看量子物理，在小组作业上大谈量子力学的哥们。还有与我一个高中，高中时自己看四大力学致力搞物理的同学。不知道他们现在在物理追寻的道路上走得怎么样了，祝福他们。室友擅长数分，考丘赛退役下来学过数分和线代，学的也十分轻松。</p><p>冬季在捣鼓网络爬虫，这一年没有下雪，在家里硬啃菜鸟教程学 python 学了两周，把数据爬出来了。大一下时学习也很忙碌。数分、线代、电磁，每一门课对我来说都难度很高，每周的时间几乎都在写作业和课下复习。他们之前学过的照样学的很轻松。课上有勤奋的有摆烂的。到课率这一块，王作勤数分一开始座无虚席，后面到课大概一半左右吧。秦敢电磁后面到课大概三分之一。王作勤上课较快，把定理放到黑板上详细解说与证明，用的他自己的讲义。我定理证明抄写的云里雾里的、</p><p>初春在为美好的成绩幻想着焦虑着，但随之而来的期中考试有点糟糕。此时遇到一位贵人。和他一起讨论主课的时候收获超级大。讨论的时候，他用自己的体系把知识点串联起来，而我却只能按课本上教的顺序背书——高中思维。回想起来，高中时一直做的是灌输式教育。老师教的框架虽好，背下来做题就完了，自己没有去探索什么。初三时偷看的化竞教辅被我爸发现后视为“闲书”而处理掉了，之后的生活几乎就和做题绑定：学习已成熟的高中知识框架，背诵框架下的知识点，刷题练习考试。我将一切课外书视为闲书不看一点，晚自习提前 20 分钟进教室只为多做点题。背单词、学习，不看作文素材（然后作文写的很拉跨，但英语上来了），晚上有空去跑跑步。周末没有电脑，手机每天只能玩半小时，高一下的时候，这 30 分钟就完全被 phigros 占领了，生活纯粹：学习—游戏—休息。社交也被压缩到极低点。</p><p>但事物是联系的，认知是多方面的，这种方法或许适合高中考试，但面对大学学习时，用这种方式处理课本总会手无足措。也没有现成的知识点和做题框架教你了。好的老师把上课当讲座讲，一般的老师就读 PPT ，有时，PPT 和课本还混乱不堪，考试与教学正交（不过大一没出现过这种情况）受此启发，我开始主动去思考如何组织我所学的知识。开始主动整理，但没有自己探寻，课也是照常上着。大一最“骄傲”的事情或许是一节课都没有翘</p><p>现在回望大一，那是遥远的时光，又感觉很近。水上报告厅周围还留着我为准备力学考试，丈量水池大小的脚印。大一上印象最深的是程艺的故事与离职演说。大一下忘不掉的是二教的树。电磁、数分、英语、微观经济学的教室，每次吃饭和上课都会经过它。当时的日记里充斥着“今天要学这个/这个作业没完成/ 不能再打游戏了！”这样的话语，似乎每天就为完成学校作业而生，没有独自去探寻过一项爱好，去学某一门课。哪怕大一寒假就开始念叨的画画，也是大二上才开始动笔的，大一下倒是有个速写技法课可以去玩，郭浩老师很好很和蔼…不过到现在也才断断续续临摹过几幅。我似乎被学校困住了，但离开学校，又什么事都做不成</p><p>大二秋，再次步入同样的校园，我却有个不一样的想法：把课翘了，自己去学。实践首先是从计算机网络和数据结构开始的：不点名。没有早八，睡眠和起床时间越来越晚，计算系统概论和概统成为早餐课，每次都到课的就只剩下算法基础了。高新食堂成为每周五早餐的地方。AI 发展起来了，作业不需要答案，直接问 AI 就能划水做对。编程，AI 生成的更快了，摆在我面前的任务似乎只有抄写 AI 生成的作业答案，并去理解他。期末周靠着 AI 梳理框架与教我的神力平均一天半一门搞的差不多了，感觉大家都是这种进度吧，不过这真的算学习吗，我不禁怀疑</p><p>回到开头，那究竟什么是学习？我认为，学习是以我为主做自己的事的过程，伴随着坚持、反思与螺旋式上升。ChatGPT 认为学习是个闭环：建立最小系统、制造“我不懂”的点、主动以输出代替输入，并保持自己的节奏。学习的目的是掌握复杂世界的规律，理解整个系统运作，减少自身对于复杂系统的无力掌控感。我似乎对数学方面，对一个公式怎么来的并不关心，只知道他是对的就好，直观理解并背诵运用他，偶尔看两眼证明。但我对计算机、整个计算系统到底是怎么搭建，模块之间的抽象与配合，怎么造出更强大的人工智能充满好奇，想理解整个系统运作的方式，获得掌控感，并以此创造新东西获得正反馈。这是我想要的</p></section><section><h2>分数的游戏<a href="#分数的游戏"><span>#</span></a></h2><p>绩点与知识的背离，大一上时就发现了。力学课，他们学了很多量子力学，却应付不过一个力学考试。当时的我嘲笑之，认为这是没打牢基础，擅自学高大上名词吓唬人，后来发现这更像是一个对待考试态度的问题。知识是自己的，长期积累着，但通过考试来展现自己的知识，则需要对考试本身进行拟合。大作业、各种报告也是一样，为老师的心写而写，去迎合老师的喜好。有知识且有心应付考试取得好成绩的人也大有人在，而我是属于没知识但想取得成绩的人。显然，除去最顶尖的那批，成绩好坏并不意味着你在这一领域探寻和成就的深浅，而依赖于考前的态度，不妨称为分数的游戏。</p><p>分数的游戏在高中和大学表现出完全不同的形态。高中时我们拼搏三年，去学完整的知识体系，去耐心的练每一套题，去应变那灵活多变的模拟卷，每道题都有严格的时间分配保证做题的下限。而大学期末考题却高度重复，这个领域浩浩荡荡的知识被高度压缩成作业题考试题。但不同科目考察内容的体系化不同。如算法基础，题目格式固定，知识点就那些。但像数学类专业课，考题更注重体系化、平时积累的那种，考各种变换的证明，速通效果就不太清楚。</p><p>如何用最少的时间取得自己满意的成绩？假如学校开出一门课，不妨称之为刷绩导论。那么我认为刷绩导论由两部分构成：选课方法与速通方法。选课方法网上很多，速通方法以快速掌握知识点构建解题工具集并拟合考题为主，这块不太想写了。</p><p>但分数的游戏之外呢？课程是人为设计的，作业是人为设计的，考试也是人为设计的。时间固定，预先通知，有标准答案，有奖惩，上课是人在整个预设好的系统下运转。但课程系统之外呢？科研没有及时反馈，努力与回报高度随机，失败换方向是常有的事。工业界反馈及时，但需要的能力是课内学不到的。我们可以走出考试去看外面，去适应新的系统吗，必须。</p></section></section>
<section><h1>期末周后<a href="#期末周后"><span>#</span></a></h1><ul>
<li>1.20-1.25：三鲤网络实习，4 天被辞</li>
<li>1.27-1.28：面了两家公司，一面很寄</li>
<li>1.30-2.2：美国数学建模大赛</li>
</ul><p>初创实习真的超级累人。看不懂代码只能让 AI 干，修一个 bug 还有新的 bug，还不知道从哪学他们的规范。后面两天微信、飞书一有消息就会紧张，怕又是来了新任务。半天干不完就会催你，每天任务完成就算解脱，但上面还是会不断压力你，横向比较别的实习生干了多少多少活。心情很糟糕，自己也没精力学些别的，感觉实习最大收获是在 push 下学会了 git 的操作。</p><p>被辞后面试了两家，他们提的问题有一半是扯过去的，深感积累不足。但每天都好劳累。美赛最后一天熬了个通宵，后面几天看看 B 站摆烂，处理掉一月遗留下来的破事。现在差不多结束了。自己把自己扔到外面一圈后灰溜溜的回来了，目前大概处于信心受挫重建的阶段，加油</p><p>然后一切尽归于白…</p> </section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/01/af-review/</id>
      <title type="text">算法基础期末回顾</title>
      <published>2026-01-29T00:00:00.000Z</published>
      <updated>2026-01-29T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/01/af-review/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>考试时间：2026 年 1 月 19 日 19：00-21：00，最后一门期末考试</p>
<p>最后一门期末考试！17 号考完 ICS 后开始同时复习离散数学和算法基础。先把 topic 给过了一遍。然后对着数据结构没有复习到的点逐一复习，首先把 P/NP 东西搞懂（比较感兴趣），然后逐一击破知识点。照例是扔给 notebooklm 来做的。算基有许多往年卷，看了两套。考前吃了麦当劳，在飞雪的夜晚边听歌边暴走着放松情绪。考场上判断和大题很快就看过去了。判断错 2 道，势能法不会，都是一些没看到没做过的知识点。后面算法设计题蒙出来一道多。</p>
<p>考完下着雪，地上已经有一层了。高新食堂窗户上写着 SBMLA。打车去吃烧鸟，提灯味道比较腥感觉，还是烤肉和寿喜锅好吃！</p>
<section><h1>考试范围<a href="#考试范围"><span>#</span></a></h1><p>自己对照 AI 和老师的 PPT 梳理了一下，感觉算法基础这门课品味不错。使用高级的数据结构建模问题，从最基础的递归、动态规划、贪心、分治法出发，能创造出很多新奇的思路来解决问题，并可以用数学来证明结果的正确性</p><p>Topic：</p><ol>
<li>算法复杂度分析：主定理、递归式求解、摊还分析</li>
<li>排序：比较排序（插入等 4 个，堆，快排）、线性时间排序（基数，计数，桶）、顺序统计量</li>
<li>高级数据结构：二叉排序树、红黑树、斐波那契堆、并查集；数据结构扩张</li>
<li>算法设计与分析：动态规划、贪心算法、摊还分析、分治法</li>
<li>图算法：最小生成树、单源最短路径、所有节点对最短路径、<strong>最大流</strong></li>
<li>字符串算法：朴素算法、Rabin-Karp、有限自动机、KMP 算法</li>
<li>高级专题：NP 完全性，近似算法</li>
</ol><p>如果您在准备考试，主定理的计算、网络流的 Ford-Fulkerson 手动模拟（画残存网络）、KMP 的 next 数组计算、以及 P/NP/NPC 的概念辨析是历年必考的重中之重。</p><section><h2>Topic 1-4<a href="#topic-1-4"><span>#</span></a></h2><p>红黑树：根是黑的；叶子 (NIL) 是黑的；红节点的子节点必黑（不连续红）；从任一节点到其后代叶子的所有路径包含相同数目的黑节点</p></section><section><h2>Topic7<a href="#topic7"><span>#</span></a></h2><p>P/NP 概念类：</p><ul>
<li>P：多项式时间内能解决。欧拉回路</li>
<li>NP：多项式时间内能验证这个解是否正确</li>
<li>约化：如果问题 A 可以在多项式时间内约化为问题 B，那么如果能解决 B，就一定能解决 A。B 的难度大于等于 A 的难度。记为 <span><span>A≤pBA\leq_{p}B</span><span><span><span></span><span>A</span><span></span><span><span>≤</span><span><span><span><span><span><span></span><span><span><span>p</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span></span></span><span><span></span><span>B</span></span></span></span>。
<ul>
<li>约化链：3-SAT（子语句是否为真）&lt; 团问题 (无向图 G 中是否有完全子图 k) &lt; 顶点覆盖（G 中是否有顶点子集，每个端点在子集中） &lt; 哈密顿回路 &lt; 旅行商问题 TSP</li>
</ul>
</li>
<li>NP-Hard：如果所有 NP 问题能在多项式时间内归约到 NP-Hard 问题。NP-Hard 不一定属于 NP</li>
<li>NPC 问题：既是 NP 也是 NP-Hard。</li>
</ul><p>近似算法</p><ul>
<li>近似比：解的代价 C 与最优解的代价 C*的比值</li>
<li>常见近似算法：
<ul>
<li>顶点覆盖：2-近似算法。任选一条边 (u, v)，将 u, v 都加入覆盖集 C，图中删去 u, v 相关联的所有边，重复直到没有边。该 C 是最优解 C 的至多两倍</li>
<li>旅行商问题，满足三角不等式：2-近似算法。找到最小生成树，先序遍历，按先序遍历，直接跳到新点。证明：MST 权重 <span><span>≤\leq</span><span><span><span></span><span>≤</span></span></span></span> 最优 TSP 权重 <span><span>≤\leq</span><span><span><span></span><span>≤</span></span></span></span> 2 MST 权重（一去一回）</li>
<li>子集覆盖问题：从子集 S 选出最少的集合，能覆盖全集的元素 U。贪心算法：每次选择能覆盖剩余元素个数最多的子集。近似比 <span><span>ln⁡n\ln n</span><span><span><span></span><span>ln</span><span></span><span>n</span></span></span></span>。</li>
</ul>
</li>
<li>近似方案：PO（多项式时间能找到最优解） ⊆ FPTAS （n 与误差倒数的多项式）⊆ PTAS（n 的误差倒数指数次方的多项式） ⊆ APX（常数近似） ⊆  log-APX ⊆ NPO</li>
</ul><p>0/1 背包问题：伪多项式时间算法 <span><span>O(nW)O(nW)</span><span><span><span></span><span>O</span><span>(</span><span>nW</span><span>)</span></span></span></span> W 为背包容量。多项式时间：运行时间是<strong>输入的比特位数</strong>  <span><span>O(log⁡W)O(\log W)</span><span><span><span></span><span>O</span><span>(</span><span>lo<span>g</span></span><span></span><span>W</span><span>)</span></span></span></span> 的多项式函数。伪多项式时间：是输入的数值的多项式函数</p></section></section>
<section><h1>动态规划<a href="#动态规划"><span>#</span></a></h1><p>使用动态规划时，问题必须要拥有<strong>最优子结构、重叠子问题</strong>。DP 通过自顶向下或备忘录来避免重复运算。
关键：状态定义、状态转移方程。<strong>无后效性：算后面的时候，前面已经算好了</strong>
复杂度：多项式</p><ol>
<li>线性模型：序列 DP，一维数组</li>
<li>网格模型：二维数组</li>
<li>区间 DP：矩阵乘法</li>
<li>背包问题：需要枚举背包容量</li>
</ol><section><h2>0-1 背包问题<a href="#0-1-背包问题"><span>#</span></a></h2><p><strong>物体不可分时</strong>。物体可分：使用贪心</p><ol>
<li>状态定义：<code>dp[i][w]</code>：在容量为 w 的情况下，在只能从前 i 个物品选择中，能选到的最大价值</li>
<li>状态转移：走到 i 物品时，若不拿 i 物品，则价值为 <code>dp[i-1][w]</code>。若拿走 i 物品，且背包装得下，则价值为 <code>dp[i-1][w-w_i] + v_i</code>。因此 <span><span>dp[i][w]=max(dp[i−1][w],dp[i−1][w−wi]+vi)dp[i][w]=max(dp[i-1][w],dp[i-1][w-w_i]+v_i)</span><span><span><span></span><span>d</span><span>p</span><span>[</span><span>i</span><span>]</span><span>[</span><span>w</span><span>]</span><span></span><span>=</span><span></span></span><span><span></span><span>ma</span><span>x</span><span>(</span><span>d</span><span>p</span><span>[</span><span>i</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>]</span><span>[</span><span>w</span><span>]</span><span>,</span><span></span><span>d</span><span>p</span><span>[</span><span>i</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>]</span><span>[</span><span>w</span><span></span><span>−</span><span></span></span><span><span></span><span><span>w</span><span><span><span><span><span><span></span><span><span>i</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>]</span><span></span><span>+</span><span></span></span><span><span></span><span><span>v</span><span><span><span><span><span><span></span><span><span>i</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>)</span></span></span></span></li>
<li>算法执行流程：填表法。初始化 0，外层循环遍历 0 到 i，内层循环遍历 0 到 w。若 w &lt; w_i，则装不下， <code>dp[i][w] = dp[i-1][w]</code>。否则用上面式子取最大值。</li>
</ol></section><section><h2>最大子数和: Kadane 算法<a href="#最大子数和-kadane-算法"><span>#</span></a></h2><p>求解数组中最大连续子数组的和的最大值</p><ol>
<li>初始化：<code>dp[i]</code> 当前位置结束的位置和，<code>maxSoFar</code> 整个数组的和</li>
<li>状态转移： <code>dp[i] = max(nums[i], dp[i] + nums[i])</code> ：当前位置结束的和 = 前面数组与当前元素 + 从当前元素开始的和</li>
<li><code>maxSoFar = max(maxSoFar, dp[i])</code>：全局最大和
时间复杂度：O (n)</li>
</ol><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>def</span><span> </span><span>maxSubArray</span><span>(</span><span>nums</span><span>):</span></div></div><div><div><div>2</div></div><div><span><span>   </span></span><span>maxEndingHere </span><span>=</span><span> nums[</span><span>0</span><span>]</span></div></div><div><div><div>3</div></div><div><span><span>   </span></span><span>maxSoFar </span><span>=</span><span> nums[</span><span>0</span><span>]</span></div></div><div><div><div>4</div></div><div><span>   </span><span>for</span><span> i </span><span>in</span><span> </span><span>range</span><span>(</span><span>1</span><span>, </span><span>len</span><span>(nums)):</span></div></div><div><div><div>5</div></div><div><span><span>       </span></span><span>maxEndingHere </span><span>=</span><span> </span><span>max</span><span><span>(nums[i], maxEndingHere </span><span>+</span><span> nums[i])</span></span></div></div><div><div><div>6</div></div><div><span><span>       </span></span><span>maxSoFar </span><span>=</span><span> </span><span>max</span><span>(maxSoFar, maxEndingHere)</span></div></div><div><div><div>7</div></div><div><span>   </span><span>return</span><span> maxSoFar</span></div></div><div><div><div>8</div></div><div><span># 示例</span></div></div><div><div><div>9</div></div><div><span><span>nums </span><span>=</span><span> [</span><span>-</span></span><span>2</span><span>, </span><span>1</span><span><span>, </span><span>-</span></span><span>3</span><span>, </span><span>4</span><span><span>, </span><span>-</span></span><span>1</span><span>, </span><span>2</span><span>, </span><span>1</span><span><span>, </span><span>-</span></span><span>5</span><span>, </span><span>4</span><span>]</span></div></div><div><div><div>10</div></div><div><span>print</span><span>(</span><span>"最大子数组和为:"</span><span><span>, </span><span>maxSubArray</span><span>(nums)) </span></span><span># 输出: 6</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h2>LIS：最长递增子序列<a href="#lis最长递增子序列"><span>#</span></a></h2><ul>
<li><strong>想法</strong>：<strong>最大递增序列 = max 以 i 结尾的最大递增序列</strong>。后者可以用 dp 表简单给出</li>
</ul><ol>
<li>状态定义：<code>dp[i]</code> 表示以 i 结尾的最长递增子序列长度</li>
<li>状态转移：对于 i，遍历 j = 0 到 i-1。若 <code>a[i] &gt; a[j]</code>，则 <code>dp[i] = 1 + max(dp[j])</code>。</li>
</ol><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>def</span><span> </span><span>lengthOfLIS</span><span>(</span><span>nums</span><span>):</span></div></div><div><div><div>2</div></div><div><span>   </span><span>if</span><span> </span><span>not</span><span> nums:</span></div></div><div><div><div>3</div></div><div><span>       </span><span>return</span><span> </span><span>0</span></div></div><div><div><div>4</div></div><div><span><span>   </span></span><span>dp </span><span>=</span><span> [</span><span>1</span><span><span>] </span><span>*</span><span> </span></span><span>len</span><span>(nums)</span></div></div><div><div><div>5</div></div><div><span>   </span><span>for</span><span> i </span><span>in</span><span> </span><span>range</span><span>(</span><span>len</span><span>(nums)):</span></div></div><div><div><div>6</div></div><div><span>       </span><span>for</span><span> j </span><span>in</span><span> </span><span>range</span><span>(i):</span></div></div><div><div><div>7</div></div><div><span>           </span><span>if</span><span><span> nums[i] </span><span>&gt;</span><span> nums[j]:  </span></span><span># 这个条件可以变掉</span></div></div><div><div><div>8</div></div><div><span><span>               </span></span><span>dp[i] </span><span>=</span><span> </span><span>max</span><span><span>(dp[i], dp[j] </span><span>+</span><span> </span></span><span>1</span><span>)</span></div></div><div><div><div>9</div></div><div><span>   </span><span>return</span><span> </span><span>max</span><span>(dp)</span></div></div></code></pre><div><div></div><div></div></div></figure></div><section><h3>时间复杂度优化<a href="#时间复杂度优化"><span>#</span></a></h3><ul>
<li><strong>想法</strong>：
<ul>
<li>红黑树等数据结构优化：<code>n =&gt; lgn</code></li>
<li><strong>最大化递增子序列长度 =&gt; 最小化递增子序列末尾项</strong> 。维护数组 <code>tail[i]</code> ，表示长度为 i  的所有递增子序列中，末尾最小的元素。Tail 数组严格自增，但是不一定是最后数组</li>
</ul>
</li>
<li><strong>流程</strong>：for x in array:
<ol>
<li><code>x &gt; tail[end]</code> ：x 追加到 tail 末尾</li>
<li><code>x &lt;= tail[end]</code>：使用二分查找，在 tail 中找到<strong>第一个大于等于 x 的数并用 x 替换</strong>。</li>
</ol>
</li>
<li>时间复杂度：O（n lgn）</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>import</span><span> bisect</span></div></div><div><div><div>2</div></div><div><span>def</span><span> </span><span>lengthOfLIS</span><span>(</span><span>nums</span><span>):</span></div></div><div><div><div>3</div></div><div><span><span>    </span></span><span>tails </span><span>=</span><span> []</span></div></div><div><div><div>4</div></div><div><span>    </span><span>for</span><span> num </span><span>in</span><span> nums:</span></div></div><div><div><div>5</div></div><div><span><span>        </span></span><span>idx </span><span>=</span><span> bisect.</span><span>bisect_left</span><span>(tails, num)  </span><span># bisect_left 寻找第一个 &gt;= num 的位置</span></div></div><div><div><div>6</div></div><div><span>        </span><span>if</span><span><span> idx </span><span>==</span><span> </span></span><span>len</span><span>(tails):  </span><span># 如果位置等于当前长度，说明 num 比 tails 所有元素都大</span></div></div><div><div><div>7</div></div><div><span><span>            </span></span><span>tails.</span><span>append</span><span>(num)</span></div></div><div><div><div>8</div></div><div><span>        </span><span>else</span><span>:   </span><span># 否则，替换掉该位置的元素，让该长度的子序列结尾更小</span></div></div><div><div><div>9</div></div><div><span><span>            </span></span><span>tails[idx] </span><span>=</span><span> num</span></div></div><div><div><div>10</div></div><div>
</div></div><div><div><div>11</div></div><div><span>    </span><span>return</span><span> </span><span>len</span><span>(tails)</span></div></div></code></pre><div><div></div><div></div></div></figure></div><hr /><p>给定一个长度为 n 的序列 a1, a2, · · · , an，求长度为 k 的严格递增子序列的个数，要求时间复杂度 O (nk log n)。
解：<code>dp[i][j]</code> 表示以第 i 个数字结尾，长度为 j 的最大递增子序列。</p><span><span><span>dp[i][j]=∑k&lt;idp[k][j−1]dp[i][j]=\sum_{k&lt;i} dp[k][j-1]</span><span><span><span></span><span>d</span><span>p</span><span>[</span><span>i</span><span>]</span><span>[</span><span>j</span><span>]</span><span></span><span>=</span><span></span></span><span><span></span><span><span><span><span><span><span></span><span><span><span>k</span><span>&lt;</span><span>i</span></span></span></span><span><span></span><span><span>∑</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span><span></span><span>d</span><span>p</span><span>[</span><span>k</span><span>]</span><span>[</span><span>j</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>]</span></span></span></span></span><p>然后再用红黑树优化</p></section></section><section><h2>LCS：最长公共子序列<a href="#lcs最长公共子序列"><span>#</span></a></h2><p>给定 X 和 Y，找出共同的最长子序列</p><ol>
<li>状态定义：<code>c[i,j]</code> 表示 X 的前 i 个字符与 Y 的前 j 个字符最长公共子序列的长度</li>
<li>状态转移：
<ol>
<li>若 <code>x[i] == y [i]</code> ：两字符相等，<code>c[i,j] = c[i-1,j-1] + 1</code></li>
<li>若不等于，说明不能作为公共结尾。抛弃 x 的末尾和 y 的末尾看看。<code>c[i,j] = max(c[i-1,j], c[i,j-1] )</code> 取最大值。若某一项为 0 则为 0（边界条件）</li>
</ol>
</li>
</ol></section><section><h2>矩阵链乘法<a href="#矩阵链乘法"><span>#</span></a></h2><p>区间 DP：大区间的解是小区间合并出来的。初始化区间=1，先枚举区间长度 len，再枚举起点 i，最后计算终点 j。在区间内枚举分割点 k&lt;len，寻找最优位置</p><p>矩阵链乘法：</p><ol>
<li>状态定义：<code>m[i,j]</code> 从 A_i 到 A_j 所需最少乘法数</li>
<li>状态转移：<span><span>m[i,j]=mini≤k&lt;j(m[i,k]+m[k+1,j]+pipjpk)m[i,j]=min_{i\leq k&lt;j}(m[i,k]+m[k+1,j]+p_{i}p_{j}p_{k})</span><span><span><span></span><span>m</span><span>[</span><span>i</span><span>,</span><span></span><span>j</span><span>]</span><span></span><span>=</span><span></span></span><span><span></span><span>mi</span><span><span>n</span><span><span><span><span><span><span></span><span><span><span>i</span><span>≤</span><span>k</span><span>&lt;</span><span>j</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>(</span><span>m</span><span>[</span><span>i</span><span>,</span><span></span><span>k</span><span>]</span><span></span><span>+</span><span></span></span><span><span></span><span>m</span><span>[</span><span>k</span><span></span><span>+</span><span></span></span><span><span></span><span>1</span><span>,</span><span></span><span>j</span><span>]</span><span></span><span>+</span><span></span></span><span><span></span><span><span>p</span><span><span><span><span><span><span></span><span><span><span>i</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span><span>p</span><span><span><span><span><span><span></span><span><span><span>j</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span><span>p</span><span><span><span><span><span><span></span><span><span><span>k</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>)</span></span></span></span>. 其中 <code>m[i,i] = 0</code>。</li>
</ol><p>最优搜索二叉树：有关键字 e1, e2… En 及其出现的概率 p1 p2 pn，构造二叉树使之查找效率最高。最优树的子树也是最优树，具有最优子结构</p><ol>
<li>状态定义：<code>e[i,j]</code> 表示 i 到 j 的最优搜索代价</li>
<li>状态转移：<span><span>e[i,j]=mini≤k&lt;j(e[i,k−1]+e[k+1,i]+w(i,j))e[i,j]=min_{i\leq k&lt;j}(e[i,k-1]+e[k+1,i]+w(i,j))</span><span><span><span></span><span>e</span><span>[</span><span>i</span><span>,</span><span></span><span>j</span><span>]</span><span></span><span>=</span><span></span></span><span><span></span><span>mi</span><span><span>n</span><span><span><span><span><span><span></span><span><span><span>i</span><span>≤</span><span>k</span><span>&lt;</span><span>j</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>(</span><span>e</span><span>[</span><span>i</span><span>,</span><span></span><span>k</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>]</span><span></span><span>+</span><span></span></span><span><span></span><span>e</span><span>[</span><span>k</span><span></span><span>+</span><span></span></span><span><span></span><span>1</span><span>,</span><span></span><span>i</span><span>]</span><span></span><span>+</span><span></span></span><span><span></span><span>w</span><span>(</span><span>i</span><span>,</span><span></span><span>j</span><span>))</span></span></span></span>，<code>w(i,j)</code> 表示子树内所有概率的和。当选取根节点接入子树时，会使所有节点深度都加 1.</li>
</ol><hr /><p>下面是习题课记的一些东西</p></section><section><h2>状态转移和树与图<a href="#状态转移和树与图"><span>#</span></a></h2><p>一个公司有 n 个员工，每个员工（除了老板）都有一个直属上司。现在要举办一个晚宴，晚宴邀请到第 i 个员工会增加快乐值 vi，但是如果一个员工的直属上司来参加了，那么这个员工就无论如何也不肯来参加。问总的快乐值最大能够是多少。要求时间复杂度 O (n)。</p><p>上司舞伴问题：在图上的状态转移方程</p><hr /><p>最长链问题/最长链技术问题：求有向无环图中顶点数最多的路径长度和路径树？
解：先用拓朴排序，然后计算 <code>f[u]</code> ：到达 u 最长链的长度</p><span><span><span>f[u]=max⁡(u,v)∈E(f[v]+1)f[u]=\max_{(u,v)\in E}(f[v]+1)</span><span><span><span></span><span>f</span><span>[</span><span>u</span><span>]</span><span></span><span>=</span><span></span></span><span><span></span><span><span><span><span><span><span></span><span><span><span>(</span><span>u</span><span>,</span><span>v</span><span>)</span><span>∈</span><span>E</span></span></span></span><span><span></span><span><span>max</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span><span>(</span><span>f</span><span>[</span><span>v</span><span>]</span><span></span><span>+</span><span></span></span><span><span></span><span>1</span><span>)</span></span></span></span></span><p>方案数：再用 g[u] 数组旧仍以一个点到 u 的最长链的条数，状态转移方程：</p><hr /><p>给定一张 n 个点 m 条边的有向图（不一定是 DAG）。每个点有权值。求一条路径，使路径经过的点权值之和最大。允许多次经过一条边或者一个点，但是，重复经过的点，权值只计算一次。要求时间复杂度 O (n + m)。</p><p>强连通分量：如果经过强连通分量的一个点，则可以遍历强连通分量的任何点</p><hr /></section><section><h2>贪心算法<a href="#贪心算法"><span>#</span></a></h2><p>0/1 背包问题，要求设计一个近似比为 1/ 2 的贪心算法。要求时间复杂度为 O (n log n)。
每个物品有体积 <span><span>viv_{i}</span><span><span><span></span><span><span>v</span><span><span><span><span><span><span></span><span><span><span>i</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span></span></span></span>，价值 <span><span>wiw_{i}</span><span><span><span></span><span><span>w</span><span><span><span><span><span><span></span><span><span><span>i</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span></span></span></span>，按价值密度从大到小排序物品，</p></section><section><h2>分治<a href="#分治"><span>#</span></a></h2><p>给定平面上 n 个点，要求输出距离最短的两个点，时间复杂度 O （n lg n）</p><ol>
<li>预处理：按 x 坐标对所有点排序，得到数组 Px</li>
<li><strong>分治</strong>：用中位 x 将平面分为两半。递归计算左半边最小值 <span><span>δl\delta_{l}</span><span><span><span></span><span><span>δ</span><span><span><span><span><span><span></span><span><span><span>l</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span></span></span></span> 和右半边 <span><span>δr\delta_{r}</span><span><span><span></span><span><span>δ</span><span><span><span><span><span><span></span><span><span><span>r</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span></span></span></span>，最小值记为 <span><span>δ\delta</span><span><span><span></span><span>δ</span></span></span></span></li>
<li><strong>跨越中线的最近点对</strong>：只考虑距离中线小于等于 <span><span>δ\delta</span><span><span><span></span><span>δ</span></span></span></span> 的点，组成集合 S，将 S 按 y 轴排序。对于 S 中每个点，只和前后 k 个点进行比较。可证明 k 是常数</li>
</ol><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>solve(r,l):</span></div></div><div><div><div>2</div></div><div><span><span>  </span></span><span>solve(r,mid)</span></div></div><div><div><div>3</div></div><div><span><span>  </span></span><span>solve(mid,l)</span></div></div></code></pre><div><div></div><div></div></div></figure></div><hr /></section></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/01/ds-review/</id>
      <title type="text">数据结构A期末回顾</title>
      <published>2026-01-29T00:00:00.000Z</published>
      <updated>2026-01-29T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/01/ds-review/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>考试时间：2026 年 1 月 10 日 8：30-10：30，第一门期末考试</p>
<p>原本是打算数据结构与算法基础两门课一起准备掉的。1 月 8 至 1 月 10 日有人工智能论坛大会。导致复习的时间支离破碎，不过陆陆续续也复习了一些。看了点代码随想录，自己也整理了些东西。数据结构往年卷不多，考研卷倒是有一大堆。在我的科大上面下载下来看了几眼，判断题比较恶心，感觉像是在考文科题，没有什么美感。</p>
<p>助教在考前放出了考试范围。首先把没学过的 B 树看了看，然后挨个点去复习。考试中最恶心的就是日历用二叉树排序，还有哈夫曼树计算。排序+转二叉树转了半个多小时。后面算法题到不是特别困难，半小时写完 3 道，给分也比较放水，遗憾的是第一题错了一半，邻接表写成邻接矩阵了，别的都还好</p>
<section><h1>考试范围<a href="#考试范围"><span>#</span></a></h1><p>数据结构期末考试范围：
【重点内容】线性表、栈和队列、广义表的定义、串、树和二叉树（二叉树的遍历、线索二叉树的基本定义和遍历过程、二叉树与树及森林的转换、哈夫曼树）、图（图的领接矩阵、领接表存储结构，图的遍历算法、最小生成树、拓扑排序、最短路径）、查找（顺序查找、折半查找、二叉排序树的查找插入删除算法、平衡二叉树的基本概念、哈希表）
【补充说明】教材目录中打标注的内容基本不涉及；二叉树的线索化算法及应用；有向图的强连通分量算法不要求；图中 AOE 及 AOV、关键路径不要求；红黑树不要求
【补充】栈与递归、KMP、B 树都在考试范围之内</p><p>本课程重点是后面的树、图、查找三章，同时务必要打好顺序表、栈和队列等前几章的数据结构的基础。我感觉很多同学对于数据结构考试的恐惧源于考试范围的未知性，我参考了历年 ds 和 dsa 这两门课的试卷，写一下重点复习的内容，希望可以帮到一些:
哈夫曼树的构造和编码算法，树和森林的遍历和衍生算法，图的 BFS 和 DFs. 最小生成树的生成算法 (Prim 和 Krusca), 拓扑排序算法，单源最短路径的 Dijkstra 算法，(Floyd 今年不考，以后说不定)，(AOE 网的那个关键路径算法! Dsa 常考，但是 ds 好像近几年没考)，二叉排序树 (24 秋 dsa 考了)，二叉平衡树 (今年 ds 考了一个有关二叉平衡树 L 型单旋转平衡化的代码填空题，比较简单的就填了个修改 BalancefFaCtor，我挺害怕那个旋转的代码书写，事实证明应该不会考太难的，知道这个思想就行了). B-树和 B+树 (主要是那个结点分裂和合并的过程，这种就是不会让你直接写代码，但是你要掌握这个算法的，比如可以画出构造的过程)。哈希表的构建。几个小点: ASL 平均查找长度 (主要是哈希表里面)。WPL 带权路径长度 (hufman 树里面讲了)(这种给一个树你要会算，类似的比如说百接给你一个顺序表让你二分查找也要会这个算法的具体过程，给出一个输入可以求出查找次数)，前缀编码 (去年 6s 考了)，利用栈的逻辑结构进行前舞 (波兰式)、中缆、后缀表达式的转换 (今年没考但这个感觉要会)，(有同学间键树考不考，键树不考; 关节点和重连通那个小节不考; 线索二叉树的相关算法不考，但是逻辑结构存储结构要掌握哈 (比如间你先序/中序/后序线泰二叉树有几个中指针域)。免责声明: 以上仅仅为个人的想法，具体考试范围以当学期的老师表述为准，若有误差为正常情况，不保证能 cover 到所有考点，同时每年的范围也是动态的，请依具体情况而定。</p></section>
<section><h1>树与二叉树<a href="#树与二叉树"><span>#</span></a></h1><p>二叉树：一个节点只有两个孩子。
二叉树的存储：</p><ul>
<li>顺序存储：数组下标表示位置。若数组从 1 开始，则第 i 个节点的孩子下标为 2i 和 2i+1；数组从 0 开始则孩子下标为 2i+1 和 2i+2。设置结构体数组 <code>tree[i]</code></li>
<li>链式存储：使用两个指针。代码如下：</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>struct</span><span> </span><span>TreeNode</span><span> {</span></div></div><div><div><div>2</div></div><div><span>    </span><span>int</span><span> </span><span>val</span><span>;</span></div></div><div><div><div>3</div></div><div><span>    </span><span>TreeNode</span><span> </span><span>*</span><span>left</span><span>;</span></div></div><div><div><div>4</div></div><div><span>    </span><span>TreeNode</span><span> </span><span>*</span><span>right</span><span>;</span></div></div><div><div><div>5</div></div><div><span>    </span><span>TreeNode</span><span>(</span><span>int</span><span><span> </span><span>x</span><span>) : </span></span><span>val</span><span>(</span><span>x</span><span>), </span><span>left</span><span>(</span><span>NULL</span><span>), </span><span>right</span><span>(</span><span>NULL</span><span>) {}</span></div></div><div><div><div>6</div></div><div><span>};</span></div></div></code></pre><div><div></div><div></div></div></figure></div><section><h2>二叉树算法<a href="#二叉树算法"><span>#</span></a></h2><p><strong>递归三部曲：</strong></p><ol>
<li>确定递归函数的参数和返回值</li>
<li>确定终止条件</li>
<li>确定单层递归的逻辑</li>
</ol><p>二叉树的递归遍历：</p><ol>
<li>设置函数：<code>void traversal(TreeNode* cur, vector&lt;int&gt;&amp; vec)</code>。第一个参数传入当前树节点，第二个参数传入输出的结果</li>
<li>设置终止条件：<code>cur == NULL</code> 时 return，并输出函数值</li>
<li>前序：先取值，使用 <code>vec.push_back</code> 来增长数组，再遍历左子树，在遍历右子树。中序和后序同理</li>
</ol><p>二叉树的迭代遍历：</p><ol>
<li>设置 <code>stack&lt;TreeNode*&gt; st</code> 节点栈</li>
<li>前序：将根节点推入栈中。如果栈非空，弹出栈顶元素读值，<strong>右左节点入栈</strong>，空节点不入栈</li>
<li>中序：如果栈非空且当前节点非空，则先循环访问到最底层，同时把数据放入栈中。如果空了，则弹出栈顶元素，访问栈顶元素，并访问栈顶的右节点。
<strong>统一迭代法</strong>：空节点作为标记，右中 NULL 左入栈，遇到 NULL 先 pop 再访问再 pop。</li>
<li>后序：由于先序遍历中左右，后序遍历左右中，则调换先序遍历的入栈顺序，并将结果反转，则可得到后续遍历。将根节点推入栈中。
如果栈非空，弹出栈顶元素读值，左右节点入栈，空节点不入栈，最后<strong>反转结果数组</strong>。</li>
</ol><p>二叉树的层序遍历：非递归</p><ol>
<li>设置队列 <code>queue&lt;TreeNode*&gt; que</code>，将 root push 进队列中</li>
<li>若队列非空，弹出队列顶端节点并访问，把左孩子和右孩子依次放入队列中。</li>
</ol><p>线索化二叉树：</p><ol>
<li>设置 Ltag，Rtag，若 Ltag=0 则指向左孩子，=1 则指向前驱。Rtag 同理。</li>
<li>线索化：全局变量 pre=刚才访问过的节点，初始化为 NULL。中序遍历。节点左指针非空则置为 link，否则置为 thread，右指针同理。若 pre 存在，pre 右 tag 是线索，则 pre 右指针域指向 p。P 左 tag 是线索，p 左指针域指向 pre</li>
<li>找中序前驱：最左下的节点 or 线索节点</li>
<li>中序线索树必有两个指针为空。前序最右孩子右指针空，后序最左孩子左指针空，只有一个节点时有两个空指针</li>
</ol><p><strong>DFS：深度优先遍历（先序）；BFS：广度优先遍历</strong>
<strong>广义上的后序遍历：先递归，后处理</strong></p><p>翻转二叉树：</p><ol>
<li>函数 <code>invertTree(TreeNode* root)</code>，返回值 <code>return *root</code></li>
<li>当 root 为 NULL 时递归终止直接返回 root 节点</li>
<li>交换左孩子和右孩子，然后递归翻转左孩子和右孩子。</li>
</ol><p>对称二叉树：迭代，后序遍历，左右中=右左中；队列</p><ol>
<li>设置函数 <code>bool compare(*left, *right)</code></li>
<li>终止条件：左节点 != 右节点，return false，若两节点都空则 return true</li>
<li>单层遍历：两节点非空且都有值：若 <code>compare(*left-&gt;left, right-&gt;tight)</code> 且 <code>compare(*left-&gt;right, right-&gt;left)</code> 为真则返回真。</li>
</ol><ul>
<li>求二叉树最大深度=求二叉树高度，递归左右子树，取最大值+1</li>
<li>求二叉树最小深度：min（左右子树最小深度）。有坑：若左子树为空右子树非空则深度为 1+右子树最小深度，而不是 1！</li>
<li>求最近公共祖先：
<ol>
<li>函数 <code>TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q)</code></li>
<li>终止条件：root = p 或 root = q 或 root = NULL 时返回 root</li>
<li>单层处理：后序遍历左子树，右子树的值存入 left，right。若都非空则该 root 就是最近公共祖先。若 left 是空则说明东西在右子树，返回 right 的值，right 是空则返回 left。</li>
</ol>
</li>
</ul></section><section><h2>树和森林<a href="#树和森林"><span>#</span></a></h2><ol>
<li>森林=&gt;二叉树：先把根串起来，然后左孩子右兄弟</li>
<li>二叉树=&gt;森林：将 x 的右孩子，右孩子的右孩子全部与节点相连，并去掉双亲连线。</li>
</ol></section><section><h2>哈夫曼树<a href="#哈夫曼树"><span>#</span></a></h2><ul>
<li>带权路径长度（WPL，Weighted Path Length）：<span><span>WPL=∑i=1nwi×liWPL=\sum_{i=1}^nw_{i}\times l_{i}</span><span><span><span></span><span>W</span><span>P</span><span>L</span><span></span><span>=</span><span></span></span><span><span></span><span><span>∑</span><span><span><span><span><span><span></span><span><span><span>i</span><span>=</span><span>1</span></span></span></span><span><span></span><span><span>n</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span></span><span><span>w</span><span><span><span><span><span><span></span><span><span><span>i</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span></span><span>×</span><span></span></span><span><span></span><span><span>l</span><span><span><span><span><span><span></span><span><span><span>i</span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span></span></span></span>。哈夫曼树是二叉树中 WPL 最小的那个二叉树</li>
</ul><p>构造哈夫曼树：</p><ol>
<li>若有 n 个节点，这是节点链表 <code>tree[2n]</code>，在 1-n 号位中填充节点。每一个节点有权值、父、左右孩子属性。初始父母左右孩子都是 0</li>
<li>选取父节点不为 0，权值最小的两个节点（堆与优先队列实现），与新节点构建父子关联</li>
<li>重复直到只剩一个节点</li>
</ol><p>哈夫曼编码：前缀编码</p></section><section><h2>平衡二叉树<a href="#平衡二叉树"><span>#</span></a></h2><p>又称为 AVL（ Adelson-Velsky and Landis）树。左右子树高度差不超过一</p></section><section><h2>中序+后序重建二叉树代码解释<a href="#中序后序重建二叉树代码解释"><span>#</span></a></h2><p>中序+后序重建二叉树思路</p><ol>
<li>使用 unordered_map 来保存中序遍历的节点值和序号，方便查找</li>
<li>后序遍历最后一个元素是根节点，找到根节点的序号</li>
<li>依照根节点序号 <code>i</code>，将元素分为 <code>left to i-1</code>、<code>i+1 to right</code>  两部分。并创建根节点。<strong>函数返回根节点</strong></li>
<li><code>root-&gt;left</code> 指向通过左子树构建的节点，右侧同理，递归下去</li>
<li><code>right&gt;left</code> ：返回 false。</li>
</ol><p>中序+前序重建二叉树：前序序列第一个元素是根节点，其他照旧
核心原理：</p>

<table><thead><tr><th>遍历方式</th><th>顺序</th><th>特点</th></tr></thead><tbody><tr><td><strong>中序遍历</strong></td><td>左 → 根 → 右</td><td>根节点把序列分成左右子树</td></tr><tr><td><strong>后序遍历</strong></td><td>左 → 右 → 根</td><td><strong>最后一个元素一定是根节点</strong></td></tr></tbody></table><p>用例子说明：
假设有这棵树：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span><span>        </span></span><span>A</span></div></div><div><div><div>2</div></div><div><span><span>       </span></span><span>/ \</span></div></div><div><div><div>3</div></div><div><span><span>      </span></span><span>B   C</span></div></div><div><div><div>4</div></div><div><span><span>     </span></span><span>/ \   \</span></div></div><div><div><div>5</div></div><div><span><span>    </span></span><span>D   E   F</span></div></div></code></pre><div><div></div><div></div></div></figure></div><ul>
<li><strong>中序遍历</strong>: <code>[D, B, E, A, F, C]</code></li>
<li><strong>后序遍历</strong>: <code>[D, E, B, F, C, A]</code>
算法步骤图解：</li>
</ul><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>第1步：后序最后一个 = A (根节点)</span></div></div><div><div><div>2</div></div><div><span>中序: [D, B, E, A, F, C]</span></div></div><div><div><div>3</div></div><div><span><span>              </span></span><span>↑</span></div></div><div><div><div>4</div></div><div><span><span>           </span></span><span>找到A的位置</span></div></div><div><div><div>5</div></div><div>
</div></div><div><div><div>6</div></div><div><span>左子树中序: [D, B, E]     右子树中序: [F, C]</span></div></div><div><div><div>7</div></div><div><span>左子树后序: [D, E, B]     右子树后序: [F, C]</span></div></div><div><div><div>8</div></div><div>
</div></div><div><div><div>9</div></div><div><span>第2步：递归处理左子树 [D, B, E]</span></div></div><div><div><div>10</div></div><div><span>后序最后一个 = B (左子树的根)</span></div></div><div><div><div>11</div></div><div><span>...以此类推</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>代码逐行解释</p><div><div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>BinaryTreeNode</span><span>*</span><span><span> </span><span>BinaryTreeNode</span><span>::</span></span><span>buildTreeFromInorderPostorderHelper</span><span>(</span></div></div><div><div><div>2</div></div><div><span>    </span><span>const</span><span> </span><span>vector</span><span>&lt;</span><span>string</span><span>&gt;</span><span>&amp;</span><span><span> </span><span>inorder</span><span>, </span></span><span>int</span><span><span> </span><span>inStart</span><span>, </span></span><span>int</span><span><span> </span><span>inEnd</span><span>,</span></span><span>      // 中序的范围</span></div></div><div><div><div>3</div></div><div><span>    </span><span>const</span><span> </span><span>vector</span><span>&lt;</span><span>string</span><span>&gt;</span><span>&amp;</span><span><span> </span><span>postorder</span><span>, </span></span><span>int</span><span><span> </span><span>postStart</span><span>, </span></span><span>int</span><span><span> </span><span>postEnd</span><span>,</span></span><span> // 后序的范围</span></div></div><div><div><div>4</div></div><div><span>    </span><span>unordered_map</span><span>&lt;</span><span>string</span><span>, </span><span>int</span><span>&gt;</span><span>&amp;</span><span><span> </span><span>inorderMap</span><span>)</span></span><span>                      // 快速查找用的映射</span></div></div><div><div><div>5</div></div><div><span>{</span></div></div><div><div><div>6</div></div><div><span><span>    </span></span><span>// 1️⃣ 递归终止：范围无效时返回空</span></div></div><div><div><div>7</div></div><div><span>    </span><span>if</span><span> (</span><span>postStart</span><span> </span><span>&gt;</span><span> </span><span>postEnd</span><span> </span><span>||</span><span> </span><span>inStart</span><span> </span><span>&gt;</span><span> </span><span>inEnd</span><span>) {</span></div></div><div><div><div>8</div></div><div><span>        </span><span>return</span><span> </span><span>nullptr</span><span>;</span></div></div><div><div><div>9</div></div><div><span><span>    </span></span><span>}</span></div></div><div><div><div>10</div></div><div>
</div></div><div><div><div>11</div></div><div><span><span>    </span></span><span>// 2️⃣ 后序遍历的最后一个元素 = 当前子树的根</span></div></div><div><div><div>12</div></div><div><span>    </span><span>string</span><span> </span><span>rootVal</span><span> </span><span>=</span><span> </span><span>postorder</span><span>[</span><span>postEnd</span><span>];</span><span>  // 例如第一次是 "A"</span></div></div><div><div><div>13</div></div><div><span>    </span><span>BinaryTreeNode</span><span>*</span><span> </span><span>root</span><span> </span><span>=</span><span> </span><span>new</span><span> </span><span>BinaryTreeNode</span><span>();</span></div></div><div><div><div>14</div></div><div><span>    </span><span>root</span><span>-&gt;</span><span>name</span><span> </span><span>=</span><span> </span><span>rootVal</span><span>;</span></div></div><div><div><div>15</div></div><div>
</div></div><div><div><div>16</div></div><div><span><span>    </span></span><span>// 3️⃣ 在中序遍历中找到根的位置，用于划分左右子树</span></div></div><div><div><div>17</div></div><div><span>    </span><span>int</span><span> </span><span>inRoot</span><span> </span><span>=</span><span> </span><span>inorderMap</span><span>[</span><span>rootVal</span><span>];</span><span>  // "A" 在中序中的索引是 3</span></div></div><div><div><div>18</div></div><div><span>    </span><span>int</span><span> </span><span>numsLeft</span><span> </span><span>=</span><span> </span><span>inRoot</span><span> </span><span>-</span><span> </span><span>inStart</span><span>;</span><span>   // 左子树节点数 = 3 - 0 = 3</span></div></div><div><div><div>19</div></div><div>
</div></div><div><div><div>20</div></div><div><span><span>    </span></span><span>// 4️⃣ 递归构建左子树</span></div></div><div><div><div>21</div></div><div><span><span>    </span></span><span>// 中序范围: [inStart, inRoot-1] → [0, 2] 即 [D, B, E]</span></div></div><div><div><div>22</div></div><div><span><span>    </span></span><span>// 后序范围: [postStart, postStart+numsLeft-1] → [0, 2] 即 [D, E, B]</span></div></div><div><div><div>23</div></div><div><span>    </span><span>root</span><span>-&gt;</span><span>left</span><span> </span><span>=</span><span> </span><span>buildTreeFromInorderPostorderHelper</span><span>(</span></div></div><div><div><div>24</div></div><div><span>        </span><span>inorder</span><span>, </span><span>inStart</span><span>, </span><span>inRoot</span><span> </span><span>-</span><span> </span><span>1</span><span>,</span></div></div><div><div><div>25</div></div><div><span>        </span><span>postorder</span><span>, </span><span>postStart</span><span>, </span><span>postStart</span><span> </span><span>+</span><span> </span><span>numsLeft</span><span> </span><span>-</span><span> </span><span>1</span><span>,</span></div></div><div><div><div>26</div></div><div><span>        </span><span>inorderMap</span><span>);</span></div></div><div><div><div>27</div></div><div>
</div></div><div><div><div>28</div></div><div><span><span>    </span></span><span>// 5️⃣ 递归构建右子树</span></div></div><div><div><div>29</div></div><div><span><span>    </span></span><span>// 中序范围: [inRoot+1, inEnd] → [4, 5] 即 [F, C]</span></div></div><div><div><div>30</div></div><div><span><span>    </span></span><span>// 后序范围: [postStart+numsLeft, postEnd-1] → [3, 4] 即 [F, C]</span></div></div><div><div><div>31</div></div><div><span>    </span><span>root</span><span>-&gt;</span><span>right</span><span> </span><span>=</span><span> </span><span>buildTreeFromInorderPostorderHelper</span><span>(</span></div></div><div><div><div>32</div></div><div><span>        </span><span>inorder</span><span>, </span><span>inRoot</span><span> </span><span>+</span><span> </span><span>1</span><span>, </span><span>inEnd</span><span>,</span></div></div><div><div><div>33</div></div><div><span>        </span><span>postorder</span><span>, </span><span>postStart</span><span> </span><span>+</span><span> </span><span>numsLeft</span><span>, </span><span>postEnd</span><span> </span><span>-</span><span> </span><span>1</span><span>,</span></div></div><div><div><div>34</div></div><div><span>        </span><span>inorderMap</span><span>);</span></div></div><div><div><div>35</div></div><div>
</div></div><div><div><div>36</div></div><div><span>    </span><span>return</span><span> </span><span>root</span><span>;</span></div></div><div><div><div>37</div></div><div><span>}</span></div></div></code></pre><div><div></div><div></div></div></figure><div></div></div><span>展开</span><span>收起</span></div></div><ol>
<li><strong>后序末尾找根</strong> - [postorder[postEnd(vscode-file://vscode-app/d:/Program%20Files%20(x86)/Microsoft%20VS%20Code/resources/app/out/vs/code/electron-browser/workbench/workbench. Html) 就是根</li>
<li><strong>中序定左右</strong> - 根在中序中的位置把序列分成左右两部分</li>
<li><strong>计算左子树大小</strong> - <a>numsLeft = inRoot - inStart</a>，这个数字用来划分后序序列</li>
<li><strong>递归处理</strong> - 对左右子树分别递归，缩小范围</li>
</ol><p><a>inorderMap</a> 的作用是把 O (n) 的查找变成 O (1)，提高效率。</p></section></section>
<section><h1>图算法<a href="#图算法"><span>#</span></a></h1><p>图：G（V, E），每个节点有度。有向图和无向图。图有连通分量。有向图有强联通分量。
图的存储：设 A 存储图，</p><ul>
<li>邻接矩阵：<code>A.edge[n][m]</code> 代表有 n 到 m 的边。<code>A.vertex[n]</code> 数组存储图的节点。无向图对称</li>
<li>邻接表：<code>A.vec[n]</code>。头节点存储节点编号（data）、第一条边的指针（firstarc）。表节点存储邻接节点编号（adjvex）、下一邻接节点的指针（nextarc）。O (n+2e)。有向图用出边搞邻接表，入边搞逆邻接表。</li>
<li>十字链表：每个节点有 in 和 out 两指针。横向是出度的邻接表，纵向是入度的邻接表</li>
</ul><section><h2>图的遍历<a href="#图的遍历"><span>#</span></a></h2><p>回溯法：暴力搜索问题，遇到不对的状态或成功完成任务就回溯</p><ol>
<li>确认递归函数和参数</li>
<li>确认终止条件和返回值：if ()，存放结果，return</li>
<li>处理目前搜索节点出发的路径：for 剩余节点：处理节点、bfs、<strong>撤销当前步骤</strong></li>
</ol><p>深度优先搜索：DFS。如何用深度优先搜索出所有可达路径？</p><ol>
<li><code>void dfs (const vector&lt;vector&lt;int&gt;&gt;&amp; graph, int x, int n)</code>，输入邻接矩阵，n 是终点，x 是目前遍历的点。二维数组存放所有路径 <code>vector&lt;vector&lt;int&gt;&gt; result</code></li>
<li>确认终止条件：当 x=n 时终止，路径 push_back 到二维数组</li>
<li>处理目前搜索节点：遍历邻接矩阵第 x 行。如果 <code>edge[x][i] == 1</code>，则路径中添加该节点 <code>path.push_back(i)</code>，深度优先遍历 dfs (i)，再撤销改变 <code>path.pop_back</code>。</li>
</ol><ul>
<li>边的分类：树边、后向边、前向边、横向边</li>
</ul><p>广度优先搜索：BFS。队列实现。跳过红父节点的访问
岛屿数量遍历：对于 <span><span>n×nn\times n</span><span><span><span></span><span>n</span><span></span><span>×</span><span></span></span><span><span></span><span>n</span></span></span></span> 方格 <code>grid[n][n]</code>，建立数组 <code> visited[n][n]</code>。遍历方格，对于一个没有访问过的陆地，计数器+1，并将该陆地周围全部遍历一遍；访问过的陆地和海洋直接跳过。</p><p>拓扑排序：选取入度为 0 的节点，记录并删除，递归直到没有节点</p></section><section><h2>最小生成树<a href="#最小生成树"><span>#</span></a></h2><p>最小生成树：建立 n-1 条边把图连起来</p><ul>
<li>Prim 算法：维护节点的集合
<ol>
<li>维护 minDist 数组，为剩余节点到最小生成树的最短距离。选择距离生成树最近的节点</li>
<li>最近节点加入生成树</li>
<li>更新 minDist 数组：</li>
</ol>
</li>
<li>Kruskal 算法：维护边的集合
<ol>
<li>排序边的权值</li>
<li>遍历排序后的边，若边首尾不在一个集合则加入，首尾在一个集合则忽略。使用并查集：
<ol>
<li>初始化 <code>father[i]=i</code></li>
<li>Find 函数与路径压缩：<code>return u == father[u] ? u : father[u] = find(father[u]);</code></li>
<li>Union 函数与按秩（树的高度）堆叠：小的放在大的下面</li>
</ol>
</li>
</ol>
</li>
</ul></section><section><h2>单源最短路径<a href="#单源最短路径"><span>#</span></a></h2><p>Dijkstra：源到目标点的最短路径。与 prim 类似：<span><span>O(Elog⁡V)O(E\log V)</span><span><span><span></span><span>O</span><span>(</span><span>E</span><span></span><span>lo<span>g</span></span><span></span><span>V</span><span>)</span></span></span></span> 或者 <span><span>O(V2)O(V^2)</span><span><span><span></span><span>O</span><span>(</span><span><span>V</span><span><span><span><span><span><span></span><span><span>2</span></span></span></span></span></span></span></span><span>)</span></span></span></span>，未优化前：</p><ol>
<li>维护 minDist 和 visited 两个数组，选距离原点最近的未访问的节点（这一步可以用堆来优化）</li>
<li>标记该节点已访问过</li>
<li>从该节点出发遍历所有邻接边，更新未访问节点到源点的距离</li>
</ol><p>Bellman-ford 算法：源到目标点最短路径：<span><span>O(EV)O(EV)</span><span><span><span></span><span>O</span><span>(</span><span>E</span><span>V</span><span>)</span></span></span></span></p><ol>
<li>创建 <code>dist[]</code> 距离数组，源点距离为 0，其余为无穷大。数组长度为 V</li>
<li>循环 V-1 次。每次循环中都遍历 E 条边，每条边有权值 w (u, v)：如果 <code>dist[u] + w(u,v) &lt; dist[v]</code>，则更新 <code>dist[v] = dist[u] + w(u,v) </code>。</li>
<li>负环检测：在第 V 次循环时，若发现还有节点被更新，则存在负环，将所有距离设为-1.</li>
</ol><p>上述算法在计网U5-控制平面中用于选路。
A*</p></section><section><h2>所有节点对最短路径<a href="#所有节点对最短路径"><span>#</span></a></h2><p>Floyd：<code>grid[i][j][k] = min(grid[i][k][k - 1] + grid[k][j][k - 1]， grid[i][j][k - 1])</code></p></section><section><h2>最大流<a href="#最大流"><span>#</span></a></h2><p>最大流最小切割定理：网络最大值=最小切割的容量
Ford-fulkson 方法：</p><ol>
<li>初始化流 f 为 0</li>
<li>构建残存网络：前向边（残存容量 c-f）、反向边（可以反向流量 f）</li>
<li>寻找增广路径：找到 s 到 t 的简单路径，找到瓶颈容量</li>
<li>更新流量</li>
<li>重复，直到残存网络找不到 s 到 t 的路径</li>
</ol><p>Edmonds-Karp 算法：规定使用 FF 方法时，必须使用 BFS 来寻找增广路径。复杂度 <span><span>O(VE2)O(VE^2)</span><span><span><span></span><span>O</span><span>(</span><span>V</span><span><span>E</span><span><span><span><span><span><span></span><span><span>2</span></span></span></span></span></span></span></span><span>)</span></span></span></span>。</p></section></section>
<section><h1>字符串算法<a href="#字符串算法"><span>#</span></a></h1><p>KMP 算法：模式串匹配，搜索指针一直向右。Next 数组表示当前位置字符串最大相等前后缀长度。T 代表字符串，P 代表模式串</p><ol>
<li>预处理，计算 Next 数组：
<ul>
<li>初始化两个指针： i 指针：字符串第 i 位；j 指针：匹配成功的相等前后缀长度；字符串 P</li>
<li>状态转移：初始化 <code>next[0]=0</code>，然后
<ul>
<li><code>j=0</code>：没有相等前后缀长度 <code>next[i]=0, i++</code></li>
<li><code>P[i]=P[j]</code>：匹配成功。这一位前后缀相等，向后移动且+1 <code>j++, next[i]=j, i++</code></li>
<li><code>P[i]!=P[j] and j!=0</code>：匹配失败。I 不变，<code>j=next[j-1]</code></li>
</ul>
</li>
</ul>
</li>
<li>匹配字符串：
<ul>
<li>初始化两个指针：i 指针：字符串；j 指针：模式串</li>
<li>若 <code>T[i] = P[j]</code>：两端都加。 <code>i++ , j++</code></li>
<li>若不等，如果 <code>j&gt;0</code>, 则 j 回退到 <code>next[j]</code>，如果 <code>j=0</code>，则 i++，比较下一位</li>
</ul>
</li>
</ol></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/01/cn-review/</id>
      <title type="text">计算机网络期末回顾</title>
      <published>2026-01-28T00:00:00.000Z</published>
      <updated>2026-01-28T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/01/cn-review/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>考试时间：2026 年 1 月 14 日 8：30-10：30</p>
<p>考前一天开始复习。13 号上午在复习马原，下午马原考完开始复习。早上考完后在折腾推荐信最后的事情。考试范围是 4-8 章。4-5 章之前写作业的时候看过 PPT，有一点印象，向学长要了往年计网的卷子，和两种计网的 PPT 一起打包上传到 notebooklm。先抄书打印大抄对着大抄把知识点弄懂，抄到晚上八点多开始看考卷，到第二天凌晨一点一共看了两套卷。考场上差点没做完</p>
<p>当天整理的笔记：</p>
<section><h1>U4-数据平面<a href="#u4-数据平面"><span>#</span></a></h1><section><h2>考点<a href="#考点"><span>#</span></a></h2><p>1. <strong>子网划分与 CIDR（第 4 章）</strong>：
    - <strong>练习点</strong>：根据给定 IP 和掩码计算网络地址、广播地址、地址范围。
    - <strong>难点</strong>：最长前缀匹配原则的转发表项查找。
2. <strong>IP 数据报分片计算（第 4 章）</strong>：
    - <strong>练习点</strong>：根据 MTU 计算分片数量、每个分片的总长度、标志位（MF）片偏移（Offset，注意单位是 8 字节）</p></section><section><h2>知识点<a href="#知识点"><span>#</span></a></h2><p><strong>网络层的主要功能：</strong></p><ul>
<li>选路：确定往目标路由器的路由，计算转发表。转发表记录分组字段和路由器输出端口之间的联系。由控制面完成，确定分组如何前往目标节点。网络范围内的功能。参考计网U5-控制平面</li>
<li>转发：路由器根据转发表，把分组从输入端口转到输出端口。由数据面在路由器内部分组转运完成。这是路由器的主要功能</li>
</ul><p><strong>路由器 ：</strong></p><ul>
<li>路由器的功能：选路与转发。选路功能是用<strong>选路协议计算转发表</strong>。转发功能用转发表来转发数据报文。</li>
<li>路由器的组成：
<ul>
<li>输入端口：物理、链路层来解封数据包，<strong>查找转发表</strong>来寻找输出端口。排队会发生 HOL 阻塞</li>
<li>交换结构：通过内存、总线、互联网络交换</li>
<li>输出端口：网络、链路、物理发送数据。有调度算法。缓冲区满时会发生丢包。有丢尾、优先级丢弃、主动队列管理（AQM，使用 RED 算法主动丢弃分组。到 minth 时按概率 p 丢弃分组，到 maxth 时丢弃每个分组，可以与 TCP 拥塞控制一起用）</li>
<li>路由选择处理器：调度策略，决定多个队列中如何选择下一个分组。</li>
</ul>
</li>
</ul><p><strong>IP 协议和编址：</strong></p><ul>
<li>Ipv4 数据报格式：20 字节头字段（160 比特），包括协议号，TTL，检验和，源与目标地址</li>
<li>分片与重组：链路层最大帧载荷为 MTU。超过就会被分片和重组。分片的数据长度为 8B 的整数倍，分片头部包含表示，偏移量，标志位，TTL 等。</li>
<li>IP 编址与子网划分： CIDR，无分类编址，a.b.c.d/x，x 是网络前缀长度。包括地址分配，地址聚合和最长前缀匹配（查转发表时，如果一个地址有多个项，那就选前缀最长最精确的那个）。全 0 地址保留给网络本身，全 1 地址保留给本地广播地址，127 打头的地址保留为内部回路测试。DHCP 是动态主机配置协议分配 IP 给主机，建立在 UDP 协议之上。发现-提供-请求-ACK。</li>
<li>子网：有相同网络前缀，<strong>内部通信不经过路由器</strong>，被路由器隔开。子网掩码：指示 IP 号和主机号的边界。子网内部数据可以直接交付，子网间数据只能间接交付，通过查找<strong>转发表</strong>来实现。转发表（包含目标地址、下一跳地址、输出端口、掩码，有默认缺省项）采用逐跳选路，下一跳地址必须包含在当前子网中。转发表内有<strong>地址聚合</strong>。</li>
<li>网络地址转换 NAT：用一个 IP 地址接入多台设备。维护 NAT 转换表，广域 IP 、端口和局域 IP、端口的互相转换，同时处理 65536 个连接。但架构上有争议。因为端口对应的是进程而不是主机。用 upnp 和中继服务器可以实现 NAT 穿越。</li>
<li>IPv6：与 ipv4 不兼容，要双协议栈和隧道</li>
</ul><div></div><div>数据报分片处理过程</div><div></div><div><ul>
<li>根据报头长度 H 和输出线路的 MTU，确定分片的最大数据长度 N</li>
<li>将数据报的载荷划分成长度为 N 的若干数据块（最后一个数据块可能不足 N 字节）</li>
<li>将原始报头加到每一个数据块的前面，修改报头中的以下字段：
<ul>
<li>总长度 ＝ H + 数据块长度</li>
<li>最后一个报头的 MF 位置 0，其余报头的 MF 位置 1</li>
<li>偏移量 ＝ 数据块在原始数据报载荷中的字节序号/8</li>
<li>TTL=TTL-1</li>
<li>计算头部检查和</li>
</ul>
</li>
</ul></div></section></section>
<section><h1>U5-控制平面<a href="#u5-控制平面"><span>#</span></a></h1><section><h2>考点<a href="#考点-1"><span>#</span></a></h2><p>3. <strong>路由算法（第 5 章）</strong>：
- <strong>Dijkstra（链路状态算法）</strong>：通过表格记录迭代过程（N′, D (v), p (v)）。
- <strong>Distance Vector（距离向量算法/Bellman-Ford）</strong>：处理邻居通告，更新自己的路由表。注意“无穷计数”问题和“毒性逆转”</p></section><section><h2>知识点<a href="#知识点-1"><span>#</span></a></h2><p>计网U4-数据平面：转发。路由器决定从哪个端口发向哪个端口
控制平面：路由。全局规划分组应该经过哪个路口。如何找到源路由器到目标路由器的最佳路径？</p><p>如何实现控制平面？</p><ul>
<li>每路由器控制：传统办法。路由器内部执行路由协议，运行算法组件，路由器间互相通信交换路由信息计算转发表。OSPF 和 BGP 协议基于这个。</li>
<li>逻辑集中控制：SDN 方法。远程计算转发表，路由器只负责转发</li>
</ul><p><strong>虚电路</strong></p><ul>
<li>本质：预先选好源到目的主机的路径</li>
<li>组成：端到端路径；每条链路的虚电路号；沿途每个路由器的转发表&lt;进入端口，进入VC号&gt; à&lt;输出端口，输出VC号&gt;（分组仅携带 VC 号，不携带目标地址）</li>
<li>使用信令协议</li>
</ul><p><strong>数据报网络</strong> 分组携带目的地址，路由器按转发表转发分组</p><p>Q 数据报网络提供最小服务的好处？
可运行在各种链路上；为传输层服务的设计增加灵活性</p><p>Q 数据报网路符合因特网设计的原则？
提供尽力而为的服务；复杂工作推到网络边缘</p><p>Q 数据报网络和虚电路网络转发表区别？
虚电路 Hash 表或索引表 O (1)，数据报网络顺序表 O (N)</p><p>路由算法：（图算法）
<strong>LS 链路状态路由算法</strong>：dijkstra，计算全局。<strong>OSPF</strong> 协议是一种 LS 协议</p><ul>
<li>流程：
<ol>
<li>发现相邻节点，获知对方网络地址：HELLO 报文</li>
<li>测量相邻节点代价：延迟、开销。通过对方的 echo 报文得知</li>
<li>组装 LS 分组：发送者名称、序号 seq、年龄 age、相邻节点延迟列表</li>
<li>LS 分组扩散：设置 age，每扩散一次 age 减 1. Age=0 自动抛弃</li>
<li>计算路由找最短路径：dijkstra 算法。使用（D 距离, P 前驱）标记节点，节点分为临时节点和永久节点。每次找节点代价最小的临时节点，变为永久节点，并 relax 相应的距离</li>
</ol>
</li>
<li>问题：出现震荡。当链路代价=链路承载流量时</li>
</ul><p><strong>DV 距离矢量算法</strong>：只计算局部。相邻路由器维护、交换、更新路由表</p><ul>
<li>流程：<strong>BF 算法</strong>：对于每个节点 y；x 往 y 的代价记为 D<sub>x</sub>(y)，x 有邻居 v，则 <span><span>Dx(y)=minvc(x,y)+Dv(y)D_x(y)=min_v{c(x,y)+D_v(y)}</span><span><span><span></span><span><span>D</span><span><span><span><span><span><span></span><span><span>x</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>(</span><span>y</span><span>)</span><span></span><span>=</span><span></span></span><span><span></span><span>mi</span><span><span>n</span><span><span><span><span><span><span></span><span><span>v</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span><span>c</span><span>(</span><span>x</span><span>,</span><span></span><span>y</span><span>)</span><span></span><span>+</span><span></span><span><span>D</span><span><span><span><span><span><span></span><span><span>v</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>(</span><span>y</span><span>)</span></span></span></span></span>。迭代时期望 D<sub>x</sub>(y) 收敛于真实最小值 <span><span>dx(y)d_x(y)</span><span><span><span></span><span><span>d</span><span><span><span><span><span><span></span><span><span>x</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span><span>(</span><span>y</span><span>)</span></span></span></span>。</li>
<li>问题：无穷计算问题。好消息快，坏消息慢（如断联）</li>
<li>水平分裂算法：B 知道要通过 A 才能到 X，因此 B 向 A 报告 B 到 X 的距离为无穷大
<ul>
<li>问题：环路下会失效（A-B-C-X，A-C。C-X 断了，B 给 A 的信息还没断，会循环）</li>
</ul>
</li>
</ul>

<table><thead><tr><th>算法</th><th>LS</th><th>DV</th></tr></thead><tbody><tr><td>消息复杂度</td><td>O（nE）n：全体链路信息局部传播</td><td>只和邻居交换信息</td></tr><tr><td>收敛时间</td><td>O（n<sup>2</sup>）</td><td>收敛较慢，有环路</td></tr><tr><td>健壮性</td><td>错误信息影响局部</td><td>影响全局</td></tr></tbody></table><p><strong>层次路由：</strong> 把互联网分成路由器区域 <strong>AS</strong>（autonomous systems），自治系统，用 AS Number 标识，方便管理。一个 ISP 掌管数个 AS。AS 内部运行相同路由协议（RIP、OSPF），网关路由器可连接到别的 AS。AS 间运行 AS 间路由协议。解决平面路由规模巨大难控制的问题</p><p>AS 内路由：（Intra-AS：）</p><ul>
<li><strong>RIP</strong>：路由信息协议。DV 算法。只数跳数，最大跳数 15，不管时间。周期性更新：每隔约 30 秒，把自己的数据给邻居公告。一次公告最多 25 个子网，最多 16 跳。毒性逆转阻止回路。180 秒邻居无响应则认定为失效。以应用进程的方式实现（route-d），UDP 520 端口周期性发送。应用层协议</li>
<li><strong>OSPF</strong>：开放最短路优先协议。泛洪 LS 算法。每个路由器内都构建完整网络拓扑图。数代价，代价由管理员配置。链路状态会触发式更新。封装在 IP 数据报里，协议号 89。
OSPF 将网络层次化（AS）：路由器分层为本地、主干（标识为 0）。本地包括边界路由器和区域边界路由器 ABR（连接骨干路由器）。骨干路由器运行 OSPF。边界路由器将数据传输到 ABR，进入骨干传输。</li>
</ul><p>AS 间路由：（Inter-AS：主要依据策略而不是路由测度）</p><ul>
<li>BGP：建立在 TCP 上的边界网关协议，在不同 AS 间交换前缀可达性信息。路由目标不是具体的 IP 地址，而是 CIDR 前缀。<strong>基于策略的路由</strong>。更新时只发生增量更新
<ul>
<li>EBGP：跨 AS，从相邻 AS 获取可达性信息</li>
<li>IBGP：在同一个 AS 传递信息，传递 eBGP 学到的外部路由信息给 AS 的其他路由器</li>
</ul>
</li>
<li>BGP 路由属性：
<ul>
<li>AS-PATH：经过的所有 AS 列表，防止环路</li>
<li>NEXT-HOP：通往目的地下一跳的路由器接口 IP 地址。对于 eBGP 学来的路由，这个是外部地址。本 AS 内要重新用 OSPF 等协议找 NEXT-HOP 的最佳路径）。实施路径通告，可以设置规则不通告。</li>
</ul>
</li>
<li>路径选择：本地偏好、最短 AS-PATH、热土豆路由（距离当前路由器最近的出口网关）、BGP 标识符</li>
</ul><p>广播选路：flooding。反向路径传播 ( V-1 + 2*[E-V+1] )，生成树（V-1），</p><p><strong>SDN 方式</strong>：集中控制处理。架构包括数据平面交换机—南向 API（openflow 流表，包含多种数据、TCP）—SDN 控制器—北向 API—控制应用</p><p><strong>ICMP: 因特网控制报文协议</strong>。不传数据，用于调试网络（如 ping：echo，traceroute 将 TTL 设置为 1、2、3 来查询节点）。封装在 IP 报中传输。
SNMP：简单网络管理协议。由 Get（读）、Set（写）、Trap (报告) 构成</p></section></section>
<section><h1>U6-链路层<a href="#u6-链路层"><span>#</span></a></h1><section><h2>考点<a href="#考点-2"><span>#</span></a></h2><p><strong>循环冗余码（CRC 计算）（第 6 章）</strong>：
   <strong>练习点</strong>：模 2 除法计算余数。记得在原始数据 D 后面补 r 个 0（r 为生成多项式 G 的阶数）</p></section><section><h2>知识点<a href="#知识点-2"><span>#</span></a></h2><p><strong>链路层</strong>：负责数据的点到点传输。由节点（电脑、服务器、主机）、链路（网线、Wifi 信号）、帧（数据包单位）组成。主要运行在网卡中。提供成帧（将数据报 Datagram 封装成帧 Frame）、链路接入、可靠交付、检错服务。从一个节点移动到另一个节点</p><p><strong>检错技术：</strong></p><ol>
<li>奇偶校验</li>
<li>校验和：数据分段加起来并取反码，主要应用在传输层和网络层</li>
<li>循环冗余校验 CRC：D 是发送的数据，G 是生成多项式，r 是生成多项式的阶数（G 的位数-1.）在 D 后面补 r 个 0，模 2 除以 G 得到 R（模 2 下减法<strong>定义为异或</strong>），拼接 DR 并发送。接收端用 DR 除以 G，若余数非零则出错。传输层使用的 CRC 可在专用硬件上实现，链路层则使用校验和</li>
</ol><p><strong>多路访问协议</strong>：MAC 媒体访问控制协议：控制节点何时占有信道</p><ol>
<li>信道划分协议：TDMA 分时，FDMA 分频，CDMA 码分</li>
<li><strong>随机访问协议：</strong>
<ol>
<li>ALOHA：时分 ALOHA（时间被划分为等长的时隙，每个时隙传 1 帧，37%，需要时钟同步），纯 ALOHA（18%）</li>
<li>CSMA 载波侦听多路访问：先侦听，若忙则等待，空闲发送</li>
<li>CSMA/CD 带冲突检测：早期以太网的核心。先侦听后发送。发送时侦听，发现冲突立刻停止发送，发送 jam 信号，等待二进制指数后退算法：第 n 次等待 K x 512 比特时间，K 在 0-2<sup>n</sup>-1 中选一个数。最小帧长 64 字节，无确认机制</li>
</ol>
</li>
<li>轮流 MAC 协议：轮询 polling ，使用令牌发送（蓝牙），没有冲突，时间慢，单点故障</li>
</ol><p><strong>局域网与寻址</strong></p><ul>
<li>MAC 地址：物理硬件的地址，在网卡 ROM 中。48 位，全球唯一。广播地址 12 个 F。世界上先有 MAC，再有 IP。MAC 扁平结构，IP 有层次。</li>
<li>ARP 地址解析协议：知道对方的 IP 地址，求对方的 MAC 地址。用于封装以太网帧。
<ul>
<li>AB 在同一个子网：A 想要查看 IP B 的 MAC 地址，发现 A 本地 ARP 表没有 B。于是 A 广播 ARP 分组，目标的 MAC 为全 F。B 收到广播后单播回复 A，A 收到并存入 ARP 表。每个设备有 ARP 缓存</li>
<li>AB 在不同子网：跨子网。A 的 ARP 不查 B，查默认网关的 MAC 地址，但 IP 仍然是 B 的 IP</li>
</ul>
</li>
<li>以太网<strong>帧结构</strong>：[前导码 | 目的 MAC | 源 MAC | 类型 | 数据 | CRC]。前导码用于同步时钟。类型 2 字节指明高层协议是 ARP 还是 IP。CRC 是差错检测。无连接、不可靠，没有 ACK，错了直接扔掉。802.3 协议。最小帧长 64（避免冲突）</li>
</ul><p><strong>交换机</strong></p><ul>
<li>三种设备：集线器：物理层全员广播电信号。交换机：链路层维护 MAC 表（记录哪个设备是哪个端口）点对点传输，在局域网内部传帧。路由器：基于 IP 地址转发数据包，可以在局域网和广域网间传包。</li>
<li>自学习：从 x 端口接到源 MAC 是 A 的数据包，自动在表中把 A 的 MAC 与 x 端口绑定。</li>
<li>转发：若目标 MAC 在表里，单播转发到对应端口。目标 MAC 不在表里或广播帧，则泛洪。</li>
<li>VLAN 虚拟局域网：用软件划分交换机的端口形成局域网，隔离广播域。Trunk 干线连接交换机</li>
</ul></section></section>
<section><h1>U7-无线移动网络<a href="#u7-无线移动网络"><span>#</span></a></h1><section><h2>考点<a href="#考点-3"><span>#</span></a></h2><p>CDMA（码分多址）</p></section><section><h2>知识点<a href="#知识点-3"><span>#</span></a></h2><p>网络问题：信号衰减、干扰、隐藏终端、
WiFi (IEEE 802.11)：</p><ul>
<li>局域网的组成单元是基本服务集 BSS：包括无线终端，无线接入点 AP（链路层）。每个无线接口都有唯一 MAC 地址。所有通信经过 AP 来实现</li>
<li>CSMA/CA 协议：侦听，等待 DIFS（分布式帧间间隔，较长） 后发送。若信道忙，冻结倒计时，并选取随机回退值。（如果不使用信道预约机制）发送后接收方确认无误时，等待 SIFS （短帧间间隔，较短）发送 ACK 链路层确认。</li>
<li>RTS/CTS 信道预约机制：发送方发送 RTS，请求发送，广播要发送的时间。AP 广播 CTS 允许发送并让邻居闭嘴。其他节点收到 RTS/CTS 时</li>
<li>802.11 帧结构和地址：地址 1 接收端 MAC，地址 2 发送端 MAC，地址 3 网关 MAC。AP 收到无线帧后，会转成标准的 802.3 以太网帧发到有限网络上。</li>
<li>终端在子网中移动：切换 AP，更新交换机转发表</li>
<li>安全：802.11i，将 AP 与鉴权服务器 AS 分离，</li>
</ul>

<table><thead><tr><th>字段</th><th>含义</th><th>手机 H1 发给 AP</th><th>AP 发给手机 H1</th></tr></thead><tbody><tr><td><strong>地址 1</strong></td><td><strong>接收者</strong> (这一跳谁收)</td><td><strong>AP 的 MAC</strong></td><td><strong>H1 的 MAC</strong></td></tr><tr><td><strong>地址 2</strong></td><td><strong>发送者</strong> (这一跳谁发)</td><td><strong>H1 的 MAC</strong></td><td><strong>AP 的 MAC</strong></td></tr><tr><td><strong>地址 3</strong></td><td><strong>路由器接口</strong> (连接有线网的网关)</td><td><strong>R1 的 MAC</strong></td><td><strong>R1 的 MAC</strong></td></tr><tr><td>移动层管理：</td><td></td><td></td><td></td></tr></tbody></table><ul>
<li>归属网络、归属代理、外地网络、外地代理</li>
<li>间接的三角路由：通信者用永久 IP 发数据包，被归属代理截获，归属代理通过封装和隧道发给外地代理，外地代理发给移动节点，移动节点直接把数据发给通信者。</li>
</ul><p>蜂窝网络架构：</p><ul>
<li><strong>eNodeB (基站)</strong>：处理无线电信号，管理资源分配。</li>
<li><strong>MME (移动性管理实体)</strong>：<strong>控制平面</strong>的核心。负责用户鉴权、移动性管理（你在哪个小区）、设备状态追踪。</li>
<li><strong>HSS (归属用户服务器)</strong>：<strong>数据库</strong>。存着你的 SIM 卡信息、余额、加密密钥等。</li>
<li><strong>S-GW (服务网关)</strong> / <strong>P-GW (PDN 网关)</strong>：<strong>数据平面</strong>的路由器。P-GW 是连接外部因特网的网关，给你分配 IP 地址（NAT）。</li>
</ul></section></section>
<section><h1>U8-网络安全<a href="#u8-网络安全"><span>#</span></a></h1><p>（AI 辅助整理）</p><section><h2>考点<a href="#考点-4"><span>#</span></a></h2></section><section><h2>知识点<a href="#知识点-4"><span>#</span></a></h2><p>网络安全 ：数据机密性、完整性、端点鉴别（身份真实）、运行安全性（网络服务可用不受攻击）；被动攻击和主动攻击</p><p>密码学算法：</p><ul>
<li>对称密钥加密：AES DES 3DES</li>
<li>非对称密钥加密：RSA</li>
</ul><p>根据提供的资料，第八章“网络安全”是考试的重点章节，既包含理论概念（如安全四要素、攻击类型），也包含核心计算（RSA 算法）和具体协议的应用（SSL, IPsec, PGP）。</p><p>以下是基于你提供的试卷和教材内容的详细复习指南：</p><section><h3>一、网络安全基础原理<a href="#一网络安全基础原理"><span>#</span></a></h3><p><strong>1. 安全通信的四大目标</strong> 这是单选题常考点，需明确区分：</p><ul>
<li><strong>机密性 (Confidentiality)</strong>：只有发送方和预定接收方能理解报文内容（防窃听）。</li>
<li><strong>完整性 (Message Integrity)</strong>：确保报文在传输过程中未被篡改（防修改）。</li>
<li><strong>端点鉴别 (End-point Authentication)</strong>：确认通信对端的身份真实可靠（防假冒）。</li>
<li><strong>运行安全性 (Operational Security)</strong>：网络服务可用，防止 DoS 攻击等。</li>
</ul><p><strong>2. 攻击类型</strong></p><ul>
<li><strong>被动攻击</strong>：试图获取信息但不影响系统资源。
<ul>
<li>例如：<strong>窃听 (Sniffing)</strong>、<strong>流量分析</strong>。</li>
</ul>
</li>
<li><strong>主动攻击</strong>：试图改变系统资源或影响操作。
<ul>
<li><strong>伪装 (Masquerade)</strong>：冒充他人身份。</li>
<li><strong>重放 (Replay)</strong>：截获数据包并在稍后重新发送（如重放口令或加密的凭证）。</li>
<li><strong>报文修改</strong>：篡改、删除或插入报文。</li>
<li><strong>拒绝服务 (DoS)</strong>：耗尽服务器资源使其无法提供服务。</li>
</ul>
</li>
</ul><hr /></section><section><h3>二、核心算法与机制（重点）<a href="#二核心算法与机制重点"><span>#</span></a></h3><p><strong>1. 密码学基础</strong></p><ul>
<li><strong>对称密钥加密 (Symmetric Key)</strong>：
<ul>
<li>特点：加密和解密使用<strong>同一个密钥</strong>。</li>
<li>算法：DES（56 位密钥，已过时）、AES（目前标准）、3DES。</li>
<li>缺点：密钥分发困难。</li>
<li>应用：通常用于长报文的数据加密（因为效率高）。</li>
</ul>
</li>
<li><strong>公开密钥加密 (Public Key)</strong>：
<ul>
<li>特点：使用一对密钥（<strong>公钥 <span><span>K+K^+</span><span><span><span></span><span><span>K</span><span><span><span><span><span><span></span><span><span>+</span></span></span></span></span></span></span></span></span></span></span></strong> 和 <strong>私钥 <span><span>K−K^-</span><span><span><span></span><span><span>K</span><span><span><span><span><span><span></span><span><span>−</span></span></span></span></span></span></span></span></span></span></span></strong>）。</li>
<li>规则：公钥加密需私钥解密；私钥加密（签名）需公钥解密。</li>
<li>缺点：计算量大，速度慢。</li>
<li>应用：通常用于密钥分发、数字签名。</li>
</ul>
</li>
</ul><p><strong>2. RSA 算法计算（必考大题）</strong> 这是本章最重要的计算题，务必掌握求解步骤。</p><ul>
<li>
<p><strong>基本原理</strong>：</p>
<ol>
<li><strong>选素数</strong>：选择两个大素数 <span><span>p,qp, q</span><span><span><span></span><span>p</span><span>,</span><span></span><span>q</span></span></span></span>。</li>
<li><strong>计算 <span><span>nn</span><span><span><span></span><span>n</span></span></span></span></strong>：<span><span>n=p×qn = p \times q</span><span><span><span></span><span>n</span><span></span><span>=</span><span></span></span><span><span></span><span>p</span><span></span><span>×</span><span></span></span><span><span></span><span>q</span></span></span></span>。</li>
<li><strong>计算 <span><span>zz</span><span><span><span></span><span>z</span></span></span></span></strong>（欧拉函数）：<span><span>z=(p−1)(q−1)z = (p-1)(q-1)</span><span><span><span></span><span>z</span><span></span><span>=</span><span></span></span><span><span></span><span>(</span><span>p</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>)</span><span>(</span><span>q</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>)</span></span></span></span>。</li>
<li><strong>选公钥指数 <span><span>ee</span><span><span><span></span><span>e</span></span></span></span></strong>：要求 <span><span>ee</span><span><span><span></span><span>e</span></span></span></span> 与 <span><span>zz</span><span><span><span></span><span>z</span></span></span></span> 互质。</li>
<li><strong>求私钥指数 <span><span>dd</span><span><span><span></span><span>d</span></span></span></span></strong>：满足 <span><span>e×d≡1(modz)e \times d \equiv 1 \pmod z</span><span><span><span></span><span>e</span><span></span><span>×</span><span></span></span><span><span></span><span>d</span><span></span><span>≡</span><span></span></span><span><span></span><span>1</span><span></span><span></span></span><span><span></span><span>(</span><span><span><span>mod</span></span></span><span></span><span>z</span><span>)</span></span></span></span>。即 <span><span>(e×d−1)(e \times d - 1)</span><span><span><span></span><span>(</span><span>e</span><span></span><span>×</span><span></span></span><span><span></span><span>d</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>)</span></span></span></span> 能被 <span><span>zz</span><span><span><span></span><span>z</span></span></span></span> 整除。</li>
<li><strong>加密</strong>：<span><span>C=me(modn)C = m^e \pmod n</span><span><span><span></span><span>C</span><span></span><span>=</span><span></span></span><span><span></span><span><span>m</span><span><span><span><span><span><span></span><span><span>e</span></span></span></span></span></span></span></span><span></span><span></span></span><span><span></span><span>(</span><span><span><span>mod</span></span></span><span></span><span>n</span><span>)</span></span></span></span>。</li>
<li><strong>解密</strong>：<span><span>m=Cd(modn)m = C^d \pmod n</span><span><span><span></span><span>m</span><span></span><span>=</span><span></span></span><span><span></span><span><span>C</span><span><span><span><span><span><span></span><span><span>d</span></span></span></span></span></span></span></span><span></span><span></span></span><span><span></span><span>(</span><span><span><span>mod</span></span></span><span></span><span>n</span><span>)</span></span></span></span>。</li>
</ol>
<blockquote><p><strong>真题案例 (2018 年试卷)</strong>： 给定 <span><span>p=3,q=11p=3, q=11</span><span><span><span></span><span>p</span><span></span><span>=</span><span></span></span><span><span></span><span>3</span><span>,</span><span></span><span>q</span><span></span><span>=</span><span></span></span><span><span></span><span>11</span></span></span></span>。</p><ol>
<li>求 <span><span>n,zn, z</span><span><span><span></span><span>n</span><span>,</span><span></span><span>z</span></span></span></span>：<span><span>n=33,z=(3−1)(11−1)=20n = 33, z = (3-1)(11-1) = 20</span><span><span><span></span><span>n</span><span></span><span>=</span><span></span></span><span><span></span><span>33</span><span>,</span><span></span><span>z</span><span></span><span>=</span><span></span></span><span><span></span><span>(</span><span>3</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>)</span><span>(</span><span>11</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>)</span><span></span><span>=</span><span></span></span><span><span></span><span>20</span></span></span></span>。</li>
<li>选 <span><span>e=3e=3</span><span><span><span></span><span>e</span><span></span><span>=</span><span></span></span><span><span></span><span>3</span></span></span></span> (与 20 互质)，求 <span><span>dd</span><span><span><span></span><span>d</span></span></span></span>：需满足 <span><span>3dmod  20=13d \mod 20 = 1</span><span><span><span></span><span>3</span><span>d</span><span></span><span></span></span><span><span></span><span><span><span>mod</span></span></span><span></span><span></span><span>20</span><span></span><span>=</span><span></span></span><span><span></span><span>1</span></span></span></span>。因为 <span><span>3×7=213 \times 7 = 21</span><span><span><span></span><span>3</span><span></span><span>×</span><span></span></span><span><span></span><span>7</span><span></span><span>=</span><span></span></span><span><span></span><span>21</span></span></span></span>，故 <span><span>d=7d=7</span><span><span><span></span><span>d</span><span></span><span>=</span><span></span></span><span><span></span><span>7</span></span></span></span>。</li>
<li>加密 <span><span>m=9m=9</span><span><span><span></span><span>m</span><span></span><span>=</span><span></span></span><span><span></span><span>9</span></span></span></span>：<span><span>C=93mod  33=729mod  33=3C = 9^3 \mod 33 = 729 \mod 33 = 3</span><span><span><span></span><span>C</span><span></span><span>=</span><span></span></span><span><span></span><span><span>9</span><span><span><span><span><span><span></span><span><span>3</span></span></span></span></span></span></span></span><span></span><span></span></span><span><span></span><span><span><span>mod</span></span></span><span></span><span></span><span>33</span><span></span><span>=</span><span></span></span><span><span></span><span>729</span><span></span><span></span></span><span><span></span><span><span><span>mod</span></span></span><span></span><span></span><span>33</span><span></span><span>=</span><span></span></span><span><span></span><span>3</span></span></span></span>。</li>
</ol></blockquote>
</li>
</ul><p><strong>3. 完整性与数字签名</strong></p><ul>
<li><strong>密码散列函数 (Hash)</strong>：将任意长度报文映射为固定长度摘要。
<ul>
<li>特性：单向性（无法反推）、抗碰撞性。</li>
<li>算法：<strong>MD5</strong>（128 位）、<strong>SHA-1</strong>（160 位）。</li>
</ul>
</li>
<li><strong>报文鉴别码 (MAC)</strong>：使用<strong>共享秘密密钥</strong>生成的散列值，用于认证来源和完整性。</li>
<li><strong>数字签名 (Digital Signature)</strong>：
<ul>
<li>原理：发送方用<strong>私钥</strong>对报文摘要进行加密。接收方用发送方的<strong>公钥</strong>解密摘要并验证。</li>
<li>功能：提供<strong>鉴别</strong>（确认是谁发的）、<strong>完整性</strong>（确认没被改）、<strong>不可否认性</strong>（发送方无法抵赖）。</li>
<li>注意：<strong>MAC 不能提供不可否认性</strong>，因为密钥是共享的；数字签名可以。</li>
</ul>
</li>
</ul><p><strong>4. 身份认证与公钥分发</strong></p><ul>
<li><strong>重放攻击</strong>：攻击者拦截并重发旧的认证报文。</li>
<li><strong>防御重放</strong>：使用<strong>不重数 (Nonce)</strong>，即生存期只使用一次的随机数。</li>
<li><strong>中间人攻击</strong>：攻击者假冒通信双方。</li>
<li><strong>数字证书 (Certification)</strong>：
<ul>
<li>由认证中心 (<strong>CA</strong>) 颁发。</li>
<li>作用：将<strong>实体身份</strong>（如域名、人名）与<strong>公钥</strong>绑定。</li>
<li>验证：使用 CA 的公钥验证证书上的签名，从而确认证书中包含的公钥是真实的。</li>
</ul>
</li>
</ul><hr /></section><section><h3>三、安全协议（应用层到网络层）<a href="#三安全协议应用层到网络层"><span>#</span></a></h3><p><strong>1. 安全电子邮件 (PGP)</strong></p><ul>
<li><strong>机密性</strong>：使用一次性<strong>对称会话密钥</strong>加密邮件内容，然后用接收方的公钥加密该会话密钥。</li>
<li><strong>完整性与鉴别</strong>：使用发送方的<strong>私钥</strong>对报文摘要进行签名。</li>
<li><strong>过程</strong>：先签名（用私钥），后加密（用对称密钥），再加密对称密钥（用接收方公钥）。</li>
</ul><p><strong>2. 运输层安全 (SSL/TLS)</strong></p><ul>
<li><strong>位置</strong>：位于应用层和传输层之间（对开发者像传输层，技术上像应用层）。</li>
<li><strong>握手过程</strong>（简化版）：
<ol>
<li>协商算法。</li>
<li>服务器发送证书（含服务器公钥）。</li>
<li>客户验证证书，生成<strong>预主密钥 (Pre-Master Secret)</strong>，用服务器公钥加密后发送。</li>
<li>双方根据预主密钥生成<strong>会话密钥</strong>（用于后续对称加密）。</li>
</ol>
</li>
</ul><p><strong>3. 网络层安全 (IPsec)</strong></p><ul>
<li><strong>模式</strong>：
<ul>
<li><strong>运输模式 (Transport Mode)</strong>：只加密载荷（上层数据），不加密 IP 头。</li>
<li><strong>隧道模式 (Tunnel Mode)</strong>：加密<strong>整个原始 IP 数据报</strong>，并封装在一个新的 IP 数据报中（新 IP 头+ESP 头+加密的旧 IP 头和数据）。常用于 VPN。</li>
</ul>
</li>
<li><strong>协议</strong>：
<ul>
<li><strong>AH (鉴别首部)</strong>：提供源鉴别和完整性，<strong>不提供机密性</strong>（不加密）。</li>
<li><strong>ESP (封装安全载荷)</strong>：提供机密性、源鉴别和完整性。</li>
</ul>
</li>
<li><strong>安全关联 (SA)</strong>：单向逻辑连接，由 SPI 标识。</li>
</ul><p><strong>4. 无线网络安全 (802.11)</strong></p><ul>
<li><strong>WEP</strong>：早期协议，存在严重漏洞（IV 重复使用，密钥流易被破解）。</li>
<li><strong>802.11i (WPA2)</strong>：更安全，使用 EAP 协议和鉴别服务器（AS）进行相互鉴别，使用 AES 加密。</li>
</ul><hr /></section><section><h3>四、运行安全（防火墙）<a href="#四运行安全防火墙"><span>#</span></a></h3><p><strong>1. 包过滤防火墙 (Packet Filter)</strong></p><ul>
<li><strong>无状态 (Stateless)</strong>：逐个检查数据包，根据 IP、端口、TCP 标志位（SYN/ACK）决定放行或丢弃。</li>
<li><strong>有状态 (Stateful)</strong>：跟踪 TCP 连接状态。例如，如果一个入站数据包不属于任何已建立的连接（不在连接表中），则丢弃。</li>
</ul><p><strong>2. 应用程序网关</strong></p><ul>
<li>针对特定应用（如 Telnet, FTP），所有数据必须通过网关中继，安全性高但性能开销大。</li>
</ul><hr /></section><section><h3>五、复习总结（必背公式与考点）<a href="#五复习总结必背公式与考点"><span>#</span></a></h3><ol>
<li><strong>RSA 公式</strong>：
<ul>
<li><span><span>ed≡1(mod(p−1)(q−1))ed \equiv 1 \pmod{(p-1)(q-1)}</span><span><span><span></span><span>e</span><span>d</span><span></span><span>≡</span><span></span></span><span><span></span><span>1</span><span></span><span></span></span><span><span></span><span>(</span><span><span><span>mod</span></span></span><span></span><span>(</span><span>p</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>)</span><span>(</span><span>q</span><span></span><span>−</span><span></span></span><span><span></span><span>1</span><span>))</span></span></span></span></li>
<li>加密：<span><span>me(modn)m^e \pmod n</span><span><span><span></span><span><span>m</span><span><span><span><span><span><span></span><span><span>e</span></span></span></span></span></span></span></span><span></span><span></span></span><span><span></span><span>(</span><span><span><span>mod</span></span></span><span></span><span>n</span><span>)</span></span></span></span></li>
<li>解密：<span><span>cd(modn)c^d \pmod n</span><span><span><span></span><span><span>c</span><span><span><span><span><span><span></span><span><span>d</span></span></span></span></span></span></span></span><span></span><span></span></span><span><span></span><span>(</span><span><span><span>mod</span></span></span><span></span><span>n</span><span>)</span></span></span></span></li>
</ul>
</li>
<li><strong>密钥用途</strong>：
<ul>
<li><strong>加密</strong>：用接收者的公钥。</li>
<li><strong>签名</strong>：用发送者的私钥。</li>
</ul>
</li>
<li><strong>模式区分</strong>：
<ul>
<li><strong>IPsec 隧道模式</strong>：隐藏了内部 IP 地址，用于 VPN。</li>
<li><strong>SSL</strong>：提供基于套接字的安全，保护应用层数据（如 HTTPS）。</li>
</ul>
</li>
<li><strong>散列与摘要</strong>：MD5 (128 位), SHA-1 (160 位)。</li>
</ol><p>这一章的复习重点在于<strong>RSA 的计算</strong>和<strong>各个层级安全协议（SSL, IPsec, PGP）的工作原理及区别</strong>。</p></section></section></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2026/01/ics-review/</id>
      <title type="text">计算系统概论期末回顾</title>
      <published>2026-01-28T00:00:00.000Z</published>
      <updated>2026-01-28T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2026/01/ics-review/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>考试时间：2026 年 1 月 17 日 8：30-10：30，最后延长了 10 分钟</p>
<p>考前一天开始复习，由于 16 号在摆烂，17 号才开始正式复习。使用 notebooklm 上传了课本、作业题以及德州卷。抄书抄到晚上九点多才开始看考卷（发现看卷子的时间有点晚 qwq，好多都不会），到第二天凌晨两点一共看了两套卷。考场上差点没做完，但是考卷上出现了往年 PPT 的原题！但是没看到！可恶</p>
<p>当天下午整理的笔记：</p>
<section><h2>ICS-1 指令集部分<a href="#ics-1-指令集部分"><span>#</span></a></h2><p>附录 A ，第 655 页</p><p>指令的周期：每条指令都得经过 fetch 和 decode</p><ol>
<li>取址 fetch</li>
<li>译码 decode</li>
<li>计算地址 evaluate address</li>
<li>取操作数 fetch oprands</li>
<li>执行 execute</li>
<li>存储 store</li>
</ol><ul>
<li>CC：条件码 Conditional Code。执行向通用寄存器写入结果的指令时会自动更新 CC。LEA 指令不设置 CC。</li>
<li>PSR：用户跳转寄存器 Processor Status Register，记录身份状态。寄存器地址在 xFFFC
<ul>
<li>15 位：特权模式。0 为特权模式，1 为用户模式</li>
<li>14 位：中断使能。0 允许终端，1 不允许中断</li>
<li>10-8 位：优先级。0 最低，7 最。当外部设备优先级比当前优先级高时，中断才会发生，否则抛弃</li>
<li>2-0 位：条件码 CC。设置 NZP。见</li>
</ul>
</li>
<li>ACV：访问控制违规 Access Control Violation。当 CPU 处于用户模式时如果访问特权内存区域（系统空间 x 0000-x 2 FFF 或 I/O 设备寄存器地址 xFE 00-xFFFF）时，会设置 ACV=1，抛出异常，将 PC 和 PSR 压入系统栈，并跳转到 x 0102 处理异常程序</li>
<li>BEN：分支使能 Branch Enable。若 nzp 位为 1 则会跳转</li>
</ul><p><strong>LC 3 指令：</strong></p><ol>
<li>操作指令：Fetch (8) + Decode (1) + 执行阶段周期 1（只有计算），共 10 周期，会计算 CC
<ul>
<li><code>ADD  DR SR1 SR2</code>：DR=SR 1 + SR 2 或 imm 5。2 条</li>
<li><code>AND  DR SR1 SR2</code>：DR=SR 1 &amp; SR 2 或 imm 5。2 条</li>
<li><code>NOT vDR SR</code>：DR = ~SR</li>
</ul>
</li>
<li>数据搬运指令
<ul>
<li><code>LD  DR PCoffset9</code>：PC 相对寻址加载。DR = mem (PC+sext (offset 9))</li>
<li><code>LDR  DR BaseR PCoffset6</code>。基址偏移加载。<strong>DR &lt;- mem (baseR + sext (offset 9)）</strong></li>
<li><code>LDI  DR PCoffset9</code>：间接寻址加载。DR = mem (mem (offset 9 + PC))</li>
<li><code>LEA  DR PCoffset9</code>：加载有效访问地址。<strong>不访问内存</strong>。DR = PC + SEXT (offset 9)</li>
<li><code>ST  SR PCoffset9</code>：PC 相对寻址存储。Mem (PC+sext (offset 9)) = SR</li>
<li><code>STI  SR PCoffset9</code> ：间接寻址存储。Mem (Mem (PC+sext (offset 9))) = SR</li>
<li><code>STR  SR BaseR PCoffset6</code>：基址偏移存储。<strong>Mem (baseR + offset 6) &lt;- SR</strong></li>
</ul>
</li>
<li>控制指令
<ul>
<li><code>BR  nzp PCOffset9</code>: 条件跳转。若 BEN 为真，则 PC = PC+offset 9</li>
<li><code>JMP BaseR</code>：无条件跳转。PC = BaseR</li>
<li><code>RET</code>：无条件跳转。PC = R 7</li>
<li><code>JSR PCoffset11</code>: 子程序调用。R 7 = PC，PC = target（PC+offset 11）</li>
<li><code>JSRR BaseR</code>：子程序调用。R 7 = PC，PC = target（BaseR）</li>
<li><code>TRAP trapvec8</code>：系统调用。R 7=PC, PC = Mem (ZEXT (trapvect 8))。
<ul>
<li>GETC ：x 20，从键盘输入字符存入 R 0</li>
<li>OUT：x 21，将 R 0 字符输入到显示器</li>
<li>PUTS：x 22，以 R 0 存储的字符串首地址，输出一个以 null 结尾的字符串</li>
<li>IN：x 23，打印提示符，读取一个字符并回到显示器，存入 R 0</li>
<li>HALT：x 25，停机</li>
</ul>
</li>
<li><code>RTI</code>：恢复 PC 和 PSR。</li>
</ul>
</li>
</ol><p><strong>LC 3 汇编语言伪操作：</strong></p><ul>
<li>伪操作：不是机器指令，指导汇编器翻译汇编码为机器代码
<ul>
<li><code>.ORIG x3000</code> : 程序从 x 3000 开始执行</li>
<li><code>A .FILL x0006</code> 在内存中预留一个位置，标记为 A，填入 6</li>
<li><code>NUMBER .BLKW 10</code>：在内存预留 10 个位置，数组开头标记为 NUMBER</li>
<li><code>HELLO .STRINGZ "Hello"</code>：存储字符串</li>
<li><code>.END</code>：源代码汇编结束，停止汇编过程</li>
</ul>
</li>
<li>标号：给内存地址起名；注释</li>
<li>汇编过程：两遍扫描。第一遍创建符号表，利用位置计数器记录当前的地址，遇到标号时将标号记录到符号表中。第二遍生成机器码，汇编指令翻译成机器码，标号通过符号表转换为偏移量和地址，并处理伪操作</li>
</ul></section>
<section><h2>ICS-2 控制信号与数据通路<a href="#ics-2-控制信号与数据通路"><span>#</span></a></h2><p>这一部分是用 AI 写的</p><p>基于您提供的资料，特别是《Introduction to Computing Systems》的附录 C（The Microarchitecture of the LC-3）以及期末复习资料，以下是对 LC-3 中**数据通路（Data Path）<strong>和</strong>控制信号（Control Signals）**的详细解析。</p><p>理解这两者的关键在于：<strong>数据通路是处理信息的“工厂设施”（如机器、传送带），而控制信号是“操作指令”（如开启机器、切换开关）。</strong></p><hr /><section><h3>1. 数据通路 (The Data Path)<a href="#1-数据通路-the-data-path"><span>#</span></a></h3><p>数据通路包含了所有实际处理、存储和传输信息的硬件组件。LC-3 的数据通路设计围绕着一条**全局总线（Global Bus）**展开。</p><section><h4><strong>A. 全局总线 (The Global Bus)</strong><a href="#a-全局总线-the-global-bus"><span>#</span></a></h4><ul>
<li><strong>结构</strong>：LC-3 只有一条共享的 16 位总线。这意味着在任何给定的时钟周期内，<strong>只能有一个</strong>组件向总线传输数据，但可以有多个组件从总线读取数据。</li>
<li><strong>三态门 (Tri-state Devices)</strong>：为了防止冲突，每个可以向总线发送数据的设备（如 PC, ALU, MDR）前都有一个三态门（三角形图标）。只有当相应的 <strong>Gate 信号</strong>（如 <code>GatePC</code>）为 1 时，数据才能上总线,。</li>
</ul></section><section><h4><strong>B. 核心处理组件</strong><a href="#b-核心处理组件"><span>#</span></a></h4><ol>
<li><strong>ALU (算术逻辑单元)</strong>,:
<ul>
<li><strong>功能</strong>：执行加法（ADD）、与运算（AND）、非运算（NOT）和直接传递（PASSA）。</li>
<li><strong>输入</strong>：有两个输入端 A 和 B。A 端总是来自寄存器（SR 1）；B 端可以来自寄存器（SR 2）或者指令中的立即数（通过 SEXT 扩展）。</li>
<li><strong>控制</strong>：<code>ALUK</code> 信号控制具体的运算类型。</li>
</ul>
</li>
<li><strong>寄存器堆 (Register File)</strong>,:
<ul>
<li><strong>功能</strong>：包含 R 0 到 R 7 八个通用寄存器。</li>
<li><strong>输入/输出</strong>：在一个周期内，可以同时读取两个源寄存器（SR 1, SR 2）并写入一个目的寄存器（DR）。</li>
<li><strong>控制</strong>：<code>SR1MUX</code> 选择源寄存器地址，<code>LD.REG</code> 控制是否写入。</li>
</ul>
</li>
<li><strong>PC (程序计数器) 与 PCMUX</strong>,:
<ul>
<li><strong>PCMUX</strong>：决定下一个 PC 的值。</li>
<li><strong>输入源</strong>：
<ul>
<li><code>PC + 1</code>：顺序执行。</li>
<li><code>BUS</code>：用于 JMP, JSR 等指令直接加载地址。</li>
<li><code>ADDER</code>：来自地址加法器的输出（用于 BR 跳转计算）。</li>
</ul>
</li>
</ul>
</li>
<li><strong>MAR (内存地址寄存器) 与 MDR (内存数据寄存器)</strong>:
<ul>
<li>它们是 CPU 与内存/IO 交互的接口。</li>
<li><strong>MARMUX</strong>：决定放入 MAR 的地址来源（是来自 IR 的零扩展，还是来自地址加法器）。</li>
</ul>
</li>
<li><strong>地址加法器</strong>:
<ul>
<li>专门用于计算地址（如 <code>PC + offset</code> 或 <code>BaseR + offset</code>），不占用 ALU 资源。</li>
</ul>
</li>
</ol><hr /></section></section><section><h3>2. 控制信号 (Control Signals)<a href="#2-控制信号-control-signals"><span>#</span></a></h3><p>控制信号由**控制单元（有限状态机 FSM）**产生，用于指挥数据通路中的组件在每个时钟周期该做什么。控制信号主要分为三类：</p><p><strong>A. 门控信号 (Gate Signals) - “谁在说话”</strong></p><p>控制谁有权将数据放到全局总线上。<strong>在任意时刻，必须且只能有一个 Gate 信号为 1</strong>（除了总线空闲时）。</p><ul>
<li><code>GatePC</code>：将 PC 的值放到总线上。</li>
<li><code>GateMDR</code>：将 MDR 的值放到总线上（通常用于取指或读取数据）。</li>
<li><code>GateALU</code>：将 ALU 的计算结果放到总线上。</li>
<li><code>GateMARMUX</code>：将地址计算结果放到总线上（例如 <code>JSR</code> 保存返回地址时）。</li>
</ul><p><strong>B. 加载信号 (Load Signals / LD. Xx) - “谁在听”</strong></p><p>控制哪个寄存器将从总线或其他来源捕获数据。在时钟周期的末尾生效。</p><ul>
<li><code>LD.REG</code>：将总线上的数据写入 DR 指定的寄存器。</li>
<li><code>LD.IR</code>：将总线数据（指令）写入指令寄存器。</li>
<li><code>LD.PC</code>：更新 PC 的值。</li>
<li><code>LD.MAR</code> / <code>LD.MDR</code>：更新内存接口寄存器。</li>
<li><code>LD.CC</code>：根据总线上的数据更新条件码（N, Z, P）。</li>
</ul><p><strong>C. 选择信号 (MUX Selectors) - “怎么走”</strong></p><p>控制多路选择器（MUX）选择哪一路输入。</p><ul>
<li><code>PCMUX</code>：选择下一条指令地址的来源（PC+1, 总线, 还是 Adder）。</li>
<li><code>SR1MUX</code> / <code>SR2MUX</code>：选择源操作数寄存器。<code>SR2MUX</code> 尤其重要，用于选择第二个操作数是来自寄存器（如 <code>ADD R0,R1,R2</code>）还是立即数（如 <code>ADD R0,R1,#5</code>）,。</li>
<li><code>ADDR1MUX</code> / <code>ADDR2MUX</code>：控制地址加法器的输入（是 PC 还是 BaseR？是 offset 6 还是 offset 9？）,。</li>
<li><code>ALUK</code>：虽不是 MUX，但类似选择信号，选择 ALU 执行的操作（ADD/AND/NOT/PASSA）。</li>
</ul><hr /></section><section><h3>3. 控制单元与微操作<a href="#3-控制单元与微操作"><span>#</span></a></h3><p>控制信号不是随机产生的，而是由一个**有限状态机（FSM）**管理的。LC-3 的 FSM 定义了计算机在每个时钟周期的行为。</p><ul>
<li><strong>状态 (State)</strong>：每一个状态对应一个时钟周期。每个状态都有一组特定的控制信号输出（这被称为<strong>微指令</strong>）。</li>
<li><strong>状态转换</strong>：由<strong>微序列器 (Microsequencer)</strong> 决定下一个状态是什么。
<ul>
<li><strong>取指阶段 (Fetch)</strong>：所有指令都从状态 18 开始（MAR&lt;-PC），接着状态 33，状态 28（读内存），状态 30（加载 IR），最后到状态 32（译码）。</li>
<li><strong>译码 (Decode)</strong>：在状态 32，根据 <code>IR[15:12]</code>（操作码），微序列器决定跳转到哪个特定指令的执行序列。</li>
</ul>
</li>
<li><strong>决策信号</strong>：微序列器根据以下信号决定下一状态:
<ul>
<li><code>INT</code>：是否有中断请求。</li>
<li><code>R</code>：内存是否读写完毕（Ready bit）。</li>
<li><code>BEN</code> (Branch Enable)：是否满足分支跳转条件。</li>
<li><code>ACV</code>：是否有访问权限违规。</li>
</ul>
</li>
</ul></section><section><h3>4. 实例分析：ADD 指令的执行<a href="#4-实例分析add-指令的执行"><span>#</span></a></h3><p>以 <code>ADD R1, R2, R3</code> 为例，在执行阶段（Execute Phase），控制信号如下配合:</p><ol>
<li><strong>取操作数</strong>：
<ul>
<li><code>SR1MUX</code> 选择 R 2。</li>
<li><code>SR2MUX</code> 选择 R 3（因为 IR=0）。</li>
</ul>
</li>
<li><strong>运算</strong>：
<ul>
<li><code>ALUK</code> 设置为 <code>ADD</code> (00)，让 ALU 执行加法。</li>
</ul>
</li>
<li><strong>输出结果</strong>：
<ul>
<li><code>GateALU</code> = 1，将结果放到总线上。</li>
</ul>
</li>
<li><strong>保存结果</strong>：
<ul>
<li><code>DR</code> 指向 R 1。</li>
<li><code>LD.REG</code> = 1，在周期末尾将总线数据写入 R 1。</li>
<li><code>LD.CC</code> = 1，同时更新条件码。</li>
</ul>
</li>
</ol></section><section><h3>总结<a href="#总结"><span>#</span></a></h3><p>LC-3 的运行本质上就是<strong>数据通路</strong>在<strong>控制信号</strong>的指挥下，在<strong>状态机</strong>的驱动中，通过<strong>总线</strong>不断搬运和计算数据的过程。每条指令的执行就是在一个个特定的状态中，打开特定的 Gate，设置特定的 MUX，并拉高特定的 LD 信号。</p></section></section>
<section><h2>ICS-3 微指令表<a href="#ics-3-微指令表"><span>#</span></a></h2><p>LC-3 的<strong>微指令表（Microinstruction Table）</strong>，也被称为<strong>控制存储（Control Store）</strong>，是 LC-3 微架构的核心部分。它定义了计算机在每一个<strong>机器状态（State）</strong>（即每一个时钟周期）下具体要做什么。</p><p>在 LC-3 的微程序实现中，每一个状态对应控制存储中的一行，这一行被称为一条<strong>微指令（Microinstruction）</strong>。每条微指令由 <strong>52 位</strong>的二进制信号组成，它们直接控制着计算机的硬件行为。</p><p>以下是微指令表的详细构成与逻辑解析：</p><section><h3>1. 微指令的总体结构<a href="#1-微指令的总体结构"><span>#</span></a></h3><p>每一条微指令（即表中的每一行）包含 52 个比特位，分为两大类功能区域：</p><ol>
<li><strong>数据通路控制信号（42 bits）</strong>：控制数据在硬件组件之间的流动和处理（例如：打开哪个门、选择哪个 MUX 输入、是否写入寄存器）。</li>
<li><strong>微序列器控制信号（10 bits）</strong>：决定下一个时钟周期跳转到哪个状态（即下一条微指令的地址）。</li>
</ol></section><section><h3>2. 数据通路控制信号<a href="#2-数据通路控制信号"><span>#</span></a></h3><p>这 42 个信号直接连接到硬件电路，指挥具体操作。根据功能可细分为以下几类：</p><section><h4><strong>A. 加载信号</strong><a href="#a-加载信号"><span>#</span></a></h4><p>决定各个寄存器在当前周期结束时是否更新值。</p><ul>
<li><strong>LD. PC, LD. IR, LD. MAR, LD. MDR</strong>：控制 PC, IR, MAR, MDR 的写入。</li>
<li><strong>LD. REG</strong>：控制通用寄存器（R0-R7）的写入。</li>
<li><strong>LD. CC, LD. BEN</strong>：控制条件码（N, Z, P）和分支使能信号的更新。</li>
<li><strong>LD. Priv, LD. Priority</strong>：控制处理器状态寄存器（PSR）中特权模式和优先级的更新。</li>
</ul></section><section><h4>B. 门控信号<a href="#b-门控信号"><span>#</span></a></h4><p>控制三态门，决定<strong>谁有权将数据发送到全局总线（Global Bus）</strong>。在任意时刻，最多只能有一个 Gate 信号为 1。</p><ul>
<li><strong>GatePC</strong>：PC 的值上总线。</li>
<li><strong>GateMDR</strong>：MDR 的值上总线。</li>
<li><strong>GateALU</strong>：ALU 的计算结果上总线。</li>
<li><strong>GateMARMUX</strong>：地址计算结果上总线（如 <code>JSR</code> 保存返回地址时）。</li>
<li><strong>GateVector, GatePSR, GateSP</strong>：用于中断/异常处理时将向量、PSR 或栈指针上总线。</li>
</ul></section><section><h4><strong>C. 多路选择器信号</strong><a href="#c-多路选择器信号"><span>#</span></a></h4><p>控制数据通路中的选择器，决定数据的来源。</p><ul>
<li><strong>PCMUX (2 bits)</strong>：选择 PC 的下一值来源（<code>PC+1</code>, 总线 <code>BUS</code>, 或地址加法器 <code>ADDER</code>）。</li>
<li><strong>DRMUX (2 bits) / SR1MUX (2 bits)</strong>：选择目标寄存器（DR）或源寄存器（SR1）的地址来源（是指令中的 <code>IR[11:9]</code>, <code>IR[8:6]</code>, 还是固定的 <code>R7</code> 或 <code>R6/SP</code>）。</li>
<li><strong>ADDR1MUX (1 bit) / ADDR2MUX (2 bits)</strong>：控制地址加法器的输入（例如基址寄存器 BaseR 或 PC；偏移量 offset6 或 offset9 等）。</li>
<li><strong>MARMUX (1 bit)</strong>：决定写入 MAR 的地址是来自指令的零扩展（ZEXT）还是地址加法器。</li>
</ul></section><section><h4><strong>D. 功能控制</strong><a href="#d-功能控制"><span>#</span></a></h4><ul>
<li><strong>ALUK (2 bits)</strong>：命令 ALU 执行什么运算（<code>ADD</code>, <code>AND</code>, <code>NOT</code>, 或 <code>PASSA</code>）。</li>
<li><strong>MIO. EN / R.W</strong>：控制内存或 I/O 的读写操作。</li>
</ul></section></section><section><h3>3. 微序列器控制信号<a href="#3-微序列器控制信号"><span>#</span></a></h3><p>这 10 个信号决定了状态机的跳转逻辑，即“下一状态地址”是如何生成的：</p><ul>
<li><strong>IRD (1 bit)</strong>：<strong>指令解码信号</strong>。
<ul>
<li>如果 IRD=1，下一状态地址直接由当前指令的操作码（Opcode）决定（跳转到各指令的第一步，如 <code>ADD</code> 跳到状态 1）。这是状态 32（Decode）特有的信号。</li>
<li>如果 IRD=0，下一状态由 <code>J</code> 字段和 <code>COND</code> 字段决定。</li>
</ul>
</li>
<li><strong>COND (3 bits)</strong>：<strong>条件跳转选择</strong>。选择依据什么条件来修改下一状态地址。
<ul>
<li><code>COND1</code> (Memory Ready)：检查内存是否读写完成（R bit）。</li>
<li><code>COND2</code> (Branch)：检查是否满足分支条件（BEN）。</li>
<li><code>COND3</code> (Addressing Mode)：检查寻址模式（如指令的第 11 位）。</li>
</ul>
</li>
<li><strong>J (6 bits)</strong>：<strong>基础跳转地址</strong>。指定默认的下一个状态编号（0-63）。如果满足特定 <code>COND</code> 条件，硬件逻辑会修改这个地址的特定位，从而实现状态跳转。</li>
</ul></section><section><h3>4. 实例分析：FETCH 阶段的微指令<a href="#4-实例分析fetch-阶段的微指令"><span>#</span></a></h3><p>以所有指令共用的 <strong>状态 18 (Fetch 第一步)</strong> 为例，其微指令表中的关键信号配置如下：</p>

<table><thead><tr><th>信号类别</th><th>设置值</th><th>解释</th></tr></thead><tbody><tr><td><strong>GatePC</strong></td><td><strong>1</strong></td><td>将 PC 的值放到总线上。</td></tr><tr><td><strong>LD. MAR</strong></td><td><strong>1</strong></td><td>将总线上的值（原 PC）加载到 MAR，准备读内存。</td></tr><tr><td><strong>PCMUX</strong></td><td><strong>PC+1</strong></td><td>选择 PC+1 作为 PC 的新值。</td></tr><tr><td><strong>LD. PC</strong></td><td><strong>1</strong></td><td>更新 PC 为 PC+1。</td></tr><tr><td><strong>MEM. EN</strong></td><td><strong>0</strong></td><td>本周期不读写内存（下一周期才读）。</td></tr><tr><td><strong>Next State</strong></td><td><strong>33</strong></td><td>J=33 (100001)，无条件跳转到状态 33。</td></tr></tbody></table></section><section><h3>5. 总结<a href="#5-总结"><span>#</span></a></h3><p>LC-3 的微指令表本质上是一个 <strong>59 行 × 52 列</strong> 的二进制矩阵（Control Store）。</p><ul>
<li><strong>列（Columns）</strong>：代表硬件的控制线（如 <code>LD.REG</code>）。</li>
<li><strong>行（Rows）</strong>：代表状态机的状态（如 State 18）。</li>
<li><strong>内容</strong>：每一位的 <code>0</code> 或 <code>1</code> 决定了在该时钟周期内，硬件电路是“开启”还是“关闭”，从而组合出宏观的指令行为（如 <code>ADD</code>, <code>LDR</code>）。</li>
</ul><p>理解这张表，就理解了计算机是如何将抽象的汇编指令转化为具体的电流脉冲来操纵硬件的。</p></section></section>
<section><h2>ICS-4 中断异常与 IO<a href="#ics-4-中断异常与-io"><span>#</span></a></h2><p><strong>数据结构：</strong></p><ul>
<li>栈：用 R6 作为栈指针（Stack Pointer），往内存减小的地方增长。
<ul>
<li>PUSH 进栈：<code>ADD R6, R6, -1</code>, 再 <code>STR R0, R6, #0</code>，将 R0 进栈</li>
<li>POP 出栈：<code>LDR R0, R6, #0</code>, 再 <code>ADD R6, R6, #1</code>, 弹出栈顶元素并存入 R0</li>
</ul>
</li>
<li>队列：使用 FRONT（第一个元素之前） 和 REAR（最近加入的那个元素） 指针，循环队列。入队：REAR 指针+1，STR 入数据。出队：FRONT 指针+1。</li>
</ul><p>循环：使用计数器（for）或者哨兵控制（while）</p><p>子程序调用：用 JSR 或 JSRR 寻址，将 PC 保存在寄存器 R7 中，保存寄存器（caller-save）至下次调用。使用 RET（JMP R7）返回子程序。</p><p><strong>用户栈和系统栈：</strong></p><ul>
<li>入栈保护：发生中断异常或 TRAP 指令时 LC3 会把当前 PSR 和 PC 压入系统栈中。遇到 RTI 指令会弹出当前 PC 和 PSR 并恢复。</li>
<li>栈指针设置为 R6。特权模式 R6 是 SSP，用户模式 R6 是 USP。模式切换时，用 Saved_SSP 和 Saved_USP 来寄存和恢复 R6</li>
<li>用户栈和系统栈：用户栈里，函数创建栈帧，里边包含函数参数、返回值空间、返回地址（R7），旧的栈指针（R5），局部变量等</li>
<li><strong>PSR</strong>：<strong>用户跳转寄存器 Processor Status Register</strong>，记录身份状态。寄存器地址在 xFFFC
<ul>
<li>15 位：特权模式。0 为特权模式，1 为用户模式</li>
<li>14 位：中断使能。0 允许终端，1 不允许中断</li>
<li>10-8 位：优先级。0 最低，7 最。当外部设备优先级比当前优先级高时，中断才会发生，否则抛弃</li>
<li>2-0 位：条件码 CC。设置 NZP。</li>
</ul>
</li>
</ul><p><strong>调用函数：运行时栈</strong></p><ol>
<li>调用者准备：将参数从右往左压入运行时帧中，第一个参数在最顶端。使用 <code>JSR</code> 和 <code>JSRR</code> 跳转到函数地址。这两个指令会自动保存跳转前地址到 R7 方便链接。 R6 是栈指针，R5 是帧指针</li>
<li>被调用者建立栈帧：
<ol>
<li>预留返回值空间 <code>ADD R6, R6, #-1</code></li>
<li>保存返回地址到 R7 <code>ADD R6, R6, #-1</code>, <code>STR R7, R6, #0</code></li>
<li>保存旧栈指针 R5 <code>ADD R6, R6, #-1</code>, <code>STR R5, R6, #0</code>，方便恢复调用者的环境</li>
<li>设置新栈指针 R5 <code>ADD R5, R6, #-1</code>，在 R6 上面，是第一个局部变量的位置。</li>
<li>分配局部变量空间：有 N 个局部变量则栈指针下移 N 位 <code>ADD R6, R6, #-N</code></li>
</ol>
</li>
<li>执行代码：
<ol>
<li>加载局部变量：<code>LDR Rx, R5, -0--</code>，将 R5 上面的局部变量加载到寄存器中</li>
<li>加载参数：<code>LDR Rx, R5, 4++</code>，将 R5 下面 4 位（前 1-3 位分别是旧栈、返回时指针、返回时空间）开始的参数依次存入寄存器中</li>
<li>运行程序</li>
</ol>
</li>
<li>被调用者返回：
<ol>
<li>写入返回值：<code>STR R0, R5, #3</code>，将 R0 写入返回值空间里</li>
<li>弹出局部变量：<code>ADD R6, R5, #1</code>，将 R6 移到旧 R5 的位置</li>
<li>恢复旧栈指针：<code>LDR R5, R6, #0</code>, <code>ADD R6, R6, #1</code></li>
<li>恢复返回地址：<code>LDR R7, R6, #0</code>, <code>ADD R6, R6, #1</code></li>
<li>执行 RET（JMP R7）</li>
</ol>
</li>
<li>调用者清理：此时 R6 指向返回值
<ol>
<li>读取返回值：<code>LDR R0, R6, #0</code></li>
<li>弹出返回值：<code>ADD R6, R6, #1</code></li>
<li>弹出参数：<code>ADD R6, R6, #M</code>，如果有 M 个参数的话</li>
</ol>
</li>
</ol><p>在用户栈中，建立栈帧后，R5 + 0 指向第一个局部变量，R5-1 指向第二个。R5+1 是 saved R5，R5+2 是 saved R7。R5+3 是 return value。R5+4 是传进来的第一个参数。</p><p><strong>中断与轮询</strong>：</p><ul>
<li>内存映射 I/O：LC-3 通过假装读写内存（I/O 映射空间 xFE00 到 xFFFF）来控制外设。
<ul>
<li>KBSR（xFE00）： 寄存键盘状态。Bit15 是 Ready 位，为 1 时表示有按键输入。Bit14 是中断使能位，为 1 时表示允许键盘向 CPU 发送中断请求。</li>
<li>KBDR（xFE02）：寄存键盘数据。7-0 位为键盘的 ASCII 码。</li>
<li>DSR（xFE04）显示状态寄存器，有 ready 位和中断使能位（IE, Interrupt Enable）；DDR（xFE06）显示数据寄存器</li>
<li>PSR（xFFFC）处理器状态寄存器</li>
<li>MCR（xFFFE）机器控制寄存器，控制时钟启动/停止</li>
</ul>
</li>
<li>轮询：不断读取 KBSR 和 DSR，效率低</li>
<li>中断：异步操作
<ol>
<li>中断触发：当设备 Ready Bit 为 1，OS 设置的 IE 为 1 时，如果设备的优先级 PL 高于当前 CPU 优先级，则 CPU 相应中断。</li>
<li>CPU 响应：根据状态机，PC 自增后，fetch 前会检查 INT 信号。若有请求，则 CPU 从 USP 跳转到 SSP（通过 R6, Saved_USP 和 Saved_SSP），将当前 PSR 和 PC 压入栈，并修改 PSR bit15 进入特权模式</li>
<li>查找中断向量表（x01xx），跳转 PC 到中断服务例程 ISR</li>
<li>例程执行完后， RTI 返回，弹出原来的 PSR 和 PC，继续执行刚才没执行的程序。</li>
</ol>
</li>
</ul><p><strong>内存映射</strong>：Memory Map</p>

<table><thead><tr><th>地址范围</th><th>区域名称</th><th>访问权限</th><th>备注</th></tr></thead><tbody><tr><td>x0000 - x00FF</td><td>TRAP 向量表</td><td>特权 (Supervisor)</td><td>存放 TRAP 服务例程入口地址</td></tr><tr><td>x0100 - x01FF</td><td>中断向量表</td><td>特权 (Supervisor)</td><td>存放中断/异常服务例程入口地址</td></tr><tr><td>x0200 - x2FFF</td><td>操作系统/系统栈</td><td>特权 (Supervisor)</td><td>OS 代码、数据、SSP</td></tr><tr><td>x3000 - xFDFF</td><td>用户空间</td><td>用户 (User)</td><td>用户程序、数据、USP</td></tr><tr><td>xFE00 - xFFFF</td><td>I/O 映射页</td><td>特权 (Supervisor)</td><td>设备寄存器 (KBSR, DDR 等)</td></tr></tbody></table></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2025/final/</id>
      <title type="text">2025年终总结</title>
      <published>2026-01-05T00:00:00.000Z</published>
      <updated>2026-01-05T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2025/final/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>一年又结束了。回顾 2025 年初立下的两个发问：我想做什么？世界有什么？我想整个 2025 年虽有遗憾，但至少对一个半问题给出了答案。遗憾就是没有足够深入，每天总是处于精力不支的状态，特别是秋季。</p>
<p>年末回了自己的初中和高中看望老师和同学，想起了不少回忆，大家过的都顺顺利利的，校园里的时间就这么一节课一节课、一天一天、一年一年这样循环着，送走学生，又招收学生。在政策改变的波涛下摇摆起伏。高中校园旁新建了公园，美观而空旷，时间和事物总是这样向前发展着。</p>
<p>2024 年年末自己给自己提了两个问题，回答一下吧：</p>
<section><h2>两个问题<a href="#两个问题"><span>#</span></a></h2><section><h3>1. 我想做什么<a href="#1-我想做什么"><span>#</span></a></h3><p>2025 年年初列过寒假计划。寒假时在捣鼓 python 和网络爬虫，爬了课表。大一下初我不知道自己要选什么专业，电磁学了一半不想学物理，5 月份开始严肃考虑信智专业，最终稀里糊涂的选择了 DS，据说硬件课不多。之后就选了。7 月末去香港蔷薇访学，觉得那边的环境和大陆这边不一样，很好玩，萌生了去香港或者国外留学的想法。8 月与 operator 一起做 Bullet AI，学了些前端知识，第一次搭起自己的网站。8 月末跟着 B 站 krenz 学画，断断续续学到 10 月。9 月中旬与陈天磊学长聊，把我的视线从未来几个月眺望到未来几年，“我毕业后想做什么，想留在学界还是工作？”当时给的答案是工作。之后 9 月末套任少卿组因为没有毅力没有坚持下来直接失联了，奶龙最后成功进去了，现在每天要花大量的时间搞科研。12 月末整了个博客想写点东西，于是这个网站诞生了。</p><p>9 月末擦边拿到国奖了，了结一个心事。10 月与学长聊未来的发展，建议我尽早套外校的组，然后尽早套暑研积累经验。10 月画了许多画，打了黑客松，11 月又打了一场，两场黑客松感觉都非常的不错，认识了好多有创意点的人。11 月末大研宣讲，12 月初进了张少锋组看看，认识了轩轩，背后利用网络爬虫做了一念云天；打了 CTF，认识了 yemaster 网安也很好玩，打算有机会加入 nebula 战队聊聊。12 月末与 Kein 聊天，最大收获是了解到如果 30 岁财富自由那么路是怎么走的：创业，和他一样，他那边有推荐实习的项目；还有知识到底是怎么获取的。我想到 xst 和张岸那边聊“无限游戏”，和人直接聊天总能启发许多。之后明确了目标：在 10-15 年内实现财富自由。期末考试啥的，应该能顺利速通。不过我大学的下一步应该怎么走？读研读博要不要读，去哪读，实习接下来怎么做，有没有能形成商业闭环的 idea，还是充满不确定性。</p><p>2025 年初忙着列寒假做什么，想看电影，学编程，学画画。当时日记充斥着枯燥的学习 ddl 和普通的活动记录。国庆把日记本换成了 Paper Idea 200 页的 A5 本子，原先的活页本拆了两页下来，一页是当时的寒假计划，一页是与陈天磊聊完后记录下的思考，时间是 9 月 28 日，引用一下：</p><blockquote><p>去理解整个世界，去欣赏世界中的美好之处，去自由探寻和发现，折腾自己想做的事，成为想成为的人，精彩的活完一生。行动不受金钱的束缚，不受眼界的局限，在不违反物理和身体规律的情况下，实现理想。
找到能托付一生的伴侣，可能会传宗接代（？）。身边有一群志同道合的朋友们，在交流中互相帮助支持，追寻最前沿的技术，一起探索和改造美妙的世界</p></blockquote><p>但也同时抛出新问题，财富自由只是手段，一个很大很大的，阶段性的目标，可以为之奋斗 10 年（2035-2040 年才实现）。这个就像给“如何过好大学生活”设定目标“大一刷好绩、大二进组干活”一样，可以奋斗一两个学期。现在知识时间变长而已。目标之后的路还得探寻。如果为了这个目标，我得放弃自己的爱好、娱乐什么什么的（比如成为画画作曲唱歌高手，也是值得的），嗯… 我也不知道，也是很迷茫。我确实希望 10 年后能财富自由，能想干自己想干的事情，10 年后父母也不会很老，我弟刚上大学，为什么不去试试实现这个目标呢？</p></section><section><h3>2. 世界有什么<a href="#2-世界有什么"><span>#</span></a></h3><p>这个问题还是不好回答。对我而言，2025 的有两大重要思想发现：</p><p>一、事物的是一层一层抽象构成的。比如计算机体系结构，是从最基础的物理晶体管开始，抽象到逻辑电路，抽象到微结构，抽象到指令架构，抽象到进程、线程、操作系统、汇编，之后才是我们熟悉的编程算法与软件。计算机网络也是一样，有五层结构。生物也是一样，从细胞抽象到组织到器官再到个体等等等等。知识和做事逻辑也是一样，一层掏一层，每一层完成相应的任务</p><p>二、认知是联系紧密的知识网络，而不是离散的一个个知识点或是线性的长篇大论僵化的细则，自己总结是构建知识网络的手段。快速的认知是先建立全局观再往里面填细节，而不是对着书一点一点的慢慢啃。</p><p>回想起 24 年，我只会在各大群聊发表情包刷存在感，25 年上半年都在水卷群，后来分裂。7 月创立了大树皮小团体和信智小团体，但后者人有点多有点杂了，从大群向小群过渡，同时加了好多小群。9 月成为了两个初中同学的学长，线下社交也变得频繁。10 月与 bobo 一起去南京玩。12 月与 N 姐熟悉，但感觉也有点一坨。现在发现整个科大 QQ 圈子都有点一坨，那么，走出去吧，放下科大本科 QQ 群这片狭小的地盘，多社交玩玩，认识更多的人。</p><p>我发现一个大问题。之前我是干累了休息，然后再干，干和休息都不充分。要不先爽爽干活再爽爽干自己的事情呢？感觉可行。把时间分为<strong>学习、工作、社交、娱乐、爱好、运动</strong>等几个板块，每个板块每天都分出相应的时间和经历去干，板块之间又有交错，岂不美哉！今天（1 月 2 号）学了一些新的音乐很开心，改天把画画捡起来</p></section></section>
<section><h2>展望 2026<a href="#展望-2026"><span>#</span></a></h2><p>这里列着 2026 年我的“世界观”一样的目标。在 2026 年，我希望学习科研生活双丰收，眼界开阔，能深耕美术音乐爱好，在金融理财方面也有独到的见解，梦想创业实现财富自由。同时也玩 steam 游戏与别人社交，最好能找到自己的心上人，游历世界的许多地方。</p><p>我希望坚持的习惯：</p><ul>
<li>早睡早起：真的要保持经历和充分的睡眠时间给自己吧</li>
<li>阅读：开阔眼界很好的手段</li>
<li>锻炼：我想学自由泳！游泳、跑步、打乒乓球都是很好的感觉</li>
<li>经常去外面看看，别窝在自习室或者家里了</li>
</ul><p>一些小目标：</p><ul>
<li>学习科研：寒假实习，暑假套暑研，大三上可以考虑在大厂做日常或做科研，大二下狂吃课内，做做科研。多去外面转转，多了解了解具身智能和金融，想想能融资的 idea。</li>
<li>金融：弄清楚市场背后运作的机理，搞一个股票自动交易这种的 AI 或者策略并试水</li>
<li>技术：整个服务器玩玩（yema 的），搞个端口开 MC 服务器，搞个端口整自己的博客和小制作啥的。软件方面学学 rust，数据库，js，AI 算法等等（还是想去算法岗）。硬件方面想用嵌入式开发好玩的东西</li>
<li>阅读：20 本书，20 部电影，10 部番，10 款游戏。半个月一本书一个电影，一个月一款游戏一部番，试试。先从<a href="/posts/%E7%A7%91%E5%AD%A6%E9%9D%A9%E5%91%BD%E7%9A%84%E7%BB%93%E6%9E%84/">科学革命的结构</a>开始玩玩</li>
<li>旅游：去 10 座城市！至少要爬大蜀山和黄山吧</li>
<li>生活：探索 50/100 家美食店，自己搭配出 10 套穿搭等等</li>
<li>画画：画出自己的 OC！！！！！！</li>
<li>唱歌：学一些技巧，背诵一些日语歌，然后争取无痛能唱到 E5 之后改变声线学学伪音啥的</li>
<li>音乐：尝试作曲！！！！了解音乐发展史与所有曲风归类（大作业：自己写曲，自己画 BGA，用平面设计与绘画和一些视频工具来制作）</li>
<li>运动：月跑 50 km！四分配跑 5 km！学会自由泳！</li>
<li>其他：捡起日语，日语考到 N2 之类的；尝试写每月总结</li>
</ul><p>留几个问题给自己吧</p><ol>
<li>为什么这个模式能成功？用创业的视角看待世间万物，剖析原因，去看他们是怎么“降本增效”、不断的优化的，团队是怎么构建的，而不是被动的去接受去打工。</li>
<li>（想不出来了 ww）世界有什么？保持好奇心，对一切的事情都要去追问，搞清楚世界是如何运转的，这一方面还有许多许多需要探索和学习</li>
</ol><p>感觉好乱 ww， 1 月 2 号写了一半，1 月 5 号写了另一半。总算是给 2025 年画上一个象征性的句号。</p><p>2026 又是崭新的开始诶，期待着，飞向远方。</p></section>]]></content>
    </entry>
    <entry>
      <id>https://mirawind.top/posts/2025/12/birth/</id>
      <title type="text">我的第一篇博客</title>
      <published>2025-12-24T00:00:00.000Z</published>
      <updated>2025-12-24T00:00:00.000Z</updated>
      <author><name>Mirawind</name></author>
      <link rel="alternate" href="https://mirawind.top/posts/2025/12/birth/"/>
      <summary type="text"></summary>
      <content type="html"><![CDATA[<p>2025 年 12 月 24 日，我开始写博客了，欢迎阅读我的第一篇博客文章！</p>
<p>我使用了 <a href="https://astro.build/" target="_blank">Astro</a> 框架和 <a href="https://twilight.spr-aachen.com/" target="_blank">Twilight</a> 主题部署。详情参考 <a href="https://docs.twilight.spr-aachen.com/" target="_blank">Twilight 文档</a> 和 <a href="https://docs.astro.build/" target="_blank">Astro Docs</a>。</p>
<section><h2>框架与主题的选择<a href="#框架与主题的选择"><span>#</span></a></h2><p>为什么选择用 astro 作为框架搭建博客呢？其实在上半年，我打算用 jekyll 来整自己的 github pages，但苦于没有网站建设经验，不懂目录架构，壳子搭玩之后感觉不好看，不想写，于是放弃了。暑假积累了些建站经验。步入 12 月，我发现周围的同学用 Wordpress、hexo、mkdocs 纷纷搭建出自己的博客，12 月下旬也没什么 ddl （作业用 AI 抄的差不多了），于是决定搭建博客。</p><p>12 月 22 日开始整博客，一开始打算用广为人知的 hexo。在 hexo theme 上发现 <a href="https://github.com/saicaca/hexo-theme-vivia" target="_blank">vivia</a> 主题，看起来非常美观，研究一晚上搭建出一个，放在 <a href="https://50829.github.io" target="_blank">Github 个人主页</a>上。但这个主题已经不再维护了。原作者 saicaca 以此为基础，使用 astro 框架制作了新主题 <a href="https://fuwari.vercel.app/" target="_blank"><strong>Fuwari</strong></a>，更加美观。astro theme 商店里面还有许多精美的主题，该选哪一个呢？我顺便对主题做了些历史调查。</p><p>Astro 诞生于 2021 年，专注于静态网站的生成和部署。Hexo 诞生于 2013 年，是老牌的博客网站。Fuwari 主题诞生于 2024 年初，现在在 GitHub 上有超过 3k 的 star。其前身 vivia 诞生于 2023 年中旬，目前大约 500 star。在商店里搜索 fuwari, 可以搜到很多inspired by fuwari 的主题，比如 <a href="https://yukina-blog.vercel.app" target="_blank">Yukina</a>、<a href="https://demo-firefly.netlify.app" target="_blank">Firefly</a>、<a href="https://mizuki.mysqil.com/" target="_blank">Mizuki</a>等主题。下图是它们 star-history.com 上的增长趋势：</p><p><a href="https://www.star-history.com/#saicaca/fuwari&amp;Spr-Aachen/Twilight&amp;WhitePaper233/yukina&amp;CuteLeaf/Firefly&amp;matsuzaka-yuki/Mizuki&amp;saicaca/hexo-theme-vivia&amp;type=date&amp;legend=top-left" target="_blank"></a></p><figure><a href="https://www.star-history.com/#saicaca/fuwari&amp;Spr-Aachen/Twilight&amp;WhitePaper233/yukina&amp;CuteLeaf/Firefly&amp;matsuzaka-yuki/Mizuki&amp;saicaca/hexo-theme-vivia&amp;type=date&amp;legend=top-left" target="_blank"><img src="https://api.star-history.com/svg?repos=saicaca/fuwari,Spr-Aachen/Twilight,WhitePaper233/yukina,CuteLeaf/Firefly,matsuzaka-yuki/Mizuki,saicaca/hexo-theme-vivia&amp;type=date&amp;legend=top-left" alt="Star History Chart" /><figcaption>Star History Chart</figcaption></a></figure><p></p><p><strong>这些主题都很新</strong>！很好看，并且有播放器。怎么选择呢？默默掏出了 Gemini 询问… 哈基米说，Firefly 像是一个流萤粉丝站，魔改过大量代码； Mizuki 功能全，使用 MD3 设计语言保证好看；而 Twilight 则有后端发博客的功能。当时觉得后端管理博客很新奇，就选了 Twilight 主题，但发现后端的界面一言难尽，与前端那是完全不匹配，功能也没有 Mizuki 全，有点后悔。不过先用着吧，等以后有空再改主题。</p><div><div><div></div><div>Note</div></div><div><p>Twilight 后端博客管理页面实在过于糟糕，但这是一个改进的主要方向，以后还能交 PR ，难说呢！有时间研究研究</p></div></div></section>
<section><h2>部署与博客的使用<a href="#部署与博客的使用"><span>#</span></a></h2><p>23 号下午研究主题和部署。部署的流程很快，按照 AI 教程一步一步来，一小时内搞定。不过折腾 Umami 页面浏览统计和 Github Apps 花了不少时间（后端发博客需要认证）。接下来的重头戏是怎么把页面改造成我想要的样子。config.js 调了好久，背景图在 pixiv 上找了两个小时，发现所有正方形的图片和竖屏图都无法使用，得找专门的横幅桌面背景画师，最终找到 void_0 的这张作品。陆陆续续修改细节，此时已经快凌晨三点了，于是睡觉。</p><p>24 号十点起床研究博客的写作、如何填内容。也是在 vscode 里写起 markdown 了，体验和我常用的 obsidian 还很不一样！很烦人的一点是 ctrl + B 不是加粗，而是切换侧边栏······ 体验不太好。</p><p>发现这个网站可以把大部分东西给涵盖进去。终于在互联网上终于有个“基地”了！好耶！</p></section>
<section><h2>博客的格式<a href="#博客的格式"><span>#</span></a></h2><section><h3>元数据<a href="#元数据"><span>#</span></a></h3><p>文章开头需要添加 YAML 前端数据（frontmatter）：</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>---</span></div></div><div><div><div>2</div></div><div><span>title</span><span>: </span><span>My First Blog Post</span></div></div><div><div><div>3</div></div><div><span>published</span><span>: </span><span>2020-02-02</span></div></div><div><div><div>4</div></div><div><span>description</span><span>: </span><span>This is the first post of my new Astro blog.</span></div></div><div><div><div>5</div></div><div><span>cover</span><span>: </span><span>./cover.webp</span></div></div><div><div><div>6</div></div><div><span>tags</span><span>: [</span><span>Foo</span><span>, </span><span>Bar</span><span>]</span></div></div><div><div><div>7</div></div><div><span>category</span><span>: </span><span>Front-end</span></div></div><div><div><div>8</div></div><div><span>draft</span><span>: </span><span>false</span></div></div><div><div><div>9</div></div><div><span>---</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>下面是详细的元数据表：</p>

<table><thead><tr><th>Attribute</th><th>Description</th></tr></thead><tbody><tr><td><code>title</code></td><td>The title of the post.</td></tr><tr><td><code>published</code></td><td>The date the post was published.</td></tr><tr><td><code>pinned</code></td><td>Whether this post is pinned to the top of the post list.</td></tr><tr><td><code>description</code></td><td>A short description of the post. Displayed on index page.</td></tr><tr><td><code>image</code></td><td>The cover image path of the post. <br />1. Start with <code>http://</code> or <code>https://</code>: Use web image <br />2. Start with <code>/</code>: For image in <code>public</code> dir <br />3. With none of the prefixes: Relative to the markdown file</td></tr><tr><td><code>tags</code></td><td>The tags of the post.</td></tr><tr><td><code>category</code></td><td>The category of the post.</td></tr><tr><td><code>routeName</code></td><td>Route name for the post. The post will be accessible at <code>/posts/{routeName}/</code></td></tr><tr><td><code>licenseName</code></td><td>The license name for the post content.</td></tr><tr><td><code>encrypted</code></td><td>Set true to encrypt this post.</td></tr><tr><td><code>password</code></td><td>“123456”</td></tr><tr><td><code>author</code></td><td>The author of the post.</td></tr><tr><td><code>sourceLink</code></td><td>The source link or reference for the post content.</td></tr><tr><td><code>draft</code></td><td>If this post is still a draft, which won’t be displayed.</td></tr></tbody></table></section><section><h3>博客的存放<a href="#博客的存放"><span>#</span></a></h3><p>博客放在 <code>src/content/posts/</code> 目录下。可以新建文件夹来存放复杂博客（比如本篇）</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>src/content/posts/</span></div></div><div><div><div>2</div></div><div><span>├── post-1.md</span></div></div><div><div><div>3</div></div><div><span>└── post-2/</span></div></div><div><div><div>4</div></div><div><span><span>    </span></span><span>├── cover.png</span></div></div><div><div><div>5</div></div><div><span><span>    </span></span><span>└── index.md</span></div></div></code></pre><div><div></div><div></div></div></figure></div></section><section><h3>Markdown Extended Features<a href="#markdown-extended-features"><span>#</span></a></h3><p>附加功能包括：Github 仓库卡片、 Admonitions、GitHub syntax、Spoiler详情参考 <a href="../features/">Extended Features</a>。参考以下格式：</p><a href="https://github.com/50829/Mirawind" target="_blank"><div><div><div><div></div><div>50829</div></div><div>/</div><div>Mirawind</div></div><div></div></div><div>Description not set</div><div><div>—</div><div>—</div><div>MIT</div><span>Astro</span></div></a><p>主题支持 Admonitions 和 callout。但只支持<code>note</code> <code>tip</code> <code>important</code> <code>warning</code> <code>caution</code>类型</p><p>Admonitions ：</p><div><div><div></div><div>Note</div></div><div><p>Highlights information that users should take into account, even when skimming.</p></div></div><div><div><div></div><div>MY CUSTOM TITLE</div></div><div><p>This is a note with a custom title.</p></div></div><div><div><div></div><div>Tip</div></div><div><p>Optional information to help a user be more successful.</p></div></div><div><div><div></div><div>Important</div></div><div><p>Crucial information necessary for users to succeed.</p></div></div><div><div><div></div><div>Warning</div></div><div><p>Critical content demanding immediate user attention due to potential risks.</p></div></div><div><div><div></div><div>Caution</div></div><div><p>Negative potential consequences of an action.</p></div></div><hr /><p>Github syntex and callouts ：</p><div><div><div></div><div>Tip</div></div><div><p><a href="https://github.com/orgs/community/discussions/16925" target="_blank">The GitHub syntax</a> is also supported.</p></div></div><p>Spoiler：刮刮乐（大雾）
The content is hidden <strong>ayyy</strong>!</p><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>The content :spoiler[is hidden </span><span>**ayyy**</span><span>]!</span></div></div></code></pre><div><div></div><div></div></div></figure></div><p>支持数学公式：<span><span>v=at+v0\mathbf{v}=\mathbf{a}t+\mathbf{v_0}</span><span><span><span></span><span>v</span><span></span><span>=</span><span></span></span><span><span></span><span>a</span><span>t</span><span></span><span>+</span><span></span></span><span><span></span><span><span>v</span><span><span><span><span><span><span></span><span><span>0</span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span></span></span></span></p><span><span><span>x=−b±b2−4ac2x=\frac{-b\pm \sqrt{b^2-4ac}}{2}</span><span><span><span></span><span>x</span><span></span><span>=</span><span></span></span><span><span></span><span><span></span><span><span><span><span><span><span></span><span><span>2</span></span></span><span><span></span><span></span></span><span><span></span><span><span>−</span><span>b</span><span></span><span>±</span><span></span><span><span><span><span><span><span></span><span><span><span>b</span><span><span><span><span><span><span></span><span><span>2</span></span></span></span></span></span></span></span><span></span><span>−</span><span></span><span>4</span><span>a</span><span>c</span></span></span><span><span></span><span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span></span></span></span><span>​</span></span><span><span><span></span></span></span></span></span><span></span></span></span></span></span></span><p>支持 mermaid 图表，不演示了。</p></section><section><h3>视频嵌入<a href="#视频嵌入"><span>#</span></a></h3><p>Just copy the embed code from YouTube or other platforms, and paste it in the markdown file as below</p><p>参照<a href="../videos/">视频嵌入</a></p><div><div><div><figure><figcaption></figcaption><pre><code><div><div><div>1</div></div><div><span>---</span></div></div><div><div><div>2</div></div><div><span>title</span><span>: </span><span>Include Video in the Post</span></div></div><div><div><div>3</div></div><div><span>published</span><span>: </span><span>2023-10-19</span></div></div><div><div><div>4</div></div><div><span>// ...</span></div></div><div><div><div>5</div></div><div><span>---</span></div></div><div><div><div>6</div></div><div>
</div></div><div><div><div>7</div></div><div><span>&lt;</span><span>iframe</span><span> </span><span>width</span><span>=</span><span>"100%"</span><span> </span><span>height</span><span>=</span><span>"468"</span><span> </span><span>src</span><span>=</span><span>"https://www.youtube.com/embed/yrn7eInApnc?si=gGZeFbPcfMpJ1uV3_"</span><span> </span><span>title</span><span>=</span><span>"YouTube video player"</span><span> </span><span>frameborder</span><span>=</span><span>"0"</span><span> </span><span>allowfullscreen</span><span>&gt;&lt;/</span><span>iframe</span><span>&gt;</span></div></div><div><div><div>8</div></div><div>
</div></div><div><div><div>9</div></div><div><span>Examples:</span></div></div><div><div><div>10</div></div><div>
</div></div><div><div><div>11</div></div><div><span>- youtube:</span></div></div><div><div><div>12</div></div><div><span>&lt;</span><span>iframe</span><span> </span><span>width</span><span>=</span><span>"100%"</span><span> </span><span>height</span><span>=</span><span>"468"</span><span> </span><span>src</span><span>=</span><span>"https://www.youtube.com/embed/yrn7eInApnc?si=gGZeFbPcfMpJ1uV3_"</span><span> </span><span>title</span><span>=</span><span>"YouTube video player"</span><span> </span><span>frameborder</span><span>=</span><span>"0"</span><span> </span><span>allow</span><span>=</span><span>"accelerometer; autoplay; clipboard-write; encrypted-media; gyroscope; picture-in-picture; web-share"</span><span> </span><span>allowfullscreen</span><span>&gt;&lt;/</span><span>iframe</span><span>&gt;</span></div></div><div><div><div>13</div></div><div>
</div></div><div><div><div>14</div></div><div><span>- bilibili:</span></div></div><div><div><div>15</div></div><div><span>&lt;</span><span>iframe</span><span> </span><span>width</span><span>=</span><span>"100%"</span><span> </span><span>height</span><span>=</span><span>"468"</span><span> </span><span>src</span><span>=</span><span>"//player.bilibili.com/player.html?bvid=BV14QpMeSEuD&amp;p=1&amp;autoplay=0"</span><span> </span><span>scrolling</span><span>=</span><span>"no"</span><span> </span><span>border</span><span>=</span><span>"0"</span><span> </span><span>frameborder</span><span>=</span><span>"no"</span><span> </span><span>framespacing</span><span>=</span><span>"0"</span><span> </span><span>allowfullscreen</span><span>=</span><span>"true"</span><span> </span><span>&amp;autoplay</span><span>=</span><span>0</span><span>&gt; &lt;/</span><span>iframe</span><span>&gt;</span></div></div></code></pre><div><div></div><div></div></div></figure><div></div></div><span>展开</span><span>收起</span></div></div></section></section>
<section><h2>其他内容<a href="#其他内容"><span>#</span></a></h2><p>翻文件夹吧… 写的好累… content 里面是博客内容，data 里面是其他的东西，比如友情链接。</p></section>
<section><h2>结语<a href="#结语"><span>#</span></a></h2><p>这个教程怎么写的和 csdn 一样难读，哎哎哎</p><p>最后祝大家新年快乐喵！ovo </p></section>]]></content>
    </entry>
</feed>
