关于『数据结构』：图论

最新推荐文章于 2023-05-27 20:27:04 发布
最新推荐文章于 2023-05-27 20:27:04 发布
阅读量535 收藏 4
点赞数
分类专栏： 图论 数据结构 文章标签： 算法 c++ 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/infor_kylin/article/details/125909648
版权

序言

  拥抱大只图论。
  诸位怎么都如此能肝，md 就我图论还没写完。
  (投放My blogs csdn & 博客园😃。)

导览

一、图的基本概念

（一）什么是图（已更）
（二）图的存储（已更）
（三）图的遍历（已更）

二、最短路

（一）Floyd（已更）
（二）Dijkstra（已更）
（三）Bellman-Ford（已更）
（四）SPFA（已更）

三、最小生成树

（一）Prim（已更）
（二）Kruskal（已更）

四、拓扑排序（咕咕）

一、图的基本概念

（一）什么是图（graph）？

  举个🌰（栗子）：


图 1-1 一个美丽的图

  图是由若干给定的顶点（例如 V 1 , V 2 V1, V2 V1,V2）及连接两顶点的边（例如 ( V 1 , V 2 ) , ( V 4 , V 5 ) (V1, V2),(V4, V5) (V1,V2),(V4,V5)）所构成的图形。
  这种图形通常用来描述某些具体事物之间的某种特定关系。顶点用于代表事物，连接两顶点的边则用于表示具体事物间的关系。
  若一张图的边数远小于其点数的平方，那么它是一张稀疏图 (sparse graph)。
  若一张图的边数接近其点数的平方，那么它是一张稠密图 (dense graph)。
  若一张图的每条边都被赋予一个数作为该边的 权，则称这张图为赋权图。如果这些权都是正实数，就称其为正权图。
  若图中存在两条边，则它们被称作一组重边(multiple edge)。
  如果一张图中有自环或重边，则称它为多重图 (multigraph)。

Tips：在题目中，如果没有特殊说明，是可以存在自环和重边的，在做题时需特殊考虑。

  若一张图中没有自环和重边，它被称为简单图 (simple graph)。
  边集为空的图称为无边图 (edgeless graph)、空图 (empty graph) 或零图 (null graph)， n n n 阶无边图记作 K ‾ n \overline K_n Kn​ 或 N k N_k Nk​。

  图的点数也被称作图的阶 (order)。

📚 更严谨的定义

  图 (graph) 是一个有序二元组 G = ( V , E ) G = (V, E) G=(V,E) 。其中 V V V 是非空集，称为点集 (vertex set)，对于 V V V 中的每个元素，我们称其为顶点 (vertex) ，简称点； E E E 为 V V V 各结点之间边的集合，称为边集 (edge set)， E E E 的元素都是二元组，用 ( x , y ) (x,y) (x,y) 表示，其中 x , y ∈ V x,y \in V x,y∈V。
  常用 G = ( V , E ) G = (V, E) G=(V,E) 表示图。当 V , E V,E V,E 都是有限集合时，称 G G G 为有限图；当 V V V 或 E E E 是无限集合时，称 G G G 为无限图。

1. 图的种类

  图有多种，包括无向图（undirected graph），有向图（directed graph），混合图（mixed graph），带权图（weighted graph）等（还有很多乱七八糟丰富多彩的图，有兴趣可自行搜索）。

（1）有向图
Ⅰ. 定义

  每条边都有方向的图称为有向图。


图 1-2 有向图（右）和无向图（左）

Ⅱ. 术语

  • 有向边：有向图中的边被称为有向边（directed edge)），又称为弧（arc），在不引起混淆的情况下也可以称作边（edge）；起点称为弧头（tail），终点称为弧尾（head）。在有向图中，与一个顶点相关联的边有出边和入边之分。

    ❔ 为什么起点是 tail，终点是 head？

      边通常用箭头表示，而箭头是从「尾」指向「头」的。

  • 有向路径：相邻顶点的序列。

  • 有向环：一条至少含有一条边且起点和终点相同的有向路径。

    ❔ 起点和终点相同不是至少两条边吗（A →B, B→A），为什么这里写的是「至少含有一条边」

      有一种情况叫做自环（loop），对 E E E 中的边 e = ( u , v ) e = (u,v) e=(u,v)，若 u = v u = v u=v，则 e e e 被称作一个自环。


    图 1-3 自环示意图

  • 有向无环图（DAG）：没有环的有向图。

  • 度（degree）：与该顶点相关联的边的条数，顶点 v v v 的度记作 d ( v ) d(v) d(v)。

    • 入度（in-degree）：与其关联的各边之中，以其为终点的边数，记作 d − ( v ) d^-(v) d−(v)。
    • 出度（out-degree）：以该顶点为起点的边数，记作 d + ( v ) d^+(v) d+(v)。
    📚 更多关于度

      若 d ( v ) = 0 d(v) = 0 d(v)=0 ，则称 v v v 为孤立点 (isolated vertex)。
      若 d ( v ) = 1 d(v) = 1 d(v)=1，则称 v v v 为叶节点 (leaf vertex)/悬挂点 (pendant vertex)。
      若 2 ∣ d ( v ) 2 \mid d(v) 2∣d(v)，则称 v v v 为偶点 (even vertex)。
      若 2 ∤ d ( v ) 2 \nmid d(v) 2∤d(v)，则称 v v v 为奇点 (odd vertex)。图中奇点的个数必然有偶数个（握手定理 推论）。
      若 d ( v ) = ∣ V ∣ − 1 d(v) = \left| V \right| - 1 d(v)=∣V∣−1，则称 v v v 为 支配点 (universal vertex)。

  • 强连通图和强连通分量：在有向图中，如果所有结点两两互相可达，则称该图为强连通的 (strongly connected)。否则，将其中的极大连通子图称为强连通分量。
  • 弱连通图和弱连通分量：若一张有向图的边替换为无向边后可以得到一张连通图，则原来这张有向图是弱连通的 (weakly connected)，将其中的极大弱连通子图称为弱连通分量 。
  • 反图 (transpose graph) ：一个有向图 G = ( V , E ) G = (V, E) G=(V,E) 的反图指的是点集不变，每条边反向得到的图。
  • 完全图 (complete digraph)：若有向图 G G G 满足任意不同两点间均有两条方向不同的边，则称 G G G 为有向完全图 。
（2）无向图
Ⅰ. 定义

  边没有方向的图称为无向图。

Ⅱ. 术语
  • 无向边：无向图中的边被称为无向边（undirected edge)），简称边（edge）。设 e = ( u , v ) e = (u,v) e=(u,v)，则 u u u 和 v v v 称为 e e e 的端点 (endpoint)。
  • 相邻：若一个顶点是一条边的端点，则称这个点与这条边是关联的（incident）或相邻的 （adjacent）。两个顶点之间如果有边连接，则称这两个顶点是相邻的（adjacent）。一个顶点 v ∈ V v \in V v∈V 的邻域 (neighborhood) 是所有与之相邻的顶点所构成的集合，记作 N ( v ) N(v) N(v)。
  • 路径：相邻顶点的序列。
  • 圈：起点和终点重合的路径。
  • 连通图：在无向图中，如果从顶点 v i vi vi 到顶点 v j vj vj 有路径，则称 v i vi vi 和 v j vj vj 连通。如果图中任意两个顶点之间都连通，则称该图为连通图，否则，将其中的极大连通子图称为连通块/连通分量。
  • 度：顶点连接的边数叫做这个顶点的度。
  • 树：没有圈的连通图。
  • 森林：没有圈的非连通图。
  • 完全图 (complete graph)：若无向简单图 G G G 满足任意不同两点间均有边，则称 G G G 为完全图， n n n 阶完全图记作 K n K_n Kn​ 。

图 1-4 连通图（左）与非连通图（右）

习题讲解 「#19884. 无根树转有根树」

原题目链接 link

「我的做题历程」：
step1：观察题面。

  「输入一个 n n n 个节点的无根树的各条边，并指定一个根节点，要求把该树转化为有根树，输出各个节点的父亲编号。」，大概能感受到的，是 DFS 遍历无根树。
  「根节点的父结点输出-1」，还有要注意的，根节点的本没有父亲，在这里我们需要输出 − 1 -1 −1。

step2：思考解法。

  我的想法是先双向存边，然后 DFS 遍历整棵树，在遍历时设置两个参数：当前节点编号，父亲结点编号（上一个节点的编号）。遍历与当前节点相关联的点，除自己的父亲以外，其余都是他的儿子。

step3：完成代码。
代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e2 + 5; 
int n, u, v, fa[N];
vector<int> a[N];
void dfs(int node, int dad) {
	fa[node] = dad; // 记录父亲
	for (int i = 0; i < a[node].size(); i++) {
		if (a[node][i] != dad) {
			dfs(a[node][i], node); // 当前节点为相关节点的父亲节点
		}
	}
	return;
}
int main() {
	scanf("%d", &n); 
	for (int i = 1; i < n; i++) {
	 	scanf("%d %d", &u, &v);
		a[u].push_back(v); // 双向存边
		a[v].push_back(u);
	}
	int root;
	scanf("%d", &root);
	dfs(root, -1); // 根没有父亲
	for (int i = 0; i < n; i++) {
		printf("%d\n", fa[i]);
	}
	return 0;
}

（二）图的表示（存储结构）

「如何用计算机来存储图的信息（顶点、边），这是图的存储结构要解决的问题？」——cqbzgm’s PPT

1. 直接存边

（1）基本思想

  使用结构体来存边，结构体内包含一条边的起点和终点（带权图中还能存边权）。也可以用数组分别存上述信息。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
struct Edge {
	int x, y, w;
} e[M];
void add(int x, int y, int w) {
	e[++tot].x = x, e[tot].y = y, e[tot].w = w;
	return;
}
（2）复杂度
  • 查询是否存在某条边： O ( m ) O(m) O(m)。
  • 遍历一个点的所有出边： O ( m ) O(m) O(m)。
  • 遍历整张图： O ( n m ) O(nm) O(nm)。
  • 空间复杂度： O ( m ) O(m) O(m)。
（3）应用

  可以用于反转边的方向，Kruskal 算法也需要这样存边。

2. 邻接矩阵

