路由算法与路由协议 – PreLunaの太虚幻境

第22题：距离向量算法更新

题目结论

第 22 题选 B。

C 到所有结点的最短路径向量为：

(11, 6, 0, 3, 5, 8)

这题考什么

这题考的是距离向量路由算法，本质就是 Bellman-Ford 思想在路由中的应用。

题目里说“下面的向量刚刚到达路由器 C”，这里的“向量”指的是：

邻居路由器当前认为自己到各个目的结点的距离列表。

比如来自 B 的向量 (5, 0, 8, 12, 6, 2)，如果按结点顺序 A, B, C, D, E, F 来看，就表示：

B 到 A 的距离是 5
B 到 B 的距离是 0
B 到 C 的距离是 8
B 到 D 的距离是 12
B 到 E 的距离是 6
B 到 F 的距离是 2

所以，这道题不是让直接看图找最短路，而是让根据邻居发来的距离向量，更新 C 自己的路由表。

前置知识：距离向量算法怎么更新

如果当前路由器是 C，那么它到某个目的结点 X 的距离应按下面公式更新：

D_C(X) = min{ C→B + D_B(X), C→D + D_D(X), C→E + D_E(X) }

意思很简单：

C 不知道全网最短路，但它可以去问邻居：

你到目标多远？
我再加上我到你的代价
最后取最小

题干已知条件

来自 B 的向量：

(5, 0, 8, 12, 6, 2)

来自 D 的向量：

(16, 12, 6, 0, 9, 10)

来自 E 的向量：

(7, 6, 3, 9, 0, 4)

测得：

C 到 B 的延迟为 6
C 到 D 的延迟为 3
C 到 E 的延迟为 5

分步计算

1. C 到 A

经 B：6 + 5 = 11
经 D：3 + 16 = 19
经 E：5 + 7 = 12

取最小，得：

C 到 A = 11

2. C 到 B

经 B：6 + 0 = 6
经 D：3 + 12 = 15
经 E：5 + 6 = 11

取最小，得：

C 到 B = 6

3. C 到 C

到自己一定是：

C 到 C = 0

这一步非常重要。
不能机械地按邻居向量去套公式，否则会算出一个绕路回自己的值，但路由器到自己的距离必须写 0。

4. C 到 D

经 B：6 + 12 = 18
经 D：3 + 0 = 3
经 E：5 + 9 = 14

取最小，得：

C 到 D = 3

5. C 到 E

经 B：6 + 6 = 12
经 D：3 + 9 = 12
经 E：5 + 0 = 5

取最小，得：

C 到 E = 5

6. C 到 F

经 B：6 + 2 = 8
经 D：3 + 10 = 13
经 E：5 + 4 = 9

取最小，得：

C 到 F = 8

最终结果

所以 C 的最短路径向量为：

(11, 6, 0, 3, 5, 8)

对应选项 B。

这类题为什么容易错

这题常见错误有 3 个。

第一，看错向量顺序。
题里默认顺序一般就是图中结点顺序，必须先对上每一位对应哪个结点。

第二，把到自己的距离也拿去套公式。
到自己必须是 0，这是路由表基本规则。

第三，把它当成纯图论最短路题去做。
这题考的不是“手动画所有路径”，而是“距离向量如何更新”。

同类题快速识别方法

只要题目出现下面这些表述，就要马上想到距离向量更新：

某路由器刚收到来自邻居的距离向量
已知到各邻居的链路代价
求该路由器到各结点的最短路径向量

做法固定就是：

逐列更新 = 到邻居代价 + 邻居到目标距离，最后取最小。

第23题：OSPF 选路 + 分组交换时延计算

题目结论

第 23 题选 C。

从 A 开始发送到 B 接收完毕，所需时间为：

80.32 ms

这题考什么

这题是典型的跨知识点综合题，同时考了两部分：

第一部分，OSPF 如何选路
第二部分，分组交换中存储转发的总时延计算

这类题看起来信息多，实际上要分两步做，不能混在一起。

第一步：用 OSPF 选最短路径

图中两条主要路径分别是：

上路

A → 左上路由器 → 右上路由器 → B

总代价：

2 + 6 + 2 = 10

下路

A → 左上路由器 → 左下路由器 → 右下路由器 → 右上路由器 → B

总代价：

2 + 3 + 1 + 1 + 2 = 9

OSPF 选的是总代价最小路径，不是跳数最少，也不是画起来更直的那条路。

所以应该走下路，总共经过 5 段链路。

第二步：算一共分成多少个分组

题目给出：

文件大小：980000 B
分组长度：1000 B
首部长度：20 B

所以每个分组真正承载的数据是：

1000 - 20 = 980 B

于是分组数为：

980000 / 980 = 1000

所以一共发送 1000 个分组。

第三步：算每个分组在一段链路上的发送时延

带宽是：

100 Mb/s

每个分组长度是：

1000 B = 8000 bit

所以一个分组在一段链路上的发送时延为：

8000 / (100 × 10^6) s = 0.00008 s = 0.08 ms

第四步：按存储转发计算总时间

在存储转发分组交换中，如果：

分组数为 n
链路段数为 h
单个分组单链路发送时延为 t

则总时间为：

(n + h - 1) × t

这里：

n = 1000
h = 5
t = 0.08 ms

所以总时间为：

(1000 + 5 - 1) × 0.08 = 1004 × 0.08 = 80.32 ms

因此选 C。

这题为什么容易错

主要有 4 个坑。

1. OSPF 选路看总代价，不看跳数

很多人会觉得上路更短，其实 OSPF 看的是权值和。

2. 1000B 不是有效数据长度

题目已经说明 20B 是首部，所以有效载荷只有 980B。

3. 忽略了端主机到路由器、路由器到端主机的链路

题目问的是从 A 发到 B 收完，整个端到端路径都要算。

4. 不会用流水线公式

如果把总时间写成：

1000 × 5 × 0.08ms

就错了。
因为分组交换是可以流水传输的，应该用：

(n + h - 1) × t

同类题快速识别方法

看到下面这种表述，就知道是两段式：

各路由器使用 OSPF，链路度量已知
分组长度、首部长度、带宽已知
求文件传输总时间

固定做法就是：

先选路，再算分组数，再算单分组发送时延，最后套 (n + h - 1) × t。

第24题：RIP 中 16 的含义

题目结论

第 24 题选 D。

R1 不能经 R2 到达 Net1。

这题考什么

这题考的是 RIP 最基础、也最重要的一条协议规则：

RIP 以跳数作为距离
最大有效距离是 15
16 表示不可达

所以当 R1 收到邻居 R2 发来的距离向量中含有 <Net1, 16> 时，表示：

R2 告诉 R1：它到 Net1 不可达。

于是 R1 可以得出结论：

R1 不能经过 R2 到达 Net1。

所以选 D。

为什么别的选项错

A 错

“R2 可以经过 R1 到达 Net1，跳数为 17”
错在 RIP 中 16 已经表示无穷大，不存在有效的 17 跳。

B 错

“R2 可以到达 Net1，跳数为 16”
错在 16 不是可达，而是不可达。

C 错

“R1 可以经过 R2 到达 Net1，跳数为 17”
同样错在 17 没有实际意义，而且 <Net1,16> 恰恰说明不可达。

这题的核心记忆点

这题其实就是一句话：

RIP 中 16 不是“很远”，而是“到不了”。

这句话一定要死记。

容易错在哪里

最常见错误就是把 16 当成普通数字看待，误以为还能再加 1 变成 17。
但 RIP 里 16 已经是“无穷大”的协议语义，不是正常跳数。

第25题：RIP 的“坏消息传得慢”和计数到无穷

题目结论

第 25 题选 B。

R2 更新后，到网络 201.1.2.0/25 的距离是：

3

先说明一下这题为什么特别容易错

这题不能按“R3 发现不可达，于是立刻对外通告 16，因此 R2 更新成 16”那种最直观思路去做。
如果这样做，会掉进陷阱。

