Add做了什么

1
2
3
4
5

#输出=输入＋F(输入)
def residual_block(x):
    # x: 这一层的输入
    output = layer(x)  # 对x做点什么（注意力、前馈等）
    return x + output  # 加回去

为什么要这么做呢，这样做首先保留了原始输入x，哪怕学习效果不好，也保留了原始x可以让你撤回。其次每一层只需要学习”增量”（输入和理想输出之间的差值），而不是从零学习完整输出。比如从5->5.1,只需要输出0.1即可，小量更容易学习。
综上：**Add提高了训练稳定性（容错）**和学习效率

Add解决了什么

缓解[[梯度消失]]： 在反向传播时，梯度可以直接通过残差路径（加号）无损地流回浅层网络，确保深层参数也能得到有效的更新信号。

信息高速公路： 为模型提供了一条“捷径”，使得网络即使很深，浅层的信息也能相对容易地传递到深层，反之亦然。

模型更容易优化： 让网络更容易学习到一个恒等映射（即输出等于输入），这通常是深层网络一个不错的起点。如果子层需要做出改变，它只需要学习相对于输入的“残差”（Residual）即可。

Add在Transformer的应用

Batch Norm做了什么

对于一个批次里的多个样本，它们有相同的特征。但不同样本的同一个特征，数值范围可能差异很大。比如一个批次里有两个人，A年收入500万，B年收入5万。那么这两个样本传入网络时，年收入这个特征的数值范围波动剧烈，导致模型在批次之间来回调整，训练不稳定。

所以我们需要让同一个特征在不同样本之间的数值范围接近，对每个特征在批次维度上进行归一化，也就是让每个特征在当前批次上的均值为0、方差为1。

对比记忆：

• LayerNorm：对一个样本的所有特征做归一化（行内归一化）
• BatchNorm：对一个批次内的同一个特征做归一化（列内归一化）

BatchNorm解决了什么

它主要解决的是训练过程中的内部协变量偏移（ICS），但视角和LayerNorm不同。

1. 内部协变量偏移