（1）基本思想

  对于一个有 V V V 个的顶点的图而言，可以使用 V × V V\times V V×V 的二维数组表示。
   G i , j G_{i, j} Gi,j​ 表示的是顶点 i i i 与顶点 j j j 的关系。 G i , j = 1 G_{i, j} = 1 Gi,j​=1 表示存在 i i i 到 j j j 的边；如果顶点 i i i 和顶点 j j j 之间无边相连， G i , j = 0 G_{i, j} = 0 Gi,j​=0。如果是带边权的图，可以在 G i , j G_{i, j} Gi,j​ 中存储 i i i 到 j j j 的边的边权。
  注：对于无向图： G i , j = G j , i G_{i, j} = G_{j, i} Gi,j​=Gj,i​。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5; 
int n, m, u, v;
bool G[N][N];
int main() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &u, &v);
		G[u][v] = G[v][u] = true;
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
 			if (G[i][j]) {
				printf("%d ", j);
			}
		}
		putchar('\n');
	}
	return 0;
}

各种邻接矩阵
（1）无向图的邻接矩阵

  在无向图中，任一顶点 i i i 的度为第 i i i 列（或第 i i i 行）所有非零元素的个数。特别地，无向图的邻接矩阵沿主对角线对称。


图 2-1 原无向图（左）及该无向图的邻接矩阵（右）

（2）有向图的邻接矩阵

  在有向图中，顶点 i i i 的出度为：第 i i i 行所有非零元素的个数；入度为：第 i i i 列所有非零元素的个数。


图 2-2 原有向图（左）及该有向图的邻接矩阵（右）

（3）带权图的邻接矩阵

  在有向图中，顶点 i i i 的出度为：第 i i i 行所有非零元素的个数；入度为：第 i i i 列所有非零元素的个数。在带权图中，如果在边不存在的情况下，将 G [ i ] [ j ] G[i][j] G[i][j] 设置为 0 0 0，则无法与权值为 0 0 0 的情况分开，因此选择较大的常数 INF \text{INF} INF 即可。


图 2-3 原带权图（左）及该带权图的邻接矩阵（右）

（2）复杂度
  • 查询是否存在某条边： O ( 1 ) O(1) O(1)。
  • 遍历一个点的所有出边： O ( n ) O(n) O(n)。
  • 遍历整张图： O ( n 2 ) O(n^2) O(n2)。
  • 空间复杂度： O ( n 2 ) O(n^2) O(n2)。
（3）应用

  使用 Floyd 时会用到，存稠密图很划算。
  其优点在于可以在常数时间内判断两点之间是否有边存在；但其缺点是表示稀疏图时，会浪费大量内存空间。


习题演练集 #3373. 「基础算法」求一个有向图中指定顶点的出度

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e2 + 5; 
int n, m, u, v, d[N];
vector<int> a[N];
int main() {
	scanf("%d %d", &n, &m); 
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &u, &v);
		a[u].push_back(v);
	}
	int root;
	scanf("%d", &root);
	printf("%d", a[root].end() - a[root].begin());
	return 0;
}

#25447. 邻接矩阵存储图

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5; 
int n, m, u, v;
bool a[N][N];
int main() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &u, &v);
		a[u][v] = a[v][u] = true;
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			if (a[i][j]) {
				printf("%d ", j);
			}
		}
		putchar('\n');
	}
	return 0;
}

3. 邻接表

（1）基本思想

  使用一个动态数组（譬如 vector<int> a[N]） 来存边，存储该点的所有出边的相关信息。

链式前向星

  链式前向星其实就是静态建立的邻接表，时间效率为 O ( m ) O(m) O(m)，空间效率也为 O ( m ) O(m) O(m)。遍历效率也为 O ( m ) O(m) O(m)。

struct Edge {
	int to, w, next;
} edge[M];
void add(int x, int y, int z) {
	edge[++tot].to = y, edge[tot].w = z, // 这条边的信息
	edge[tot].next = head[x], // 当前边的前驱	
	head[x] = tot; // 起点 u 的最后一条边 	
	return;
}
for (int i = head[u]; i; i = e[i].next) {  // 遍历 u 的出边
	int v = e[i].to;
}

各种邻接表
（1）无向图的邻接表

  在无向图中，任一顶点 i i i 的度为第 i i i 列（或第 i i i 行）所有非零元素的个数。特别地，无向图的邻接矩阵沿主对角线对称。


图 2-4 原无向图（左下）及该无向图的邻接表（右下）

（2）有向图的邻接表(出边表、入边表)

  出边表的表结点存放的是从表头结点出发的有向边所指的尾顶点，入边表（逆邻接表）的表结点存放的则是指向表头结点的某个头顶点。


图 2-5 原有向图（a）及该有向图的邻接表（b）和逆邻接表（c）

（3）带权图的邻接表

  在表结点中增加一个存放权的字段。


图 2-6 原带权图（左）及该带权图的邻接矩阵（右）
（2）复杂度
  • 查询是否存在某一条边： O ( d + ( u ) ) O(d^+(u)) O(d+(u))。
  • 遍历点 u u u 的所有出边： O ( d + ( u ) ) O(d^+(u)) O(d+(u))。
  • 遍历整张图： O ( n + m ) O(n + m) O(n+m)。
  • 空间复杂度： O ( m ) O(m) O(m)。
（3）应用

  存图很适合，内存占用少，但不能快速查询一条边是否存在，也不能直接对一个点的出边进行排序。
  特点在于边是带编号的，在遍历边时很方便。如果 tot 的初始值为奇数，存双向边时 i ⊕ 1 i \oplus 1 i⊕1 即是 i i i 的反边（详见《算法竞赛》p63）。

习题演练集
#25448. 邻接表存储图

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 1e3 + 5; 
int n, m, u[N], v[N];
struct node {
	int id, d;
} a[N];
vector<node> G[N];
bool cmp(node x, node y) { return x.d == y.d ? x.id < y.id : x.d < y.d; }
int main() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= n; i++) {
		a[i].id = i;
		a[i].d = 0;
	}
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &u[i], &v[i]);
		a[u[i]].d++;
		a[v[i]].d++;
	}
	for (int i = 1; i <= m; i++) {
		G[u[i]].push_back(a[v[i]]);
		G[v[i]].push_back(a[u[i]]);
	}
	for (int i = 1; i <= n; i++) {
		sort(G[i].begin(), G[i].end(), cmp);
		for (int j = 0; j < G[i].size(); j++) {
			printf("%d ", G[i][j].id);
		}
		putchar('\n');
	}
	return 0;
}

#25449. 邻接表存储带权的无向图

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
// 链式前向星
#include <bits/stdc++.h>
using namespace std;
const int N = 2e2 + 5, M = 1e3 + 5; 
int n, m, u[N], v[N], w[N], head[M], tot;
struct line {
	int u, v, w;
} a[N];
struct Edge {
	int to, w, next;
} edge[M];
void add(int x, int y, int z) {
	edge[++tot].to = y, edge[tot].w = z,
	edge[tot].next = head[x], head[x] = tot;
	return;
}
bool cmp(line x, line y) {
	if (x.w == y.w) {
		return x.v > y.v;
	} else {
		return x.w > y.w;
	}  
}
int main() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &a[i].u, &a[i].v, &a[i].w);
	}
	sort(a + 1, a + m + 1, cmp);
	for (int i = 1; i <= m; i++) {
		add(a[i].u, a[i].v, a[i].w);
		add(a[i].v, a[i].u, a[i].w);
	}
	for (int i = 1; i <= n; i++) {
		for (int j = head[i]; j; j = edge[j].next) {
			printf("%d ", edge[j].to);
		}
		putchar('\n');
	}
	return 0;
}

（三）图的遍历

  从图中的某个顶点出发，按某种方法对图中的所有顶点访问且仅访问一次。为了保证图中的顶点在遍历过程中仅访问一次，要为每一个顶点设置一个访问标志。
  (没什么好讲的，就照搬课件吧)
  (他们都在搞笑，我也要！！1heihei)

1. DFS

  (不撞南墙不回头——cqbzgm)
  深度优先搜索 (Depth-First Search) 遍历类似于树的先根遍历，是树的先根遍历的推广。
  假设初始状态是图中所有顶点未曾被访问，则深度优先搜索可从图中某个顶点 v v v 出发，访问此顶点，然后依次从 v v v 的未被访问的邻接点出发深度优先遍历图，直至图中所有和 v v v 有路径相通的顶点都被访问到；若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。


图 3-1 原无向图（左）及该有向图的 DFS 遍历过程（右）

2. BFS

  (一石激起千层浪——cqbzgm)
  广度优先搜索 (Breadth-First Search) 遍历类似于树的按层次遍历的过程。
  假设从图中某顶点 v v v 出发，在访问 v v v 之后依次访问 v v v 的各个邻接点中未被访问过的，然后分别从这些邻接点出发依次访问它们的邻接点，并使「先被访问的顶点的邻接点」先于「后被访问的顶点的邻接点」被访问，直至图中所有已被访问的顶点的邻接点都被访问到。若此时图中尚有顶点未被访问，则另选图中一个未曾被访问的顶点作起始点，重复上述过程，直至图中所有顶点都被访问到为止。
  换句话说，广度优先搜索遍历图的过程是以 v v v 为起始点，由近至远，依次访问和 v v v 有路径相通且路径长度为 1 ,   2 ,   … 1,\ 2,\ … 1, 2, … 的顶点。


图 3-1 原无向图（左）及该有向图的 DFS 遍历过程（右）

习题演练集
#3376. 有向图的DFS

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e2 + 5; 
int n, m, u, v, d[N];
bool vis[N];
vector<int> a[N];
void dfs(int node, int fa) {
	vis[node] = true;
	printf("%d ", node);
	sort(a[node].begin(), a[node].end());
	for (int i = 0; i < a[node].size(); i++) {
		if (a[node][i] != fa && !vis[a[node][i]]) {
			dfs(a[node][i], node);
		}
	}
	return;
}
int main() {
	scanf("%d %d", &n, &m); 
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &u, &v);
		a[u].push_back(v);
	}
	for (int i = 1; i <= n; i++) {
		if (!vis[i]) {
			dfs(i, -1);	
		}
	}
	return 0;
}
#3377. 有向图的BFS

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e2 + 5; 
int n, m, u, v, d[N];
bool vis[N];
vector<int> a[N];
void bfs(int node) {
	vis[node] = true;
	queue<int> q;
	q.push(node);
	int x;
	while (q.size()) {
		x = q.front();
		q.pop();
		printf("%d ", x);
		sort(a[x].begin(), a[x].end());
		for (int i = 0; i < a[x].size(); i++) {
			if (!vis[a[x][i]]) {
				q.push(a[x][i]);
				vis[a[x][i]] = true;
			}
		}
	}
	return;
}
int main() {
	scanf("%d %d", &n, &m); 
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &u, &v);
		a[u].push_back(v);
	}
	for (int i = 1; i <= n; i++) {
		if (!vis[i]) {
			bfs(i);
		}
	}
	return 0;
}
#3424. 有向图的连通度