这道题的标准考法是在考 RIP 的经典缺陷：

坏消息传得慢
计数到无穷

也就是说，虽然网络实际上已经坏了，但由于其他路由器手里还保留着旧的错误可达信息，RIP 会在一段时间内不断错误更新，距离从 2 变 3、再变 4、再变 5……最后才涨到 16。

这题问的正是第一次更新后的结果。

这题考什么

这题考的是 RIP 的动态更新过程，而不是只考“16 表示不可达”这个静态定义。

必须把第24题和第25题区分开：

第24题考：16 的语义是什么
第25题考：发生故障后，RIP 为什么还会暂时算出一个较小的错误距离

故障前的收敛状态

目标网络 201.1.2.0/25 是直接挂在 R3 上的。

因此在故障前、全网已经收敛时：

R3 到该网络的距离为 1
R1 到该网络的距离为 2
R2 到该网络的距离为 2

这一步要先建立起来，否则后面没法推。

故障发生后，R3 为什么会算出 3

现在 R3 检测到 201.1.2.0/25 不可达。

如果只看它自己的直连状态，它当然应该认为直连这条路坏了。
但 RIP 不是只看本地链路，它会根据保存的邻居距离向量重新计算最短路。

这时，R1 和 R2 还没有来得及知道故障，它们仍保留旧信息：

R1 还认为到该网络的距离是 2
R2 还认为到该网络的距离是 2

于是 R3 重新计算：

min{16, 2+1, 2+1} = min{16, 3, 3} = 3

这里的 16 表示“本来直连已坏，按本地看是不可达”；
但由于邻居还在说“我能到”，R3 反而误以为可以通过邻居绕到目标网络，于是把自己的距离更新成了 3。

这就是 RIP 的典型错误现象。

R2 为什么更新后也是 3

R3 把“我到该网络距离为 3”的新向量通告给邻居后，R2 再重新计算。

此时 R2 保存着的邻居信息中：

R1 到该网络距离仍为 2
R3 到该网络距离变成了 3

所以 R2 重新计算：

min{2+1, 3+1} = min{3, 4} = 3

于是 R2 更新后，到该网络的距离就变成了 3。

因此答案是 B。

这题的本质是什么

这题本质上是在考：

距离向量算法在故障时可能被旧信息误导。

也就是说，路由器并不知道邻居所谓的“可达”是不是其实要绕回自己，它只会机械地比较数值大小。
于是就会出现：

R3 以为可以经 R1 或 R2 到目标网络
R1、R2 又可能继续以为可以通过别的路由器到目标网络
距离不断增加：3、4、5……直到 16

这就叫计数到无穷。

为什么这题不能直接写 16

因为题目问的是：

R3 向 R2 通告一次新的距离向量后，R2 更新后是多少。

这说明它考的是第一次故障传播后 RIP 的重新计算结果，不是问“最终彻底收敛后是多少”。

在第一次更新时，由于旧向量还在，R2 暂时算出来的是 3，而不是 16。

这类题的典型陷阱

这题常见误区有两个。

1. 把 RIP 当作“收到坏消息立刻全网同步”

这是错误的。
RIP 的缺陷恰恰就是坏消息传播慢，不会立刻全网一致。

2. 把第24题的思路照搬到第25题

第24题是静态语义题。
第25题是动态更新题。
两者不能混用。

22～25题的知识主线总结

这四题其实刚好构成了一条完整主线。

第22题

考距离向量算法正常情况下如何更新

核心是：

到邻居的代价 + 邻居到目标的距离，再取最小

第23题

考OSPF 如何选路，以及分组交换总时延如何计算

核心是：

OSPF 比的是链路代价和
存储转发总时延用 (n + h - 1) × t

第24题

考RIP 中 16 的协议语义

核心是：

16 = 不可达

第25题

考RIP 的缺陷：坏消息传得慢、计数到无穷

核心是：

虽然网络坏了，但邻居还保留旧信息，所以短时间内会错误更新成 3、4、5……，而不是立刻变成 16。

补充说明：第25题为什么会出现“答案是 3”这种特殊情况

第25题最特殊的地方，不在于算术，而在于它考的不是“正常 RIP 更新”，而是 RIP 在故障场景下的异常收敛现象。

平时一看到“某网络不可达”，第一反应往往是：

16 = 不可达

于是很容易直接把答案写成 16。
但这道题的标准答案是 3，原因就在于它考的是一个很典型的补充知识点：

计数到无穷（count to infinity）

这道题为什么属于“特殊情况”

如果按最朴素的理解：

R3 直连网络 201.1.2.0/25
现在 R3 发现这个网络坏了
那么 R3 到该网络的距离就应该变成 16
R2 再收到这个 16，也就该把自己的距离改成 16

这种理解本身不算错，但它对应的是一种“理想化的、没有旧错误信息干扰”的思路。

而第25题考的恰恰不是这个理想过程。
它考的是：

在 RIP 中，邻居手里还保留着旧的可达信息时，坏消息不会立刻传遍全网，反而会诱发错误更新。

所以这题是一个故障传播的特殊场景题。

这个特殊情况的本质：R3 被旧信息骗了

故障发生前，路由已经收敛：

R3 到目标网络距离为 1
R1 到目标网络距离为 2
R2 到目标网络距离为 2

现在目标网络从 R3 这边断掉了。

如果只看 R3 自己的直连情况，那么确实应该认为：

R3 到该网络 = 16

但是 RIP 不只看“我直连是不是坏了”，
它还会看邻居之前发给自己的距离向量。

而此时 R1、R2 还没有意识到网络已经坏了，它们仍然保留着旧值：

R1 还认为距离是 2
R2 还认为距离是 2

于是 R3 就会重新计算：

min(16, 2+1, 2+1) = 3

这一步就是这道题最特别的地方。

也就是说：

R3 明明是最先发现故障的那个路由器，却因为邻居手里还拿着旧路由，反而误以为“也许还可以绕经邻居到达目标网络”。

于是它对外通告的距离，就不是 16，而是 3。

为什么 R2 最后也会得到 3

R2 收到 R3 发来的更新后，看到：

R1 还说到该网络距离为 2
R3 现在说到该网络距离为 3

于是 R2 再重算：

min(2+1, 3+1) = 3

所以 R2 更新后，到该网络的距离也会变成 3。

这就是为什么第25题选 3，而不是 16。

这类现象叫什么

这类现象就叫：

坏消息传得慢

进一步说，它对应的经典现象就是：

计数到无穷

也就是原来应该尽快变成“不可达”的路由，不会一下子跳到 16，
而是可能经历：

3 → 4 → 5 → …… → 16

最后才真正收敛为不可达。

所以这题的“3”不是最终稳定结果，而是故障传播过程中的一个中间结果。

为什么说它是“补充知识”，而不是普通基础题

因为普通基础题通常只考：

RIP 的度量是跳数
16 表示不可达
收到 <Net,16> 就理解为“到不了”

这类题是静态定义题。

而第25题往前走了一步，它在考：

当网络刚出故障，而各路由器的距离向量还没来得及同步更新时，会发生什么。

所以它已经不是单纯记忆定义了，而是在考 RIP 的缺陷与收敛过程。

从复习角度看，这类题属于“理解型补充考点”。

第25题为什么特别容易误判

因为它正好卡在两个知识点之间。

一方面，脑子里牢牢记着：

16 = 不可达

另一方面，题目又在考：

“明明已经不可达了，为什么路由器还会暂时算出一个 3？”

如果没有把“RIP 可能被旧邻居信息误导”这件事单独拎出来，就很难接受这个答案。

所以这题本质上不是在否定“16 表示不可达”，
而是在提醒：

即使真实网络已经不可达，RIP 的路由表也可能不会立刻正确反映这个事实。

什么时候会直接变成 16，而不是出现 3

这也是这道题最值得补充的一点。

如果题目明确给出下面这些条件之一，那么往往不会出现这种“先变成 3”的现象：

