408数据结构-图的应用2-最短路径 自学知识点整理

前置知识：最小生成树，图的遍历

---

最短路径

当图是带权图时，把从一个顶点$v_0$到图中其余任意一个顶点$v_i$的一条路径所经过边上的权值之和，定位为该路径的带权路径长度，把带权路径长度最短的那条路径（不唯一）称为最短路径。
求解最短路径的算法通常都依赖于一种性质，即两点之间的最短路径也包含了路径上其他顶点之间的最短路径。带权有向图$G$的最短路径问题一般可分为两类：一类是单源最短路径，顾名思义“单个源头”，即求从图中某一顶点到其他各顶点的最短路径，可通过经典的$Dijkstra$（迪杰斯特拉）算法求解；另一类是求每对顶点间的最短路径，可通过$Floyed$（弗洛伊德）算法来求解。

回顾：BFS算法求解单源最短路径

广度优先搜索查找最短路径只是对无权图而言的。

无权图可以视为一种特殊的带权图，只是每条边的权值为$1$。

若图$G=(V,E)$为无权图，定义从顶点$u$到顶点$v$的最短路径$d(u,v)$为$u$到$v$的任何路径中最少的边数；若从$u$到$v$没有通路，则$d(u,v)=\infty$。
使用$BFS$，我们可以求解一个满足上述定义的“无权图的单源最短路径问题”，这是由广度优先搜索总是按照距离由近到远来遍历图中每个顶点的性质决定的。
首先是预处理：使用邻接表对图进行存储。

#define MaxVertexNum 810
#define INF 0x7fffffff
//INF就是无穷大

typedef struct ArcNode {
	int adjvex;
	struct ArcNode* nextarc;
}ArcNode;
typedef struct VNode {
	int data;
	ArcNode* firstarc;
}VNode, AdjList[MaxVertexNum];
typedef struct {
	AdjList vertices;//邻接表存储图
	int vexnum, arcnum;
}ALGraph;
bool Visited[MaxVertexNum];//辅助数组标记顶点是否被访问

typedef struct LinkNode {
	int Vertex;//图的顶点编号
	struct LinkNode* next;
}LinkNode;
typedef struct {
	LinkNode* front, * rear;//链队列
}LinkQueue;

void InitQueue(LinkQueue& Q) {
	LinkNode* p = (LinkNode*)malloc(sizeof(LinkNode*));
	p->Vertex = -1;
	p->next = NULL;
	Q.front = Q.rear = p;//初始化队列
	return;
}

bool Q_Is_Empty(LinkQueue Q) {//队列判空
	return Q.front == Q.rear ? true : false;
}

void EnQueue(LinkQueue& Q, int i) {//新元素入队
	LinkNode* p = (LinkNode*)malloc(sizeof(LinkNode*));
	p->Vertex = i;
	p->next = NULL;
	Q.rear->next = p;
	Q.rear = p;
	return;
}

void DeQueue(LinkQueue& Q, int& x) {//队头元素出队
	LinkNode* p = Q.front->next;
	x = p->Vertex;
	Q.front->next = p->next;
	if (Q.rear == p)Q.rear = Q.front;
	free(p);
	return;
}

$BFS$求解单源最短路径问题：即求顶点$u$到其他顶点的最短路径。

//求顶点u到其他顶点的最短路径
void BFS_MIN_Distance(ALGraph G, LinkQueue& Q, int u) {
	int d[MaxVertexNum], path[MaxVertexNum], v;
	//d[i]表示从u到i结点的最短路径；path[i]表示顶点u到顶点i的最短路径上，顶点i的直接前驱
	memset(d, INF, sizeof(d));//初始化路径长度为无穷大
	memset(path, -1, sizeof(path));//初始化所有顶点的直接前驱为-1
	Visited[u] = true, d[u] = 0;
	EnQueue(Q, u);
	while (!Q_Is_Empty(Q)) {//BFS主过程
		DeQueue(Q, u);//队头元素出队
		for (ArcNode* w = G.vertices[u].firstarc; w != NULL; w = w->nextarc) {
			//遍历u的所有邻接点
			v = w->adjvex;
			if (!Visited[v]) {//若未访问
				Visited[v] = true;//标记访问
				d[v] = d[u] + 1;//路径长度加1
				path[v] = u;//最短路径中，应是从u到v
				EnQueue(Q, v);//顶点w入队
			}
		}
	}
	return;
}

$BFS$的完整代码可以看我的Github：传送门

其中，数组$d[]$是用来记录每一个顶点到原始顶点的最短路径的长度，而数组$path[]$则是用来记录每一个顶点在这个最短路径上的直接前驱。通过$path[]$数组，可以从某一个顶点出发，一直逆向找到原始顶点，从而确定最短路径上经过的所有顶点。

知识点回顾：广度优先生成树
以原始顶点为根节点，对无权图构建一棵广度优先生成树，它的深度（高度）一定是最小的，各顶点所在的层数，也直接反映了原始顶点到该顶点的距离。