link

  该题等价于是求图的传递闭包。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e3 + 5; 
int n, m, u, v, t, sum[N];
bitset<N> G[N]; // 可以用 bitset 优化
char ch;
int main() {
	scanf("%d", &n); 
	for (int i = 1; i <= n; i++) {
		scanf("\n");
		for (int j = 1; j <= n; j++) {
			ch = getchar();
			G[i][j] = ch - '0';
		}
		G[i][i] = true;
	}
	ll cnt = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			if (G[i][j])
				G[i] |= G[j]; // 如果他们联通就合并他们能到达的点
		}
	}
	for (int i = 1; i <= n; i++) { // 防止有的集合在不完整时就与其它集合合并
		for (int j = 1; j <= n; j++) {
			if (G[i][j])
				G[i] |= G[j];
		}
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			cnt += G[i][j];
		}
	}
	printf("%lld", cnt);
	return 0;
}
#3380. 「Uva 10004」二染色

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 2e2 + 5; 
int n, m, u, v, c[N];
bool check;
bitset<N> vis;
vector<int> G[N];
void dfs(int node, int fa, int color) {
	if (!check) {
		return;
	} 
	c[node] = color;
	for (int i = 0; i < G[node].size(); i++) {
		if (!c[G[node][i]]) {
			dfs(G[node][i], node, -color);
		} else {
			if (-color != c[G[node][i]]) {
				check = false;
				return;
			}
		}
	} 
	return;
}
int main() {
	while (~scanf("%d", &n) && n) {
		scanf("%d", &m);
		for (int i = 0; i < n; i++) {
			G[i].clear();
			c[i] = 0;
			vis[i] = false;
		}
		for (int i = 1; i <= m; i++) {
			scanf("%d %d", &u, &v);
			G[u].push_back(v);
			G[v].push_back(u);
		}
		check = true;
		c[0] = 1;
		dfs(0, -1, 1);
		if (check) {
			printf("BICOLORABLE\n");
		} else {
			printf("NOT BICOLORABLE\n");
		}
	}
	return 0;
}
#3304. 一笔画问题

link

  一笔画问题的代码实现关键在于：当每次遍历过一条边时，就把这条边删掉，这样就不会重复遍历。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e3 + 5; 
int n, m, u, v, d[N];
bool a[N][N];
void dfs(int node) {
	for (int i = n; i >= 1; i--) {
		if (a[node][i]) {
			a[node][i] = a[i][node] = false;
			dfs(i);
		}	
	}
	printf("%d ", node);
	return;
}
int main() {
	scanf("%d %d", &n, &m); 
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &u, &v);
		a[u][v] = true, d[u]++;
		a[v][u] = true, d[v]++;
	}
	int id = 1;
	for (int i = 1; i <= n; i++) {
		if (d[i] & 1) {
			id = i;
			break;
		}
	}
	dfs(id);
	return 0;
}
#3378. 哈密顿路问题

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <cstdio>
#include <vector>
#include <bitset>
using namespace std;
const int N = 2e2 + 5; 
int n, op, cnt;
bitset<N> vis;
vector<int> a[N];
void dfs(int node, int sum) {
	if (sum == n) {
		cnt++;
		return;
	}
	vis[node] = true;
	for (int i = 0; i < a[node].size(); i++) {
		if (!vis[a[node][i]]) {
			vis[a[node][i]] = true;
			dfs(a[node][i], sum + 1);
			vis[a[node][i]] = false;
		}
	}
	return;
}
int main() {
	scanf("%d", &n); 
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			scanf("%d", &op);
			if (op) {
				a[i].push_back(j);
			}
		}
	}
	for (int i = 1; i <= n; i++) {
		vis.reset();
		dfs(i, 1);
	}
	printf("%d", cnt);
	return 0;
}



二、最短路

性质

  1. 对于边权为正的图，任意两个结点之间的最短路，不会经过重复的结点；
  2. 对于边权为正的图，任意两个结点之间的最短路，不会经过重复的边；
  3. 对于边权为正的图，任意两个结点之间的最短路，任意一条路上的结点数不会超过总结点数（以后简称 n n n），边数不会超过 n − 1 n - 1 n−1。

（一）Floyd 算法

  Floyd 算法又称为插点法，是一种利用动态规划的思想寻找给定的加权图中多源点之间最短路径的算法，与 Dijkstra 算法类似。
  该算法名称以创始人之一、1978年图灵奖获得者、斯坦福大学计算机科学系教授罗伯特·弗洛伊德命名。

1. 基本原理

  1. 从任意一条单边路径开始。任意两点之间的距离是边的权，如果两点之间没有边相连，则权为无穷大（常设 INF = 0x3f3f3f3f \text{INF}=\text{0x3f3f3f3f} INF=0x3f3f3f3f）；
  2. 对于每一对顶点 u u u 和 v v v，查询是否存在一个顶点 w w w 使得从 u u u 到 w w w 再到 v v v 比已知的路径更短。如果就是更新它。

Tips: 一般 N N N 的很小的最短路才用 Floyd。

2. 算法描述

初始化：

  把图用邻接矩阵 f f f 表示出来，如果从 v i v_i vi​ 到 v j v_j vj​ 有路可达，则 f i , j = d f_{i, j} = d fi,j​=d， d d d 表示该路的长度；否则 f i , j = + ∞ f_{i, j} = +\infty fi,j​=+∞。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
for (int i = 1; i <= n; i++) {
	for (int j = 1; j <= n; j++) {
		f[i][j] = INF; // 初始化为极大值（在这里可以看做无穷大）
	}
	f[i][i] = 0; // 自己到自己的距离是 0
}
for (int i = 1; i <= m; i++) {
	scanf("%d %d %d", &u, &v, &w);
	f[u][v] = f[v][u] = min(f[u][v], w); // 处理重边（具体取长取短视题目而定）
}

算法部分：
Part1 \text{Part1} Part1 计算最短路

  运用动态规划的思想。我们定义一个三维数组 f k , i , j f_{k, i, j} fk,i,j​，表示只允许经过前 k k k 个结点，结点 i i i 到结点 j j j 的最短路长度。
  明显地， f n , i , j f_{n, i, j} fn,i,j​ 就是结点 i i i 到结点 j j j 的最短路长度。
  于是我们顺手就可以写出 Floyd 的状态转移方程（ f k − 1 , i , j f_{k - 1, i, j} fk−1,i,j​ 表示不经过 k k k 点， f k − 1 , i , k + f k − 1 , k , j f_{k - 1, i, k} + f_{k - 1, k, j} fk−1,i,k​+fk−1,k,j​ 表示经过 k k k 点）：
f k , i , j = min ⁡ ( f k − 1 , i , j , f k − 1 , i , k + f k − 1 , k , j ) ( 1 ≤ i , j , k ≤ n ) f_{k, i, j} = \min(f_{k - 1, i, j}, f_{k - 1, i, k} + f_{k - 1, k, j})(1\le i,j,k \le n) fk,i,j​=min(fk−1,i,j​,fk−1,i,k​+fk−1,k,j​)(1≤i,j,k≤n)
  通过上式可以发现，第一维只代表阶段的转移，对结果无影响。于是乎，第一维可以被省略，转而在原有基础上迭代（但要保证 k k k 的循环一定是正序）。
  状态转移方程又变为：
f i , j = min ⁡ ( f i , j , f i , k + f k , j ) ( 1 ≤ i , j , k ≤ n ) f_{i, j} = \min(f_{i, j}, f_{i, k} + f_{k, j})(1\le i,j,k \le n) fi,j​=min(fi,j​,fi,k​+fk,j​)(1≤i,j,k≤n)
  抹去第一维的操作为我们节省了大把空间，也使 Floyd 的适用范围更广。

Part2 \text{Part2} Part2 输出路径

   若要输出路径，则需要定义一个矩阵 p r e pre pre 用来记录所经过点的信息， p r e i , j pre_{i, j} prei,j​ 表示从 i i i 到 j j j 所经过的结点中， i i i 号结点的后一个结点，初始化为 p r e i , j = i pre_{i, j} = i prei,j​=i。在 f f f 中包含有两点之间最短道路的信息，而在 p r e pre pre 中则包含了最短路路径的信息。多源最短路计算加上路径输出，这才是完整的 Floyd 算法。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
// 初始化示意
for (int i = 1; i <= m; i++) {
	scanf("%d %d %d", &x, &y, &w);
	if (f[x][y] > w) {
		f[y][x] = f[x][y] = w;
		pre[x][y] = y;
		pre[y][x] = x;
	}	
}
// Floyd
void floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (f[i][j] >= f[i][k] + f[k][j]) { // 可以更新或本身就在最短路上的结点都要记录
					if (f[i][j] == f[i][k] + f[k][j] && i != k) { 
						pre[i][j] = min(pre[i][j], pre[i][k]); // 一般题目会要求字典序最小且经过边最少，所以要比 min	
					} else if (f[i][j] > f[i][k] + f[k][j]) { // 更新最短路
						f[i][j] = f[i][k] + f[k][j];
						pre[i][j] = pre[i][k]; // 这个时候就直接赋值
					}
				}
			}	
		}
	}
	return;
}

算法结束：

   f i , j f_{i, j} fi,j​得出的就是任意起点 i i i 到任意终点 j j j 的最短路径。

3. 讨论

Part1 \text{Part1} Part1 为什么枚举中转点的循环k要放在最外层？

  Floyd 的原始状态转移方程为：
