以下题目和算法思路均来自AcWing
这个文章当作我的笔记了,方便以后的复习
在这里再次感谢y总
图论问题的算法
有向图的拓扑排序
给定一个 n n n个点 m m m条边的有向图,点的编号是 1 1 1到 n n n,图中可能存在重边和自环。
请输出任意一个该有向图的拓扑序列,如果拓扑序列不存在,则输出 − 1 −1 −1。
若一个由图中所有点构成的序列 A A A满足:对于图中的每条边 ( x , y ) (x,y) (x,y), x x x在 A A A中都出现在 y y y之前,则称 A A A是该图的一个拓扑序列。
输入格式
第一行包含两个整数
n
n
n和
m
m
m。
接下来 m m m行,每行包含两个整数 x x x和 y y y,表示存在一条从点 x x x到点 y y y的有向边 ( x , y ) (x,y) (x,y)。
输出格式
共一行,如果存在拓扑序列,则输出任意一个合法的拓扑序列即可。
否则输出 − 1 −1 −1。
数据范围
1
≤
n
,
m
≤
105
1≤n,m≤105
1≤n,m≤105
输入样例:
3 3
1 2
2 3
1 3
输出样例:
1 2 3
通过入度的数量来判断当前的点是否是该输出
C++ 代码
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#include<vector>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N], ne[N], idx;
int din[N]; // 入度的大小
vector<int> ans;
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
void topsort() {
queue<int> store;
for (int i = 1; i <= n; i++)
if (din[i] == 0)
store.push(i);
while (store.size()) {
auto t = store.front();
store.pop();
ans.push_back(t);
for (int i = h[t]; ~i; i = ne[i]) {
int j = e[i];
if (--din[j] == 0)
store.push(j);
}
}
}
int main() {
memset(h, -1, sizeof h);
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
scanf("%d%d", &x, &y);
add(x, y);
din[y]++;
}
topsort();
if (ans.size() != n) cout << "-1" << endl;
else {
for (int i = 0, len = ans.size(); i < len; i++)
printf("%d ", ans[i]);
}
return 0;
}
单源最短路径算法
dijkstra
给定一个 n n n 个点 m m m 条边的有向图,图中可能存在重边和自环,所有边权均为正值。
请你求出 1 1 1 号点到 n n n 号点的最短距离,如果无法从 1 1 1 号点走到 n n n 号点,则输出 − 1 −1 −1。
输入格式
第一行包含整数
n
n
n 和
m
m
m。
接下来 m m m行每行包含三个整数 x , y , z x,y,z x,y,z,表示存在一条从点 x x x 到点 y y y 的有向边,边长为 z z z。
输出格式
输出一个整数,表示
1
1
1 号点到
n
n
n 号点的最短距离。
如果路径不存在,则输出 − 1 −1 −1。
数据范围
1
≤
n
≤
500
1≤n≤500
1≤n≤500,
1
≤
m
≤
105
1≤m≤105
1≤m≤105,
图中涉及边长均不超过
10000
10000
10000。
输入样例:
3 3
1 2 2
2 3 1
1 3 4
输出样例:
3
算法的步骤:
- 寻找路径最小的点
- 用这个点更新他的周围的点
- 将点添加到路径中
C++ 代码
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 510;
int n, m;
int g[N][N]; // 从i到j的距离
int dist[N]; // 到起点的距离
bool st[N]; // 是否已经被遍历过
void dijkstra(int start) {
memset(dist, 0x3f, sizeof dist); // 初始化距离
dist[start] = 0;
for (int i = 0; i < n - 1; i ++) {
int minv = -1;
for (int j = 1; j <= n; j++) // 寻找路径最小的点
if (!st[j] && (minv == -1 || dist[minv] > dist[j]))
minv = j;
for (int j = 1; j <= n; j++) // 用这个点更新周围的点
dist[j] = min(dist[j], dist[minv] + g[minv][j]);
st[minv] = true; // 将点添加到路径中
}
}
int main() {
memset(g, 0x3f,sizeof g); //初始化地图
cin >> n >> m;
while (m--) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
g[x][y] = min(g[x][y], z);
}
dijkstra(1);
if (dist[n] == 0x3f3f3f3f)
cout << -1 << endl;
else
cout << dist[n] << endl;
return 0;
}
dijkstra堆优化版
给定一个 n n n 个点 m m m 条边的有向图,图中可能存在重边和自环,所有边权均为非负值。
请你求出 1 1 1 号点到 n n n 号点的最短距离,如果无法从 1 1 1 号点走到 n n n 号点,则输出 − 1 −1 −1。
输入格式
第一行包含整数
n
n
n 和
m
m
m。
接下来 m m m 行每行包含三个整数 x , y , z x,y,z x,y,z,表示存在一条从点 x x x 到点 y y y 的有向边,边长为 z z z。
输出格式
输出一个整数,表示
1
1
1 号点到
n
n
n 号点的最短距离。
如果路径不存在,则输出 − 1 −1 −1。
数据范围
1
≤
n
,
m
≤
1.5
×
1
0
5
1≤n,m≤1.5×10^{5}
1≤n,m≤1.5×105,
图中涉及边长均不小于
0
0
0,且不超过
10000
10000
10000。
数据保证:如果最短路存在,则最短路的长度不超过
1
0
9
10^{9}
109。
输入样例:
3 3
1 2 2
2 3 1
1 3 4
输出样例:
3
用堆可以优化查找最小路径的这个过程
C++代码
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
const int N = 150010;
int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c) {
e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void dijkstra(int start) {
priority_queue<PII, vector<PII>, greater<PII>> store;
memset(dist, 0x3f, sizeof dist);
dist[start] = 0;
store.push({0, start});
while (store.size()) {
auto temp = store.top(); // 获取最短路径的点
store.pop();
int distance = temp.x, ver = temp.y;
if (st[ver]) continue; // 将点添加到路径中
st[ver] = true;
for (int i = h[ver]; ~i; i = ne[i]) { // 更新这个点连接的点的距离
int j = e[i];
if (dist[j] > dist[ver] + w[i]) {
dist[j] = dist[ver] + w[i];
store.push({dist[j], j});
}
}
}
}
int main() {
memset(h, -1, sizeof h); //初始化地图
cin >> n >> m;
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
dijkstra(1);
if (dist[n] == 0x3f3f3f3f)
cout << -1 << endl;
else
cout << dist[n] << endl;
return 0;
}
Bellman-Ford
给定一个 n n n 个点 m m m 条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你求出从 1 1 1 号点到 n n n 号点的最多经过 k k k 条边的最短距离,如果无法从 1 1 1 号点走到 n n n 号点,输出 i m p o s s i b l e impossible impossible。
注意:图中可能 存在负权回路 。
输入格式
第一行包含三个整数
n
,
m
,
k
n,m,k
n,m,k。
接下来 m m m 行,每行包含三个整数 x , y , z x,y,z x,y,z,表示存在一条从点 x x x 到点 y y y 的有向边,边长为 z z z。
输出格式
输出一个整数,表示从
1
1
1 号点到
n
n
n 号点的最多经过
k
k
k 条边的最短距离。
如果不存在满足条件的路径,则输出 i m p o s s i b l e impossible impossible。
数据范围
1
≤
n
,
k
≤
500
1≤n,k≤500
1≤n,k≤500,
1
≤
m
≤
10000
1≤m≤10000
1≤m≤10000,
任意边长的绝对值不超过
10000
10000
10000。
输入样例:
3 3 1
1 2 1
2 3 1
1 3 3
输出样例:
3
bellman-ford比dijkstra更有广泛性, 他处理的图可以有负权边,dijkstra则不可以
核心思想:
对所有的边进行n-1轮松弛操作,因为在一个含有n个顶点的图中,任意两点之间的最短路径最多包含n-1边。换句话说,第1轮在对所有的边进行松弛后,得到的是源点最多经过一条边到达其他顶点的最短距离;第2轮在对所有的边进行松弛后,得到的是源点最多经过两条边到达其他顶点的最短距离;第3轮在对所有的边进行松弛后,得到的是源点最多经过一条边到达其他顶点的最短距离…
https://zhuanlan.zhihu.com/p/72185593
C++ 代码
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 510, M = 10010, INF = 0x3f3f3f3f;
int n, m, k;
int h[N], e[M], ne[M], w[M], idx;
int dist[N], backup[N];
void add(int a, int b, int c) {
e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void bellman_ford(int start) {
memset(dist, 0x3f,sizeof dist);
dist[start] = 0;
for (int v = 0; v < k; v++){
memcpy(backup, dist, sizeof dist);
for (int i = 1; i <= n; i++)
for (int j = h[i]; ~j; j = ne[j]) {
int t = e[j];
dist[t] = min(dist[t], backup[i] + w[j]); // 松弛操作
}
}
}
int main() {
memset(h, -1, sizeof h);
cin >> n >> m >> k;
while (m --) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
add(x, y, z);
}
bellman_ford(1);
if (dist[n] > INF / 2) cout << "impossible" << endl;
else cout << dist[n] << endl;
return 0;
}
SPFA
给定一个 n n n 个点 m m m 条边的有向图,图中可能存在重边和自环, 边权可能为负数。
请你求出 1 1 1 号点到 n n n 号点的最短距离,如果无法从 1 1 1 号点走到 n n n 号点,则输出 i m p o s s i b l e impossible impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数
n
n
n 和
m
m
m。
接下来 m m m 行每行包含三个整数 x , y , z x,y,z x,y,z,表示存在一条从点 x x x 到点 y y y 的有向边,边长为 z z z。
输出格式
输出一个整数,表示
1
1
1 号点到
n
n
n 号点的最短距离。
如果路径不存在,则输出 i m p o s s i b l e impossible impossible。
数据范围
1
≤
n
,
m
≤
1
0
5
1≤n,m≤10^{5}
1≤n,m≤105,
图中涉及边长绝对值均不超过
10000
10000
10000。
输入样例:
3 3
1 2 5
2 3 -3
1 3 4
输出样例:
2
堆优化版的bellman-ford算法, 在最坏的情况下和bellman-ford算法是一个复杂度
C++ 代码
#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>
using namespace std;
const int N = 100010, INF = 0x3f3f3f3f;
int n, m;
int h[N], e[N], ne[N], w[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c) {
e[idx] = b, ne[idx] = h[a], w[idx] = c, h[a] = idx++;
}
void spfa(int start) {
memset(dist, 0x3f,sizeof dist);
dist[start] = 0;
queue<int> store;
store.push(start);
st[start] = true;
while (store.size()) {
int temp = store.front();
store.pop();
st[temp] = false;
for (int i = h[temp]; ~i; i = ne[i]) {
int j = e[i];
if (dist[j] > dist[temp] + w[i]) { // 松弛操作
dist[j] = dist[temp] + w[i];
if (!st[j]) { // 当队列中没有当前的点的时候才会添加
store.push(j);
st[j] = true;
}
}
}
}
}
int main() {
memset(h, -1, sizeof h);
cin >> n >> m;
while (m--) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
spfa(1);
if (dist[n] > INF / 2) cout << "impossible" << endl;
else cout << dist[n] << endl;
return 0;
}
多源最短路算法
Floyed
给定一个 n n n 个点 m m m 条边的有向图,图中可能存在重边和自环,边权可能为负数。
再给定 k k k 个询问,每个询问包含两个整数 x x x 和 y y y,表示查询从点 x x x 到点 y y y 的最短距离,如果路径不存在,则输出 i m p o s s i b l e impossible impossible。
数据保证图中不存在负权回路。
输入格式
第一行包含三个整数
n
,
m
,
k
n,m,k
n,m,k。
接下来 m m m 行,每行包含三个整数 x , y , z x,y,z x,y,z,表示存在一条从点 x x x 到点 y y y 的有向边,边长为 z z z。
接下来 k k k 行,每行包含两个整数 x , y x,y x,y,表示询问点 x x x 到点 y y y 的最短距离。
输出格式
共
k
k
k 行,每行输出一个整数,表示询问的结果,若询问两点间不存在路径,则输出
i
m
p
o
s
s
i
b
l
e
impossible
impossible。
数据范围
1
≤
n
≤
200
1≤n≤200
1≤n≤200,
1
≤
k
≤
n
2
1≤k≤n2
1≤k≤n2
1
≤
m
≤
20000
1≤m≤20000
1≤m≤20000,
图中涉及边长绝对值均不超过
10000
10000
10000。
输入样例:
3 3 2
1 2 1
2 3 2
1 3 1
2 1
1 3
输出样例:
impossible
1
C++ 代码
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 210, INF = 0x3f3f3f3f;
int n, m, k;
int g[N][N];
void floyed() {
for (int k = 1; k <= n; k++)
for (int i = 1; i <= n; i++)
for (int j = 1 ; j <= n; j++)
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
int main() {
memset(g, 0x3f,sizeof g);
cin >> n >> m >> k;
for (int i = 1; i <= n; i++)
g[i][i] = 0;
for (int i = 1; i <= m; i++) {
int x, y, z;
scanf("%d%d%d", &x, &y, &z);
g[x][y] = min(g[x][y], z);
}
floyed();
while (k--) {
int x, y;
scanf("%d%d", &x, &y);
if (g[x][y] > INF / 2) printf("impossible\n");
else printf("%d\n", g[x][y]);
}
return 0;
}
最小生成树算法
prim
给定一个 n n n 个点 m m m 条边的无向图,图中可能存在重边和自环,边权可能为负数。
求最小生成树的树边权重之和,如果最小生成树不存在则输出 i m p o s s i b l e impossible impossible。
给定一张边带权的无向图 G = ( V , E ) G=(V,E) G=(V,E),其中 V 表示图中点的集合, E E E 表示图中边的集合, n = ∣ V ∣ n=|V| n=∣V∣, m = ∣ E ∣ m=|E| m=∣E∣。
由 V V V 中的全部 n n n 个顶点和 E E E 中 n − 1 n−1 n−1 条边构成的无向连通子图被称为 G G G 的一棵生成树,其中边的权值之和最小的生成树被称为无向图 G G G 的最小生成树。
输入格式
第一行包含两个整数
n
n
n 和
m
m
m。
接下来 m m m 行,每行包含三个整数 u , v , w u,v,w u,v,w,表示点 u u u 和点 v v v 之间存在一条权值为 w w w 的边。
输出格式
共一行,若存在最小生成树,则输出一个整数,表示最小生成树的树边权重之和,如果最小生成树不存在则输出
i
m
p
o
s
s
i
b
l
e
impossible
impossible。
数据范围
1
≤
n
≤
500
1≤n≤500
1≤n≤500,
1
≤
m
≤
1
0
5
1≤m≤10^{5}
1≤m≤105,
图中涉及边的边权的绝对值均不超过
10000
10000
10000。
输入样例:
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例:
6
普里姆算法查找最小生成树的过程,采用了贪心算法的思想。对于包含 N 个顶点的连通网,普里姆算法每次从连通网中找出一个权值最小的边,这样的操作重复 N-1 次,由 N-1 条权值最小的边组成的生成树就是最小生成树。
http://c.biancheng.net/algorithm/prim.html
算法步骤
- 初始化距离,将他初始化为正无穷
- n次迭代
- 找到不在集合中的距离最小的点 t t t
- 用 t t t 来更新其他点到集合的距离
- 把 t t t 加到集合中
C++ 代码
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int n, m;
int g[N][N];
int dist[N];
bool st[N];
int prim() {
memset(dist, 0x3f,sizeof dist);
int res = 0;
for (int i = 0; i < n; i++) {
int t = -1;
for (int j = 1; j <= n; j++) {
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
}
if (i && dist[t] == INF) return INF;
if (i) res += dist[t];
st[t] = true;
for (int j = 1; j <= n; j++) dist[j] = min(dist[j], g[t][j]);
}
return res;
}
int main() {
memset(g, 0x3f,sizeof g);
cin >> n >> m;
for (int i = 1; i <= n; i++) g[i][i] = 0;
while (m--) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
g[u][v] = min(g[u][v], w);
g[v][u] = min(g[v][u], w);
}
int sum = prim();
if (sum == INF) cout << "impossible" << endl;
else cout << sum << endl;
return 0;
}
Kruskal
给定一个 n n n 个点 m m m 条边的无向图,图中可能存在重边和自环,边权可能为负数。
求最小生成树的树边权重之和,如果最小生成树不存在则输出 i m p o s s i b l e impossible impossible。
给定一张边带权的无向图 G = ( V , E ) G=(V,E) G=(V,E),其中 V 表示图中点的集合, E E E 表示图中边的集合, n = ∣ V ∣ n=|V| n=∣V∣, m = ∣ E ∣ m=|E| m=∣E∣。
由 V V V 中的全部 n n n 个顶点和 E E E 中 n − 1 n−1 n−1 条边构成的无向连通子图被称为 G G G 的一棵生成树,其中边的权值之和最小的生成树被称为无向图 G G G 的最小生成树。
输入格式
第一行包含两个整数
n
n
n 和
m
m
m。
接下来 m m m 行,每行包含三个整数 u , v , w u,v,w u,v,w,表示点 u u u 和点 v v v 之间存在一条权值为 w w w 的边。
输出格式
共一行,若存在最小生成树,则输出一个整数,表示最小生成树的树边权重之和,如果最小生成树不存在则输出
i
m
p
o
s
s
i
b
l
e
impossible
impossible。
数据范围
1
≤
n
≤
1
0
5
1≤n≤10^{5}
1≤n≤105,
1
≤
m
≤
2
∗
1
0
5
1≤m≤2∗10^{5}
1≤m≤2∗105,
图中涉及边的边权的绝对值均不超过
1000
1000
1000。
输入样例:
4 5
1 2 1
1 3 2
1 4 3
2 3 2
3 4 4
输出样例:
6
适合稀疏图
算法思路:
- 先将所有的边按权重从小到大的进行排序
- 枚举每条边 ( a , b ) (a, b) (a,b) 权重是 c c c 若 a , b a,b a,b 不连通,则将这条边加入到集合中
C++ 代码
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 200010;
int n, m;
int p[N];
struct Edge {
int a, b, w;
bool operator< (const Edge &W) const {
return w < W.w;
}
}edges[N];
int find(int x) {
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 0; i < m; i++) {
int a, b, w;
scanf("%d%d%d", &a, &b, &w);
edges[i] = {a, b, w};
}
sort(edges, edges + m);
for (int i = 1; i <= n; i++) p[i] = i;
int res = 0, cnt = 0; // 最小生成树的所有数边的权重之和, 加入的边数
for (int i = 0; i < m; i++) {
int a = edges[i].a, b = edges[i].b, w = edges[i].w;
a = find(a), b = find(b);
if (a != b) {
p[a] = b; // 将两个点合并
res += w;
cnt++;
}
}
if (cnt < n - 1) cout << "impossible" << endl;
else cout << res << endl;
}
染色法判定二分图
给定一个 n n n 个点 m m m 条边的无向图,图中可能存在重边和自环。
请你判断这个图是否是二分图。
输入格式
第一行包含两个整数
n
n
n 和
m
m
m。
接下来 m m m 行,每行包含两个整数 u u u 和 v v v,表示点 u u u 和点 v v v 之间存在一条边。
输出格式
如果给定图是二分图,则输出
Y
e
s
Yes
Yes,否则输出
N
o
No
No。
数据范围
1
≤
n
,
m
≤
1
0
5
1≤n,m≤10^{5}
1≤n,m≤105
输入样例:
4 4
1 3
1 4
2 3
2 4
输出样例:
Yes
C++ 代码
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N * 2], ne[N * 2], idx;
int g[N];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
bool dfs(int u, int a) {
g[u] = a;
for (int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if (!g[j]) {
if(!dfs(j, 3 - a)) return false;
}
else if (g[j] == a) return false;
}
return true;
}
int main() {
memset(h, -1, sizeof h);
cin >> n >> m;
while (m--) {
int u, v;
scanf("%d%d", &u, &v);
add(u, v);
add(v, u);
}
bool flag = true;
for (int i = 1; i <= n; i++) {
if (!g[i]) {
if(!dfs(i, 1)){
flag = false;
break;
}
}
}
if (flag) cout << "Yes" << endl;
else cout << "No" << endl;
}
笔记
最短路和最小生成树的区别
最小生成数能保证整个拓扑图的所有路径之和最小, 但不能保证任意两点之间是最短路径
最短路径是从一点出发, 到达目的地的路径最小
单源最短路和多源最短路的区别
单源最短路: 从一个点出发到任意一个点的距离最短
多源最短路: 从任意点出发到任意点的距离最短