图论
本节由于内容过多不再详细列出所有习题内容
深度优先搜索 DFS
数据结构 栈/stack 所用空间o(n) 第一次搜得到的点不具有“最短性”
每一个DFS都有一个搜索树（但存不需要存树，只要存当前，而且由于DFS是递归实现，系统会帮我们用栈储存），DFS俗称“暴搜”，关键是考虑顺序，想好“空位“个数，然后填充，填充完后，回溯，回溯完恢复现场，保证进完分支再回来没有变化。
dfs() 重要变量之一：int u,代表枚举数/到第几层，u=0即第一层，什么都没填充，u==n（n为”空位个数“）即最后一层填充满。
剪枝：当前方案已经不合法时，直接回溯，无需继续搜。
先判断下一个节点是否合法（剪枝），递归进入下一个节点，先存储状态，递归推进，回溯，还原现场
例.AcWing842 排列数字
给定一个整数 $n$，将数字 $1 \sim n$ 排成一排，将会有很多种排列方法。
现在，请你按照字典序将所有的排列方法输出。
输入格式
共一行，包含一个整数 $n$。
输出格式
按字典序输出所有排列方案，每个方案占一行。
数据范围
$1 \le n \le 7$
输入样例
3
输出样例
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
题解
#include <iostream>
using namespace std;
const int N = 10;
int n;
int path[N];
void dfs(int u, int state)
{
if (u == n)
{
for (int i = 0; i < n; i ++ ) printf("%d ", path[i]);
puts("");
return;
}
for (int i = 0; i < n; i ++ )
if (!(state >> i & 1))
{
path[u] = i + 1;
dfs(u + 1, state + (1 << i));
}
}
int main()
{
scanf("%d", &n);
dfs(0, 0);
return 0;
}
例.AcWing843 n皇后问题
题解
#include <iostream>
using namespace std;
const int N = 20;
int n;
char g[N][N];
bool col[N], dg[N], udg[N];
void dfs(int u)
{
if (u == n)
{
for (int i = 0; i < n; i ++ ) puts(g[i]);
puts("");
return;
}
for (int i = 0; i < n; i ++ )
if (!col[i] && !dg[u + i] && !udg[n - u + i])
{
g[u][i] = 'Q';
col[i] = dg[u + i] = udg[n - u + i] = true;
dfs(u + 1);
col[i] = dg[u + i] = udg[n - u + i] = false;
g[u][i] = '.';
}
}
int main()
{
cin >> n;
for (int i = 0; i < n; i ++ )
for (int j = 0; j < n; j ++ )
g[i][j] = '.';
dfs(0);
return 0;
}
广度优先搜索 BFS
数据结构 队列/queue 所用空间o(2^n) 第一次搜得到的点具有“最短性”：所有边的权重都是1的时候求最短路才能用BFS
框架：把初始状态放入queue，while(queue不空){拿队头，扩展队头}
例.AcWing844 走迷宫
给定一个 $n \times m$ 的二维整数数组，用来表示一个迷宫，数组中只包含 $0$ 或 $1$，其中 $0$ 表示可以走的路，$1$ 表示不可通过的墙壁。
最初，有一个人位于左上角 $(1, 1)$ 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。
请问，该人从左上角移动至右下角 $(n, m)$ 处，至少需要移动多少次。
数据保证 $(1, 1)$ 处和 $(n, m)$ 处的数字为 $0$，且一定至少存在一条通路。
输入格式
第一行包含两个整数 $n$ 和 $m$。
接下来 $n$ 行，每行包含 $m$ 个整数（$0$ 或 $1$），表示完整的二维数组迷宫。
输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。
数据范围
$1 \le n, m \le 100$
输入样例
5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 0
0 1 1 1 0
0 0 0 1 0
输出样例
8
理解
其中队列手动实现 深刻理解：记录每个点是第几层到的，这样没被记过的点说明没走过
开两个数组，一个存图，一个存是第几层/距原点距离
0 1 0 0 0 a 1 g h i
0 1 0 1 0 b 1 f 1 h
0 0 0 0 0 ---> c d e f g
0 1 1 1 0 d 1 1 1 h
0 0 0 1 0 e f g 1 i //这里用abcde表示第几层，其实可以用数字这里是为了表示的时候跟1区分
题解
#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
const int N = 110;
int n, m;
int g[N][N];//存图
int d[N][N];//存距离
PII q[N * N];
int bfs()
{
int hh = 0, tt = 0;//手动实现队列
q[0] = { 0,0 };
memset(d, -1, sizeof d);
d[0][0] = 0;
int dx[4] = { -1,0,1,0 }, dy[4] = { 0,1,0,-1 };//移动坐标的小技巧：向量，或者说在某个方向的偏移量
while (hh <= tt)
{
auto t = q[hh++];
for (int i = 0; i < 4; i++)
{
int x = t.first + dx[i], y = t.second + dy[i];
if (x >= 0 && x < n && y >= 0 && y < m && g[x][y] == 0 && d[x][y] == -1)
{
d[x][y] = d[t.first][t.second] + 1;
q[++tt] = { x,y };
}
}//遍历该层所有的点
}//遍历所有的点所有层数：判断依据就是队列空了
return d[n - 1][m - 1];//返回坐标为n-1,m-1的点的距离
}
int main()
{
cin >> n >> m;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> g[i][j];
cout << bfs() << endl;
return 0;
}
注
如何记录走的路径？开一个二维数组prev记录路径
例.AcWing845 八数码
在一个 $3×3$ 的网格中，$1 \sim 8$ 这 $8$ 个数字和一个 x 恰好不重不漏地分布在这 $3 \times 3$ 的网格中。
例如：
1 2 3
x 4 6
7 5 8
在游戏过程中，可以把 x 与其上、下、左、右四个方向之一的数字交换（如果存在）。
我们的目的是通过交换，使得网格变为如下排列（称为正确排列）：
1 2 3
4 5 6
7 8 x
例如，示例中图形就可以通过让 x 先后与右、下、右三个方向的数字交换成功得到正确排列。
交换过程如下：
1 2 3 1 2 3 1 2 3 1 2 3
x 4 6 4 x 6 4 5 6 4 5 6
7 5 8 7 5 8 7 x 8 7 8 x
现在，给你一个初始网格，请你求出得到正确排列至少需要进行多少次交换。
输入格式
输入占一行，将 $3 \times 3$ 的初始网格描绘出来。
例如，如果初始网格如下所示：
1 2 3
x 4 6
7 5 8
则输入为：1 2 3 x 4 6 7 5 8
输出格式
输出占一行，包含一个整数，表示最少交换次数。
如果不存在解决方案，则输出 $-1$。
输入样例
2 3 4 1 5 x 7 6 8
输出样例
19
题解
#include <iostream>
#include <algorithm>
#include <unordered_map>
#include <queue>
using namespace std;
int bfs(string state)
{
queue<string> q;
unordered_map<string, int> d;
q.push(state);
d[state] = 0;
int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};
string end = "12345678x";
while (q.size())
{
auto t = q.front();
q.pop();
if (t == end) return d[t];
int distance = d[t];
int k = t.find('x');
int x = k / 3, y = k % 3;
for (int i = 0; i < 4; i ++ )
{
int a = x + dx[i], b = y + dy[i];
if (a >= 0 && a < 3 && b >= 0 && b < 3)
{
swap(t[a * 3 + b], t[k]);
if (!d.count(t))
{
d[t] = distance + 1;
q.push(t);
}
swap(t[a * 3 + b], t[k]);
}
}
}
return -1;
}
int main()
{
char s[2];
string state;
for (int i = 0; i < 9; i ++ )
{
cin >> s;
state += *s;
}
cout << bfs(state) << endl;
return 0;
}
树与图
树与图的存储
树是一种特殊的图（无环连通图）
图：有向图/无向图 边有/无方向 无向图是一种特殊的有向图（双向可行） 所以以下都只讨论有向图
有向图存储 模板
邻接矩阵（二维 bool/int(边权) 数组，g【a】【b】如果是true代表a—>b是一条边）（不能存储重复边、浪费空间大、主要用于存稠密图）
邻接表（每个节点是一个单链表，类比拉链法哈希表，多少点就多少个节点，每个节点存的是这个点所有可以直达到的点，链表一般用头插法）
//邻接表模板
// 对于每个点k，开一个单链表，存储k所有可以走到的点。h[k]存储这个单链表的头结点
int h[N], e[N], ne[N], idx;
//有权重就新开一个数组w[]即可
// 添加一条边a->b
// 跟拉链法哈希表特别像
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
// 初始化
idx = 0;
memset(h, -1, sizeof h);//很重要
树与图的遍历
深度优先遍历 （有向图）
int dfs(int u)//根据有向图存储来思考，表示以树/图的第u个点为起点开始遍历，由于有向图的特性，路径是有方向的，所以dfs完全结束后不是一定遍历这个图的所有点，只是遍历这个节点所能到达的节点。
{
st[u] = true; // st[u] 表示点u已经被遍历过 state
for (int i = h[u]; i != -1; i = ne[i])//每一个节点都是根节点，所以都能等价为以某个节点开始画的拉链，然后遍历这个节点单链表上的每个点，即u所能直达的所有点
{
int j = e[i];//这个拉链表的e[]都是图的节点值(1~n)，图的节点值，这个单链表每个节点都如果没走过都可以当成dfs的参数按照这种思路再来一遍。
//不要打成ne[i]
if (!st[j]) dfs(j);
}
}
//思路总结，for循环这个节点所有能直达的点，然后这些能直达的的点全部都再用dfs()来找他们能直达的点，故深度优先（先第一个节点 能直达第一个节点 能直达第一个节点...）。
//i只是数组下标，e[i]存的是一个一个节点(值)，真正的节点是值是j=e[i]
//图的节点值就是节点
先一条路走到底，再回溯走没走过的点走到底，再回溯，重复，直到走完。（除了回溯会经过，一般每个点只会遍历一次，所以不用恢复现场）
例.AcWing846 树的重心
题目描述
给定一颗树，树中包含 $n$ 个结点（编号 $1 \sim n$）和 $n-1$ 条无向边。
请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。
重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。
题解
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = N * 2;
int n;
int h[N], e[M], ne[M], idx;
int ans = N;
bool st[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
int dfs(int u)
{
st[u] = true;
int size = 0, sum = 0;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (st[j]) continue;
int s = dfs(j);
size = max(size, s);
sum += s;
}
size = max(size, n - sum - 1);
ans = min(ans, size);
return sum + 1;
}
int main()
{
scanf("%d", &n);
memset(h, -1, sizeof h);
for (int i = 0; i < n - 1; i ++ )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
}
dfs(1);
printf("%d\n", ans);
return 0;
}
宽度优先遍历 （有向图）
queue<int> q;
st[1] = true; // 表示1号点已经被遍历过
q.push(1);
//队头为1号点，放在队列里，while(队列不空) 取出队头，扩展点放入队列
while (q.size())
{
int t = q.front();
q.pop();
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j])
{
st[j] = true; // 表示点j已经被遍历过
q.push(j);
}
}
}
例.AcWing847 图中点的层次
题目描述
求1到n号点经过最少的点的个数
题解
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N], ne[N], idx;
int d[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
int bfs()
{
memset(d, -1, sizeof d);//故最后若输出d[n]==-1就默认走不到-1
queue<int> q;
d[1] = 0;
q.push(1);
while (q.size())
{
int t = q.front();
q.pop();
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (d[j] == -1)
{
d[j] = d[t] + 1;
q.push(j);
}
}
}
return d[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for (int i = 0; i < m; i ++ )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
cout << bfs() << endl;
return 0;
}
拓扑排序 广搜思想
有向图的拓扑序列（每条边，起点在终点的前面他就是一个拓扑序列，排成一条直线排好后，所有的边都是从前指向后的），如果存在环一定不存在拓扑序列，可以证明有向无环图（至少有一个入度为0的点）一定存在拓扑序列，它被称为拓扑图
对于某个节点而言：入度：有多少条边指向自己，出度：有多少条边出去
入度为0可以排在最前，所以第一步把所有入度为0的点放在队列，while(队列不空) {取队头t，枚举t所有出边,删掉t->j,j的入度d[j]--; if(d[j]==0),j也可以放到前头，j入队}
例.AcWing848 有向图的拓扑序列
题解 拓扑排序模板
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010;
int n, m;
int h[N], e[N], ne[N], idx;
int d[N];
int q[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
bool topsort()
{
int hh = 0, tt = -1;
for (int i = 1; i <= n; i ++ )
if (!d[i])
q[ ++ tt] = i;
while (hh <= tt)
{
int t = q[hh ++ ];
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (-- d[j] == 0)
q[ ++ tt] = j;
}
}
return tt == n - 1;
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
for (int i = 0; i < m; i ++ )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
d[b] ++ ;
}
if (!topsort()) puts("-1");
else
{
for (int i = 0; i < n; i ++ ) printf("%d ", q[i]);
puts("");
}
return 0;
}
最短路问题：关键在于如何建图，如何使用模板，侧重点不在于原理。
单源最短路/多源汇最短路 （源点：起点、汇点：终点）
单源最短路：所有边权都是正数 （规定n是点数，m是边数）
朴素dijkstra算法 O(n^2+m),适合稠密图,点少边多 m~n^2
//如果有重边，只存最短即可（要这么考虑是因为根据邻接矩阵一条边只能存一个值），自己指自己的闭环会被直接跳过
/*
S:当前已经确定的距离最近的点
先初始化距离，dis[1]=0,dis[i]=正无穷
for(i:1~n)
{t<-不在s中距离s最近的点，s<-t,用t更新其他点的距离，判断1到x的距离是否比1到t再到x大，如果是，就更新dist[x]，(dist[x]>dist[t]+w)}
*/
//稀疏图，邻接矩阵存。
int g[N][N]; // 存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N]; // 存储每个点的最短路是否已经确定
// 求1号点到n号点的最短路，如果不存在则返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
//哪个点dist==0哪个点就是起点
//一开始st[1]不能为true，因为1要被选择用于更新别的dist，除了1以外别的点的dist一开始全都是正无穷
for (int i = 0; i < n - 1; i ++ )//只要循环n-1次，选n-1个点，选点是为了更新其他点，最后一个点是不需要再被拿出来更新别的点，它已经是最后一个点了。
{
int t = -1; // 在还未确定最短路的点中，寻找距离最小的点
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))//这步可以用堆来找，即堆优化版dijkstra
t = j;
//if(t==n) break;//如果已经到n就可以直接停，这意味着dist[t]已经确定
// 用t更新其他点的距离
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
st[t] = true;
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510;
int n, m;
int g[N][N];
int dist[N];
bool st[N];
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < n - 1; i ++ )
{
int t = -1;
for (int j = 1; j <= n; j ++ )
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
for (int j = 1; j <= n; j ++ )
dist[j] = min(dist[j], dist[t] + g[t][j]);
st[t] = true;
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = min(g[a][b], c);
}
printf("%d\n", dijkstra());
return 0;
}
堆优化版dijkstra算法 O(mlogn),适合稀疏图,点多边少 m~n
//在未确定的点中找最近的点，这步可以用最小堆（用pair存距离和点）来找，即堆优化版dijkstra
//不用担心重边，邻接表可以存重边，同时算法可以结果最短
//堆里面更新一个点的距离的方法是插入一个新的堆元素，一个点到起点的距离可能被更新多次，最小的那次一定会最先出队，这是算法本身决定的。
typedef pair<int, int> PII;//int,int顺序是先距离后坐标，不能反了，因为pair排序先排第一关键字，我们需要的是距离最短的点而不是坐标最小的点
int n; // 点的数量
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边//用优先队列的堆，但会有冗余，当我想更改数字的时候不能改，只能加
int dist[N]; // 存储所有点到1号点的距离
bool st[N]; // 存储每个点的最短距离是否已确定
// 求1号点到n号点的最短距离，如果不存在，则返回-1
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;//不要忘了初始化
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1}); // first存储距离，second存储节点编号
while (heap.size())//取出距离最小的点
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;//提高效率,同时跳过冗余点
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])//遍历所有点的所有边，即遍历所有边，m次，一次for就是遍历这个点能直达的所有边
{
int j = e[i];
if (dist[j] > distance + w[i])
{
dist[j] = distance + w[i];//w[i]就是t到j的距离
heap.push({dist[j], j});//不修改堆值，而是直接把值压入栈，根据最小堆，先出来的是新值（新值小），这样后出来的由于st[ver]=true直接continue没有影响
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int, int> PII;
const int N = 1e6 + 10;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int dijkstra()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1});
while (heap.size())
{
auto t = heap.top();
heap.pop();
int ver = t.second, distance = t.first;
if (st[ver]) continue;
st[ver] = true;
for (int i = h[ver]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[ver] + w[i])
{
dist[j] = dist[ver] + w[i];
heap.push({dist[j], j});
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
cout << dijkstra() << endl;
return 0;
}
单源最短路：存在负权边
for n次{for 所有边(对边数据没有要求，结构体都行) dist[b]=min(dust[b],dist[a]+w)}
Bellman-Ford O(nm) 如果对最短路的边数有限制，不能用SPFA
一般情况（对边数无限制，可被SPFA替代）
int n, m; // n表示点数，m表示边数
int dist[N]; // dist[x]存储1到x的最短路距离
struct Edge // 边，a表示出点，b表示入点，w表示边的权重
{
int a, b, w;
}edges[M];
// 求1到n的最短路距离，如果无法从1走到n，则返回-1。
int bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;//不要忘了初始化
// 如果第n次迭代仍然会松弛三角不等式(dist[b] >= dist[a] + w)，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路，有负权回路不一定有最短路，因为如果负权回路在去n的路径上的话，最短可以负无穷。给定经过边数另说。
for (int i = 0; i < n; i ++ )//！这个能保证最短路经过不超过n条边，给定k就是经过不超过k条边，也就是有边数限制。
{
for (int j = 0; j < m; j ++ )
{
int a = edges[j].a, b = edges[j].b, w = edges[j].w;
if (dist[b] > dist[a] + w)
dist[b] = dist[a] + w;//松弛操作
}
}
if (dist[n] > 0x3f3f3f3f / 2) return -1;//更新的时候，正无穷有可能会被负权边更新成正无穷减去一个数。
return dist[n];
}
有总经过边数k的限制 Bellman-Ford改进模板
其实就是多一个memcpy的备份，由于bellman-ford每次for都会for一遍所有的边，也就是说虽然只经过一次迭代，但1 直达/k次内到 不了的点的dist仍然会被更新，用备份代替下一次for前的dist，更新都更新在dist上，保证了每次都是一层一层往前推进，一层内到不了的会被覆盖。
struct Edge
{
int a, b, c;
}edges[M];
int n, m, k;
int dist[N];
int last[N];//备份
int bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;//不要忘了初始化
for (int i = 0; i < k; i ++ )
{
memcpy(last, dist, sizeof dist);
for (int j = 0; j < m; j ++ )
{
auto e = edges[j];
dist[e.b] = min(dist[e.b], last[e.a] + e.c);//使用备份来更新数据
}
}
if (dist[n] > 0x3f3f3f3f / 2) return -1;
return dist[n];
}
示例
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, M = 10010;
struct Edge
{
int a, b, c;
}edges[M];
int n, m, k;
int dist[N];
int last[N];
void bellman_ford()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
for (int i = 0; i < k; i ++ )
{
memcpy(last, dist, sizeof dist);
for (int j = 0; j < m; j ++ )
{
auto e = edges[j];
dist[e.b] = min(dist[e.b], last[e.a] + e.c);
}
}
}
int main()
{
scanf("%d%d%d", &n, &m, &k);
for (int i = 0; i < m; i ++ )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edges[i] = {a, b, c};
}
bellman_ford();
if (dist[n] > 0x3f3f3f3f / 2) puts("impossible");
else printf("%d\n", dist[n]);
return 0;
}
SPFA 一般O(m),最坏O(nm) 对Bellman-Ford的优化 只要没有负环，边数限制，就能用，适用性最广（正权图也行，只是有可能慢于堆优化版dijkstra，被卡就换dijkstra）
//用宽搜来优化
//原理dist[b] > dist[a] + w，只有dist[a]变小，后面才能变小，所以dist[a]不变时直接跳过
//用队列来存变小的节点，只有变小才存
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N]; // 存储每个点到1号点的最短距离
bool st[N]; // 存储每个点是否在队列中//其他数据结构也行
// 求1号点到n号点的最短路距离，如果从1号点无法走到n号点则返回-1
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true;//防止存重复的点，st[]存的是某个点是否在队列里
while (q.size())//只要队列不空就继续迭代
{
auto t = q.front();//取队头
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])//遍历更新t的所有出边，只有t减小了，t的出边才会减小
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j]) // 如果队列中已存在j，则不需要将j重复插入
{
q.push(j);//更新了，就加入，谁更新了，谁后面的点才会变小
st[j] = true;
}
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 100010;
int n, m;
int h[N], w[N], e[N], ne[N], idx;
int dist[N];
bool st[N];
void add(int a, int b, int c)
{
e[idx] = b, w[idx] = c, ne[idx] = h[a], h[a] = idx ++ ;
}
int spfa()
{
memset(dist, 0x3f, sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true;
while (q.size())
{
int t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return dist[n];
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
int t = spfa();
if (t == 0x3f3f3f3f) puts("impossible");
else printf("%d\n", t);
return 0;
}
SPFA判断负环：根据抽屉原理，实际上bellman-ford也行，只是spfa快
int n; // 总点数
int h[N], w[N], e[N], ne[N], idx; // 邻接表存储所有边
int dist[N], cnt[N]; // dist[x]存储1号点到x的最短距离，cnt[x]存储1到x的最短路中经过的点数
bool st[N]; // 存储每个点是否在队列中
// 如果存在负环，则返回true，否则返回false。
bool spfa()
{
// 不需要初始化dist数组，如果存在负环，cnt[]某个点一定会被更新无穷次，一定会被return true，所以就算不初始化也行。同时原本的初始化dist[1]=0预定了1是起点，但判断负环不止要1是起点，其他都得判断。
// 原理：如果某条最短路径上有n个点（除了自己），那么加上自己之后一共有n+1个点，由抽屉原理一定有两个点相同，所以存在环。
queue<int> q;
for (int i = 1; i <= n; i ++ )
{
q.push(i);
st[i] = true;
}//是否存在负环，而不是是否存在从一开始的负环，所以所有点都要来一遍
while (q.size())
{
auto t = q.front();
q.pop();
st[t] = false;
for (int i = h[t]; i != -1; i = ne[i])
{
int j = e[i];
if (dist[j] > dist[t] + w[i])
{
dist[j] = dist[t] + w[i];
cnt[j] = cnt[t] + 1;//每次更新就+1，因为此时到j的边数为1到t的边数+1
//不用每次归零，因为cnt[j]并不是++，而是由上个节点加一更新而来
if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
多源汇最短路
Floyd算法 O(n^3) 不允许负权回路，可以处理负权。 应用典型：n小m大，多次查询
//用邻接矩阵存图，同时floyd也是处理这个矩阵。
//INF能多大就多大，比如1e9，重边存最短，自环删去/或者不管（因为我们是最短路算法），先初始化d[][]，初始化完再读入每条边。
//初始化：
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
// 算法结束后，d[a][b]表示a到b的最短距离
void floyd()//别忘了在主函数调用它一遍
{
for (int k = 1; k <= n; k ++ )
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}//原理：动态规划，从i这个点只经过1到k这些中间点到j的最短距离，d[k,i,j]=d[k-1,i,k]+d[k-1,k,j],即只以 1 ~ k-1 与 k 这个点 作为中间点，故得到方程等号左边的式子。
//如果d[i][j]在算完之后仍然接近正无穷INF，具体看题目数据大小的限制，就说明i->j不存在通路。
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 210, INF = 1e9;
int n, m, Q;
int d[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 ++ )
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
int main()
{
scanf("%d%d%d", &n, &m, &Q);
for (int i = 1; i <= n; i ++ )
for (int j = 1; j <= n; j ++ )
if (i == j) d[i][j] = 0;
else d[i][j] = INF;
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
d[a][b] = min(d[a][b], c);
}
floyd();
while (Q -- )
{
int a, b;
scanf("%d%d", &a, &b);
int t = d[a][b];
if (t > INF / 2) puts("impossible");
else printf("%d\n", t);
}
return 0;
}
最小生成树 (一般是无向图)
普利姆算法 (Prim) 类似于dijkstra
朴素版Prim O(n^2) 稠密图
思路：把所有距离初始化成正无穷，找到不在集合S的距离最近的点t，用t来更新其他点到集合的距离(即某点到集合每个点中距离最短的边的长度)
int n; // n表示点数
int g[N][N]; // 邻接矩阵，存储所有边
int dist[N]; // 存储其他点到当前最小生成树的距离
bool st[N]; // 存储每个点是否已经在生成树中
memset(g,0x3f,sizeof g);//主函数初始化
// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
int prim()
{
memset(dist, 0x3f, sizeof dist);
int res = 0;//最小生成树所有点距离之和
for (int i = 0; i < n; i ++ )//i表示目前开始选第几个点，而不是图的第几个点/下标是几的点，这不是一个概念，选哪个点是第二层for(int j)的那个循环。
{
int t = -1;
for (int j = 1; j <= n; j ++ )//一开始什么都没选，n个点选n次，所以循环n次，第一个点选谁都行，因为最后如果成功所有点都连通，树是无向图
if (!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
if (i && dist[t] == INF) return INF;//如果t不是第一个点(即i！=0)，且最近距离为正无穷，那么就说明不连通，没有最小生成树
if (i) res += dist[t];//只要不是第一个点，dist[t]就表示的是距离当前已经确定的点集合最近的边的长度，而如果是第一个点，还没有距离这种说法。
st[t] = true;
for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j]);
/*
dist[j]表示的是到树最小的距离，直接就是dist[j]和g[t][j]中找最小值，而不需要加dist[t]，加了就是到根的距离了
这个需要先累加再更新，防负自环(或者g[a][a]=0)，dist[j]循环到t的时候由于g[t][t]是负值会影响dist[t]，而树不允许自环，所以要先累加再更新。
用已确定的点更新其他剩下的点
这句赋值可以加一个前提if(!st[j])帮助理解，但是实际可以不加，因为如果j已经确定了，不会被选中，就算更新什么东西也没什么影响。但如果先更新dist再累加，就需要这条语句了，不然会被负自环影响
*/
}
return res;
}
//注意初始化时时g[a][b]=g[b][a]=min(),树是无向图
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
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()
{
scanf("%d%d", &n, &m);
memset(g, 0x3f, sizeof g);
while (m -- )
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a][b] = g[b][a] = min(g[a][b], c);
}
int t = prim();
if (t == INF) puts("impossible");
else printf("%d\n", t);
return 0;
}
堆优化版Prim算法 (mlogn) 稀疏图 （一般不用，因为用Kruskal替代，简单好写）
库鲁斯卡尔算法 (Kruskal) (并查集思想) O(mlogm) 稀疏图
步骤
1、将所有边按权重从小到大排序 O(mlogm) （本算法瓶颈）
2、从小到大的枚举每条边ab,权重c,如果ab不连通,就把这条边加入集合中 （使用并查集）时间复杂度O(m)
int n, m; // n是点数，m是边数
int p[N]; // 并查集的父节点数组
struct Edge // 存储边
{
int a, b, w;
bool operator< (const Edge &W)const
{
return w < W.w;
}
}edges[M];
int find(int x) // 并查集核心操作
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int kruskal()
{
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) return INF;//n-1次是因为有一个点作为父节点不会被添加到别的节点上，故cnt到n-1即可
return res;
}
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = 200010, INF = 0x3f3f3f3f;
int n, m;
int p[N];
struct Edge
{
int a, b, w;
bool operator< (const Edge &W)const
{
return w < W.w;
}
}edges[M];
int find(int x)
{
if (p[x] != x) p[x] = find(p[x]);
return p[x];
}
int kruskal()
{
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) return INF;
return res;
}
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};
}
int t = kruskal();
if (t == INF) puts("impossible");
else printf("%d\n", t);
return 0;
}
二分图
定义：把所有点划分成两块，所有的边的两端都分别来自于这两个不同的点集合
二分图性质：二分图一定不含奇数环（环中边数是奇数），不含奇数环一定是二分图
染色法：判定是不是二分图 (O(m+n) 深度优先遍历，BFS也行但由于要写队列代码量稍大)
思路：for(int i=1~n) 如果i未染色，就对其染色，同时dfs能直达的点染相反的颜色，若这个过程出现矛盾就说明不是二分图，没有矛盾就是二分图。注：染色是DFS来做的，所以每次需要染色的时候，直接调用dfs
//M表示边数，由于是无向图，M应该是题目边数最大数据范围的两倍
int n; // n表示点数
int h[N], e[M], ne[M], idx; // 邻接表存储图
int color[N]; // 表示每个点的颜色，-1表示未染色，0表示白色，1表示黑色
// 参数：u表示当前节点，c表示当前点要染的颜色
bool dfs(int u, int c)//返回true表示染色过程没有问题
{
color[u] = c;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (color[j] == -1)
{
if (!dfs(j, !c)) return false;
}//这个花括号不能省略，因为两个if后面接else if无法确定else在哪个if之后
else if (color[j] == c) return false;
}
return true;
}
bool check()//check()对没有染色的点调用dfs染色
{
memset(color, -1, sizeof color);
bool flag = true;
for (int i = 1; i <= n; i ++ )
if (color[i] == -1)
if (!dfs(i, 0))
{
flag = false;
break;
}
return flag;
}
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 100010, M = 200010;
int n, m;
int h[N], e[M], ne[M], idx;
int color[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
bool dfs(int u, int c)
{
color[u] = c;
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (!color[j])
{
if (!dfs(j, 3 - c)) return false;
}
else if (color[j] == c) return false;
}
return true;
}
int main()
{
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b), add(b, a);
}
bool flag = true;
for (int i = 1; i <= n; i ++ )
if (!color[i])
{
if (!dfs(i, 1))
{
flag = false;
break;
}
}
if (flag) puts("Yes");
else puts("No");
return 0;
}
匈牙利算法（常见）：给定一个二分图求最大匹配 O(mn),实际运行时间一般远小于O(mn)
二分图的最大匹配：比如一个男生集合一个女生集合，边代表了之间有一定关系基础，最多能选多少组匹配，其中每组一男一女，并且不存在同一个人出现在两组或更多组，这个组数的最大值就是二分图最大匹配。
这里是没有限制的最大匹配，若有限制，如不能交叉，考虑是线性DP的LIS模型，详见level3第一讲
思路：每次A匹配一个点的时候，如果备选项B已经被匹配了，就看一下现备选项B的匹配方C能不能换一个新的匹配，若能就换，若不能就对这个匹配方C再递归，直到更换/没法换，再把这个点A匹配上/不匹配
int n1, n2; // n1表示第一个集合中的点数，n2表示第二个集合中的点数
int h[N], e[M], ne[M], idx; // 邻接表存储所有边，匈牙利算法中只会用到从第一个集合指向第二个集合的边，所以这里只用存一个方向的边
int match[N]; // 存储第二个集合中的每个点当前匹配的第一个集合中的点是哪个
bool st[N]; // 表示第二个集合中的每个点是否已经被遍历过
bool find(int x)//同时是负责分配、递归、报告分配是否成功。
{
for (int i = h[x]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j])//如果j（j是S2中的点，或者说i能直达的点（由于是二分图，i不可能有直达S1的边））没有被遍历过(用于减少find()的递归，同时让递归时的原匹配方不再用这个点，而是寻找下家，如果一直递归找到最后都无法调和，就返回false，如果调和开了就让j匹配上x，即match[j]=x同时返回true表示匹配成功)
{
st[j] = true;
if (match[j] == 0 || find(match[j]))
{
match[j] = x;
return true;
}
}
}
return false;
}
//初始化的时候，对于两个点集S1,S2，存S1—>S2的边就行了（虽然是无向边）（如果此时匈牙利算法处理的是S1的话）。
// 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ )//设n1为S1的点数量
{
memset(st, false, sizeof st);
if (find(i)) res ++ ;
}
使用范例
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 510, M = 100010;
int n1, n2, m;
int h[N], e[M], ne[M], idx;
int match[N];
bool st[N];
void add(int a, int b)
{
e[idx] = b, ne[idx] = h[a], h[a] = idx ++ ;
}
bool find(int x)
{
for (int i = h[x]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j])
{
st[j] = true;
if (match[j] == 0 || find(match[j]))
{
match[j] = x;
return true;
}
}
}
return false;
}
int main()
{
scanf("%d%d%d", &n1, &n2, &m);
memset(h, -1, sizeof h);
while (m -- )
{
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
memset(st, false, sizeof st);
if (find(i)) res ++ ;
}
printf("%d\n", res);
return 0;
}
浙公网安备 33010602011771号