1. 使用了毒性逆转

也就是把不可达路由明确按 16 通告给相关邻居，防止对方再误以为“还有路”。

2. 使用了水平分割

从某个接口学来的路由，不再从该接口原样发回去，减少环路和错误反馈。

3. 题目明确按“理想更新”处理

有些题不会考 RIP 的缺陷，只考最直接的更新逻辑。
这种题里，一看到故障，就按 16 处理即可。

所以第25题之所以特殊，恰恰是因为它默认考的是：

没有及时抑制错误传播的普通 RIP 场景。

关于这道题，最应该记住的一句话

第25题不是在考“16 的定义”，
而是在考：

为什么真实故障已经发生，但 RIP 协议仍可能暂时算出一个假的可达距离。

这个“假的可达距离”，就是 3。

这部分补充知识最适合怎么记

这道题可以压缩成一个非常适合考前回忆的小结论：

当 RIP 网络中某条真实路径刚失效时，最先发现故障的路由器不一定马上对外通告 16；如果邻居还保留着旧的可达距离，它可能会被误导，重新算出一个更小但错误的距离值，这就是坏消息传得慢和计数到无穷现象。

把这句话记住，第25题这种“答案看着不合理，其实考的是协议缺陷”的题就不容易再掉坑里了。

这两题都属于“路由协议 + 路由算法”的典型考法。第26题考的是常见路由协议运行在哪一层、封装到什么协议里；第27题考的是距离—向量算法的更新规则，也就是拿到邻居的距离向量之后，如何重新计算自己到各目的网络的距离。

先给结论：

第26题选 D：UDP、IP、TCP。
第27题选 D：9，20，28，20。

26题怎么做

题目问的是：直接封装 RIP、OSPF、BGP 报文的协议分别是什么。

这道题本质上不是考“谁是路由协议”这么简单，而是考“这些路由协议工作时，报文到底交给谁来承载”。

先记住三个固定搭配

RIP → UDP
OSPF → IP
BGP → TCP

所以顺序是：

RIP、OSPF、BGP
对应
UDP、IP、TCP

答案就是 D。

为什么是这样

1）RIP 直接封装在 UDP 中

RIP 是应用层路由协议，使用 UDP 传输，端口号是 520。
考试里最常见的表述就是：

RIP 使用 UDP
RIP 是距离—向量路由协议
RIP 以跳数作为度量，最大跳数 15，16 表示不可达

所以看到 RIP，第一反应就应该是 UDP。

2）OSPF 直接封装在 IP 中

OSPF 不通过 TCP，也不通过 UDP，而是直接由 IP 承载。
也就是说，OSPF 报文放在 IP 数据报的数据部分中，靠 IP 首部中的协议字段区分，OSPF 的协议号是 89。

这一点非常容易和 RIP、BGP 混淆，因为大家都是路由协议，但封装方式不同。
考试就喜欢专门拿这一点出选择题。

3）BGP 直接封装在 TCP 中

BGP 是外部网关协议，运行在 TCP 之上，端口号 179。
BGP 之所以使用 TCP，是因为它更强调可靠传输、按序交付、会话维持。

所以看到 BGP，第一反应就是 TCP。

这题考了哪些知识点

这题主要考了三个点：

第一，常见路由协议的分类与特征。
RIP 是距离—向量协议，OSPF 是链路状态协议，BGP 是路径向量协议。

第二，路由协议报文的封装方式。
这是最核心的考点，也是本题的直接落点。

第三，网络层协议与传输层协议的区分。
很多人会把“路由协议属于网络层”误理解成“它们都直接封装在 IP 里”。这是错的。
“功能上属于网络层控制协议”和“报文通过谁来传”是两件事。

这题为什么容易错

最容易错在 OSPF。

很多人背成了“RIP 和 BGP 都是应用层，所以都走传输层；OSPF 也是路由协议，可能也走 UDP 或 TCP”，结果就错了。
OSPF 的特殊点就在于：它直接使用 IP，不经过 TCP/UDP。

这类题最稳的做法不是临场推，而是直接背成固定搭配：

RIP—UDP
OSPF—IP
BGP—TCP

这是高频送分点。

27题怎么做

这题是一个标准的距离—向量路由算法更新题。

题目给出：

路由器 E 到邻居 A、B、C、D 的直接链路距离分别是：

E→A = 8
E→B = 10
E→C = 12
E→D = 6

又给出了 A、B、C、D 到 Net1～Net4 的距离向量。
要求的是：E 更新后，到各目的网络的距离是多少。

先说做题公式

距离—向量算法的核心公式就是：

E到某目的网络的距离 = min{ 经过某邻居的代价 }

也就是：

D_E(目的网络) = min[ c(E,A)+D_A(目的网络), c(E,B)+D_B(目的网络), c(E,C)+D_C(目的网络), c(E,D)+D_D(目的网络) ]

其中：

c(E,A) 表示 E 到邻居 A 的直接链路代价
D_A(目的网络) 表示 A 告诉 E：A 到该目的网络的距离

这道题就是把每个目的网络都按这个公式算一遍。

题目表格整理

邻居的距离向量是：

目的网络	A	B	C	D
Net1	1	23	20	22
Net2	12	35	30	28
Net3	24	18	16	36
Net4	36	30	8	24

而 E 到各邻居的直接链路代价是：

到 A：8
到 B：10
到 C：12
到 D：6

分别计算

1）到 Net1 的距离

经 A：8 + 1 = 9
经 B：10 + 23 = 33
经 C：12 + 20 = 32
经 D：6 + 22 = 28

取最小值，得到：

D_E(Net1) = 9

2）到 Net2 的距离

经 A：8 + 12 = 20
经 B：10 + 35 = 45
经 C：12 + 30 = 42
经 D：6 + 28 = 34

取最小值，得到：

D_E(Net2) = 20

3）到 Net3 的距离

经 A：8 + 24 = 32
经 B：10 + 18 = 28
经 C：12 + 16 = 28
经 D：6 + 36 = 42

取最小值，得到：

D_E(Net3) = 28

这里注意，经过 B 和经过 C 都是 28，最短距离一样，题目只问距离，不问下一跳，所以写 28 即可。

4）到 Net4 的距离

经 A：8 + 36 = 44
经 B：10 + 30 = 40
经 C：12 + 8 = 20
经 D：6 + 24 = 30

取最小值，得到：

D_E(Net4) = 20

最终结果

所以 E 更新后，到 Net1～Net4 的距离分别是：

9，20，28，20

答案选 D。

27题考了哪些知识点

这题主要考四个知识点，而且很典型。

1）距离—向量算法的更新思想

每个路由器并不知道全网拓扑，只知道：

自己到邻居的代价
邻居告诉自己的“到各目的地的距离”

然后通过“到邻居的代价 + 邻居到目的地的代价”来迭代更新。

2）距离向量表的含义

表里不是“邻居编号”，也不是“跳数固定为1”，而是：

邻居到各目的网络的当前估计距离。

这点必须看明白，不然后面不会算。

3）最短路径的局部递推

对于某个目的网络，要把“经过每个邻居的总代价”都列出来，然后取最小值。

4）链路代价不一定是1

这题尤其容易误判成 RIP 那种“每经过一个路由器跳数 +1”。
但题目明确说的是：

“直接链路距离分别是 8、10、12、6”

所以这里加的不是 1，而是各自的链路代价。

这正是本题的陷阱。

这题为什么容易错

第一类错误：把它当成 RIP 跳数题

有些人一看到“距离—向量算法”，就直接代入“每跳 +1”。
于是会把公式写成：

邻居到目的网络的距离 + 1

这是错误的。

因为本题给的是一般化的距离—向量算法，链路代价已经明确不是统一的 1，而是 8、10、12、6。
所以应该加实际链路代价，而不是固定加1。

第二类错误：把邻居的最小值直接抄下来