f k , i , j = min ⁡ ( f k − 1 , i , j , f k − 1 , i , k + f k − 1 , k , j ) ( 1 ≤ i , j , k ≤ n ) f_{k, i, j} = \min(f_{k - 1, i, j}, f_{k - 1, i, k} + f_{k - 1, k, j})(1\le i,j,k \le n) fk,i,j​=min(fk−1,i,j​,fk−1,i,k​+fk−1,k,j​)(1≤i,j,k≤n)
  由此，可以发现第一维的 k k k 其实表示的是不同的阶段，枚举着不同情况下的所有结果，而并不是在枚举中转点，必须放在最外层（譬如区间 DP 中，长度 l e n len len 就是一个阶段，放在最外层，代表合并不同数量的单元时，其不同的最优结果）。若认为 k k k 是决策（即枚举 i → j i \to j i→j 的中间点），将 k k k 放在最里层循环中，便会得到错误的结果。
  所以，我们可以得到： k k k 不是在枚举中转点，而是在表示 DP 的阶段，故阶段循环必须放在最外层。

4. 复杂度

  • 时间复杂度： O ( n 3 ) O(n^3) O(n3)；
  • 空间复杂度： O ( n 2 ) O(n^2) O(n2)。

习题讲解 「#47253. 最短路上的统计」

原题目链接 link

「我的做题历程」：

（敢情我爆了一道弱智题）

step1：观察题面。

  「一个无向图上，没有自环，所有边的权值均为1，对于一个点对（a,b） 我们要把所有a与b之间所有最短路上的点的总个数输出。」，不是吧，就这。（实际蒟蒻被打脸了）

step2：思考解法。

  刚开始想复杂了，莫名其妙做出了一股区间 DP 的味道。
  (hh，xswl)
  然而，只需要先求出最短路再暴力枚举路径累加即可。

step3：完成代码。
代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <cstdio>
using namespace std;
const int N = 1e2 + 5, INF = 0x3f3f3f3f;
int n, m, a, b, p, f[N][N], sum[N][N];
void Floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++){
			for (int j = 1; j <= n; j++) {
				if (f[i][j] > f[i][k] + f[k][j]) {
					f[i][j] = f[i][k] + f[k][j];
				}
			}
		}
	}
	for (int k = 1; k <= n; k++) { // 就，就感觉自己挺弱智的
		for (int i = 1; i <= n; i++){
			for (int j = 1; j <= n; j++) {
				if (f[i][j] == f[i][k] + f[k][j]) {
					sum[i][j]++;
				}
			}
		}
	}
	return; 
}
int main() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			f[i][j] = INF;
		}
		f[i][i] = 0;
	}
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &a, &b);
		f[a][b] = f[b][a] = 1;
	}
	Floyd();
	scanf("%d", &p);
	for (int i = 1; i <= p; i++) {
		scanf("%d %d", &a, &b);
		printf("%d\n", sum[a][b]);
	}
	return 0;
}
习题讲解 「#76. Sightseeing Trip」

原题目链接 link

「我的做题历程」：
step1：观察题面。

  「给定一张无向图，求图中一个至少包含 3 3 3 个点的环，环上的节点不重复，并且环上的边的长度之和最小。」，（看到这里我人都傻了，啥？最小环？） 。无向图求最小环的话，应该要先求多源最短路，毕竟在输入时我们无法确定哪个是环上的点。
  「在本题中，你需要输出最小环的方案，若最小环不唯一，输出任意一个均可。若无解，输出 No solution.」，特别提醒：无解的 「No solution.」最末有一个句号（看漏的自觉打脸，我已经开始打了）。

step2：思考解法。

  刚开始没有想法，直到看见题解。
  (kaiwanxiao’o)
  既然要求最小环，首先这一定是一个简单环，那这个环一定可以被分成 i → j i \to j i→j 和 j → i j \to i j→i 两部分，但如果要求一个环至少包含三个点的话，仅仅需要 i → ⋯ j → k → i i\to \cdots j \to k \to i i→⋯j→k→i 就够了。故问题变成：求 ( f i , j + w j , k + w k , i ) m i n (f_{i, j} + w_{j, k} + w_{k, i})_{min} (fi,j​+wj,k​+wk,i​)min​ 。

step3：完成代码。
代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 2e2 + 5;
int n, m;
long long w[N][N], f[N][N], pre[N][N], minn = 1e12, a, b, c; 
// 十年 OI 一场空，不开 long long 见祖宗
vector<int> ans;
void get(int x, int y) {
	if (!pre[x][y]) {
		return ;
	} 
	get(x, pre[x][y]);
	ans.push_back(pre[x][y]);
	get(pre[x][y], y);
	return;
}
void floyd() {
	for (int k = 1; k <= n; k++) { 
		// 求只经过前 k 个点的最小环
		for (int i = 1; i < k; i++) {
			for (int j = i + 1; j < k; j++) { // 防止与 i 重复
				 // {k, i, j} 代表经过前 k 个点 从 i 到 j 的最短路径
				 // 若 i，j 均不取 k，则一定不会经过第 k 个点 
				if (f[i][j] + w[j][k] + w[k][i] < minn) {
				// 环的路线：i -> ... -> j -> k -> i
				// 虽然这里只枚举了 i < j 的情况，但由无向图的对称性可知 j > i 的情况与 i < j 的情况是相同的
					minn = f[i][j] + w[j][k] + w[k][i];
					ans.clear(); // 若被更新则答案清零
					ans.push_back(i);
					get(i, j); // 填补 i -> j 中间的点
					ans.push_back(j);
					ans.push_back(k);
				}
			}
		} 
		// 求只经过前 k 个点的最短路径
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (f[i][k] + f[k][j] < f[i][j]) {
					f[i][j] = f[i][k] + f[k][j];
					pre[i][j] = k; // 记录 i 的后继（后一个点）
				}
			}
		}
	}
	return;
}
int main() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			f[i][j] = w[i][j] = 1e12;
		}
		f[i][i] = w[i][i] = 0;
	}
	for (int i = 1; i <= m; i++) {
		scanf("%lld %lld %lld", &a, &b, &c);	
		w[b][a] = w[a][b] = f[b][a] = f[a][b] = min(f[a][b], c);
		// 为了方便的求环，需要记录权值
	}
	floyd();
	if (minn == 1e12) {
		printf("No solution.");
		return 0;
	}
	for (int i = 0; i < ans.size(); i++) {
		printf("%lld ", ans[i]);
	}
	return 0;
}

习题演练集
#3608. 跑步(Floyd模板)

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 2e1 + 5;
int n, k, x, a, b;
double c, f[N][N];
bool vis[N][N];
void floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
			}
		}
	}
	return;
}
int main() {
	scanf("%d %d %d", &n, &k, &x);
	memset(f, 127, sizeof f);
	for (int i = 1; i <= k; i++) {
		scanf("%d %d %lf", &a, &b, &c);
		if (vis[a][b]) {
			f[a][b] = max(f[a][b], c); // 注意读题
		} else {
			f[a][b] = c;
			vis[a][b] = true;
		}
		if (vis[b][a]) {
			f[b][a] = max(f[b][a], c);
		} else {
			f[b][a] = c;
			vis[b][a] = true;
		}
	}
	for (int i = 1; i <= n; i++) {
		f[i][i] = 0;
	}
	floyd();
	for (int i = 1; i <= x; i++) {
		scanf("%d %d", &a, &b);
		if (f[a][b] - int(f[a][b])) { // 判断小数点后是否有数（判断是否为浮点数）
			printf("%.1lf\n", f[a][b]);	
		} else {
			printf("%d\n", int(f[a][b]));
		}
	}
	return 0;
}
#6235. GF和猫咪的玩具

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5;
int n, m, a, b, f[N][N], ans;
void floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
			}
		}
	}
	return;
}
int main() {
	scanf("%d %d", &n, &m);
	memset(f, 0x3f, sizeof f);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &a, &b);
		f[a][b] = 1; // 无向图跑 Floyd 需跑双向边
		f[b][a] = 1;
	}
	for (int i = 1; i <= n; i++) {
		f[i][i] = 0;
	}
	floyd();
	ans = 0;
	for (int i = 1; i <= n; i++) {
		for (int j = i + 1; j <= n; j++) {
			// printf("%d ", f[i][j]);
			ans = max(ans, f[i][j]);
		}
		// putchar('\n');
	}
	printf("%d", ans);
	return 0;
}
#8171. 「基础算法」最短路径问题

link

  这里需要引入一下勾股定理：两直角边的平方和等于斜边的平方。此处 ( x 1 − x 2 ) 2 + ( y 1 − y 2 ) 2 = l 2 (x_1 - x_2)^2 + (y_1 - y_2)^2 = l^2 (x1​−x2​)2+(y1​−y2​)2=l2。


图 1-1 示意图

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5;
int n, m, c, d, s, t;
double f[N][N];
bool vis[N][N];
struct node {
	double x, y;
} a[N]; 
void floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
			}
		}
	}
	return;
}
int main() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			f[i][j] = 0x7f7f7f7f;
		}
		f[i][i] = 0;
	}
	for (int i = 1; i <= n; i++) {
		scanf("%lf %lf", &a[i].x, &a[i].y);
	}
	scanf("%d", &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &c, &d);
		f[c][d] = min(f[c][d], sqrt((a[c].x - a[d].x) * (a[c].x - a[d].x) + (a[c].y - a[d].y) * (a[c].y - a[d].y))); // 求两点间的直线距离可以使用勾股定理
		f[d][c] = f[c][d];
		
	}
	floyd();
	scanf("%d %d", &s, &t);
	printf("%.2lf\n", f[s][t]);	
	return 0;
}
#3147. 多源最短路

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 5e2 + 5, INF = 0x3f3f3f3f;
int n, x, f[N][N], ans;
void init() {
	scanf("%d", &n);
	for (int i = 1; i <= n; i++) {
		f[i][i] = 0;
		for (int j = 1; j <= n; j++) {
			f[i][j] = INF;
		}
	}
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			scanf("%d", &x);	
			f[i][j] = min(f[i][j], x);
		} 
	}
}
void floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				f[i][j] = min(f[i][j], f[i][k] + f[k][j]);
			}
		}
	}
	return;
}
void solve() {
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			printf("%d ", f[i][j]);
		}
		putchar('\n');
	}
	return;
}
int main() {
	init();
	floyd();
	solve();
	return 0;
}
#30135. 多源最短路方案