首先你需要知道模型的训练过程：
前向传播 → 计算损失 → 反向传播 → 计算梯度 → 更新所有层的参数(W1,W2,W3…）

1
2
3
4
5
6
7
8
9
10
11
12
13

# 假设一个2层网络，批次大小为2
# 批次输入：两个样本
x = [[1, 100],   # 样本1：特征1=1，特征2=100
     [2, 50]]    # 样本2：特征1=2，特征2=50
# 第1步训练
W1 = [[0.1, 0.2]]  # 初始权重
h1 = x @ W1.T = [[0.1*1+0.2*100, 0.1*2+0.2*50]] = [[20.1, 10.2]]  # 输出范围正常
# 计算损失，更新W1（假设梯度让W1变大）
W1_new = [[0.5, 0.6]]
h1_new = x @ W1_new.T = [[0.5*1+0.6*100, 0.5*2+0.6*50]] = [[60.5, 31.0]]
# 第2层看到h1从[20.1, 10.2]变成[60.5, 31.0]
# 变化很大！而且两个样本的特征1和特征2之间的比例也变了
# 这就是BatchNorm要解决的第2层输入分布不稳定问题

我们知道模型训练过程中，参数会不断更新，导致每一层的输入分布也在变化。如果同一个特征在不同样本之间数值范围波动太大（比如年收入这个特征，有的样本是5万，有的是500万），那么：

• 梯度计算会被大数值样本主导：年收入500万的那个样本，它的梯度会远远大于年收入5万的样本，模型只关注“有钱人”，忽略了“普通人”的模式。
• 训练震荡：这个批次样本A（高收入）主导更新，下个批次样本B（低收入）主导更新，模型来回摇摆，难以收敛。

2. 对学习率更友好

没有BatchNorm时，你对学习率非常敏感：

• 学习率稍大：遇到大数值样本，一步跨太远，崩了
• 学习率稍小：遇到小数值样本，几乎不动- Batch Normalization（批量归一化） 是一种标准化技术，用于深度神经网络训练
  有了BatchNorm，每个特征的数值范围都被稳定在相似的尺度上，你可以用更大的学习率，训练更快更稳。

注意：BatchNorm主要解决的是批次内特征尺度不一致导致的训练不稳定，而不是直接解决梯度爆炸/消失（虽然它能缓解）。梯度爆炸/消失更多是网络深度和激活函数的问题。

BatchNorm的具体实现

前文提到，我们需要对每个特征在批次维度上进行归一化，也就是让这个特征在当前批次上的均值为0、方差为1。

公式：

其中：

• μ_B：当前批次上，某个特征的平均值

• σ_B^2：当前批次上，某个特征的方差

• γ和β：可学习的缩放和平移参数（和LayerNorm一样）

举个例子

假设一个批次有2个样本，每个样本有3个特征（年龄、年收入、步数）：

text

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

批次数据：
样本A: [25, 500000, 8000]
样本B: [35, 300000, 6000]

**对“年收入”这个特征进行BatchNorm**（其他特征同理）：

1. 计算这一列的均值：μ = (500000 + 300000) / 2 = 400000
    
2. 计算这一列的方差：σ² = ((500000-400000)² + (300000-400000)²) / 2 = (100000² + (-100000)²) / 2 = 10^10
    
3. 标准差：σ = 100000
    
4. 归一化：
    
    - 样本A的年收入：(500000 - 400000) / 100000 = 1
        
    - 样本B的年收入：(300000 - 400000) / 100000 = -1
        

经过BatchNorm处理后：

text

1
2

样本A: [年龄归一化后, 1, 步数归一化后]
样本B: [年龄归一化后, -1, 步数归一化后]

γ和β同样是可学习参数。如果网络发现原始分布更好，可以把γ=100000、β=400000学回来（还原原始值）；如果某种中间分布更好，也可以调整。

和[[LayerNorm]]的对比

用上面的例子：

• LayerNorm后：样本A自己的年龄、收入、步数三个数范围接近（比如[-0.7, 1.4, -0.7]）

• BatchNorm后：样本A和样本B的收入这两个数范围接近（比如[1, -1]）

这样下来你得到了什么？

1. 特征尺度统一：不同样本的同一个特征不再有量级差异。年收入500万和30万的人，在归一化后可能变成1和-0.5，处于同一数量级。高收入样本不再主导梯度。
2. 训练更稳定：每个批次输入给下一层的分布都大致相同（均值0、方差1），参数更新不再被批次间的数值波动干扰。
3. 可以使用更大的学习率：因为数值范围被控制住了，不用担心一步踩空。
4. 有一定正则化效果：因为每个批次的均值和方差都有微小波动，相当于给训练引入了噪声，可以防止过拟合（这也是为什么BatchNorm层后面通常不需要再加Dropout的原因之一）。

一个关键的注意事项

BatchNorm在训练和推理时的行为不同：

• 训练时：用当前批次的均值和方差
• 推理时：用训练过程中所有批次的移动平均（running average），因为推理时可能只有一个样本，没法算批次统计量

这是BatchNorm和LayerNorm的一个本质区别：LayerNorm不依赖批次大小，训练推理行为一致；BatchNorm依赖批次大小，且训练推理行为不同。

LayerNorm做了什么

对于一个样本的几个特征，也许他们的特征值分布太分散。比如一个人的年收入是10000000，但是他的身高体重是180cm和70kg。那么这个数据传递给下一个网络时，年收入的权重就会远远盖过身高体重等。让模型的训练只由某个特征主导。
所以我们需要让一个样本的特征值在数值范围上接近，对单个样本的所有特征进行归一化，也就是使其均值为0、方差为1。

LayNorm解决了什么

一般来说我们认为它解决了两个问题

1. -内部协变量偏移
   名词听起来很抽象，首先你需要知道模型的训练过程。
   前向传播 → 计算损失 → 反向传播 → 计算梯度 → 更新所有层的参数(W1,W2,W3…）

1
2
3
4
5
6
7
8
9
10
11
12
13
14

# 假设一个3层网络
x = [1, 2, 3]  # 输入
# 第1步训练
W1 = [[0.1, 0.2, 0.3]]  # 初始
h1 = [0.1*1+0.2*2+0.3*3] = [1.4]  # 输出范围正常
# 计算损失，更新W1（假设梯度让W1变大）
W1_new = [[0.5, 0.6, 0.7]]
h1_new = [0.5*1+0.6*2+0.7*3] = [0.5+1.2+2.1] = [3.8]  # 范围变大
# 第2层看到h1从1.4变成3.8（变化很大！）
# 这就是ICS：第2层的输入分布变了，而且范围变散了
# 这种范围变大会影响第2层的梯度计算
# 导致第2层的参数W2更新指向错误方向
# 然后W2又会让第3层看到更分散的数据...
# 恶性循环

我们知道模型训练过程中是参数是会不断更新的，以此来变化下一层的输入。那么如果有一个数值过于大，大的纬度就会主导梯度，其他维度被忽略。并且更新时由于过大过小，模型需要猛踩刹车或者猛踩油门，也就是w的变化会忽大忽小而不能做出有效调整。

2. 梯度消失与梯度爆炸
   前面提到，数据范围分散会导致更新时输出值过大过小，分别会导致梯度爆炸与消失
   • 梯度爆炸：数值范围层层放大（例如每层放大10倍），传递到输出层时已达天文数字。反向传播时，这些巨大数值相乘，导致梯度超过 float 32 表示范围，变成 inf（无穷大）。模型瞬间崩坏，Loss 直接变成 NaN。这就是你说的“超范围”。
   • 梯度消失：数值范围层层缩小（例如每层缩小到 0.1 倍），传递到输出层时已接近 0。反向传播时，多次乘以小于 1 的数，梯度变成 0。模型再也学不到任何东西，Loss 永远不降。

LayerNorm的具体实现

前文提到，我们需要对一个样本的每个特征进行归一化，也就是方差为1均值为0
公式：
![[Pasted image 20260507191827.png]]
例如一个样本如下：原始数据：[25, 500000, 8000]
μ≈169341.67
σ≈233,760
归一化后的值=x−μ/σ
经过 LayerNorm 处理后：[-0.724, 1.415, -0.690]
（公式里的 γ 和 β 是两个可学习的参数。网络训练时可以调整它们。
比如，假设网络学习到 γ=2,β=0.5γ=2,β=0.5，那么最终输出就是：

• −0.724×2+0.5=−0.948−0.724×2+0.5=−0.948
• 1.415×2+0.5=3.331.415×2+0.5=3.33
• −0.690×2+0.5=−0.88−0.690×2+0.5=−0.88
  这样网络就有了灵活性：如果原始分布是最好的，它可以把 γ=1,β=0γ=1,β=0 学回来；如果另一种分布更好，它可以调整。）

这样下来你得到了什么？

1. 范围接近了：原来的 25 和 500000 相差 2 万倍，现在 -0.724 和 1.415 相差只有 2 倍左右。收入高的特征不再“欺负”其他特征了。
2. 以0为中心：数据现在有正有负，大致分布在 -1 到 +1 之间。
3. 分布标准：这组新数据的均值是 0，标准差是 1。你可以快速验证一下：(−0.724+1.415−0.690)/3≈0(−0.724+1.415−0.690)/3≈0（均值0），离散程度也标准化了。

LayerNorm在Transformer里的运用

![[Pasted image 20260507193403.png|345]]
这是Transformer的解码器架构

[[Add]] & Norm层

它实际上由两个独立的操作组成：残差连接（Add） 和 层归一化（Layer Normalization, Norm）。这两个操作协同工作，极大地提升了 Transformer 的训练稳定性、收敛速度和最终性能。
Norm 操作接收来自 Add 的输出（原始输入 + 子层变换）。这个组合信号的分布可能会剧烈变化，尤其是在训练初期。LN 将其“拉回”到一个相对稳定（均值为0，方差为1）的分布，极大地减少了训练的不稳定性，显著加快了收敛速度。γ 和 β 让模型能自适应地调整这个分布。

2.2 与[[BatchNorm]]的对比

梯度消失：反向传播时，梯度随着网络层数加深而指数级衰减，逐渐趋近于 0，导致浅层（靠近输入层）的参数几乎不更新，模型学不到底层的特征。

二、具体是怎样发生的？

2.1 核心原因：也是连乘效应

和梯度爆炸一样，梯度消失也是链式法则连乘的结果。区别在于：

• 梯度爆炸：乘数都 > 1 → 越乘越大
• 梯度消失：乘数都 < 1 → 越乘越小

python

1
2
3
4

# 一个3层网络的梯度传播（和前一讲相同的形式）
∂loss/∂W₁ = ∂loss/∂h₃ · W₃ · ∂h₃/∂h₂ · W₂ · ∂h₂/∂h₁ · W₁ · ∂h₁/∂W₁
              ↑                              ↑
         从loss传来的初始梯度          每过一层就多乘一个数

如果每个乘数都小于 1，梯度就会指数级衰减到 0。

2.2 触发条件

2.3 数字演算（以 sigmoid 为例）

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

sigmoid 函数特性：
- 输出范围：(0, 1)
- 最大值处导数：σ'(0) = 0.25
- 饱和区（|x|>5）导数：≈ 0.00...

假设：
- 每层激活函数的导数 ≈ 0.25（乐观估计）
- 初始梯度（从 loss 传下来）= 1

经过第 1 层后：梯度 = 1 × 0.25 = 0.25
经过第 2 层后：梯度 = 0.25 × 0.25 = 0.0625
经过第 3 层后：梯度 = 0.0625 × 0.25 = 0.015625
...
经过第 10 层后：梯度 = 1 × 0.25^10 ≈ 9.5 × 10⁻⁷（不到百万分之一）
经过第 20 层后：梯度 = 1 × 0.25^20 ≈ 9.1 × 10⁻¹³（几乎为 0）

# 指数衰减，同样可怕

注意：sigmoid 的实际导数往往小于 0.25（因为大多数输入不在 0 附近），所以实际衰减比这个例子更快。

三、梯度消失会导致什么后果？

3.1 浅层参数不更新

python

1
2
3
4
5
6

# 以 10 层网络为例
第 10 层（靠近输出）：梯度 ≈ 1    → 参数正常更新 ✓
第 9 层：梯度 ≈ 0.25              → 参数更新变慢 ⚠️
第 8 层：梯度 ≈ 0.0625            → 几乎不动 ⚠️
第 7 层：梯度 ≈ 0.0156            → 基本不动 ❌
第 6 层及以下：梯度 ≈ 0.000...    → 完全不动 ❌

3.2 模型“学不动”了

• 深层（靠近输出）：勉强能学到一些东西，但因为没有浅层特征支撑，效果很差
• 浅层（靠近输入）：几乎没被训练，仍然是随机初始化的状态
• 整体效果：模型的 loss 下降极慢，或者卡在一个很高的值下不去

3.3 深层网络反而比浅层网络差

这是最反直觉的现象：

python

1
2
3
4
5
6

# 现象
20 层网络  <  10 层网络  <  5 层网络  （效果对比）

# 原因
不是过拟合，而是：20 层网络的浅层梯度已经消失了，有效层数可能只有 5 层左右
其余 15 层是“僵尸层”——既没学到东西，还增加了噪声

四、哪些场景特别容易发生梯度消失？

4.1 使用 sigmoid 或 tanh 激活函数

sigmoid 的导数最大值只有 0.25，连乘几层就消失了。这也是为什么现代深度学习几乎不用 sigmoid 作为隐藏层激活函数。

4.2 权重初始化太小

python

1
2
3
4
5

# 错误的初始化方式
W = torch.randn(512, 512) * 0.01   # 权重太小了！
# 每层输出方差 ≈ 0.0001，激活函数输入极小
# sigmoid(0.01) ≈ 0.5025，导数 ≈ 0.25（还好）
# 但 tanh(0.01) ≈ 0.01，导数 ≈ 0.9999（较安全）

4.3 网络层数过深

即使是 ReLU，没有残差连接的话，深层网络梯度消失风险也很大。因为：

• 如果某层激活函数输出为 0（ReLU 死亡），梯度就断了
• 权重的随机性可能导致部分层有效梯度 < 1

4.4 RNN 处理长序列

RNN 的时间步展开和深度网络类似。

• 梯度消失：RNN 记不住很久以前的信息（LSTM 部分解决）
• 梯度爆炸：RNN 在某个时间步突然崩溃（梯度裁剪解决）

五、如何解决？（重点）

5.1 使用 ReLU 及其变体（最关键）

python

1
2
3
4
5
6
7
8
9
10
11
12

# ReLU：最简单、最常用
def relu(x):
    return max(0, x)
# 导数为 1（当 x > 0）或 0（当 x < 0）
# 正区间梯度不衰减！

# 变体：LeakyReLU（解决了 ReLU 死亡问题）
def leaky_relu(x, alpha=0.01):
    return max(alpha * x, x)
# 负区间也有小梯度，神经元不会“死亡”

# 变体：ELU / GELU / Swish（各有优缺点）

ReLU 带来的问题：

• ReLU 死亡：如果输入始终为负，神经元输出恒为 0，梯度为 0，永远无法复活
• 解决方案：LeakyReLU、ELU、或更小的学习率 + 合理的初始化

5.2 残差连接（Add）

原理：让梯度有一条不经过任何权重乘法的直通路径。

python

1
2
3
4

# 残差块
def residual_block(x):
    output = layer(x)      # 对 x 做变换
    return x + output      # 输出 = 输入 + 变换

梯度传播时：

text

1
2
3
4
5
6

∂loss/∂x = ∂loss/∂output × ∂output/∂x
         = ∂loss/∂output × (1 + ∂layer/∂x)
         = ∂loss/∂output + ∂loss/∂output × ∂layer/∂x
                       ↑
                这条路径不经过 layer 的权重！
                梯度可以直接从 output 传到 x

效果：即使 ∂layer/∂x 的梯度消失为 0，∂loss/∂x 仍然有 ∂loss/∂output，不会消失。

5.3 使用 LayerNorm / BatchNorm

原理：把激活函数的输入稳定在非饱和区（比如均值 0、方差 1 附近），让导数保持在较大值。

python

1
2
3

# 以 sigmoid 为例
没有归一化时：x 可能很大（比如 10）→ sigmoid(10)≈1 → 导数≈0
有归一化后：x 被拉回 0 附近 → sigmoid(0)=0.5 → 导数≈0.25

5.4 合理的权重初始化（Xavier / Kaiming）

原理：让每层的输出方差保持为 1，输入信号不衰减。

python

1
2
3
4
5
6
7

# Xavier 初始化（适合 tanh / sigmoid）
nn.init.xavier_uniform_(W)
# 让 Var(output) = Var(input)

# Kaiming 初始化（适合 ReLU）
nn.init.kaiming_uniform_(W, nonlinearity='relu')
# 专门针对 ReLU 设计，考虑了 ReLU 会砍掉一半神经元

5.5 使用 LSTM / GRU（RNN 专用）

原理：引入门控机制（遗忘门、输入门、输出门），让梯度可以选择性地通过，不会在每个时间步都衰减。

python

1
2
3
4
5

# LSTM 的核心思想
# 有一条“细胞状态”高速公路，梯度可以在上面长时间保持
c_t = f_t * c_{t-1} + i_t * g_t
# f_t 是遗忘门（0~1），控制多少旧信息保留
# 如果 f_t 接近 1，梯度几乎不衰减

六、如何判断发生了梯度消失？

6.1 明显的信号

6.2 监控代码

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

# 训练循环中监控各层梯度的分布
for name, param in model.named_parameters():
    if param.grad is not None:
        grad_mean = param.grad.mean().item()
        grad_std = param.grad.std().item()
        print(f"{name}: mean={grad_mean:.2e}, std={grad_std:.2e}")

# 观察规律：
# 正常情况：浅层和深层的梯度量级相近
# 梯度消失：深层梯度 1e-3，浅层梯度 1e-8（差了 5 个数量级）

# 也可以可视化
import matplotlib.pyplot as plt

gradients = [p.grad.norm().item() for p in model.parameters()]
plt.plot(gradients)
plt.yscale('log')  # 对数坐标，更容易看出衰减趋势
plt.title('梯度范数分布（左：浅层，右：深层）')
plt.show()

七、梯度消失 vs 梯度爆炸：对比总结

梯度爆炸：反向传播时，梯度随着网络层数加深而指数级增长，变成天文数字（如 10^8 甚至 inf），导致参数更新步长巨大，模型直接崩溃。

二、具体是怎样发生的？

2.1 核心原因：连乘效应

反向传播时，梯度从输出层往输入层传播，每经过一层都要乘以该层权重的某种组合。如果这些乘数都大于1，梯度就会指数级膨胀。

python

1
2
3
4

# 一个3层网络的梯度传播（简化示意）
∂loss/∂W₁ = ∂loss/∂h₃ · W₃ · ∂h₃/∂h₂ · W₂ · ∂h₂/∂h₁ · W₁ · ∂h₁/∂W₁
              ↑                              ↑
         从loss传来的初始梯度          每过一层就多乘一个W

2.2 触发条件

2.3 数字演算

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14

假设：
- 每层权重的“尺度”约为 2
- 激活函数用 ReLU（导数恒为 1）
- 初始梯度（从 loss 传下来）= 1

经过第 1 层后：梯度 = 1 × 2 = 2
经过第 2 层后：梯度 = 2 × 2 = 4
经过第 3 层后：梯度 = 4 × 2 = 8
...
经过第 10 层后：梯度 = 1 × 2^10 = 1024
经过第 20 层后：梯度 = 1 × 2^20 ≈ 1,048,576（百万级）
经过第 30 层后：梯度 = 1 × 2^30 ≈ 1,073,741,824（十亿级）

# 指数增长，非常可怕

三、梯度爆炸会导致什么后果？

3.1 参数变成 NaN

python

1
2
3
4
5
6
7

# 正常的参数更新公式
w_new = w_old - learning_rate × gradient

# 假设 gradient = 1e9，learning_rate = 0.001
# 更新步长 = 1e9 × 0.001 = 1e6
# w_old 原本可能是 0.5，一步之后变成 1000000.5
# 下一轮前向传播，w × x 直接爆掉

3.2 Loss 变成 NaN（Not a Number）

因为参数数值巨大，前向传播时计算的中间值也会巨大。一旦超过浮点数表示范围（float32 上限约 3.4e38），就会变成 inf（无穷大）。inf 参与任何运算，结果都是 NaN。

3.3 模型无法恢复

一旦参数中出现 NaN，后续所有计算都是 NaN。模型永远回不到正常状态，训练必须中断并从头重启。

四、哪些场景特别容易发生梯度爆炸？

4.1 RNN / LSTM 处理长序列

RNN 在每个时间步使用同一个权重矩阵。如果这个矩阵的特征值大于 1，梯度经过 100 个时间步的反向传播，就会被放大 100 次方倍。

python

1
2
3
4

# RNN 的循环结构
h_t = tanh(W_h @ h_{t-1} + W_x @ x_t)
# 梯度从第100步传回第1步，需要乘100次 W_h
# 如果 W_h 的特征值 > 1 → 爆炸

这也是为什么后来有了 LSTM 和 GRU——它们用门控机制来缓解这个问题。

4.2 初始化权重过大

python

1
2
3

# 错误的初始化方式
W = torch.randn(512, 512) * 2   # 均值为0，标准差为2
# 每层输出范围放大2倍，梯度也随层数指数放大

4.3 层数过深且没有保护机制

Transformer 有 12~24 层，如果不用残差连接和层归一化，梯度爆炸风险很高。

五、如何解决？（重点）

5.1 梯度裁剪（最推荐）

原理：计算所有梯度的整体范数（可以理解为“梯度的总长度”），如果超过设定阈值，就按比例缩小，但保持方向不变。

python

1
2
3
4
5
6
7
8
9
10
11
12

# PyTorch 中的用法（只需一行代码）
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)

# 具体效果演示
原始梯度 = [0.5, 100, 0.3, 500]
计算整体范数 ≈ sqrt(0.5² + 100² + 0.3² + 500²) ≈ 506

max_norm = 1.0
缩放因子 = 1.0 / 506 ≈ 0.002

裁剪后 ≈ [0.001, 0.198, 0.0006, 0.988]
# 方向没变（比例关系保留），但整体大小被限制在1以内

优点：

• 直接有效，99% 的情况下能解决爆炸
• 计算成本极低（只多一步范数计算）
• 对训练速度影响微乎其微

缺点：

• 只是“压在合理范围”，没有解决爆炸的根源

5.2 合理的权重初始化

原理：让每层输出的方差保持为 1，避免信号和梯度指数放大。

python

1
2
3
4
5

# Xavier / Glorot 初始化（适合 tanh / sigmoid）
nn.init.xavier_uniform_(W)

# Kaiming / He 初始化（适合 ReLU）
nn.init.kaiming_uniform_(W, nonlinearity='relu')

效果：权重尺度约在 1 / √fan_in 左右，不会显著大于 1。

5.3 使用归一化层

LayerNorm（Transformer 用）和 BatchNorm（CNN 用）通过稳定每一层的数值范围，间接防止梯度爆炸。

5.4 使用残差连接

残差连接 output = x + F(x) 让梯度有一条直通路径：∂loss/∂x 可以直接从输出传到输入，不经过任何权重矩阵乘法。这条路径上的梯度不会爆炸。

六、如何判断发生了梯度爆炸？

6.1 明显的信号

6.2 监控代码

python

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

# 训练循环中加入梯度监控
for name, param in model.named_parameters():
    if param.grad is not None:
        grad_norm = param.grad.norm().item()
        if grad_norm > 100:
            print(f"⚠️ 梯度爆炸警告！{name}: {grad_norm}")
        elif grad_norm > 10:
            print(f"🔔 梯度偏大：{name}: {grad_norm}")

# 或者监控整体梯度范数
total_norm = 0
for p in model.parameters():
    if p.grad is not None:
        total_norm += p.grad.norm().item() ** 2
total_norm = total_norm ** 0.5
print(f"全局梯度范数: {total_norm}")  # 正常 <10，爆炸时 >1000

七、总结：一张表说清楚

信号量

要了解pv,首先要了解信号量。
人们为了实现进程同步互斥，为了机器知道运行状态（进程通常分为三个状态，就绪，运行，阻塞），定义了一个变量来表示系统种某种资源的数量。

• 如果信号量S>0，说明有资源可以使用
• 如果信号量S<0，说明有进程正在等待这个资源
• 如果信号量S=0，说明资源刚好用完，没有进程在等待
  那么如何改变信号量，就是PV操作了

定义理解

• p是申请占用一个资源，将信号量-1，如果信号量小于0，就进入阻塞，否则继续进行
• V是释放一个资源，将信号量+1，我理解为通知，因为释放一个资源后，如果有另一个等待该资源的进程，就可以通知他运行了。简答来说，释放是操作，通知是结果。

可以这么理解，当信号量的值为 2 的时候，表示有 2 个资源可以使用，当信号量的值为 -2 的时候，表示有两个进程正在等待使用这个资源。

如何实现互斥

总结一下：互斥等于进程共享一个初值为1的信号量，进入临界区前p一下，出来后v一下。

第一步：定义一个互斥信号量mutex

mutex是一个约定俗成的命名，看到就知道是用来做互斥保护临界区的。是 Mutex（Mutual Exclusion，互斥锁）的缩写

1

semaphore mutex=1//初始化互斥信号量

(semaphore表示信号量类型，有的教材写作 sem_t)
为什么mutex要初始化为1？
反过来想，初始化为0会发生什么？
第一个进程执行p(mutex)，s-1后s<0直接阻塞自己了

第二步：在临界区前后进行PV

也就是说把对临界资源的访问置于PV操作之间

1
2
3
4
5
6
7
8
9
10
11

semaphore mutex=-1;
p1(){
P(mutex);//申请占用资源
临界区
V(mutex);//释放资源
}
p2(){
P(mutex);
临界区
V(mutex);
}

也许你会疑惑p1p2不是重复的吗，但是这是一个重要思想
pv操作必须成对出现

如何实现同步

进程同步就是要各并发进程有序进行。比如司机售票员问题。需要售票员先关门，司机才能开车。而不能司机开车了售票员再关门。
同步 = 在先行进程里V一下（通知），在后行进程里P一下（等待），信号量初值0。

第一步：定义变量

1

semaphore event=0;

第二步：对每个对象进行思考

比如司机，需要进行开车停车，售票员则需要进行开门关门。关系为：
停车后->开门
关门后->开车
所以对于司机，他需要等待关门P,然后开车，车停后通知售票员开门V。
对于售票员，他需要通知司机可以启动V,然后等司机关门后停车P。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

司机() {
    while(1) {
        P(start);        //  等关门
        启动车辆();
        正常行驶();
        到站停车();
        V(open);         //  通知售票员：可以开门了
    }
}

售票员() {
    while(1) {
        关车门();
        V(start);        // 通知司机：可以启动了
        售票();
        P(open);         //  等停车
        开车门();
    }
}

为什么 V(start) 要放在 售票() 之前，而不是之后？
因为V 应该尽早发（条件满足就立刻发通知），不需要等把本进程所有事做完。
这样可以提高并发度。

PV实例题目

1.家人吃水果（同步）

题目

v桌上有一空盘，最多允许存放一只水果。爸爸可向盘中放一个苹果或放一个桔子，儿子专等吃盘中的桔子，女儿专等吃苹果。
试用P、V操作实现爸爸、儿子、女儿三个并发进程的同步。

思路

• 设置信号量表示不同操作对象的状态
• 思考每个主体需要做的事

这道题目来说，盘子有一个，盘子有三个状态（空盘，桔子，苹果）。那我设置三个信号量S,So，Sa，表示是否空盘。能否取桔子和苹果。
然后对于爸爸来说，他需要等盘子空（p(s)），然后放水果。如果是苹果就要通知女儿(V（Sa）)。反之亦然。
对于女儿来说，她需要等待苹果（p(Sa)），如果等到了她拿走，就要通知爸爸盘子空了(V(S))

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

semaphore S = 1;    // 空盘信号量（初值1：一开始是空盘）
semaphore So = 0;   // 桔子信号量（初值0：一开始没有桔子）
semaphore Sa = 0;   // 苹果信号量（初值0：一开始没有苹果）

// 爸爸进程
father() {
    while(1) {
        P(S);           // 等盘子空（盘子必须是空才能放）
        放水果();
        if (放的是桔子) {
            V(So);      // 通知儿子：有桔子了
        } else {
            V(Sa);      // 通知女儿：有苹果了
        }
    }
}

// 儿子进程
son() {
    while(1) {
        P(So);          // 等盘子里有桔子
        取桔子();
        V(S);           // 通知爸爸：盘子空了（因为桔子被取走了）
        吃桔子();
    }
}

// 女儿进程
daughter() {
    while(1) {
        P(Sa);          // 等盘子里有苹果
        
        取苹果();
        V(S);           // 通知爸爸：盘子空了（因为苹果被取走了）
        
        吃苹果();
    }
}

2.读者登记表（互斥）

题目

有一阅览室，读者进入时必须先在一张登记表上进行登记，该表为每一座位列一表目，包括座号和读者姓名。读者离开时要消掉登记信号，阅览室中共有100个座位，请写出算法。
注意：不是生产者-消费者关系，而是多个读者共享一个登记表，所以主要是互斥

思路

• 找出资源和约束定义变量
• 理出流程

资源是座位和登记表，约束是，没有空座不能进，登记表只能一个人用。所以seats用来计数（初始值100），mutex用来保护登记表（初始时置为1）。

流程为：读者进入，申请座位。如果有座位就登记，登记完释放。阅读走之后再登记，再释放，然后释放座位。

为什么不能先释放座位再登记？，其实可以，但这样更优雅。
如果先 V(seats) 再注销：

• 座位已经释放了，其他读者可能被唤醒并进来
• 但这个人还占着登记表在注销
• 新进来的读者在 P(mutex) 那里等
• 逻辑上没问题，但登记表被占用的时间变长了
  标准做法让登记表尽快释放。

代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

semaphore seats = 100;   // 空座位数
semaphore mutex = 1;     // 登记表互斥信号量
// 读者进程
reader() {
    while(1) {
        P(seats);        // 1. 申请座位（没空就等）
        P(mutex);        // 2. 申请登记表
        登记();           // 写信息
        V(mutex);        // 3. 释放登记表
        阅读();           // 4. 读书
        P(mutex);        // 5. 申请登记表
        注销();           // 删信息
        V(mutex);        // 6. 释放登记表
        V(seats);        // 7. 释放座位
    }
}

channal

对比

• 用PV操作，是自己在管理“等待”和“通知”的逻辑。
• 用Channel，是把数据交给通道，同步的逻辑由通道自动完成。
  可以将Channel理解为在更高编程语言层面，对PV操作和信号量机制的一种封装和升级。

channel 的两种主要同步模式

1. 同步（无缓冲）Channel：强制握手

这是最纯粹的“通道即同步”模式。在C++的CSP（Communicating Sequential Processes）库或类似实现中最为典型

• 核心机制：一个发送操作必须等到一个接收操作准备好，两者才会“相遇”（Rendezvous），完成数据传输。在此之前，双方都会阻塞等待
• 同步效果：它强制生产者和消费者在某一时刻同步，无需任何额外的锁或条件变量，就能保证“数据被发送”这一事件与“数据被接收”这一事件同时发生。
• 代码示例（概念性）：

1
2
3
4
5
6
7
8
9
10

// 伪代码，展示同步通道的行为
channel<int> sync_chan; // 假设这是一个同步（无缓冲）通道

// 线程 A (发送者)
sync_chan.send(42);     // 此处会阻塞，直到线程B准备好接收

// 线程 B (接收者)
int value = sync_chan.receive(); // 此处会阻塞，直到线程A发送数据
// 当线程A的send和线程B的receive都执行到对应行时，数据被原子地传递，
// 然后两个线程可以继续执行。

2. 异步（缓冲）Channel：解耦通信与同步

这种模式更侧重于通信，同步是作为队列满或空时的边界条件存在。

• 核心机制：通道内部有一个缓冲区。发送者将数据放入缓冲区，如果缓冲区没满，就立即返回，不会阻塞。接收者从缓冲区取数据，如果缓冲区不为空，也立即返回
• 同步效果：
  • 生产快于消费：当缓冲区满了，下一次send操作就会阻塞，直到消费者取走数据。此时，生产者被同步到消费者的进度上。
  • 消费快于生产：当缓冲区空了，下一次receive操作就会阻塞，直到生产者放入新数据。此时，消费者被同步到生产者的进度上。
• 代码示例（Boost.Fiber）：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#include <boost/fiber/buffered_channel.hpp>
#include <boost/fiber/fiber.hpp>
#include <iostream>

int main() {
    // 创建一个容量为2的缓冲通道
    boost::fibers::buffered_channel<int> chan{2};

    boost::fibers::fiber producer([&chan] {
        for (int i = 0; i < 5; ++i) {
            chan.push(i); // push 操作可能因为队列满而阻塞
            std::cout << "Produced: " << i << std::endl;
        }
        chan.close();
    });

    boost::fibers::fiber consumer([&chan] {
        int i;
        while (boost::fibers::channel_op_status::success == chan.pop(i)) {
            std::cout << "Consumed: " << i << std::endl;
            // pop 操作可能因为队列空而阻塞
        }
    });

    producer.join();
    consumer.join();

    return 0;
}

上一讲我们讲了操作系统的三大角色：

1. 裁判（Referee）

   管理资源、保护、隔离、权限，不让进程互相干扰。

2. 幻术师（Illusionist）

   把丑陋硬件变成干净、易用的虚拟资源（线程、地址空间、文件等）。

3. 粘合剂（Glue）

   提供统一服务（窗口、文件系统、网络），让写程序更简单。

老师强调：

同一个物理硬件上，可以同时运行多个进程，每个进程都以为自己独占整台机器。

进程之间禁止互相访问 / 修改对方状态，也不能非法修改操作系统或存储。

一旦违规 → 操作系统直接终止进程 → 段错误（segmentation fault）。

二、硬件为什么极度复杂？

老师用 Skylake 处理器架构 举例：

• CPU 直连高带宽 DRAM、高速显卡
• 通过 DMI 接口连接 PCH 芯片组（原南桥）
• 下面挂着：PCIe 高速设备、磁盘、USB、网口、音频、raid 等
• 再下层还有更低速的设备

结论：

硬件极其杂乱、多样、复杂 → 必须由操作系统来管理与抽象。

三、系统复杂度的直观体现：代码行数

• Linux 从 2.2 到 3.1，代码量增长 6 倍以上

• 现代汽车：约 1 亿行代码

• 设备驱动（第三方开发）是

  BUG 重灾区

  统计：超过

  50%~60% 的系统崩溃来自驱动程序

• 安全漏洞：Spectre、Meltdown（投机执行导致内核数据泄露）

老师核心观点：

操作系统的根本意义：抽象硬件、驯服复杂度。

四、操作系统如何 “化繁为简”？（核心抽象）

硬件太烂 → OS 换成更好用的虚拟概念：

• 物理 CPU → 线程（Thread）
• 物理内存（零散 DRAM）→ 地址空间（Address Space）
• 磁盘 / SSD 裸数据块 → 文件系统（File System）
• 原始网络包 → Socket 接口
• 裸机 → 进程（Process）

五、本节课正式内容：操作系统 四大基本概念（必考）

老师明确：今天讲 4 个 OS 最基础概念，全程围绕它们展开。

概念一：线程（Thread）— 执行流

1. 线程是什么？

线程 = 一个独立的执行上下文（execution context）

包含：

• 程序计数器（PC）
• 寄存器集合
• 执行标志（flags）
• 栈（stack）
• 相关内存状态

2. 线程 = 虚拟化的 CPU（核心）

你在 61C 学的是物理 CPU 的取指执行。

OS 把它虚拟化 → 变成线程。

3. 常驻（resident）是什么意思？

当线程的 上下文在 CPU 寄存器里，它就是正在运行、常驻的。

一个核（core）同一时刻只能有一个线程常驻。

4. 线程挂起（suspended）

• 上下文不在寄存器里
• 被保存到内存中的 TCB（Thread Control Block，线程控制块）
• 程序计数器不再指向它

5. 多线程 “并发” 幻觉怎么实现？

单 CPU = 时分多路复用（time multiplexing）

• 运行线程 A 一小会儿
• 切换
• 运行线程 B 一小会儿
• 切换
• 运行线程 C…

因为切换极快 → 人感觉 “同时运行”。

6. 上下文切换（context switch）做什么？

1. 把当前线程所有寄存器、PC、栈指针保存到内存 TCB
2. 加载下一个线程的上下文到 CPU
3. 开始执行新线程

切换耗时：几微秒

不能切换太快，否则大部分时间都在切换（颠簸 /thrashing）。

概念二：地址空间（Address Space）

1. 定义

地址空间 = 程序可访问的所有地址集合 + 对应状态

例：32 位地址空间

0 ~ 0xFFFFFFFF（约 4GB）

2. 地址空间内部布局

• 代码段（text/code）：指令
• 静态数据段（data）：全局变量、静态变量、字符串常量
• 栈（stack）：局部变量、函数调用
• 堆（heap）：malloc 分配的内存

3. 早期简单保护：基址 + 界限（Base + Bound）

最早的硬件保护方案：

• 两个寄存器：基址、界限
• 程序只能访问 [base, bound] 之间的内存
• 访问越界 → 直接报错

优点：简单、硬件成本低

缺点：扩展麻烦、会产生内存碎片

4. 进阶：地址翻译（虚拟内存）

后面课程重点：

把程序使用的 虚拟地址 → 页表翻译 → 物理地址

• 无碎片
• 可以离散存放
• 可以置换到磁盘
• 可以隔离保护

概念三：进程（Process）— 本讲最重要

1. 进程是什么？

进程 = 带权限限制的执行环境

= 保护后的地址空间 + 一个或多个线程 + 文件等资源

2. 为什么需要进程？

早期只有线程：

• 所有线程共享同一份地址空间
• 一个线程崩溃 → 全盘崩溃
• 线程可互相改写内存、窃取数据
• 线程可以改写操作系统 → 系统直接挂掉

进程 = 隔离 + 保护 + 权限

3. 进程核心特性

• 每个进程有独立地址空间
• 进程之间无法互相访问
• 一个进程崩了 → 不影响其他
• OS 受保护，不会被随意破坏

4. 进程 vs 线程（老师反复强调）

• 进程：资源容器、保护单位（地址空间、文件、权限）
• 线程：执行单位、活跃单位（PC、寄存器、栈）
• 一个进程至少有一个线程
• 同一进程内的线程共享地址空间
• 不同进程完全隔离

概念四：双重模式（Dual Mode）— 安全基石

1. 处理器至少两种模式：

1. 内核模式（Kernel Mode / Supervisor）

   • 全权访问所有资源
   • 可以修改页表、关中断、操作硬件

2. 用户模式（User Mode）

   • 权限受限
   • 不能修改页表
   • 不能关中断
   • 不能直接访问硬件

2. 为什么需要双模式？

防止用户程序：

• 霸占 CPU（死循环不放手）
• 破坏操作系统
• 访问别的进程数据
• 随意操控硬件

3. 如何进入内核模式？（仅三种合法入口）

1. 系统调用（system call）：进程主动请求服务
2. 中断（interrupt）：时钟、磁盘、网络等事件
3. 异常 / 陷阱（exception/trap）：除零、缺页、非法访问

→ 所有入口都由操作系统严格控制。

六、完整运行模型（老师最终总结图）

1. 程序从磁盘加载

2. 操作系统创建

   进程

   • 分配独立地址空间
   • 建立页表
   • 分配栈、堆

3. 从入口开始执行，运行在用户模式

4. 需要服务 → 系统调用 → 进入内核模式

5. 内核完成操作，返回用户态

6. 时钟中断触发 → 操作系统切换进程

七、本节课所有管理与作业提醒（全覆盖）

• 作业 0（Homework 0）：立刻开始，熟悉工具、GDB、编译、虚拟机
• Project 0：明天发布，独立完成，不许合作
• 项目缓交天数（slip days）：作业与项目共用 4 天
• 本周五是 退课截止日期（drop date）
• 可选 C/C++ 复习课：明天举行
• 课程全程使用 C 语言，项目在 Pintos 操作系统上开发

八、老师强调的易错点（必看）

1. 线程不自带缓存，一个核的缓存被所有线程共享
2. 线程不在 CPU 运行时，状态存在 TCB（内存里）
3. 进程 = 保护单位；线程 = 执行单位
4. 没有地址翻译 + 双模式 → 系统完全不安全
5. 早期系统（Win3.1、Mac 早期）无强保护 → 极易崩溃
6. 上下文切换需要保存与恢复 全部寄存器

九、本讲最终结论（老师原话总结）

现代操作系统建立在 四大基本概念 之上：

1. 线程（Thread）：执行流、虚拟化 CPU
2. 地址空间（Address Space）：内存视图
3. 进程（Process）：受保护的执行环境
4. 双重模式（Dual Mode）：内核态 / 用户态，安全基础

它们一起实现：虚拟化、隔离、保护、并发。

本文通过b站视频字幕整理

一、本章整体内容框架

1. 基础概念：网络 → 计算机网络 → Internet
2. 核心要素：协议（Protocol）
3. 网络三大组成：网络边缘、接入网、核心网
4. 核心交换：线路交换、分组交换
5. 网络结构：网络的网络（ISP 层次）
6. 性能指标：丢包、延迟、吞吐量
7. 核心思想：分层体系结构
8. 拓展：Internet 发展历史

二、基础概念：从网络到互联网

1. 网络（通用定义）

• 本质：节点 + 边 构成的拓扑关系
• 与大小、形状无关，只看连接关系
• 例子：电话网、社交网、蜘蛛网、神经网络

2. 计算机网络

• 定义：联网的计算机构成的系统

• 两类节点

  • 主机节点（端系统 / Host）

    ：数据的源与目标

    • PC、手机、平板、服务器、IoT 设备

  • 数据交换节点

    ：只转发，不产生 / 不消费数据

    • 交换机（链路层）、路由器（网络层）、负载均衡设备

• 两类链路

  • 接入链路：主机 ↔ 交换节点
  • 骨干链路：交换节点 ↔ 交换节点

3. Internet（互联网）

• 定义：以 TCP/IP 协议族 为核心，由大量网络通过路由器互联而成的 网络的网络
• 区分
  • 大写 Internet：全球公用互联网
  • 小写 internet：企业 / 内网（私网）
• 特点：长期迭代、全球共建、极度复杂、高度开放

三、核心要素：协议（Protocol）

1. 协议是什么

• 对等层实体在通信时必须遵守的规则集合
• 是网络设备能互通的根本保证

2. 协议三要素

1. 语法：报文格式、长度、字段结构
2. 语义：字段含义、代表什么意义、做什么动作
3. 时序：通信顺序、触发条件、先后逻辑

3. 协议的作用

• 实现互操作性：不同厂商设备可以互通
• 标准来源：IETF → RFC 文档（开放、公开）

4. 典型协议

• 网络层：IP
• 传输层：TCP、UDP
• 应用层：HTTP、DNS 等

四、网络核心思想：分层体系结构

1. 为什么分层

• 把复杂问题拆解，每层只做一件事
• 下层为上层提供服务，上层依赖下层

2. 五层核心作用（极简理解）

1. 物理层
   • 传信号：电磁波、光信号
2. 数据链路层
   • 相邻节点点到点传输（帧）
3. 网络层
   • 主机 ↔ 主机端到端传输
   • IP：尽力而为、不可靠
4. 传输层
   • 进程 ↔ 进程通信
   • TCP：可靠；UDP：无连接、快
5. 应用层
   • 实现具体应用：网页、游戏、支付、直播、文件传输

3. 分层思想总结

• 下层支撑上层
• 对等层用协议通信
• 逐层增强服务、逐步靠近应用

六、互联网的两种理解视角

1. 构成视角（硬件 + 协议）

• 主机、交换设备、链路、协议
• 由无数网络互联而成：网络的网络

2. 服务视角（应用 + 基础设施）

• 分布式应用进程：网络存在的目的
• 通信基础设施：为应用提供服务
• 接口：Socket API
• 服务类型
  • 面向连接：TCP
  • 无连接：UDP

七、必须掌握的核心思想

1. 网络 = 节点 + 边
2. 计算机网络 = 主机 + 交换节点 + 链路 + 协议
3. Internet = 网络的网络，以 TCP/IP 为核心
4. 协议 = 通信规则，是互通的基础
5. 分层 = 拆解复杂网络的唯一正确思路
6. 网络为应用服务，应用是网络的价值

这里推荐两个资源

【CS162精翻·英文原声】伯克利大学《计算机操作系统》(2020)_哔哩哔哩_bilibili

UCB CS162 操作系统笔记（一）-CSDN博客

这个CSDN上的笔记是所有字幕整理成了文字，我习惯先阅读我要学习的部分，然后再去看一遍视频，接着做笔记的时候再次阅读（仅供参考）

总课程有二十五章，每章约90min左右，当然我想想要吃透是需要3h的。我会在一月内尽量完成这门课的学习。（立flag）

一、时延引入：操作系统是系统运行的核心

课程开篇通过经典的Jeff Dean计算机时延对照表，直观展现不同硬件操作的时间量级差异，从纳秒级的缓存访问到毫秒级的跨洋网络传输，时间跨度极大。而能让这些差异巨大的硬件协同工作、支撑上层应用稳定运行的关键，就是操作系统。

[!NOTE]

核心结论：没有操作系统，无法高效、安全地使用硬件资源；操作系统为应用和程序员屏蔽硬件差异，提供统一抽象接口，是连接应用与硬件的关键中间层。

经典计算机时延对照表

操作系统的核心作用：管理多应用间的资源共享，处理系统安全问题，本学期核心学习的构建模块包括进程、线程、并发、调度、协调、地址空间、保护与安全等。

二、日常案例：手机搜索背后的系统逻辑

通过日常手机搜索场景，直观展现操作系统核心模块的实际落地与协同，理解系统底层组件的整合逻辑：

完整流程：手机发起搜索 → 连接DNS服务 → 解析域名获取IP → 访问对应数据中心 → 负载均衡器分配后端服务器 → 服务器执行搜索、生成结果与广告 → 结果原路返回手机

1. DNS（域名系统）详解

定义：Domain Name System，全球分布式、层级化的域名解析系统，核心功能是将人类可读的域名（如baidu.com），翻译为计算机可识别的IP地址，实现域名与IP地址的相互转换。

• 层级架构：树状结构，分为根域名服务器、顶级域服务器（com/cn/org）、权威域名服务器，每层仅负责自身管辖范围，不存储全量数据
• 分布式特性：无单台服务器存储全球所有域名，每台服务器仅负责局部数据，查询时逐级请求
• 缓存机制：解析结果会缓存，TTL（过期时间）控制缓存时效，大幅提升解析速度，是DNS高性能的关键
• 网络协议：默认使用UDP 53端口，速度快、无连接，适合小型查询；大型请求切换为TCP协议

2. 负载均衡器（LB）详解

定义：Load Balancer，数据中心入口的流量调度组件，相当于网络流量的交通警察。

• 核心作用：将用户请求均匀分发至多台后端服务器，避免单台服务器过载，实现高并发承载与高可用
• 工作逻辑：检测后端服务器负载状态，选择空闲服务器转发请求，服务器处理完成后，将结果回传给用户

延伸问题：DNS服务器的一致性与安全性

1. 多DNS服务器如何保持数据一致？ 采用树形层级架构，每层仅管理自身权限范围内的数据；域名更新时，先修改权威服务器，再逐级向上通知刷新；依靠TTL缓存过期机制，实现最终一致性，无需实时强同步，兼顾效率与稳定性。
2. 为什么难以入侵DNS系统？ 物理层面：服务器全球分散部署，跨国家、跨运营商，无法同时攻破；逻辑层面：层级隔离，单台服务器被入侵仅影响局部数据；技术层面：默认53端口严格管控，配合TSIG事务签名、DNSSEC数字签名，防止数据伪造与劫持。

三、操作系统的定义

目前操作系统无统一公认的定义，课程中给出核心界定：

操作系统包含内核（Kernel）与配套程序，其中内核是计算机中始终运行的核心程序，其余内容要么是随系统发布的系统程序，要么是用户使用的应用程序。

四、拆解“操作”与“系统”

1. 什么是系统（System）

系统由多个相互关联的硬件部件组成，部件之间相互交互、相互依赖；系统追求鲁棒性（Robustness），需要具备完善的错误处理机制，防范恶意操作与误操作，正视硬件的局限性与故障风险，并非简单的硬件拼接。

2. 什么是操作（Operating）

“操作”核心是对系统资源的管控，包含三大核心：

• 资源共享：协调多应用竞争CPU、内存、磁盘、网络等硬件资源
• 隔离与保护：实现进程间的权限隔离，单个程序崩溃不影响整个系统，防止非法访问
• 多路复用/并发：单CPU硬件基础上，通过快速切换任务，实现多任务同时运行的效果

3. 硬件与软件的接口：虚拟化核心

硬件与软件的接口问题，本质就是虚拟化问题。上层应用直接运行在复杂杂乱的硬件上，无法实现受控、安全、统一的访问，课程默认学习者已完成CS61C学习，掌握计算机硬件基础组成：

• 处理器（CPU）：包含寄存器，可存储数据、内存地址，支持进程切换时的状态保存与恢复
• 内存：存储各类数据，部分内存专属操作系统使用，不同区域对应不同进程，实现进程隔离
• 缓存：位于CPU与内存之间，加速数据访问，提升系统处理速度
• 页表：实现虚拟地址到物理地址的转换，支撑虚拟内存功能
• 外部设备：存储设备、网络设备、显示器、GPU等，通过总线与控制器连接，实现硬件协同

硬件本身复杂度极高，指令集架构（ISA）仅提供基础标准化，仍无法满足便捷编程的需求，操作系统的核心价值，就是将底层硬件细节全部抽象，提供干净的边界与虚拟化视图，大幅降低应用编程难度。

五、操作系统的核心：抽象与虚拟化（幻觉性质）

操作系统最核心的特性是幻觉性质（Illusion），即通过虚拟化技术，为上层应用提供硬件本身不存在、却简洁易用的抽象接口，让应用误以为独占硬件资源，无需关注底层硬件的复杂性。

1. 核心抽象内容（硬件中不存在，由操作系统创造）

• 线程：虚拟化CPU，将单个物理CPU转化为多个可独立运行的执行单元，实现并发
• 地址空间（虚拟内存）：虚拟化物理内存，为每个进程提供独立、连续、受保护的内存视图，营造“无限内存”的幻觉
• 文件：虚拟化磁盘块，将硬件层面零散的存储块，封装为易用的文件与目录，实现持久化存储
• 用户与权限：创造用户概念，实现系统权限管控，保障系统安全
• 套接字/消息队列：虚拟化网络传输，将不可靠的网络数据包，转化为可靠、有序的通信接口

2. 虚拟化模型

操作系统运行在硬件之上，作为核心中间层，将底层杂乱的硬件资源，转化为标准化、易用的运行环境，应用程序不直接接触硬件，仅与操作系统提供的抽象交互。

六、关键概念：程序与进程

1. 进程的定义

进程是操作系统提供的、具备受限权限的执行环境，相当于一个干净的运行容器，是应用程序实际运行的载体，也是操作系统虚拟化的核心产物。

2. 进程包含的核心内容

• 独立的地址空间（受保护的内存块）
• 一个或多个线程（执行单元）
• 打开的文件、网络套接字

3. 程序与进程的区别

• 程序：磁盘上存储的二进制代码文件，是静态、未运行的状态
• 进程：程序被实例化、加载运行后的动态状态，是操作系统分配资源的基本单位

核心结论：应用程序感知到的“机器”，并非真实物理硬件，而是操作系统提供的进程抽象；每个运行的程序对应独立进程，进程提供的接口远比原始硬件简洁易用。

七、操作系统的三大核心角色（必考）

1. 裁判（Referee）

作为系统资源的管理者，负责CPU、内存、设备等资源的分配与调度，实现进程间的隔离、保护与公平竞争，处理权限与安全问题，避免资源争抢与系统崩溃。

2. 幻术师/抽象大师（Illusionist）

通过虚拟化技术，为应用制造独占硬件、资源无限的幻觉，屏蔽硬件差异与底层细节，提供进程、线程、地址空间、文件等高层抽象，让编程更简单。

3. 粘合剂（Glue）

作为软硬件生态的连接层，提供统一的存储、网络、设备访问接口，将零散的硬件、驱动、应用粘合在一起，实现跨硬件、跨平台的兼容运行。

第一讲核心总结

1. 操作系统是硬件与应用之间的中间层，核心是虚拟化+抽象，解决硬件复杂性问题
2. 内核是操作系统始终运行的核心，负责资源管理与抽象提供
3. 进程是应用运行的核心载体，程序是静态代码，进程是动态运行实例
4. 操作系统兼具裁判、幻术师、粘合剂三大角色，实现资源共享、隔离保护、便捷编程三大目标

接下来我会把题目按照三个等级整理，L1,L2,L3

L1

L1-5 这是字符串题

其实就是一个映射题目啦，第一个输入用string读入，第二个输入对应的是第i个字母的美观值。那直接用一个数组存。要求计算第i个小写字母出现了多少次，用一个数组来计数，把字母映射为字母的数字顺序（s[i]-‘a’+1）。得分就是两个映射，先映射为数字，再用美观值数组映射美观值。代码附上

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#include <bits/stdc++.h>
using namespace std;
int ch[10000];
int ans[10000];
void solve()
{
    string s;
    int sum = 0;
    cin >> s;
    for (int i = 1; i <= 26; i++) {
        int x;
        cin >> x;
        ch[i] = x;
    }
    for (int i = 0; i < s.size(); i++) {
        sum += ch[s[i] - 'a' + 1];
        ans[s[i] - 'a' + 1]++;
    }
    for (int i = 1; i <= 26; i++) {
        if(i==26){
            cout <<ans[i];
        }
        else{
           cout << ans[i] << " "; 
        }
        
    }
    cout << endl
         << sum;
}

int main()
{
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    solve();
    return 0;
}

L1-7 大幂数

当你试图寻找某些规律时，就会发现没有规律，所以这道题只能枚举了。暴力呢，也要有策略的暴力，这道题是有两个变量的，底数个数和幂k。因为k越大，枚举项数越小，而且k有上限31，所以从31开始从大到小遍历。如果内层遍历项数的循环大于所给数了，break掉这层循环开始尝试下一个k。

但是这里涉及时间的问题，是的我们需要用到快速幂。

补一下快速幂模板，这是原理

这是代码

1
2
3
4
5
6
7
8
9
10
11

long long fast_pow(long long base, int exp)
{
    long long result = 1;
    while (exp > 0) {
        if (exp & 1)
            result *= base;
        base *= base;
        exp >>= 1;
    }
    return result;
}

但是呢你用这个写就会wa。为什么呢

• i=100, k=10 → 100^10 ≈ 10^20，已经超过 long long 最大值。

但我们真正关心的是：i^k 是否已经超过 n。如果 i^k > n，那么 sum = 1^k + 2^k + ... + i^k 一定大于 n（因为所有项都是正数），所以我们可以提前停止循环，不需要继续计算更大的 i。

所以我们进行一个剪枝

1
2
3
4
5
6
7
8
9
10
11

long long safe_pow(long long base, int exp, long long limit)
{
    long long result = 1;
    for (int i = 0; i < exp; ++i) {
        if (limit / base < result) {
            return limit + 1;   // 表示幂结果已经超过 limit
        }
        result *= base;
    }
    return result;
}

ok，附上完整代码

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49

#include <bits/stdc++.h>
using namespace std;

long long safe_pow(long long base, int exp, long long limit)
{
    long long result = 1;
    for (int i = 0; i < exp; ++i) {
        if (limit / base < result) {
            return limit + 1;   // 表示幂结果已经超过 limit
        }
        result *= base;
    }
    return result;
}

void solve()
{
    long long n;
    cin >> n;

    for (int k = 30; k >= 1; k--) {
        long long sum = 0;

        for (int i = 1;; i++) {
            long long power = safe_pow(i, k, n);
            sum += power;

            if (sum == n) {
                for (int j = 1; j <= i; j++) {
                    if (j > 1) cout << "+";
                    cout << j << "^" << k;
                }
                cout << endl;
                return;
            }

            if (sum > n || power > n) {
                break;
            }
        }
    }
    cout << "Impossible for " << n << "." << endl;
}

int main()
{
    solve();
    return 0;
}

L1-8 现代战争

嗯一道语法题

1. 数据结构设计
   • 使用结构体数组存储每个建筑的位置和价值
   • 使用row和col数组标记被炸掉的行和列
2. 核心算法流程
   • 读取地图数据，同时将所有建筑信息存入结构体数组
   • 按建筑价值排序（从小到大）
   • 从大到小选择k个未被炸掉的最高价值建筑进行轰炸
   • 输出剩余的行和列组成的缩小后地图

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79

#include <iostream>
#include <algorithm>
#include <cstring>
 
using namespace std;
 
struct node
{
int x;
int y;
int w;
}nodes[ 1000005 ];
 
int mp[ 1005 ][ 1005 ];
int row[ 1005 ];
int col[ 1005 ];
 
int cmp( node a, node b )
{
return a.w < b.w;
}
 
int n, m, k;
int length = 0;
 
int main ( )
{
memset( row, 0, sizeof ( row ) );
memset( col, 0, sizeof ( col ) );
cin >> n >> m >> k;
 
for ( int i = 0; i < n; ++ i )
{
for ( int j = 0; j < m; ++ j )
{
cin >> mp[ i ][ j ];
nodes[ length ].x = i;
nodes[ length ].y = j;
nodes[ length ].w = mp[ i ][ j ];
++ length;
}
}
sort ( nodes, nodes + length, cmp );
 
int x, y;
while ( k )
{
-- length;
x = nodes[ length ].x;
y = nodes[ length ].y;
if ( row[ x ] || col[ y ] )
continue;
++ row[ x ];
++ col[ y ];
-- k;
}
    int flag;
for ( int i = 0; i < n; ++ i )
{
if ( row[ i ] )
continue;
        flag = 1;
for ( int j = 0; j < m; ++ j )
{
if ( col[ j ] )
continue;
            if ( flag )
            {
                cout << mp[ i ][ j ];
                flag = 0;
            }
            else
                cout << " "<< mp[ i ][ j ];
}
cout << endl;
}
 
return 0;
}

map用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249

#include <bits/stdc++.h>
using namespace std;

// 1. 不同的定义方式
void map_definition() {
    // 默认升序 map (按键从小到大)
    map<int, string> m1;
    
    // 降序 map (按键从大到小)
    map<int, string, greater<int>> m2;
    
    // 自定义排序规则
    struct cmp {
        bool operator()(int a, int b) const {
            return a % 10 < b % 10;  // 按个位数排序
        }
    };
    map<int, string, cmp> m3;
}

// 2. 插入元素
void map_insert() {
    map<int, string> m;
    
    // 方法1: 使用 [] 操作符 (如果键不存在则创建，存在则修改)
    m[1] = "one";
    m[2] = "two";
    m[1] = "ONE";  // 修改键1的值
    
    // 方法2: 使用 insert (如果键已存在则插入失败)
    m.insert({3, "three"});
    m.insert(pair<int, string>(4, "four"));
    m.insert(make_pair(5, "five"));
    
    // 方法3: 批量插入
    vector<pair<int, string>> v = {{6, "six"}, {7, "seven"}};
    m.insert(v.begin(), v.end());
}

// 3. 访问元素
void map_access() {
    map<int, string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
    
    // 方法1: 使用 [] (如果键不存在会创建)
    string s1 = m[1];  // s1 = "one"
    string s2 = m[4];  // 键4不存在，创建空字符串
    
    // 方法2: 使用 at (如果键不存在会抛出异常)
    try {
        string s3 = m.at(2);  // s3 = "two"
        string s4 = m.at(5);  // 抛出 out_of_range 异常
    } catch (const out_of_range& e) {
        cout << "键不存在" << endl;
    }
    
    // 方法3: 使用 find (安全访问，不创建新元素)
    auto it = m.find(3);
    if (it != m.end()) {
        cout << "找到: " << it->first << " -> " << it->second << endl;
    }
}

// 4. 遍历元素
void map_traversal() {
    map<int, string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
    
    // 方法1: 范围for循环 (C++11)
    for (const auto& p : m) {
        cout << p.first << " : " << p.second << endl;
    }
    
    // 方法2: 迭代器遍历
    for (auto it = m.begin(); it != m.end(); ++it) {
        cout << it->first << " : " << it->second << endl;
    }
    
    // 方法3: 反向遍历 (从大到小)
    for (auto it = m.rbegin(); it != m.rend(); ++it) {
        cout << it->first << " : " << it->second << endl;
    }
}

// 5. 删除元素
void map_erase() {
    map<int, string> m = {{1, "one"}, {2, "two"}, {3, "three"}, {4, "four"}};
    
    // 方法1: 按键删除
    m.erase(2);  // 删除键为2的元素
    
    // 方法2: 用迭代器删除
    auto it = m.find(3);
    if (it != m.end()) {
        m.erase(it);  // 删除迭代器指向的元素
    }
    
    // 方法3: 删除范围内的元素
    auto start = m.find(1);
    auto end = m.find(4);
    if (start != m.end() && end != m.end()) {
        m.erase(start, end);  // 删除从start到end(不包括end)的元素
    }
    
    // 方法4: 清空所有元素
    m.clear();  // 删除所有元素
}

// 6. 查找和统计
void map_find() {
    map<int, string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
    
    // find: 查找键，返回迭代器
    auto it = m.find(2);
    if (it != m.end()) {
        cout << "找到键2，值为: " << it->second << endl;
    } else {
        cout << "未找到键2" << endl;
    }
    
    // count: 统计键出现的次数 (对于map只能是0或1)
    if (m.count(3)) {
        cout << "键3存在" << endl;
    }
    
    // lower_bound: 返回第一个键 >= 给定键的迭代器
    auto lb = m.lower_bound(2);  // 指向键2
    
    // upper_bound: 返回第一个键 > 给定键的迭代器
    auto ub = m.upper_bound(2);  // 指向键3
    
    // equal_range: 返回一对迭代器，表示键等于给定值的范围
    auto range = m.equal_range(2);
    // range.first 指向键2，range.second 指向键3
}

// 7. 大小和容量
void map_capacity() {
    map<int, string> m = {{1, "one"}, {2, "two"}, {3, "three"}};
    
    cout << "大小: " << m.size() << endl;        // 3
    cout << "是否为空: " << m.empty() << endl;   // 0 (false)
    cout << "最大容量: " << m.max_size() << endl;
}

// 8. 交换和比较
void map_swap_compare() {
    map<int, string> m1 = {{1, "one"}, {2, "two"}};
    map<int, string> m2 = {{3, "three"}, {4, "four"}};
    
    // 交换两个map的内容
    m1.swap(m2);
    
    // map的比较 (按键的顺序)
    if (m1 < m2) {
        cout << "m1 < m2" << endl;
    }
}

// 9. 自定义类型作为键
struct Student {
    string name;
    int id;
    
    // 需要定义比较运算符
    bool operator<(const Student& other) const {
        if (name != other.name) return name < other.name;
        return id < other.id;
    }
};

void map_custom_key() {
    map<Student, int> scores;
    scores[{"Alice", 1001}] = 95;
    scores[{"Bob", 1002}] = 87;
}

// 10. multimap (允许重复键)
void multimap_example() {
    multimap<int, string> mm;
    
    // 插入 (允许重复键)
    mm.insert({1, "one"});
    mm.insert({1, "uno"});
    mm.insert({2, "two"});
    
    // 遍历指定键的所有值
    auto range = mm.equal_range(1);
    for (auto it = range.first; it != range.second; ++it) {
        cout << it->second << endl;  // 输出: one, uno
    }
    
    // count 可能大于1
    cout << "键1出现次数: " << mm.count(1) << endl;  // 2
}

// 11. unordered_map (哈希表，无序，更快)
void unordered_map_example() {
    unordered_map<int, string> um;
    
    // 基本操作和map类似，但元素无序
    um[1] = "one";
    um[2] = "two";
    um[3] = "three";
    
    // 遍历顺序不保证
    for (const auto& p : um) {
        cout << p.first << " : " << p.second << endl;
    }
}

// 12. 综合示例：统计单词频率
void word_count() {
    vector<string> words = {"apple", "banana", "apple", "orange", "banana", "apple"};
    
    map<string, int> freq;
    
    // 统计频率
    for (const string& word : words) {
        freq[word]++;  // 键不存在时自动创建，值为0，然后++
    }
    
    // 按频率从高到低输出
    vector<pair<string, int>> sorted(freq.begin(), freq.end());
    sort(sorted.begin(), sorted.end(), 
         [](const auto& a, const auto& b) {
             return a.second > b.second;
         });
    
    for (const auto& p : sorted) {
        cout << p.first << ": " << p.second << endl;
    }
}

int main() {
    // 调用各种示例函数来测试
    map_definition();
    map_insert();
    map_access();
    map_traversal();
    map_erase();
    map_find();
    map_capacity();
    map_swap_compare();
    map_custom_key();
    multimap_example();
    unordered_map_example();
    word_count();
    
    return 0;
}

vector基本用法

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267

#include <bits/stdc++.h>
using namespace std;

// ==================== 1. vector 基本操作 ====================

void vector_basic() {
    // 1.1 创建和初始化
    vector<int> v1;
    vector<int> v2(10);
    vector<int> v3(10, 5);
    vector<int> v4 = {1, 2, 3, 4, 5};
    vector<int> v5(v4);
    vector<int> v6(v4.begin(), v4.begin() + 3);

    // 1.2 添加元素
    v1.push_back(10);
    v1.emplace_back(20);
    v1.insert(v1.begin(), 5);
    v1.insert(v1.begin() + 2, 15);
    
    // 1.3 访问元素
    int a = v1[0];
    int b = v1.at(1);
    int c = v1.front();
    int d = v1.back();
    
    // 1.4 删除元素
    v1.pop_back();
    v1.erase(v1.begin() + 1);
    v1.erase(v1.begin(), v1.begin() + 2);
    v1.clear();
    
    // 1.5 大小和容量
    cout << "大小: " << v1.size() << endl;
    cout << "容量: " << v1.capacity() << endl;
    cout << "是否为空: " << v1.empty() << endl;
    
    // 1.6 调整大小
    v1.resize(20);
    v1.resize(25, 100);
    v1.reserve(100);
}

// ==================== 2. vector 遍历 ====================

void vector_traversal() {
    vector<int> v = {1, 2, 3, 4, 5};
    
    for (int i = 0; i < v.size(); i++) {
        cout << v[i] << " ";
    }
    
    for (auto it = v.begin(); it != v.end(); ++it) {
        cout << *it << " ";
    }
    
    for (auto it = v.rbegin(); it != v.rend(); ++it) {
        cout << *it << " ";
    }
    
    for (int x : v) {
        cout << x << " ";
    }
    
    for (int& x : v) {
        x *= 2;
    }
}

// ==================== 3. vector 常用算法 ====================

void vector_algorithms() {
    vector<int> v = {5, 2, 8, 1, 9, 3, 7, 4, 6};
    
    sort(v.begin(), v.end());
    sort(v.begin(), v.end(), greater<int>());
    
    auto it = find(v.begin(), v.end(), 5);
    if (it != v.end()) {
        cout << "找到了: " << *it << endl;
    }
    
    if (binary_search(v.begin(), v.end(), 5)) {
        cout << "存在" << endl;
    }
    
    reverse(v.begin(), v.end());
    
    sort(v.begin(), v.end());
    auto last = unique(v.begin(), v.end());
    v.erase(last, v.end());
    
    int maxVal = *max_element(v.begin(), v.end());
    int minVal = *min_element(v.begin(), v.end());
    
    int sum = accumulate(v.begin(), v.end(), 0);
    
    int cnt = count(v.begin(), v.end(), 5);
    
    fill(v.begin(), v.begin() + 5, 100);
    
    random_shuffle(v.begin(), v.end());
}

// ==================== 4. 二维vector ====================

void vector_2d() {
    vector<vector<int>> matrix1;
    
    vector<vector<int>> matrix2(3, vector<int>(4, 0));
    
    vector<vector<int>> matrix3 = {
        {1, 2, 3},
        {4, 5, 6},
        {7, 8, 9}
    };
    
    vector<vector<int>> matrix4;
    matrix4.push_back({1, 2, 3});
    matrix4.push_back(vector<int>(4, 0));
    
    int val = matrix3[1][2];
    matrix3[0][1] = 10;
    
    for (int i = 0; i < matrix3.size(); i++) {
        for (int j = 0; j < matrix3[i].size(); j++) {
            cout << matrix3[i][j] << " ";
        }
        cout << endl;
    }
    
    for (const auto& row : matrix3) {
        for (int x : row) {
            cout << x << " ";
        }
        cout << endl;
    }
}

// ==================== 5. vector实现邻接表 ====================

class Graph {
private:
    int n;
    vector<vector<int>> adj;

    void dfsHelper(int u, vector<bool>& visited) {
        visited[u] = true;
        cout << u << " ";
        for (int v : adj[u]) {
            if (!visited[v]) {
                dfsHelper(v, visited);
            }
        }
    }

public:
    Graph(int vertices) : n(vertices), adj(vertices + 1) {}
    
    void addEdge(int u, int v) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }
    
    void addDirectedEdge(int u, int v) {
        adj[u].push_back(v);
    }
    
    void removeEdge(int u, int v) {
        auto& neighbors = adj[u];
        neighbors.erase(remove(neighbors.begin(), neighbors.end(), v), neighbors.end());
    }
    
    bool hasEdge(int u, int v) {
        for (int neighbor : adj[u]) {
            if (neighbor == v) return true;
        }
        return false;
    }
    
    vector<int> getNeighbors(int u) {
        return adj[u];
    }
    
    void print() {
        for (int i = 1; i <= n; i++) {
            cout << i << ": ";
            for (int neighbor : adj[i]) {
                cout << neighbor << " ";
            }
            cout << endl;
        }
    }
    
    void dfs(int start) {
        vector<bool> visited(n + 1, false);
        dfsHelper(start, visited);
        cout << endl;
    }
    
    void bfs(int start) {
        vector<bool> visited(n + 1, false);
        queue<int> q;
        
        visited[start] = true;
        q.push(start);
        
        while (!q.empty()) {
            int u = q.front();
            q.pop();
            cout << u << " ";
            
            for (int v : adj[u]) {
                if (!visited[v]) {
                    visited[v] = true;
                    q.push(v);
                }
            }
        }
        cout << endl;
    }
    
    int countComponents() {
        vector<bool> visited(n + 1, false);
        int count = 0;
        
        for (int i = 1; i <= n; i++) {
            if (!visited[i]) {
                count++;
                dfsHelper(i, visited);
            }
        }
        return count;
    }
};

struct Edge {
    int to;
    int weight;
    Edge(int t, int w) : to(t), weight(w) {}
};

class WeightedGraph {
private:
    int n;
    vector<vector<Edge>> adj;

public:
    WeightedGraph(int vertices) : n(vertices), adj(vertices + 1) {}
    
    void addEdge(int u, int v, int w) {
        adj[u].emplace_back(v, w);
        adj[v].emplace_back(u, w);
    }
    
    void print() {
        for (int i = 1; i <= n; i++) {
            cout << i << ": ";
            for (const Edge& e : adj[i]) {
                cout << "(" << e.to << "," << e.weight << ") ";
            }
            cout << endl;
        }
    }
};

3`