比如 Net1 这一行，看到 A 到 Net1 是 1，就直接以为 E 到 Net1 也是 1。
这也错了。

因为 E 不直接连到 Net1，它要先到 A，再由 A 去 Net1。
所以总代价应该是：

E到A的代价 + A到Net1的代价 = 8 + 1 = 9

第三类错误：算对一半，没有逐项比较

有些人看到某一列比较小，就直接选了，没把四个邻居都算完。
这类题一定要老老实实把四条路径都列出来再取最小值。

以后怎么快速识别这类题

做这类题时，可以按下面这个固定流程走：

第一步，先看题目说的是不是距离—向量算法。
如果是，那基本就是“邻居代价 + 邻居通告值，再取最小”。

第二步，立刻判断“加的是 1 还是实际链路代价”。
这一步最关键。

如果题目说“跳数”“RIP”“每条链路代价相同”，通常按 +1
如果题目给了具体链路权值，比如 8、10、12、6，就按具体值相加

第三步，对每个目的网络单独列出四个候选值。
不要心算，不要跳步。

第四步，取最小值。
如果有并列最小，只问距离时写最小值即可；若问下一跳，则任选一个最优邻居。

两题放在一起看，知识主线是什么

这两题虽然题型不同，但都在考“路由”这一章里最核心的两条线。

一条线是路由协议本身：

RIP、OSPF、BGP分别是什么
各自工作机制有什么不同
报文由谁承载

另一条线是路由算法如何算路径：

距离—向量怎么更新
链路状态和距离—向量的区别
度量值到底是什么

第26题偏“协议记忆型送分点”，第27题偏“算法计算型基础题”。
复习时这两类题最好放在一起整理，因为“协议是什么”和“协议内部大致怎么计算”本来就是一体的。

这三题是一个很典型的“路由协议综合题组”，分别在考三类能力：

第1题考“路由协议为什么选不同的传输方式”；
第2题考“RIP 距离向量更新”；
第3题考“OSPF 最短路径计算”。

这组题不能只背定义，必须会从协议机制反推出题目答案。下面按题目顺序完整拆开。

第1题：RIP 用 UDP，OSPF 用 IP，BGP 用 TCP，为什么？

本题结论

RIP 用 UDP，是因为它实现简单、开销小，适合周期性发送整张路由表，不需要建立连接。

OSPF 直接用 IP，是因为它本身就是网络层内部路由协议，需要自己控制报文类型、邻接建立、链路状态泛洪和可靠机制，直接放在 IP 上效率更高，不必再套 UDP/TCP。

BGP 用 TCP，是因为 BGP 属于自治系统之间的路由协议，要求高可靠、按序传输，路由更新量大且重要，使用 TCP 可以直接利用连接管理、确认、重传、流量控制等机制。

RIP 周期性和邻站交换路由信息，而 BGP 不这样做，是因为：
RIP 是距离向量协议，需要靠周期性交换整张路由表来维持一致性；
BGP 是路径向量协议，建立 TCP 连接后，先交换一次完整路由，以后只在路由变化时发送增量更新，再配合 Keepalive 保活，不需要周期性整表广播。

这题怎么组织答案

这题本质不是问“记忆点”，而是问“协议机制与封装方式是否匹配”。

1）RIP 为什么用 UDP

RIP 是应用层协议，但它的工作方式很“轻”：

第一，它传输的对象比较简单，就是距离向量；
第二，它本来就会周期性发送更新报文，所以即便某次丢了，下一轮还会再发；
第三，它只和邻居交换，不需要像 TCP 那样建立连接、维护连接状态。

所以用 UDP 的好处就是：

无连接，简单；
首部开销小；
适合周期性广播/组播更新；
实现成本低。

这里的考试表述通常可以写成：
“RIP 使用 UDP，可减少连接建立与维护开销，适合周期性、简单的路由更新报文传输。”

2）OSPF 为什么直接用 IP

OSPF 也是网络层路由协议，但它不像 RIP 那样简单周期发表，而是要做很多更底层、更精细的控制：

它要发现邻居、建立邻接关系、发送 Hello、发送链路状态更新、泛洪 LSU/LSA，还要自己保证链路状态数据库同步的一致性。

如果再套一层 TCP 或 UDP，反而不方便。尤其是 TCP 的“面向连接、端到端可靠传输”机制，并不适合 OSPF 这种“本地邻接、链路状态泛洪”的工作方式。

所以 OSPF 直接封装在 IP 数据报中，优点是：

少一层封装，效率高；
便于自行定义协议报文类型；
便于直接控制泛洪与邻居通信；
不受 TCP 面向连接机制束缚。

考试里常写成：
“OSPF 直接使用 IP，有利于减少额外开销，并由协议自身实现邻接维护和链路状态可靠泛洪。”

3）BGP 为什么用 TCP

BGP 是自治系统之间的路由协议，它面临的是大规模、复杂、重要的路由交换，不能像 RIP 一样“丢了下次再说”。

BGP 需要：

路由更新可靠送达；
路由更新按序到达；
支持长连接会话；
减少重复实现重传、确认等机制。

因此 BGP 直接依赖 TCP。这样它不需要自己再去造一套可靠传输机制。

考试中可以写：
“BGP 使用 TCP，可利用 TCP 提供的可靠、按序、面向连接传输，提高域间路由交换的可靠性。”

为什么 RIP 周期性交换，而 BGP 不这样做

这是这题最容易丢分的点。

RIP 要周期性交换的原因

RIP 是距离向量协议。每个路由器只知道“到某目的网有多远、经谁走”，不知道整个拓扑。
因此它必须不断和邻居交换自己的距离向量，才能逐步修正全网路由。

而且 RIP 采用“整表通告”的方式，本身就带有周期更新机制。

BGP 不周期性交换整张表的原因

BGP 不是靠周期性整表刷新来维持路由，而是：

先建立 TCP 会话；
建立时交换全部路由；
之后只发送变化部分；
通过 Keepalive 保持邻居关系。

这样做的原因是：互联网规模太大，如果像 RIP 一样周期性整表广播，开销会非常大，效率很低。

所以一句话总结就是：

RIP 靠“周期性整表更新”维持正确性；
BGP 靠“TCP 长连接 + 增量更新 + 保活”维持正确性。

第1题标准化答法

可以直接写成下面这种考试答案：

RIP 使用 UDP，优点是无连接、开销小、实现简单，适合周期性传输路由更新报文。
OSPF 直接使用 IP，减少了传输层封装开销，便于协议自身完成邻居发现、链路状态泛洪和同步控制。
BGP 使用 TCP，能够利用 TCP 提供的可靠传输、按序交付和连接管理功能，适合自治系统间重要路由信息的交换。
RIP 周期性与邻站交换路由信息，是因为 RIP 属于距离向量协议，需要周期性整表更新来维持路由一致性；而 BGP 建立 TCP 连接后，通常只在路由变化时发送增量更新，并通过 Keepalive 维持会话，因此不需要像 RIP 那样周期性交换整张路由表。

第2题：RIP 更新后的 B 路由表怎么求

先读题干信息

B 原路由表（表1）是：

目的网络	距离	下一跳
N1	7	A
N2	2	C
N6	8	F
N8	4	E
N9	4	D

C 发给 B 的距离向量（表2）是：

| 目的网络 | 距离 |
|—|—:|—|
| N2 | 15 |
| N3 | 2 |
| N4 | 8 |
| N8 | 2 |
| N7 | 4 |

第一步：先把 C 的距离统一加 1

因为 B 到这些网络要先走到邻居 C，所以 B 经 C 到各网的距离应为“C 报的距离 + 1”。

因此得到：

目的网络	经 C 的新距离
N2	16
N3	3
N4	9
N8	3
N7	5

这里要马上意识到：
在 RIP 中，16 表示不可达。

第二步：逐项更新 B 的路由表

对 N2

原来 B 到 N2 的表项是：N2, 2, C
现在收到来自 C 的新信息：经 C 到 N2 的距离变成 16。