原题目链接 link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e2 + 5, M = 2 * 5e3 + 5, INF = 0x3f3f3f3f;
ll n, m, q, x, y, w, f[N][N], pre[N][N];
void init() {
	scanf("%lld %lld %lld", &n, &m, &q);
	for (int i = 1; i <= n; i++) {
		for (int j = 1; j <= n; j++) {
			f[i][j] = INF;
		}
		f[i][i] = 0;
	}
	for (int i = 1; i <= m; i++) {
		scanf("%lld %lld %lld", &x, &y, &w);
		if (f[x][y] > w) {
			f[y][x] = f[x][y] = w;
			pre[x][y] = y;
			pre[y][x] = x;
		}	
	}
	return;
}
void floyd() {
	for (int k = 1; k <= n; k++) {
		for (int i = 1; i <= n; i++) {
			for (int j = 1; j <= n; j++) {
				if (f[i][j] >= f[i][k] + f[k][j]) {
					if (f[i][j] == f[i][k] + f[k][j] && i != k) {
						pre[i][j] = min(pre[i][j], pre[i][k]);
					} else if (f[i][j] > f[i][k] + f[k][j]){
						f[i][j] = f[i][k] + f[k][j];
						pre[i][j] = pre[i][k];
					}
				}
			}
		}
	}
	return;
}
void print(ll node) {
	if (!pre[node][y]) {
		return;
	}
	printf("%lld ", node);
	print(pre[node][y]);
	return;
}
void solve() {
	for (int i = 1; i <= q; i++) {
		scanf("%lld %lld", &x, &y);
		if (f[x][y] == INF) {
			printf("-1\n");
		} else {
			printf("%lld\n", f[x][y]);
			print(x);
			printf("%lld\n", y);
		}
	}
	return;
}
int main() {
	init();
	floyd();
	solve();
	return 0;
}

（二）Dijkstra 算法

  Dijkstra 算法是从一个顶点到其余各顶点的最短路径算法，解决的是非负权图中的单源最短路问题。
  该算法由荷兰计算机科学家 E. W. Dijkstra 于 1959 年提出。

1. 基本原理

  1. 结点分成两组：已经确定最短路（记作 S S S 集合）、尚未确定最短路（记作 T T T 集合）；
  2. 初始化 d i s dis dis 数组为 + ∞ +\infty +∞， d i s s = 0 dis_s = 0 diss​=0 ；
  3. 不断从 T T T 中选择路径长度最短的点放入 S S S。
  4. 对那些刚刚加入 S S S 的结点的所有出边执行松弛操作。
算法过程欣赏（从左往右从上至下）

❔ 什么是松弛

  举一个形象的用烂了的🌰（栗子）：
  用一根橡皮筋直接连接 a ,   b a,\ b a, b 两点，现存一点 k k k，使得 a → k → b a \to k \to b a→k→b 比 a → b a \to b a→b 的距离更短。把橡皮筋改为 a → k → b a \to k \to b a→k→b 后 ，橡皮筋更加松弛。


图 2-1 松弛示意图

  更严谨的定义：松弛操作是指对于每个顶点 v ∈ V v\in V v∈V，都设置一个属性 d i s v dis_v disv​，用来描述从源点 s s s 到 v v v 的最短路径上权值的上界，称为最短路径估计（shortest-path estimate）。

2. 算法描述

初始化：

  设起点为 s s s， d i s [ v ] dis[v] dis[v] 表示从指定起点 s s s 到 v v v 的最短路径， p r e v pre_v prev​ 为 v v v 的前驱，用来输出路径。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
for (int i = 1; i <= n; i++) {
	dis[i] = INF; // 初始化为极大值（在这里可以看做无穷大）
	vis[i] = false; // 最开始所有点都没有确定最短路
	pre[i] = 0;
}
dis[s] = 0;
vis[s] = true;

算法部分：
Part1 \text{Part1} Part1 计算最短路

朴素算法 O ( n 2 ) O(n^2) O(n2)：

  1. 在没有被访问过的点中找一个相邻顶点 k k k，使得 d i s k dis_k disk​ 是最小的；
  2. k k k 标记为已确定的最短路 v i s k = true vis_k=\text{true} visk​=true;
  3. 用 for 循环更新与 k k k 相连的每个未确定最短路径的顶点 v v v (所有未确定最短路的点都松弛更新)。
代码（抵制学术不端行为，拒绝 Ctrl + C）： 
for (int i = 1; i <= n; i++) {
	dis[i] = INF, vis[i] = false;
}
dis[s] = 0; //初始化源点到源点最短路权 0
vis[i] = true; //初始化源点已经是最短路点
for (int i = 1; i < n; i++) { //枚举没被设定为最短路的点
    int minn = INF, k; //找源点到j点的最短路的点
    for (int j = 1; j <= n; j++) {
    	if (!vis[j] && dis[j] < minn) {
            minn = dis[j];
            k = j;
        }
	}                                
    vis[k] = true; //将k点标记为已找到最短路
    for (int j = 1; j <= n; j++) { //松弛未标记最短路的点 
        if (dis[j] > dis[k] + w[k][j]) { 
            dis[j] = dis[k] + w[k][j];
        }
	} 
}
printf("%d", dis[t]);

优先队列优化：
  我们可以发现，如果边数远小于 n 2 n^2 n2，对此可以考虑用优先队列进行优化，取出最短路径的复杂度降为 O ( log ⁡ m ) O(\log m) O(logm)；可以用链式前向星存边来优化每次松弛的复杂度，其复杂度降为 O ( e ) O(e) O(e)（ e e e 为该点的边数）。
  如果同一个点的最短路被更新多次，而先前更新时插入的元素不能被删除，也不能被修改，只能留在优先队列中，故优先队列内的元素个数是 m m m，时间复杂度为 O ( m log ⁡ m ) O(m\log m) O(mlogm)。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
void Dijkstra() {
	memset(dis, 0x7f, sizeof dis);
	memset(vis, 0, sizeof vis);
	dis[s] = 0;
	q.push(make_pair(0, s));
	int x;
	while (q.size()) {
		x = q.top().second;
		q.pop();
		if (vis[x]) {
			continue;
		}
		vis[x] = true;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
				q.push(make_pair(-dis[y], y));
			}
		}
	}
	return;
}
Part2 \text{Part2} Part2 输出路径

   若要输出路径，则需要定义一个一维数组 p r e pre pre 用来记录所经过点的信息， p r e i pre_{i} prei​ 表示 i i i 号结点的前一个结点。

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
struct Edge { // 链式前向星存储
	int to, w, next;
} e[M];
void add(int u, int v, int w) {
	e[++tot].to = v, e[tot].w = w, 
	e[tot].next = head[u], head[u] = tot;
	return;
}
int dis[N];
bool vis[N];
priority_queue< pair<int, int> > q;
void Dijkstra() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF;
		vis[i] = false;
	}
	dis[s] = 0;
	q.push(make_pair(0, s));
	int x;
	while (q.size()) {
		x = q.top().second;
		q.pop();
		if (vis[x]) {
			continue;
		}
		vis[x] = true;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
				pre[y] = x;
				q.push(make_pair(-dis[y], y));
			} else if (dis[y] == dis[x] + w) {
				pre[y] = min(pre[y], x);
			}
		}
	}
	return;
}
void print(int node) {
	if (!node) {
		return;
	}
	print(pre[node]);
	printf("%d ", node);
	return;
}
void solve() {
	if (dis[t] == INF) {
		printf("no solution");
	} else {
		printf("%d\n", dis[t]);
		print(t);
	}
	return;
}

算法结束：

   d i s v dis_v disv​为 s s s 到 v v v 的最短路距离； p r e v pre_v prev​ 为 v v v 的前驱结点，用来输出路径。

3. 讨论

Part1 \text{Part1} Part1 为什么 Dijkstra 不能用于负权图？

  在 Dijkstra 的正确性证明中，关键不等式 D ( y ) ≤ D ( u ) D(y) \le D(u) D(y)≤D(u) 是在图上所有边边权非负的情况下得出的。当图上存在负权边时，这一不等式不再成立，Dijkstra 算法的正确性将无法得到保证，算法可能会给出错误的结果。

Dijkstra 算法的正确性证明（摘自 OI Wiki）

  下面用数学归纳法证明，在所有边权值非负的前提下，Dijkstra 算法的正确性。

  简单来说，我们要证明的，就是在执行 1 操作时，取出的结点 最短路均已经被确定，即满足 D ( u ) = d i s ( u ) D(u) = dis(u) D(u)=dis(u)。

  初始时 S ≠ ∅ S \ne \varnothing S=∅，假设成立。

  接下来用反证法。

  设 u u u 点为算法中第一个在加入 S S S 集合时不满足 D ( u ) = d i s ( u ) D(u) = dis(u) D(u)=dis(u) 的点。因为 s s s 点一定满足 ，且它一定是第一个加入 S S S 集合的点，因此将 u u u 加入 S S S 集合前， S ≠ ∅ S \ne \varnothing S=∅，如果不存在 s s s 到 u u u 的路径，则 D ( u ) = d i s ( u ) = + ∞ D(u) = dis(u) = +\infty D(u)=dis(u)=+∞，与假设矛盾。

  于是一定存在路径 s → x → y → u s \to x \to y \to u s→x→y→u，其中 y y y 为 s → u s \to u s→u 路径上第一个属于 T T T 集合的点，而 x x x 为 y y y 的前驱结点（显然 x ∈ S x \in S x∈S）。需要注意的是，可能存在 s = x s = x s=x 或 y = u y = u y=u 的情况，即 s → x s \to x s→x 或 y → u y \to u y→u 可能是空路径。

  因为在 u u u 结点之前加入的结点都满足 D ( u ) = d i s ( u ) D(u) = dis(u) D(u)=dis(u)，所以在 x x x 点加入到 S S S 集合时，有 D ( x ) = d i s ( x ) D(x) = dis(x) D(x)=dis(x)，此时边 ( x ,   y ) (x,\ y) (x, y) 会被松弛，从而可以证明，将 u u u 加入到 S S S 时，一定有 D ( y ) = d i s ( y ) D(y) = dis(y) D(y)=dis(y)。

  下面证明 D ( u ) = d i s ( u ) D(u) = dis(u) D(u)=dis(u) 成立。在路径 s → x → y → u s \to x \to y \to u s→x→y→u 中，因为图上所有边边权非负，因此 D ( y ) ≤ d i s ( y ) D(y) \le dis(y) D(y)≤dis(y)。从而 d i s ( y ) ≤ D ( y ) ≤ D ( u ) ≤ d i s ( u ) dis(y) \le D(y) \le D(u) \le dis(u) dis(y)≤D(y)≤D(u)≤dis(u)。但是因为 u u u 结点在 1 过程中被取出 T T T 集合时， 结点还没有被取出 T T T 集合，因此此时有 d i s ( u ) ≤ d i s ( y ) dis(u) \le dis(y) dis(u)≤dis(y)，从而得到 d i s ( y ) = D ( y ) = D ( u ) = d i s ( u ) dis(y) = D(y) = D(u) = dis(u) dis(y)=D(y)=D(u)=dis(u)，这与 D ( u ) ≠ d i s ( u ) D(u) \ne dis(u) D(u)=dis(u) 的假设矛盾，故假设不成立。

  因此我们证明了，1 操作每次取出的点，其最短路均已经被确定。命题得证。