$Dijkstra$算法求解单源最短路径问题

$Dijkstra$算法通过设置一个集合$S$记录已求得的最短路径的顶点。初始时把源点$v_0$放入$S$，集合$S$每并入一个新顶点$v_i$，都要修改源点到集合$V-S$中顶点当前的最短路径长度值。
构造过程中，设置三个辅助数组：

• $final[]$：标记各顶点是否已找到最短路径，即是否已归入集合$S$。
• $dist[]$：记录从源点$v_0$到其他各顶点当前的最短路径长度，它的初始值为：若从$v_0$到$v_i$有弧，则$dist[i]$为弧上的权值；否则置$dist[i]$为$\infty$。
• $path[]$：$path[i]$表示从源点到顶点$i$之间的最短路径的前驱结点。在算法结束时，可根据其值追溯得到源点$v_0$到顶点$v_i$的最短路径。

假设从顶点$0$出发，即$v_0=0$，集合$S$最初只包含顶点$0$，邻接矩阵$arcs$表示带权有向图，$arcs[i][j]$表示有向边$<i,j>$的权值，若不存在有向边$<i,j>$，则$arcs[i][j]$为$\infty$。

$Dijkstra$算法的步骤如下（不考虑对$path[]$的操作）：

1. 初始化：集合$S$初始为$0$，$dist[]$初始值$dist[i]=arcs[0][i],i=1,2,\cdots ,n-1$。
2. 从顶点集合$V-S$中选出$v_j$，满足 d i s t [ j ] = M i n { d i s t [ i ] ∣ v i ∈ V − S } dist\left[ j \right]=Min\left\{ dist\left[ i \right]\left| {{v}_{i}}\in V-S \right. \right\} dist[j]=Min{dist[i]∣vi​∈V−S}，$v_j$就是当前求得的一条从$v_0$出发的最短路径的终点，令 S = S ⋃ { j } S=S\bigcup \left\{ j \right\} S=S⋃{j}。
3. 修改从$v_0$出发到集合$V-S$上任意一个顶点$v_k$可达的最短路径长度：若$dist\left[j\right]+arcs\left[j\right]\left[k\right]<dist\left[k\right]$，则更新$dist\left[k\right]=dist\left[j\right]+arcs\left[j\right]\left[k\right]$。

下面是王道书上的一个关于实例的讲解，读者可以自己耐心看看理解一下$Dijkstra$算法的执行过程。
（图片来自王道考研408数据结构2025）

显然，$Dijkstra$算法也是基于贪心策略的。
使用邻接矩阵表示时，时间复杂度为$O(|V{|}^2)$。使用带权的邻接表表示时，虽然修改$dist[]$的时间可以减少，但由于在$dist[]$中选择最小分量的时间不变，所以时间复杂度仍为$O(|V{|}^2)$。
即使只求解从源点到特定顶点的最短路径，时间复杂度依旧为$O(|V{|}^2)$。

注意：边上带有负权值时，$Dijkstra$算法将失效。既有可能出现有更短的路径而无法修改的情况，也有可能出现负环而导致死循环的情况。
（对前一种情况，例如：$v_0->v_1=10,v_0->v_2=7,v_1->v_2=-5$，$Dijkstra$算法会将$dist[2]$置为$7$而后无法更新，实际上有一条距离更短的路径存在）
（对后一种情况，例如：$v_0->v_1=1,v_1->v_0=-2,v_1->v_2=1$，此时$v_0$和$v_1$之间构成一段负环，越走路径长度越小，会导致$Dijkstra$算法陷入死循环）

思考：$Dijkstra$算法与$Prim$算法有何异同之处？

答：$Dijkstra$算法的流程、操作与$Prim$算法都很相似，核心思想都是基于贪心策略实现。区别在于：
①目的不同：$Dijkstra$算法的目的是构建单源点的最短路径树，$Prim$算法的目的是构建最小生成树。
②算法思路略有不同：$Prim$算法从一个点开始，每次选择权值最小的边，将其连接到已构建的生成树上，直至所有顶点都已加入；而$Dijkstra$算法每次找出到源点距离最近且为归入集合的点，并把它归入集合，同时以这个点为基础更新从源点到其他所有顶点的距离。
③适用的图不同：$Prim$算法只能用于带权无向图，$Dijkstra$算法可用于带权有向图或带权无向图（权值必须非负）。
时间复杂度不同：两个算法的时间复杂度之间有所不同。

$Floyed$算法求各顶点之间最短路径问题