因为原来的下一跳本来就是 C，所以要按来自同一下一跳的新信息更新。
因此 N2 应更新为：

N2, 16, C

也就是“不可达”。

这是本题最大陷阱。
很多人会误写成“保留原来的 2”，这是错的。RIP 中如果来自原下一跳的度量变了，就要跟着改。

对 N3

原表没有 N3，新加入：

N3, 3, C

对 N4

原表没有 N4，新加入：

N4, 9, C

对 N8

原来 B 到 N8 是：N8, 4, E
现在经 C 可达 N8 的距离是 3。

比较 3 和 4，选更小的，因此更新为：

N8, 3, C

对 N7

原表没有 N7，新加入：

N7, 5, C

对 N1、N6、N9

C 没有提供更优路径，保持不变。

所以，B 更新后的路由表是

目的网络	距离	下一跳
N1	7	A
N2	16	C
N3	3	C
N4	9	C
N6	8	F
N7	5	C
N8	3	C
N9	4	D

这里如果老师更倾向“不可达项删除”的写法，也有教材会把 N2 删除。
但按 RIP 机制更标准的写法，是先记为距离 16，表示不可达；老化后再删除。

第2问：B 收到发往 N2 的 IP 分组时怎么处理

因为更新后 B 到 N2 的距离为 16，在 RIP 中表示不可达。
因此 B 不能继续转发这个分组。

标准处理是：

丢弃该 IP 分组；
向源主机发送 ICMP“目的网络不可达”差错报文。

第2题完整答案写法

第1问答案

C 发来的距离向量加 1 后，B 经 C 到各目的网络的距离分别为：
N2 为 16，N3 为 3，N4 为 9，N8 为 3，N7 为 5。

再与 B 原路由表比较并更新：
N2 原下一跳就是 C，因此更新为距离 16；
N3、N4、N7 为新增表项；
N8 经 C 的距离 3 小于原来的 4，因此改为经 C 转发；
N1、N6、N9 保持不变。

故更新后的路由表为：

目的网络	距离	下一跳
N1	7	A
N2	16	C
N3	3	C
N4	9	C
N6	8	F
N7	5	C
N8	3	C
N9	4	D

第2问答案

B 收到发往 N2 的 IP 分组时，应发现到 N2 的距离为 16，说明目的网络不可达，因此应丢弃该分组，并可向源主机发送 ICMP 目的网络不可达报文。

这类题的通用解法

RIP 更新题可以固定按四步走：

第一步，先把邻居通告的距离全部加 1。
第二步，同目的网络若原下一跳就是该邻居，则直接更新。
第三步，若原下一跳不是该邻居，则比较新旧距离，取更小者。
第四步，新目的网络直接加入，16 视为不可达。

真正最容易错的只有一个点：

“来自原下一跳的新信息变差了，要不要更新？”

答案是：要。

第3题：OSPF 下求 R6 到 N1、N2、N3、N4 的路由表

先看图怎么读

题目说明非常关键：

“端口处的数字是该路由器向该链路转发分组的代价。”

这说明这是 OSPF 的“接口开销”模型，不是简单把一条线当成一个固定权值。

所以做题时要按“从当前路由器发出时，经过的每个出接口代价求和”。

先找 R6 的两条出口

R6 只有两条可能的方向：

向上到 R5，代价 6；
向左到 R3，代价 6。

但继续走下去，两条路总代价不同。

先求到 N3 的最短代价

从 R6 到 N3 有两种主要走法。

走 R6 → R3 → N3

代价 = R6到R3 的 6 + R3到N3 的 1 = 7

走 R6 → R5 → R4 → N3

代价 = R6到R5 的 6 + R5到R4 的 8 + R4到N3 的 1 = 15

所以到 N3 的最短路径是经 R3，总代价 7。

再求到 N4

最短明显是：

R6 → R3 → N4

代价 = R6到R3 的 6 + R3到N4 的 2 = 8

再求到 N1

到 N1 最短路应该先到 N3，再到 R1，再到 N1。

路径：

R6 → R3 → N3 → R1 → N1

代价 = R6到R3 的 6 + R3到N3 的 1 + R1到N1 的 3 = 10

这里 N3 是一个网络，网络到相连路由器不再额外增加转发代价，所以只加路由器出接口代价即可。

另一条路如果绕 R5、R4 再到 N3，明显更大：

6 + 8 + 1 + 3 = 18

所以到 N1 走 R3。

再求到 N2

同理：

R6 → R3 → N3 → R2 → N2

代价 = R6到R3 的 6 + R3到N3 的 1 + R2到N2 的 3 = 10

绕 R5、R4 会更大，不取。

所以 R6 的路由表为

目的网络	最短路径代价	下一跳
N1	10	R3
N2	10	R3
N3	7	R3
N4	8	R3

如果题目要求写“输出线路”，本质上也是走向 R3 的那个接口。

第3题标准答案表述

根据 OSPF 最短路径算法，从 R6 出发计算到各网络的最小代价：

到 N3：R6→R3→N3，代价为 6+1=7；
到 N4：R6→R3→N4，代价为 6+2=8；
到 N1：R6→R3→N3→R1→N1，代价为 6+1+3=10；
到 N2：R6→R3→N3→R2→N2，代价为 6+1+3=10。

因此，R6 关于 N1、N2、N3、N4 的路由表如下：

目的网络	代价	下一跳
N1	10	R3
N2	10	R3
N3	7	R3
N4	8	R3

这三题分别考了什么知识点

这组题其实把“网络层路由”里最核心的三块都考到了。

第1题考的是不同路由协议的工作层次与封装选择：
RIP—UDP，OSPF—IP，BGP—TCP，以及 RIP 与 BGP 更新机制的差异。

第2题考的是 RIP 的距离向量更新规则：
邻居通告加 1、同一下一跳更新、更短路径替换、16 表示不可达。

第3题考的是 OSPF 的最短路径计算：
把接口数字理解成“出接口代价”，再按最短路径求到目的网络的总代价和下一跳。

这组题最容易错的地方

第1题容易错在只背结论，不讲“为什么”

比如只写“RIP 用 UDP，BGP 用 TCP”，但没解释“RIP 周期整表、BGP 增量更新”，分数就不高。

第2题容易错在 N2

很多人看到原表里 N2 距离是 2，就不愿意改。
但本题来自 C 的更新告诉 B：经 C 去 N2 的代价已经变成 16。
而原来 B 到 N2 的下一跳正好就是 C，所以必须更新成 16。

第3题容易错在把图上的数字当“链路总权值”

这道 OSPF 题图上的数字是“端口代价”，不是一整条边的统一权值。
所以必须按“沿路经过的每个路由器出接口代价求和”，不是简单数跳数，也不是只看某一段链路。

这道 2013 统考题，本质上是一个很典型的“路由聚合 + 最长前缀匹配 + 域间路由协议”综合题。
真正难点不在算，而在于能不能一眼看出三件事：

第一，哪些网段可以聚合；
第二，聚合之后会不会和直连子网重叠；
第三，重叠以后靠什么规则保证转发仍然正确。

这题的标准思路如下。

先看题目到底考什么。
R2 位于 AS2 中，它一边通过 S0 连到 R1，另一边通过 S1 连到 R3，自己还有一个 E0 直连子网 194.17.20.128/25。
所以对 R2 来说，路由来源分三类：

一类是经 R1 到达 AS1 的两个子网；
一类是自己 E0 直连的子网；
一类是经 R3 到达 AS2 内另外两个子网。

第 1 问：给出 R2 的路由表

先做路由聚合

AS1 中两个子网是：

153.14.5.0/25
153.14.5.128/25

这两个 /25 正好拼成一个 /24，所以可以聚合为：

153.14.5.0/24

下一跳显然是 R1，图中给出的 R1 接口 IP 是 153.14.3.2，所以这条路由写成：

153.14.5.0/24 -> 153.14.3.2 -> S0