4. 复杂度

  • 时间复杂度： O ( n 2 ) O(n^2) O(n2)（普通的）； O ( n log ⁡ n ) ∼ O ( m log ⁡ n ) O(n\log n)\sim O(m\log n) O(nlogn)∼O(mlogn)（堆优化的）；
  • 空间复杂度： O ( n ) O(n) O(n)。
习题演练集
#8172. 单源点最短路问题

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <cstdio>
#include <queue>
using namespace std;
typedef long long ll;
const int N = 2e3 + 5, M = 2 * 1e4 + 5, INF = 0x3f3f3f3f;
int n, m, a, b, c, s, t, tot, head[N], pre[N];
struct Edge {
	int to, w, next;
} e[M];
void add(int u, int v, int w) {
	e[++tot].to = v, e[tot].w = w, 
	e[tot].next = head[u], head[u] = tot;
	return;
}
void init() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &a, &b, &c);
		add(a, b, c);
	}
	scanf("%d %d", &s, &t);
	return;
}
int dis[N];
bool vis[N];
priority_queue< pair<int, int> > q;
void Dijkstra() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF;
		vis[i] = false;
	}
	dis[s] = 0;
	q.push(make_pair(0, s));
	int x;
	while (q.size()) {
		x = q.top().second;
		q.pop();
		if (vis[x]) {
			continue;
		}
		vis[x] = true;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
				pre[y] = x;
				q.push(make_pair(-dis[y], y));
			} else if (dis[y] == dis[x] + w) {
				pre[y] = min(pre[y], x);
			}
		}
	}
	return;
}
void print(int node) {
	if (!node) {
		return;
	}
	print(pre[node]);
	printf("%d ", node);
	return;
}
void solve() {
	printf("%d\n", dis[t]);
	print(t);
	return;
}
int main() {
	init();
	Dijkstra();
	solve();
	return 0;
}
#8169. 有向图的单源点最短路径

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <cstdio>
#include <queue>
using namespace std;
typedef long long ll;
const int N = 2e3 + 5, M = 2 * 1e4 + 5, INF = 0x3f3f3f3f;
int n, m, a, b, c, s, t, tot, head[N], pre[N];
struct Edge {
	int to, w, next;
} e[M];
void add(int u, int v, int w) {
	e[++tot].to = v, e[tot].w = w, 
	e[tot].next = head[u], head[u] = tot;
	return;
}
void init() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d", &a, &b);
		add(a, b, 1);
	}
	scanf("%d %d", &s, &t);
	return;
}
int dis[N];
bool vis[N];
priority_queue< pair<int, int> > q;
void Dijkstra() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF;
		vis[i] = false;
	}
	dis[s] = 0;
	q.push(make_pair(0, s));
	int x;
	while (q.size()) {
		x = q.top().second;
		q.pop();
		if (vis[x]) {
			continue;
		}
		vis[x] = true;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
				pre[y] = x;
				q.push(make_pair(-dis[y], y));
			} else if (dis[y] == dis[x] + w) {
				pre[y] = min(pre[y], x);
			}
		}
	}
	return;
}
void print(int node) {
	if (!node) {
		return;
	}
	print(pre[node]);
	printf("%d ", node);
	return;
}
void solve() {
	if (dis[t] == INF) {
		printf("no solution");
	} else {
		printf("%d\n", dis[t]);
		print(t);
	}
	return;
}
int main() {
	init();
	Dijkstra();
	solve();
	return 0;
}
#3144. 无向图单源最短路

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <bits/stdc++.h>
using namespace std;
const int N = 2505, M = 12205;
int n, m, s, t, c, d, z, dis[N], head[N], tot;
bool vis[M];
struct Edge {
	int to, w, next;
} e[M];
priority_queue<pair<int, int> > q;
void add(int u, int v, int w) {
	e[++tot].to = v, e[tot].w = w, 
	e[tot].next = head[u], head[u] = tot;
	return;
}
void dijkstra() {
	memset(dis, 0x7f, sizeof dis);
	memset(vis, 0, sizeof vis);
	dis[s] = 0;
	q.push(make_pair(0, s));
	int x;
	while (q.size()) {
		x = q.top().second;
		q.pop();
		if (vis[x]) {
			continue;
		}
		vis[x] = true;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
				q.push(make_pair(-dis[y], y));
			}
		}
	}
	return;
}
int main() {
	scanf("%d %d %d %d", &n, &m, &s, &t);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &c, &d, &z);
		add(c, d, z);
		add(d, c, z);
	}
	dijkstra();
	printf("%d", dis[t]);
	return 0;
}

（三）Bellman-Ford 算法

  Bellman-Ford 算法是求解单源最短路径问题的一种算法。
  该算法由理查德·贝尔曼（Richard Bellman）和莱斯特·福特创立。有时候这种算法也被称为 Moore-Bellman-Ford 算法，因为 Edward F. Moore 也为这个算法的发展做出了贡献。
  其优于 Dijkstra 算法的方面是边的权值可以为负数、实现简单，缺点是时间复杂度过高，高达 O ( V E ) O(VE) O(VE)。但算法可以进行若干种优化，提高效率。

1. 基本原理

  对图进行 V − 1 V-1 V−1 次松弛操作，得到所有可能的最短路径。

算法过程欣赏（从左往右从上至下）

2. 算法描述

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
int dis[N];
void Bellman_Ford() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF; 
	}
	dis[s] = 0;
	for (int i = 1; i < n; i++) { // 松弛 n - 1 次
		for (int j = 1; j <= m; j++) { // 对每一条边进行松弛
			int y = e[j].y, x = e[j].x; 
			if (dis[y] > dis[x] + e[j].w) {
				dis[y] = dis[x] + e[j].w;
			}
		}
	}
	return;
}

3. 讨论

Part1 \text{Part1} Part1 在 Bellman-Ford 算法中怎样判有向环？

  当从 s s s 点出发，抵达一个负环时，松弛操作会无休止地进行下去。在 Bellman-Ford 中，对于最短路存在的图，松弛操作最多只会执行 n − 1 n - 1 n−1 轮。因此，如果第 n n n 轮循环时仍然存在能松弛的边，说明从 s s s 点出发，能够抵达一个负环。
  需要注意的是，以 s s s 点为源点跑 Bellman-Ford 算法时，如果没有给出存在负环的结果，只能说明从 s s s 点出发不能抵达一个负环，而不能说明图上不存在负环。（譬如 #91. 「Vijos P1053」Easy SSSP，就是血与泪的教训）
  因此如果需要判断整个图上是否存在负环，最严谨的做法是建立一个超级源点（正常一点说，虚点），向图上每个节点连一条权值为 0 0 0 的边，然后以超级源点为起点执行 Bellman-Ford 算法。

Part2 \text{Part2} Part2 Bellman-Ford 可以优化吗？

  是的，很多时候我们并不需要那么多无用的松弛操作。
  很显然，只有上一次被松弛的结点，所连接的边，才有可能引起下一次的松弛操作。
  那么我们用队列来维护「哪些结点可能会引起松弛操作」，就能只访问必要的边了。
  这种做法就是我们接下来要记载的 SPFA 算法。（除此之外还有堆优化、栈优化、LLL 优化、SLF 优化，D´Esopo-Pape 算法等奇形怪状杂七杂八优美的优化可以自行了解）

4. 复杂度

  • 时间复杂度： O ( n m ) O(nm) O(nm)；
  • 空间复杂度： O ( n ) O(n) O(n)。
习题演练集
#2848. 非负权单源最短路

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
const int M = 12400 + 5, N = 2.5e3+ 5, INF = 0x3f3f3f3f;
int n, m, a, b, c, s, t, tot;
struct Edge {
	int u, v, w;
} e[M];
void add(int u, int v, int w) {
	e[++tot].u = u, e[tot].v = v,e[tot].w = w; 
	return;
}
void init() {
	scanf("%d %d %d %d", &n, &m, &s, &t);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &a, &b, &c);
		add(a, b, c);
		add(b, a, c);
	}
	return;
}
int dis[N];
void Bellman_Ford() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF;
	}
	dis[s] = 0;
	for (int i = 1; i < n; i++) {
		for (int j = 1; j <= 2 * m; j++) {
			int x = e[j].u, y = e[j].v, w = e[j].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
			}
		}
	}
	return;
}
void solve() {
	printf("%d", dis[t]);
}
int main() {
	init();
	Bellman_Ford();
	solve();
	return 0;
}
#9890. 带负权单源点最短路

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <algorithm>
#include <cstdio>
using namespace std;
const int M = 4e4 + 5, N = 5e2 + 5, INF = 0x3f3f3f3f;
int n, m, a, b, c, s, t, tot, pre[M];
struct Edge {
	int x, y, w;
} e[M];
void add(int u, int v, int w) {
	e[++tot].x = u, e[tot].y = v, e[tot].w = w;
	return;
}
void init() {
	scanf("%d %d", &n, &m);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &a, &b, &c);
		add(a, b, c);
	}
	scanf("%d %d", &s, &t);
	return;
}
void print(int node) {
	if (!pre[node]) {
		return;
	}
	print(pre[node]);
	printf("%d ", node);
	return;
}
int dis[N];
void Bellman_Ford() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF;
	}
	dis[s] = 0;
	for (int i = 1; i < n; i++) {
		for (int j = 1; j <= m; j++) {
			int y = e[j].y, x = e[j].x; 
			if (dis[y] > dis[x] + e[j].w) {
				dis[y] = dis[x] + e[j].w;
				pre[y] = x;
			}
			if (dis[y] == dis[x] + e[j].w) {
				pre[y] = min(pre[y], x);
			}
		}
	}
	for (int i = 1; i <= m; i++) {
		int y = e[i].y, x = e[i].x; 
		if (dis[y] > dis[x] + e[i].w) {
			printf("No Solution");
			return;
		}
	}
	printf("%d\n%d ", dis[t], s);
	print(t);
	return;
}
int main() {
	init();
	Bellman_Ford();
	return 0;
}

