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

最短路径

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

回顾：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;
}

//求顶点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】【模板】单源最短路径（弱化版） 解题报告

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;