AS2 中由 R3 连接的两个子网是：

194.17.20.0/25
194.17.21.0/24

这两个网段可以聚合为：

194.17.20.0/23

这里很多人第一次会不敢合并，因为会发现 194.17.20.128/25 也落在这个 /23 范围里。
但这恰恰是这题的设计点：可以聚合，重叠没关系，后面靠最长前缀匹配解决。

R3 的接口 IP 给的是 194.17.24.2，所以这条聚合路由是：

194.17.20.0/23 -> 194.17.24.2 -> S1

R2 自己直连的子网是：

194.17.20.128/25

这条不需要下一跳，直接从 E0 发出即可。

所以，R2 的最简路由表应为

目的网络	下一跳	接口
153.14.5.0/24	153.14.3.2	S0
194.17.20.128/25	直接交付	E0
194.17.20.0/23	194.17.24.2	S1

这里“直接交付”也可以写成“-”或“直连”，看老师或题目习惯。

第 2 问：R2 收到目的地址为 194.17.20.200 的 IP 分组，经哪个接口转发？

先判断这个地址属于哪些网段。

194.17.20.200 落在：

194.17.20.128/25 中，因为这个 /25 的地址范围是 194.17.20.128 ~ 194.17.20.255
同时也落在 194.17.20.0/23 中，因为 /23 的范围是 194.17.20.0 ~ 194.17.21.255

也就是说，这个目的地址会匹配两条路由：

194.17.20.128/25 -> E0
194.17.20.0/23 -> S1

此时不能随便选，而是要按 最长前缀匹配。
/25 比 /23 更长、更具体，所以优先选 /25 这一条。

因此，R2 会通过 E0 接口 转发该 IP 分组。

第 2 问答案

R2 通过 E0 接口转发。

第 3 问：R1 与 R2 之间利用哪个路由协议交换路由信息？该报文封装到哪个协议的分组中传输？

R1 属于 AS1，R2 属于 AS2。
它们处在两个不同自治系统之间，所以这里使用的是 BGP，更准确地说是 eBGP。

BGP 的一个常考点是：
BGP 报文不是直接封装到 IP 数据报中，而是先封装到 TCP 报文段中传输。

也就是：

BGP 报文 → TCP 报文段 → IP 数据报

第 3 问答案

R1 与 R2 之间使用 BGP（严格说是 eBGP） 交换路由信息。
BGP 报文封装在 TCP 报文段 中传输。

这道题为什么容易错

最容易错的地方有两个。

第一个错法，是第 1 问不敢把 194.17.20.0/25 和 194.17.21.0/24 聚合成 194.17.20.0/23。
原因是看到它和 194.17.20.128/25 有重叠，就以为不能聚合。实际上可以聚合，只要保留更具体的直连路由即可。

第二个错法，是第 2 问看到 194.17.20.200 属于 194.17.20.0/23，就直接选 S1。
这说明没有用最长前缀匹配。考试里只要出现“一个地址同时匹配多条路由”，优先级永远先看掩码长度，掩码长的优先。

这类题以后怎么快速识别

看到这种题，建议固定按这个顺序做：

先把“直连网段”和“经邻居到达的网段”分开。
然后只对“同一方向、同一下一跳”的多个网段做聚合。
聚合完以后，再检查是否与某条更具体的直连路由重叠。
如果重叠，不必慌，只要保留更具体路由，转发时靠最长前缀匹配即可。
最后如果题目问不同 AS 之间的协议，直接想到 BGP；如果再问封装，直接想到 TCP。

OSPF 链路状态题与路由表压缩题解析

这道题很有代表性，因为它不是单纯考 OSPF 的定义，而是把三个层面的内容放到了一起：先根据链路状态信息恢复拓扑并计算最短路径，再根据最短路径填写路由表，最后再结合最长前缀匹配，把路由表压缩到尽可能少。做这类题时，思路一定不能乱，否则很容易把“Router ID”“下一跳地址”“出口接口”“路径代价”这些概念混在一起。

一、先把题目考的核心抓出来

这道题本质上考了四件事。

第一是 OSPF 的最短路径计算。也就是根据各链路的 Metric，确定从 R1 到各目的网络应该走哪条路径。

第二是路由表项的含义。路由表里写的不是整条路径，而是“目的网络、下一跳、出口接口”。

第三是路由聚合与最长前缀匹配。题目要求“路由项尽可能少”，这就不是机械地把每个子网写一条，而是要看哪些路由能合并。

第四是 TTL 的变化规律。IP 分组每经过一个路由器，TTL 减 1，到主机时不再减少。

这一题之所以容易出错，就是因为很多人把“先求最短路”和“再压缩路由表”这两个阶段混为一谈。实际上，必须先把每个子网各自的最优路径算对，之后才谈得上合并路由项。

二、根据题图先恢复 R1 到各子网的最短路径

从图中可以读出如下信息。

R1 直连 192.1.1.0/24，接口是 E0，代价为 1。
R1 到 R2 的链路代价为 3，R1 这侧接口是 L0，R2 对端地址是 10.1.1.2。
R1 到 R3 的链路代价为 2，R1 这侧接口是 L1，R3 对端地址是 10.1.1.10。
R2 直连 192.1.6.0/24，代价为 1。
R3 直连 192.1.5.0/24，代价为 1。
R4 直连 192.1.7.0/24，代价为 1。
R2 到 R4 的链路代价为 4。
R3 到 R4 的链路代价为 6。

现在从 R1 出发，分别求到各个 192.1.x.0/24 子网的最短代价。

到 192.1.1.0/24：这是 R1 自己直连网络，所以总代价就是 1。

到 192.1.5.0/24：最明显的路径是 R1 → R3 → 192.1.5.0/24，总代价为：

2 + 1 = 3

到 192.1.6.0/24：路径为 R1 → R2 → 192.1.6.0/24，总代价为：

3 + 1 = 4

到 192.1.7.0/24：这里有两种候选路径。

路径 1：R1 → R2 → R4 → 192.1.7.0/24
总代价：

3 + 4 + 1 = 8

路径 2：R1 → R3 → R4 → 192.1.7.0/24
总代价：

2 + 6 + 1 = 9

所以应该选路径 1，也就是经过 R2 再到 R4。

这样，R1 到各子网的最短路径结果就出来了：

目的网络	最短路径	代价
192.1.1.0/24	R1 直连	1
192.1.5.0/24	R1 → R3 → 192.1.5.0/24	3
192.1.6.0/24	R1 → R2 → 192.1.6.0/24	4
192.1.7.0/24	R1 → R2 → R4 → 192.1.7.0/24	8

三、由最短路径转成 R1 的路由表项

这一步是很多人最容易写错的地方。

路由表项写的是“去某个目的网络时，我下一步把分组交给谁，从哪个接口送出去”。所以要特别区分三件东西：

Router ID 不是下一跳地址。
下一跳通常写相邻路由器在该链路上的接口 IP。
接口写的是本路由器自己的输出接口，不是对端的接口。

因此：

去 192.1.1.0/24 时，因为它是直连网络，所以可以写“直连”，接口为 E0。

去 192.1.5.0/24 时，R1 的下一跳是 R3。R3 在这条链路上的接口地址是 10.1.1.10，R1 自己发出去的接口是 L1。

去 192.1.6.0/24 时，R1 的下一跳是 R2。R2 在这条链路上的接口地址是 10.1.1.2，R1 的输出接口是 L0。

去 192.1.7.0/24 时，虽然最终要经过 R4，但对 R1 来说，下一跳仍然只是 R2，所以下一跳依旧是 10.1.1.2，接口依旧是 L0。

所以，不做压缩时，R1 的路由表应为：

目的网络	下一跳	接口
192.1.1.0/24	直连	E0
192.1.5.0/24	10.1.1.10	L1
192.1.6.0/24	10.1.1.2	L0
192.1.7.0/24	10.1.1.2	L0

四、为什么还能继续压缩路由表