（四）SPFA 算法

  SPFA 算法是 Bellman-Ford算法的队列优化算法的别称，通常用于求含负权边的单源最短路径，以及判负权环。SPFA 最坏情况下复杂度和朴素 Bellman-Ford 相同，为 O ( V E ) O(VE) O(VE)。
  SPFA算法的全称是：Shortest Path Faster Algorithm，是西南交通大学段凡丁于 1994 年发表的论文中的名字。不过，段凡丁的证明是错误的，且在 Bellman-Ford 算法提出后不久（1957 年）已有队列优化内容，所以国际上不承认 SPFA 算法是段凡丁提出的。

1. 基本原理

  先将源点加入队列。然后从队列中取出一个点（此时该点为源点），对该点的邻接点进行松弛，如果该邻接点松弛成功且不在队列中，则把该点加入队列。如此循环往复，直到队列为空，则求出了最短路径。

2. 算法描述

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
void print(int node) {
	if (!pre[node]) {
		return;
	}
	print(pre[node]);
	printf("%d ", node);
	return;
}
int dis[N];
bool vis[N];
queue<int> q;
void SPFA() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF, vis[i] = false;
	}
	dis[s] = 0, vis[s] = true, q.push(s);
	int x;
	while (q.size()) {
		x = q.front();
		q.pop();
		vis[x] = false;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w; 
			if (dis[y] > dis[x] + e[i].w) {
				dis[y] = dis[x] + e[i].w;
				pre[y] = x;
				if (!vis[y]) {
					q.push(y);
					vis[y] = true;
				}
			} 
			else if (dis[y] == dis[x] + e[i].w) {
				pre[y] = min(pre[y], x);
			}
		}
	}
	if (dis[t] == INF) {
		printf("-1"); 
	} else {
		printf("%d\n%d ", dis[t], s);
		print(t);
	}
	return;
}

3. 讨论

Part1 \text{Part1} Part1 在 SPFA 算法中怎样判有向环？

  如果某个点进入队列的次数超过 n n n 次则存在负环 ( 存在负环则无最短路径，如果有负环则会无限松弛,而一个带 n n n 个点的图至多松弛 n − 1 n-1 n−1 次) 。

Part2 \text{Part2} Part2 怎样看待「SPFA」已死的说法？

  （emm…怎么说呢）段凡丁于 1994 年发表的论文中给出了 SPFA 算法的证明。不过，段凡丁的证明是错误的，段凡丁论文中时间复杂度的证明 （ O ( K E ) O(KE) O(KE)， K K K 是常数）也是错误的。该算法的最坏复杂度为 O ( V E ) O(VE) O(VE)。

段凡丁的论文（部分）

图 4-1 伪代码


图4-2 正确性证明


图 4-3 时间复杂度证明

  段凡丁论文里的 SPFA 正确性证明分成两部分：一定能找到最短路；算法能在有限次操作后找到最短路。从他的代码和证明来看，他当时并没有想到负环的情况（即每个点至多入队 n − 1 n-1 n−1 次），他这个代码一旦有负环就停不下来了。
  他的复杂度证明的也是很奇妙，仅凭实验就断定算法的复杂度，而没有理论上的证明，显然是行不通的。所以 SPFA 这个算法不是很受待见，在某乎上就有「SPFA 这玩意，既然都知道它复杂度是扯淡的，那它就应该被当成一个骗分算法。」，「如果出题人不卡骗分算法，就是不尊重写 dij 的选手。卡 SPFA 是出题人负责任的体现」，甚至还有专门卡 SPFA 的数据。
  说句老实话，在无恶意数据下跑负权图的 SPFA 确实挺快。而且有一部分题比较适合用 SPFA。SPFA 被卡了也就是个 Bellman-Ford 的时间复杂度，不用白不用嘛，当然正权图里还是 Dijkstra 好。

4. 复杂度

  • 时间复杂度： O ( n m ) O(nm) O(nm)；
  • 空间复杂度： O ( n ) O(n) O(n)。
习题演练集
#30143. 非负权单源最短路（强化版）

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
const int M = 2e6 + 5, N = 1e6 + 5, INF = 0x3f3f3f3f;
int n, m, a, b, c, s, t, tot, head[N];
struct Edge {
	int to, w, next;
} e[M];
void add(int u, int v, int w) {
	e[++tot].to = v, e[tot].w = w,
	e[tot].next = head[u], head[u] = tot; 
	return;
}
void init() {
	scanf("%d %d %d %d", &n, &m, &s, &t);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &a, &b, &c);
		add(a, b, c);
		add(b, a, c);
	}
	return;
}
int dis[N];
bool vis[N];
queue<int> q;
void SPFA() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF;
	}
	dis[s] = 0;
	vis[s] = true;
	q.push(s);
	int x;
	while (q.size()) {
		x = q.front();
		q.pop();
		vis[x] = false;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
				if (!vis[y]) {
					q.push(y);
					vis[y] = true;
				}
			}
		} 
	} 
	return;
}
void solve() {
	if (dis[t] == INF) {
		printf("-1");
	} else {
		printf("%d", dis[t]);	
	}
	return;
}
int main() {
	init();
	SPFA();
	solve();
	return 0;
}
#30144. 非负权单源最短路（输出方案）

link

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
#include <algorithm>
#include <cstdio>
#include <queue>
using namespace std;
const int M = 2e6 + 5, N = 1e6 + 5, INF = 0x3f3f3f3f;
int n, m, a, b, c, s, t, tot, head[N], pre[N];
struct Edge {
	int to, w, next;
} e[M];
void add(int u, int v, int w) {
	e[++tot].to = v, e[tot].w = w,
	e[tot].next = head[u], head[u] = tot; 
	return;
}
void init() {
	scanf("%d %d %d %d", &n, &m, &s, &t);
	for (int i = 1; i <= m; i++) {
		scanf("%d %d %d", &a, &b, &c);
		add(a, b, c);
		add(b, a, c);
	}
	return;
}
int dis[N];
bool vis[N];
queue<int> q;
void SPFA() {
	for (int i = 1; i <= n; i++) {
		dis[i] = INF;
	}
	dis[s] = 0;
	vis[s] = true;
	q.push(s);
	int x;
	while (q.size()) {
		x = q.front();
		q.pop();
		vis[x] = false;
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to, w = e[i].w;
			if (dis[y] > dis[x] + w) {
				dis[y] = dis[x] + w;
				pre[y] = x;
				if (!vis[y]) {
					q.push(y);
					vis[y] = true;
				}
			} else if (dis[y] == dis[x] + w) {
				pre[y] = min(pre[y], x);
			}
		} 
	} 
	return;
}
void print(int node) {
	if (!pre[node]) {
		return;
	}
	print(pre[node]);
	printf(" %d", node);
	return;
}
void solve() {
	if (dis[t] == INF) {
		printf("-1");
	} else {
		printf("%d\n%d", dis[t], s);
		print(t);	
	}
	return;
}
int main() {
	init();
	SPFA();
	solve();
	return 0;
}


三、最小生成树

  百度百科定义：一个有 n n n 个结点的连通图的生成树是原图的极小连通子图，且包含原图中的所有 n n n 个结点，并且有保持图连通的最少的边。
  OI Wiki：我们定义无向连通图的最小生成树（Minimum Spanning Tree，MST）为边权和最小的生成树。
  注意：只有连通图才有生成树，而对于非连通图，只存在生成森林。

（一）Prim 算法

  普里姆算法（Prim算法），图论中的一种算法，可在加权连通图里搜索最小生成树。
  该算法于 1930 1930 1930 年由捷克数学家沃伊捷赫·亚尔尼克（英语：Vojtěch Jarník）发现；并在 1957 1957 1957 年由美国计算机科学家罗伯特·普里姆（英语：Robert C. Prim）独立发现。因此，在某些场合，普里姆算法又被称为 DJP 算法、亚尔尼克算法或普里姆－亚尔尼克算法。

1. 基本原理

  1. 以任意一个点为基准点；
  2. 节点分为两组：
    1. 在 MST 上到基准点的路径已经确定的点；
    2. 尚未在 MST 中与基准点相连的点。
  3. 不断从第2组中选择与第1组距离最近的点加入第1组。

注：类似于 Dijkstra，本质也是贪心， O ( n 2 ) O(n^2) O(n2)

  对图进行 V − 1 V-1 V−1 次松弛操作，得到所有可能的最短路径。

1. 基本原理

  先将源点加入队列。然后从队列中取出一个点（此时该点为源点），对该点的邻接点进行松弛，如果该邻接点松弛成功且不在队列中，则把该点加入队列。如此循环往复，直到队列为空，则求出了最短路径。

算法过程欣赏（动图）

2. 算法描述

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
ll d[N];
bool vis[N];
priority_queue< pair<ll, int > > q;
void Prim() {
	for (int i = 1; i <= n; i++) {
		d[i] = INF;
	}
	d[1] = 0; 
	q.push(make_pair(0, 1));
	int x;
	while (q.size()) {
		x = q.top().second;
		q.pop();
		if (vis[x]) {
			continue;
		}
		vis[x] = true;
		MST += d[x];
		for (int i = head[x]; i; i = e[i].next) {
			int y = e[i].to;
			ll w = e[i].w;
			if (d[y] > w) {
				d[y] = w;
				q.push(make_pair(-d[y], y));
			}
		}
	}
	return;
}

3. 讨论