求所有顶点之间的最短路径问题描述如下：已知一个各边权值均非负的带权有向图，对任意两个顶点$v_i\ne v_j$，要求求出$v_i$与$v_j$之间的最短路径和最短路径长度。
$Floyed$算法的实现基于动态规划（$dp$），即把一个大问题分解为若干个性质相同，但规模更小的子问题，通过求解这些子问题的最优解进而求得大问题的最优解。类似于贪心，但是贪心求解的是局部最优解，可能会出现得不到全局最优解的情况，而动态规划使用了状态转移方程，能够较好地规避这个问题。关于动态规划的更多内容请参见：动态规划基础 - OI Wiki。
$Floyed$算法的基本思想是：递推产生一个$n$阶方阵序列$A^{\left(-1\right)},A^{\left(0\right)},\cdots ,A^{\left(k\right)},\cdots ,A^{\left(n-1\right)}$，其中$A^{(k)}[i][j]$表示从顶点$v_i$到顶点$v_j$之间的路径长度，$k$表示绕行第$k$个顶点的运算步骤（即增加第$k$个顶点作为中继点，$k=-1$时表示无任何中继点）。初始时，对于任意两个顶点$v_i$和$v_j$，若它们之间存在边，则以此边上的权值作为它们之间的最短路径，若不存在则置为$\infty$。之后逐步尝试在原路径中加入顶点$k$（$k=0,1,\cdots ,n-1$）作为中继顶点。若增加中继顶点后，得到的新路径比原来的路径长度要小，则以此新路径代替原路径。算法描述如下：

• 定义一个$n$阶方阵序列$A^{\left(-1\right)},A^{\left(0\right)},\cdots ,A^{\left(k\right)},\cdots ,A^{\left(n-1\right)}$，其中，
• $$A^{\left(-1\right)}\left[i\right]\left[j\right]=arcs\left[i\right]\left[j\right]$$
• $$A^{\left(k\right)}\left[i\right]\left[j\right]=Min\left\{A^{\left(k-1\right)}\left[i\right]\left[j\right],A^{\left(k-1\right)}\left[i\right]\left[k\right]+A^{\left(k-1\right)}\left[k\right]\left[j\right]\right\},k=0,1,\cdots ,n-1$$

式中，$A^{\left(0\right)}\left[i\right]\left[j\right]$是从顶点$v_i$到顶点$v_j$、中继顶点是$v_0$的最短路径的长度。$A^{\left(k\right)}\left[i\right]\left[j\right]$是从顶点$v_i$到$v_j$、中继顶点是序号不大于$k$的顶点的最短路径的长度。$Floyed$算法是一个迭代的过程，每迭代一次，在从$v_i$到$v_j$的最短路径上就多考虑了一个顶点；经过$n$次迭代后，所得到的$A^{\left(n-1\right)}\left[i\right]\left[j\right]$就是$v_i$到$v_j$的最短路径长度，即方阵$A^{\left(n-1\right)}$中就保存了任意一对顶点之间的最短路径长度。
下面是王道书上的一个关于实例的讲解，读者可以自己耐心看看理解一下$Floyed$算法的执行过程。当然，我个人认为王道的课在这一块讲得更好，比书上的东西更加清晰一些，感兴趣的读者可以去看看相关视频：王道计算机考研 数据结构 P67 6.4_4_最短路径问题_Floyed算法。
（图片来自王道考研408数据结构2025）

其核心代码实现，其实非常简单：

for (int k = 0; k < n; ++k)
	for (int i = 0; i < n; ++i)
		for (int j = 0; j < n; ++j)
			if (A[i][j] > A[i][k] + A[k][j])
				A[i][j] = A[i][k] + A[k][j], path[i][j] = k;

$Floyed$算法的时间复杂度为$O(|V{|}^3)$。因为其代码结构简单紧凑，不包含其他复杂的数据结构，因此隐含的常数系数是很小的（不容易被卡常），对中等规模的输入来说，它仍然是相当有效的。
$Floyed$算法允许图中有带负权值的边，但不允许有负权回路（这样的图里可能不存在最短路）。
$Floyed$算法同样适用于带权无向图。
求各顶点之间最短路径问题也可以使用$Dijkstra$算法，前提是图中没有负权值的边。依次将所有顶点都作为源点，分别运行一次$Dijkstra$算法，时间复杂度同样为$O(|V{|}^3)$。当然，$Dijkstra$算法可以使用 堆/优先队列 优化，使得时间复杂度从$O(n^2)$降到$O(nlogn)$（$n=|V|$），不过408考研初试并不需要掌握这么高级的东西。

相关例题：【洛谷P3371】【模板】单源最短路径（弱化版） 解题报告

• 这篇博客是我对$Dijkstra$算法的应用，感兴趣的读者可以看看。另外我也写了这题$Floyed$算法的40分解法，完整代码可以参看我的Github：传送门。
• 核心代码如下：

for (int k = 1; k <= n; ++k)
	for (int i = 1; i <= n; ++i)
		for (int j = 1; j <= n; ++j)
			if (A[i][j] > A[i][k] + A[k][j])
				A[i][j] = A[i][k] + A[k][j], path[i][j] = k;

另外求解最短路径问题的算法还有$Bellman-ford$算法，$SPFA$算法等，408考研初试也并不要求掌握这些。不过我以前打$OI$的时候学过，所以提一嘴，实际上我以前学的也不好就是了。

---

408考研初试中，对这部分主要考察手动推算相关算法的执行过程，对代码的考查频率较低。
以上。