题目明确说“路由表中的路由项尽可能少”，这说明不能停在上面这 4 项，还得继续看能不能聚合。

这时候要检查的不是“地址像不像”，而是两个条件是否同时满足：

同一组目的网络是否能用一个更大的前缀表示；
这些网络的下一跳和出口接口是否完全相同。

观察 192.1.6.0/24 和 192.1.7.0/24：

它们地址连续。
它们的下一跳都为 10.1.1.2。
它们的输出接口都为 L0。

所以这两项可以聚合成一项：

192.1.6.0/23

因为 /23 的覆盖范围正好是：

192.1.6.0 ~ 192.1.7.255

这就刚好把 192.1.6.0/24 和 192.1.7.0/24 两个网段都包含进来了。

因此，压缩后的最简路由表为：

目的网络	下一跳	接口
192.1.1.0/24	直连	E0
192.1.5.0/24	10.1.1.10	L1
192.1.6.0/23	10.1.1.2	L0

这就是这道题第 1 问最稳妥、最自然的答案。

五、第二问为什么是从 L0 转发，TTL 为什么是 61

题目说，主机 192.1.1.130 向主机 192.1.7.211 发送一个 TTL = 64 的 IP 分组。

先看目的地址 192.1.7.211 会匹配哪条路由。

在 R1 的最简路由表中：

192.1.1.0/24 显然不匹配。
192.1.5.0/24 也不匹配。
192.1.6.0/23 的覆盖范围是 192.1.6.0 ~ 192.1.7.255，所以 192.1.7.211 落在这个范围里。

因此，R1 一定会按照这条聚合路由转发，也就是：

下一跳是 10.1.1.2，接口是 L0

所以第 2 问前半问的答案是：R1 通过 L0 接口转发该 IP 分组。

接着看 TTL。

TTL 的规则非常机械：每经过一个路由器，TTL 减 1。主机发送时不减，主机接收时也不会再减。

该分组实际经过的路由器是：

R1 → R2 → R4

也就是一共经过 3 个路由器，所以 TTL 的变化过程为：

64 → 63 → 62 → 61

因此，主机 192.1.7.211 收到该分组时，TTL 是 61。

这一问特别容易错成 62，原因通常是少算了一个路由器。很多人下意识只算中间转发的两个路由器 R2、R4，却忘了 R1 自己也是一个转发路由器。只要 IP 分组进入 R1 并由 R1 转发出去，R1 就已经会让 TTL 减 1。

六、第三问本质上是在考默认路由的发布

题目最后问：如果 R1 增加一条 Metric 为 10 的链路连接 Internet，那么 R1 的 LSI 需要增加哪些信息。

这道题在考研语境下，不必往真实 OSPF 协议的各种 LSA 类型上钻得太深，先抓住本质：R1 现在变成了一个能到达外部网络的出口路由器，所以它应该向其他路由器表明“我这里可以通向 Internet”。

在路由表层面，这个信息最典型的表达方式就是默认路由：

0.0.0.0/0

因此，在题目这个简化的 LSI 表达方式下，核心新增信息应当是：

Prefix = 0.0.0.0/0
Metric = 10

也就是说，要增加一条表示“可到达默认网络”的记录。

如果把题目理解得更细一点，因为新增的是“一条链路”，那么还可以补充理解为：R1 还会多一条新的外连链路信息，包括这条链路上的本地 IP 地址，以及该链路的 Metric 为 10。但在题目这种表格结构和得分逻辑下，真正关键的得分点仍然是这条默认前缀信息。

所以第 3 问写成下面这样最稳：

新增一条到 Internet 的默认路由信息：
Prefix = 0.0.0.0/0，Metric = 10

七、这类题以后怎么快速做

把这道题抽象一下，今后遇到类似题目，基本都可以按这个模板做。

1. 先算“到每个目的网络”的最短路

注意不是先写路由表，而是先把每个网络的最优路径和总代价算出来。
这一步如果错了，后面所有下一跳、接口、TTL 都会跟着错。

2. 再把最短路翻译成路由表项

翻译时固定问自己三个问题：

这个目的网络是什么？
我的第一跳交给谁？
我是从自己的哪个接口发出去？

只要把“下一跳”和“出口接口”分清，路由表就不会乱。

3. 再检查能不能聚合

聚合必须同时满足两个条件：

地址前缀上可合并；
下一跳相同，接口也相同。

只看地址连续而忽略下一跳是否一致，是这类题最常见的陷阱。

4. TTL 只按“经过几个路由器”来减

每过一个路由器，减 1。
主机不参与减 TTL。
不要少算第一台路由器，也不要把目的主机算进去。

八、这道题最容易犯的几个错误

这题非常适合拿来总结错因，因为每个错误都很典型。

1. 把 Router ID 当成下一跳地址

这是 OSPF 题里很常见的错误。
Router ID 是协议内部标识，不等于路由表里填写的下一跳 IP。
路由表里通常写相邻路由器在该链路上的接口地址。

2. 把对端接口当成自己的出口接口

比如去 R2，R1 的出口接口是 L0，不是 R2 的接口。
题目问的是“R1 通过哪个接口转发”，所以一定写 R1 自己的接口名。

3. 只会逐项写路由，不会做聚合

题目专门说“路由项尽可能少”，这时就说明不能只停留在普通路由表层面，必须想到前缀合并。

4. TTL 少减一次

尤其是源主机就在 R1 直连网段时，很多人会误以为 R1 不算“经过的路由器”。其实只要是由 R1 转发出去，R1 就一定会使 TTL 减 1。

九、最终答案整理

第 1 问：R1 的最简路由表

目的网络	下一跳	接口
192.1.1.0/24	直连	E0
192.1.5.0/24	10.1.1.10	L1
192.1.6.0/23	10.1.1.2	L0

第 2 问

R1 通过 L0 接口转发该 IP 分组。
主机 192.1.7.211 收到该 IP 分组时，TTL 为 61。

第 3 问

R1 的 LSI 至少应增加一条默认路由信息：

Prefix = 0.0.0.0/0
Metric = 10

这道第 6 题是把 RIP、OSPF、TTL、RIP 收敛、BGP 会话类型、BGP 选路这几块串在一起考，属于很典型的“跨知识点综合题”。这类题最重要的不是只看某一个点，而是先把图的层次分清：

AS1 是内部自治系统，内部跑 RIP。
AS2、AS3、AS4 和 AS1 之间属于不同自治系统之间的通信，涉及 BGP。
210.2.3.0/24 和 210.2.4.0/24 是 AS1 内部的两个目的网络。
136.5.16.0/20 是外部可达网络，通过不同 AS 向 AS1 通告。

先把答案直接给出来：

AS4 应选择 OSPF。
初始 TTL 至少应设为 16。
到 210.2.3.0/24 全部收敛至少需要 30s；到 210.2.4.0/24 全部收敛至少需要 60s。
R44 向 R13 通告时，使用 eBGP 会话，通告报文是 UPDATE；R13 向 R14、R15 通告时，使用 iBGP 会话。
R14 的下一跳是 R11，R15 的下一跳是 R13。

下面按题目顺序详细拆。

第 1 问：AS4 应该选 RIP 还是 OSPF

本题结论

AS4 应选择 OSPF。

为什么

题干已经给了一个很关键的信息：
“AS4 规模较大，自治系统内任意两个主机间通信，经过路由器的数量可能超过 20 个。”

这句话几乎就是在提示不能选 RIP。

因为 RIP 的度量是“跳数”，并且规定：

最大跳数 = 15

也就是说，超过 15 跳就认为不可达。

而题目明确说 AS4 内部可能超过 20 个路由器，因此如果选 RIP，就会出现“明明能到，但 RIP 认为不可达”的问题，所以不能选 RIP。

OSPF 属于链路状态协议，没有 RIP 这种 15 跳上限，更适合大规模自治系统，收敛速度也更快，所以应该选 OSPF。

这类题怎么快速识别