Part1 \text{Part1} Part1 Prim 和 Kruskal 的区别？

  Prim 算法的本质是不断加点（而不是 Kruskal 算法的加边）。

4. 复杂度

  • 时间复杂度： O ( n 2 + m ) O(n^2+ m) O(n2+m)（普通的）； O ( ( n + m ) log ⁡ n ) ∼ O ( m log ⁡ n ) O((n + m)\log n)\sim O(m\log n) O((n+m)logn)∼O(mlogn)（堆优化的）

（二）Kruskal 算法

  Kruskal 算法是一种常见并且好写的最小生成树算法，由 Kruskal 发明。该算法的基本思想是从小到大加入边，是个贪心算法。
  Kruskal 算法适合于求边稀疏的网的最小生成树。

1. 基本原理

  1. 以任意一个点为基准点；

  2. 节点分为两组：

    1. 在 MST 上到基准点的路径已经确定的点；
    2. 尚未在 MST 中与基准点相连的点。

  3. 不断从第2组中选择与第1组距离最近的点加入第1组。

注：类似于 Dijkstra，本质也是贪心， O ( n 2 ) O(n^2) O(n2)

  对图进行 V − 1 V-1 V−1 次松弛操作，得到所有可能的最短路径。

1. 基本原理

  1. 利用并查集，起初每个点各自构成一个集合；
  2. 所有边按照边权从小到大排序，依次扫描；
  3. 若当前扫描到的边连接两个不同的点集就合并。

注：本质也是贪心， O ( m log ⁡ n ) O(m\log n) O(mlogn)。与 Prim 算法相比，没有基准点，该算法是不断选择两个距离最近的集合进行合并的过程。

算法过程欣赏（动图）

2. 算法描述

代码（抵制学术不端行为，拒绝 Ctrl + C）： 
void MakeSet() {
	for (int i = 1; i <= n; i++) {
		fa[i] = i;
	}
	return;
}
int FindSet(int node) {
	if (fa[node] == node) {
		return node;
	}
	return fa[node] = FindSet(fa[node]);
}
void UnionSet(int x, int y) {
	x = FindSet(x), y = FindSet(y);
	if (x == y) {
		return;
	} 
	fa[x] = y;
	return;
}
bool cmp(Edge x, Edge y) { return x.w < y.w; }
void Kruskal() {
	MakeSet();
	sort(e + 1, e + n, cmp);
	int x, y, w;
	for (int i = 1; i < n; i++) {
		x = FindSet(e[i].u), y = FindSet(e[i].v), w = e[i].w;
		UnionSet(x, y);
	}
	return;
}

3. 复杂度

  • 时间复杂度： O ( m log ⁡ m ) O(m \log m) O(mlogm)

未完待续。。。
叭叭~(≧∇≦)ﾉ

北柒kylin
关注
  • 0
    点赞
  • 踩
  • 4
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
数据结构之图论算法
Nerdant
11-25 932
一、图的基本概念和定义 图是由顶点的有穷非空集合和顶点之间边的集合组成，通常表示为G=(V,E)； 图的顶点个数不能为0，但边数可以为0，一般没有空图的说法，图论里的零图是表示只由孤立节点组成的图。 数据结构中讨论的图都是简单图，即没有环也没有重边的图。 一条边依附于两个点，两点的邻接意味着两点由一条边相连。 含有n个顶点的无向完全图有n*(n-1)/2条边，有向完全图有n*(n-1)...
数据结构-图论-PPT
02-04
数据结构图论是计算机科学中研究图的数据结构和算法的领域。图是由顶点和边组成的数学结构，广泛应用于计算机科学、信息科学、物理科学等领域。 图的定义：图G由两个集合V(Vertex)和E(Edge)组成，记为G=(V,E)，其中...
数据结构之图论
weixin_46516647的博客
08-29 1858
（重点内容：深搜和广搜；图的基本概念及其性质；图的存储结构及特性；基于存储结构上的遍历和各种应用；图的相关算法的思想）图G由顶点集V和遍集V组成，记为G=(V,E)；V表示顶点(数据元素)的有穷非空集合；E表示边的有穷集合。（图不能为空，图中不能一个顶点也没有，边集可以为空，此时只有顶点而没有边）E为有向边（弧）的有限集合，有向边是顶点的有序对，记为，称为从v到w的弧，或v邻接到wE是无向边的有限集合图中任意两个顶点都一条边相连。对于无向图完全图有n(n-1)/2条边；...............
数据结构与算法——图论基础与图存储结构
程序员吴师兄的博客
03-25 2065
1 前言由于后续更新「面试专场」的好几篇文章都涉及到图这种数据结构，因此打算先普及一下 图 的相关理论支持，如果后面的相关内容有些点不太容易理解，可以查阅此篇文章。本...
数据结构之图论算法（三）——构造图的最小生成树
huxxyyy的博客
08-25 2096
构造图的最小生成树 生成树： 通过对无向图的生成树进行深度遍历和广度遍历后，我们发现它都遵循一个性质： MST性质：设N =（V，E）是一个连通网，U是
【数据结构与算法】图论及其相关算法
十八岁讨厌编程的博客
05-27 3426
本文涉及图的基本介绍、表示方法、DFS、BFS、解决最小生成树的算法、解决最短路径的算法等内容。
数据结构——图论
02-06
该文件包括图的头文件，另外还实现了邻接表的Dijkstra算法
数据结构-图论相关功能及算法
06-11
数据结构-图论相关功能及算法
考研数据结构第七章-图论必刷题
04-27
考研数据结构第七章-图论必刷题。 该文件里面一共有42道题，其中包括选择题，填空题和应用大题。这些题目都是历年各大名校的考研真题，非常具有参考意义。学完图论这章，只需要刷完这里面的题目就足够了。所有的...
程序员的数学4：图论入门.pptx
最新发布
10-14
在编程中，我们通常会使用节点和边来表示数据结构，例如树、图等。 图论的基本概念包括图、节点、边、度数等。图可以分为有向图和无向图两种，边的两端连接到两个节点。在有向图中，边的两端连接到两个节点，但方向...
数据结构 图论 最经典的结合
05-19
)scrollAmount。它表示速度，值越大速度越快。建议设为1～3比较好。 b)width和height，表示滚动区域的大小，width是宽度，height是高度。特别是在做垂直滚动的时候，一定要设height的值。 c)direction。表示滚动的方向，默认为从右向左：←。可选的值有right、down、up。滚动方向分别为：right表示→，up表示↑，down表示↓。 d)scrollDelay，这也是用来控制速度的，不添加，即默认为90。值越大，速度越慢。通常scrollDelay是不需要设置的。 e)behavior。用它来控制属性，默认为循环滚动，可选的值有alternate(交替滚动)、slide(幻灯片效果，指的是滚动一次，然后停止滚动)
数据结构与算法——图论
偷得浮生半日闲
08-23 887
一、图的概念 图形由顶点/节点和连接这些顶点的边/线组成。 图可以是无向的（意味着在与每个双向边相关联的两个顶点之间没有区别）或者可以指向图（意味着其边缘从一个顶点指向另一个顶点但不一定在另一个方向上）。 可以对图形进行加权（通过向每个边缘分配权重，其表示与该连接相关联的数值）或者图形可以是未加权的（所有边缘具有单位权重1或者所有边缘具有相同的恒定权重） 图的可视化 顶点（vertex） ...
数据结构—图论
不忘初心，知行统一
11-26 1483
图论〔Graph Theory〕是数学的一个分支。它以图为研究对象。图论中的图是由若干给定的点及连接两点的线所构成的图形，这种图形通常用来描述某些事物之间的某种特定关系，用点代表事物，用连接两点的线表示相应两个事物间具有这种关系。 图论是一种表示 "多对多" 的关系 图是由顶点和边组成的：(可以无边，但至少包含一个顶点) 一组顶点：通常用 V(vertex) 表示顶点集合一组边：通常用
数据结构——图论（java）
wind_cp的博客
10-06 5324
一.基本概念 1、顶点（vertex） 表示某个事物或对象。由于图的术语没有标准化，因此，称顶点为点、节点、结点、端点等都是可以的。 2、边（edge） 通俗点理解就是两个点相连组合成一条边，表示事物与事物之间的关系。需要注意的是边表示的是顶点之间的逻辑关系，粗细长短都无所谓的。包括上面的顶点也一样，表示逻辑事物或对象，画的时候大小形状都无所谓。 3、同构（Isomorphism ） ...
数据结构 图论集合01 邻接矩阵、邻接表 代码 java
半亩方糖
11-21 7615
【数据结构】图（邻接矩阵、邻接表）的JAVA代码实现组成常用术语图的分类数据结构（重点）代码 组成 顶点 + 边 （边可以没有但是至少有一个顶点） 图Graph是顶点vertex集合和边（也称之为弧 edge)集合组成。 G=(V,E) 这里V是vertex顶点集合，E是edge边集合 E=(Vi,Vj) 表示顶点i和顶点j之间的连线（边，弧） 常用术语 无向边：2边都能通行，用圆括号表示（类似双链表） 有向边：反之，用尖括号表示，（也称之为弧） 权：可以表示一个距离，（带权重的图Graph叫做
数据结构之图论概念大全
Z_timer的博客
10-28 6053
本文一些概念引用他人博文 如有侵权 联系删除 顶点的度、入度、出度 无向图及性质 无向完全图：连通图:极大连通子图：极小连通子图：生成树：最小生成树及算法：生成森林 非连通图：连通图及特性 有向图及性质 极大强连通子图：极小强连通子图：不存在这个概念 最小树形图（难点，考研忽略）：邻接矩阵 邻接表 逆邻接表 十字链表 邻接多重表 特殊矩阵 图的遍历BFS DFS最短路径Dijkstra Floyd （逆）拓扑排序 AOV网 关键路径 AOE网（路径长度、完成工程的最短时间、关键路径） 稠密图、稀疏图
数据结构--图论
CS171_chengl的博客
11-25 892
目录 一、图的基本知识 二、图的存储结构 （1）邻接矩阵 （2）邻接表 三、图的遍历方式 （1）DFS（Deep First Search 深度优先搜索） （2）BFS（Breadth First Search 宽度优先搜索&amp;广度优先搜索） （3）略谈DFS与BFS其他用途 四、图的应用 （1）最小生成树(MST-Minimum Spanning Tree) 1.普...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值