只要看到下面这种表述，基本就往 OSPF 想：

网络规模大
路由器数量多
路径可能超过 15 跳
希望快速收敛

只要题目把“超过 15 跳”这种话写出来，几乎就是在排除 RIP。

第 2 问：TTL 至少应设置为多少

本题结论

初始 TTL 至少应设置为 16。

解题关键

TTL 每经过 一个路由器，就减 1。
终点主机接收分组时，不会再把 TTL 减 1。

题干说：

“AS3 规模较小，自治系统内任意两个主机间通信，经过路由器的数量不超过 15 个。”

也就是说，最坏情况下，一个 IP 分组要经过 15 个路由器。

为了让分组在通过最后一个路由器后仍然能被正常转发到目标主机，TTL 在最后一个路由器转发之后必须仍然大于 0。

如果初始 TTL = 15，那么：

过第 1 个路由器后变 14
…
到第 15 个路由器时会减到 0

TTL 变成 0 时，路由器就要丢弃该分组，因此 15 不够。

所以至少应满足：

初始 TTL = 路由器个数 + 1 = 15 + 1 = 16

易错点

很多人会误写成 15，原因是把“经过 15 个路由器”直接等同于“TTL 设 15 就够”。
这是错的。因为 TTL 是在路由器转发时先减 1，再决定是否继续转发。

第 3 问：RIP 收敛时间怎么求

这一问是整题里最容易出错的地方，因为很多人会忽略“启动后立即交换初始距离向量”这句话。

先看拓扑关系

AS1 内部链路可以从图上读出来：

上层：R11 — R12 — R13
纵向/斜向：R11 — R14，R12 — R15，R13 — R15
下层：R14 — R15 — R16

并且：

210.2.3.0/24 直接连在 R14 这一侧
210.2.4.0/24 直接连在 R16 这一侧

题目又说：

所有路由器同时启动
启动后立即交换一次初始距离向量
之后每隔 30s 再交换一次最新距离向量

所以计算时刻要从“初始交换”开始算，不能平白多加一个 30s。

3.1 到达 210.2.3.0/24 的正确路由，至少多长时间

本题结论

至少需要 30s。

推理过程

第 0 轮：t = 0，交换初始距离向量

210.2.3.0/24 是 R14 直连网络，因此一开始只有 R14 知道这条路由。
在 t = 0 交换初始距离向量后，R14 的邻居就能学到这条路由。

R14 的邻居有：

所以在 t = 0 后，已知该路由的路由器有：

R14（本来就知道）
R11
R15

第 1 轮：t = 30s，再交换一次

这时 R11 和 R15 会把自己学到的路由继续通告出去。

于是：

R12 可从 R11 或 R15 学到
R13 可从 R15 学到
R16 可从 R15 学到

这样 R11～R16 全部都知道到达 210.2.3.0/24 的正确路由了。

所以最少时间是 30s。

一个更快的判断方法

看“离直连路由器最远的那个路由器”有几跳。

对于 210.2.3.0/24，直连路由器是 R14。
从 R14 到最远的路由器，最远只需要经过两轮传播：

第 0 轮：先传给一跳邻居
第 1 轮：再传给两跳邻居

因此总时间就是 1 个更新周期，即 30s。

3.2 到达 210.2.4.0/24 的正确路由，至少多长时间

本题结论

至少需要 60s。

推理过程

210.2.4.0/24 是 R16 直连网络。

第 0 轮：t = 0

R16 先把路由通告给它的邻居。
R16 的邻居只有 R15。

所以 t = 0 后知道该路由的有：

第 1 轮：t = 30s

R15 再向外传播，于是：

R14 学到
R12 学到
R13 学到

这时还剩 R11 不知道。

第 2 轮：t = 60s

R14 或 R12 再把该路由传给 R11，
于是 R11 也学到。

至此，R11～R16 全部获得到达 210.2.4.0/24 的正确路由。

所以最少时间是 60s。

这一问最容易错在哪里

错法 1：把“立即交换初始距离向量”忘了

如果忘了这句话，就会把答案多算一个周期，写成：

210.2.3.0/24：60s
210.2.4.0/24：90s

这是常见错误。

错法 2：不会数传播轮次

RIP 这种题，本质就是“距离向量一轮一轮向外扩散”。

可以记一个做题模板：

直连路由器：初始就知道
初始交换后：一跳邻居知道
再过一个周期：两跳邻居知道
再过一个周期：三跳邻居知道

也就是“每过一个更新周期，已知范围向外扩一跳”。

第 4 问：BGP 会话类型和报文类型

本题结论

R44 向 R13 通告到网络 136.5.16.0/20 的路由时：

使用 eBGP 会话
使用 UPDATE 报文通告

R13 再把该网络可达性信息通告给 R14 和 R15 时：

使用 iBGP 会话

为什么

R44 到 R13

R44 属于 AS4，R13 属于 AS1。
不同自治系统之间建立的 BGP 会话叫 eBGP。

而 BGP 中携带可达性信息、撤销路由信息、路径属性信息的报文，是 UPDATE 报文。

所以这里是：

R44 -> R13：eBGP + UPDATE

R13 到 R14、R15

R13、R14、R15 都在 AS1 内部。
同一自治系统内部的 BGP 会话叫 iBGP。

所以：

R13 -> R14/R15：iBGP

这类题的秒杀思路

只看是否跨 AS：

跨 AS：eBGP
同 AS：iBGP

只要题目说“通告路由”“发布可达性信息”，优先想到 UPDATE 报文。

第 5 问：R14 和 R15 最终选择哪个下一跳

这一问考的是 BGP 选路。

题目给出的三条路由

到达目的网络 136.5.16.0/20，有三条候选：

下一跳 R11，AS 路径：AS2 AS8 AS19
下一跳 R12，AS 路径：AS3 AS7 AS11 AS19
下一跳 R13，AS 路径：AS4 AS10 AS19

第一步：先比 AS_PATH 长度

在“无策略约束”下，先看 AS_PATH 长度，通常优先选更短的 AS 路径。

三条路径长度分别是：

经 R11：3
经 R12：4
经 R13：3

所以经 R12 的那条路径更长，先淘汰。
剩下：

经 R11
经 R13

第二步：再比到下一跳的内部代价

剩下两条 AS_PATH 长度相同，这时通常比较到 BGP 下一跳的 IGP 代价，谁离出口更近，就从谁出去。这就是常说的“热土豆路由”。

5.1 R14 选谁

从图上看：

R14 到 R11：1 跳（直接相连）
R14 到 R13：可走 R14 → R15 → R13，共 2 跳

因此 R14 更靠近 R11，应该选经 R11 的那条出口路由。

所以：

R14 的下一跳 = R11

5.2 R15 选谁

从图上看：

R15 到 R13：1 跳（直接相连）
R15 到 R11：最少 2 跳，可走 R15 → R14 → R11，或者 R15 → R12 → R11

因此 R15 更靠近 R13，应该选经 R13 的那条出口路由。

所以：

R15 的下一跳 = R13

这道综合题到底在考什么

这题实际上在同时考 5 个判断模板：

内部网关协议选型
看到“大规模、超 15 跳”，就要排除 RIP，选 OSPF。
TTL 的最小值
记住：
最小 TTL = 经过的路由器数 + 1
RIP 收敛时间
记住：
“距离向量每过一个更新周期，最多向外传播一跳。”
但要特别看题目有没有说“启动后立即交换一次初始距离向量”。
BGP 会话类型
- 跨 AS：eBGP
- 同 AS：iBGP
BGP 选路
在无策略约束下，先比 AS_PATH 长度；若相同，再比到出口的内部代价，谁近走谁。

这类题的难点，不在于某一个知识点特别难，而在于容易把多个协议的规则混在一起。做题时最好先在草稿上标明：

哪些属于 AS 内部
哪些属于 AS 之间
哪个协议负责哪一段
哪条路由是直连、哪条是传播得到的

这样基本就不会乱。