第三章 搜索和图论
DFS
深度优先搜索会搜得比较深，当搜到叶子结点的时候就会回溯
该图的深搜序列就是：
a->b->d->i->r->i->s->i->d->j->d->b->e->k->e->l…h->q
可以把深搜看成一个很执着的人，不管走哪条路，只有走到头才会回头，而且回头的时候也不是一下回到起点，而是一边回头一边看有没有新的路可以走
使用的数据结构是 stack，使用的空间和我们的高度成正比，不具有最短性
每个 dfs 都对应一个 搜索树
我们在拿到题目的时候，需要思考，我们用怎么样的顺序来遍历，才会最快捷
核心思想是：回溯，剪枝
每次存的都是路径，也不需要存整个搜索树，回溯的时候要注意恢复现场
模板
int dfs(int u)
{
st[u] = true; // st[u] 表示点u已经被遍历过
for (int i = h[u]; i != -1; i = ne[i])
{
int j = e[i];
if (!st[j]) dfs(j);
}
}
例题
给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。
现在，请你按照字典序将所有的排列方法输出。
输入格式
共一行，包含一个整数 n。
输出格式
按字典序输出所有排列方案，每个方案占一行。
数据范围
1≤n≤71≤n≤7
输入样例：
3输出样例：
1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1
第一层有 1，2，3
第二层比如 1 的子节点只有 2 和 3，因为不能重复
#include<iostream>
using namespace std;
const int N = 10;
int n;
int path[N];
bool st[N];
// u = 1,就是第一层，u = 2,就是第二层...
void dfs(int u)
{
if(u == n)
{
for(int i = 0;i < n;i++)
{
cout << path[i] << " ";
}
cout << endl;
return;
}
for(int i = 1;i <= n;i++)
{
if(!st[i])
{
path[u] = i;
st[i] = true;
dfs(u+1);
st[i] = false;
}
}
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
dfs(0);
return 0;
}
n−n−皇后问题是指将 nn 个皇后放在 n×n 的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。
现在给定整数 n，请你输出所有的满足条件的棋子摆法。
输入格式
共一行，包含整数 n。
输出格式
每个解决方案占 n 行，每行输出一个长度为 n 的字符串，用来表示完整的棋盘状态。
其中
.表示某一个位置的方格状态为空，Q表示某一个位置的方格上摆着皇后。每个方案输出完成后，输出一个空行。
注意：行末不能有多余空格。
输出方案的顺序任意，只要不重复且没有遗漏即可。
数据范围
1≤n≤9
输入样例：
4输出样例：
.Q.. ...Q Q... ..Q. ..Q. Q... ...Q .Q..
先看第一行皇后可以放哪一列，枚举每一行皇后放哪一行上去
搜索顺序和全排列是一样的
这题要注意剪枝，也就是不符合我们规则的序列，要及时停止
比如说我们已经有序列 1，3
这个时候我枚举了一个 4，也就是在 第 3 行，第 4 列枚举一个皇后，这个时候我去判断下是否和我已经有的皇后冲突，如果冲突，那么就直接 return，也就不用继续往下搜了
#include<iostream>
using namespace std;
const int N = 20;
int n;
char g[N][N];
bool col[N],dg[N],udg[N];
// u = 1,就是第一层，u = 2,就是第二层...
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.tie(0);
ios::sync_with_stdio(false);
cin >> n;
for(int i = 0;i < n;i++)
{
for(int j = 0;j < n;j++)
{
g[i][j] = '.';
}
}
dfs(0);
return 0;
}
BFS
更像一个海王，她可以同时看很多条路
比如这个树，第一次遍历会把 b 和 c 遍历到，第二层会把 b e f g h 全部遍历到才会到下一层
使用的数据结构是queue，使用的空间就是 2h，具有最短路性质
当每条边的权重一样的时候，我们搜到的一定是最短路
模板
queue<int> q;
st[1] = true; // 表示1号点已经被遍历过
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 (!st[j])
{
st[j] = true; // 表示点j已经被遍历过
q.push(j);
}
}
}
例题
给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。
最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。
请问，该人从左上角移动至右下角 (n,m)处，至少需要移动多少次。
数据保证 (1,1)处和 (n,m)处的数字为 0，且一定至少存在一条通路。
输入格式
第一行包含两个整数 n 和 m。
接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。
输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。
数据范围
1≤n,m≤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
首先我们将与起点距离为 1 的点放进来
再把距离为 2 的点放进来
以此类推把距离为 3 的点放进来
由于终点是第八层被扩展到的，所以起点到终点的距离是 8
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 110;
typedef pair<int,int> PII;
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); //全部初始化为 -1
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];
//前四个是约束边界，g[x][y] = 0 代表是空地，d[x][y] = -1 代表没有走过
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];
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
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;
}
在一个 3×3 的网格中，1∼8 这 8 个数字和一个
x恰好不重不漏地分布在这 3×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×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
把所有状态，看成图论当中的一个点，如果某一个状态通过某种操作可以变成另一个状态的话，就连一条单向边，边的权重都是 1
那也就变成了 给定一个起点，求走到终点要多少步
那么如何表示一个点，也就是一个状态？
--直接用一个字符串表示一个状态，如“1234x5678”
如何把状态压入队列？
--queue
如何记录每一个状态的距离？
--unordered_map<string,int> dist
如何判断一个状态能变成哪些状态？
例如 “1234x5678”
我们先将其恢复成 3x3 的样子，然后枚举 x 的上下左右，再将枚举出来的矩阵恢复成字符串
#include<iostream>
#include<algorithm>
#include<queue>
#include<unordered_map>
using namespace std;
int bfs(string start)
{
string end = "12345678x";
queue<string> q;
unordered_map<string,int> dist;
q.push(start);
dist[start] = 0;
int dx[4] = {-1,0,1,0},dy[4] = {0,1,0,-1};
while(q.size()){
auto t = q.front();
q.pop();
int distance = dist[t];
if(t == end)
{
return distance;
}
// 状态转移部分
// 用k 来存 x 的位置，find(x) 会返回x的下标
int k = t.find("x");
int x = k/3, y = k%3; // 把一维数组下标转化成二维数组下标
for(int i = 0;i < 4;i++)
{
int a = x+dx[i];
int b = y+dy[i];
if(a >=0 && a < 3 && b >= 0 && b < 3)
{
swap(t[k],t[a*3+b]);
if(!dist.count(t))
{
//没有找到过的状态，更新下距离
dist[t] = distance+1;
q.push(t);
}
// 恢复状态
swap(t[k],t[a*3+b]);
}
}
}
return -1;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
string start; //state 来存初始状态
for(int i = 0;i < 9;i++)
{
char c;
cin >> c;
start += c;
}
cout << bfs(start) << endl;
return 0;
}
树和图的存储
树是一种特殊的图，无环连通图
图分为有向图和无向图
如果是无向图就建立两个边 a -> b && b -> a ，所有无向图就是特殊的有向图
邻接矩阵 g[a,b] 记录 a -> b 如果有权重，其值就是权重，没有权重这个值就是一个 布尔值，true代表有边，邻接矩阵不能存储重边
邻接表 每个点上都是一个单链表，每个单链表存储每个点能走到哪些点
如图所示的图一共有四个点，所以开 4 个单链表
1：–> 3 --> 4 --> 空
2：–> 1 --> 4 --> 空
3：–> 4 --> 空
4：–> 空
单链表中点的次序不重要
此时我们插入一条 2 --> 3 的点
那么就找到 2 这个单链表 然后把 3 插入这个单链表，一般选择是头插
也可以用 vector 来模拟邻接表
模板
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 100010 ， M = N * 2;
// h存的 N 个链表的链表头,e存的是我们所有结点的值是多少，ne存的是每个结点的 next值是多少
int h[N],e[M],ne[M],idx;
void add(int a,int b){
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
//初始化
memset(h,-1,sizeof h);
return 0;
}
树和图的深度优先遍历
模板
void dfs(int u)
{
st[u] = true // u 已经被遍历了
for(int i = h[u];i != -1;i = ne[i])
{
int j = e[i]; // 定的图里的编号是多少
if(!st[j])
{
dfs(j);
}
}
}
例题
给定一颗树，树中包含 n 个结点（编号 1∼n）和 n−1 条无向边。
请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。
重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。
输入格式
第一行包含整数 n，表示树的结点数。
接下来 n−1行，每行包含两个整数 a 和 b，表示点 a和点 b 之间存在一条边。
输出格式
输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最大值。
数据范围
1≤n≤105
输入样例
9 1 2 1 7 1 4 2 8 2 5 4 3 3 9 4 6输出样例：
4
例如我有如下树
此时如果我把 1 删除后，剩下三个连通块分别为
那么最大点数为 4 ，如果删掉 2
最大的点树就是 6
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10; //数据范围是10的5次方
const int M = 2 * N; //以有向图的格式存储无向图，所以每个节点至多对应2n-2条边
int h[N]; //邻接表存储树，有n个节点，所以需要n个队列头节点
int e[M]; //存储元素
int ne[M]; //存储列表的next值
int idx; //单链表指针
int n; //题目所给的输入，n个节点
int ans = N; //表示重心的所有的子树中，最大的子树的结点数目
bool st[N]; //记录节点是否被访问过，访问过则标记为true
void add(int a,int b){
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
// 返回以 u 为根的子树的大小
int dfs(int u) {
int res = 0; //存储 删掉某个节点之后，最大的连通子图节点数
st[u] = true; //标记访问过u节点
int sum = 1; //存储 以u为根的树 的节点数, 包括u，如图中的4号节点
//访问u的每个子节点
for (int i = h[u]; i != -1; i = ne[i]) {
int j = e[i];
//因为每个节点的编号都是不一样的，所以 用编号为下标 来标记是否被访问过
if (!st[j]) {
int s = dfs(j); // u节点的单棵子树节点数 如图中的size值
res = max(res, s); // 记录最大联通子图的节点数
sum += s; //以j为根的树 的节点数
}
}
//n-sum 如图中的n-size值，不包括根节点4；
res = max(res, n - sum); // 选择u节点为重心，最大的 连通子图节点数
ans = min(res, ans); //遍历过的假设重心中，最小的最大联通子图的 节点数
return sum;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
memset(h,-1,sizeof h);
cin >> n;
for(int i = 0;i < n - 1;i++)
{
int a,b;
cin >> a >> b;
add(a,b);
add(b,a);
}
//初始化
dfs(1);
cout << ans << endl;
return 0;
}
树和图的宽度优先遍历
模板
queue<int> q;
st[1] = true; // 表示1号点已经被遍历过
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 (!st[j])
{
st[j] = true; // 表示点j已经被遍历过
q.push(j);
}
}
}
例题
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环。
所有边的长度都是 1，点的编号为 1∼n。
请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
数据范围
1≤n,m≤105
输入样例：
4 5 1 2 2 3 3 4 1 3 1 4输出样例：
1
我第一次发散到这个点的时候，就是我到这个点的最短路径
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 100010;
int n,m;
int h[N],e[N],ne[N],idx;
int d[N],q[N];
void add(int a,int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
int bfs()
{
int hh=0,tt=0;
q[0]=1; //0号节点是编号为1的节点
memset(d,-1,sizeof d);
d[1]=0; //存储每个节点离起点的距离
//当我们的队列不为空时
while(hh<=tt)
{
//取出队列头部节点
int t=q[hh++];
//遍历t节点的每一个邻边
for(int i=h[t];i!=-1;i=ne[i])
{
int j=e[i];
//如果j没有被扩展过
if(d[j]==-1)
{
d[j]=d[t]+1; //d[j]存储j节点离起点的距离，并标记为访问过
q[++tt] = j; //把j结点 压入队列
}
}
}
return d[n];
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
for(int i = 0;i < m;i++)
{
int a,b;
cin >> a >> b;
add(a,b);
}
cout << bfs() << endl;
return 0;
}
拓扑排序
有向图才会有拓扑序列
比方说有图如下
1–2–3 就是一个拓扑序列
拓扑序列要求 对于每条边 起点都要在终点前面，并不是每一个图都有拓扑序
比方说
所以 有向无环图 又被称为拓扑图
每个点有入度和出度，入度就是有多少条边指向自己，出度就是自己指向多少条边
入度为 0 就代表不会有任何一条边要求在我前面
模板
bool topsort()
{
int hh = 0, tt = -1;
// d[i] 存储点i的入度
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;
}
例题
给定一个 n 个点 m 条边的有向图，点的编号是 1 到 n，图中可能存在重边和自环。
请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1。
若一个由图中所有点构成的序列 A 满足：对于图中的每条边 (x,y)，x 在 A 中都出现在 y 之前，则称 A 是该图的一个拓扑序列。
输入格式
第一行包含两个整数 n 和 m。
接下来 mm 行，每行包含两个整数 x 和 y，表示存在一条从点 x 到点 y 的有向边 (x,y)。
输出格式
共一行，如果存在拓扑序列，则输出任意一个合法的拓扑序列即可。
否则输出 −1。
数据范围
1≤n,m≤105
输入样例：
3 3 1 2 2 3 1 3输出样例：
1 2 3
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 100010;
int n,m;
int h[N],e[N],ne[N],idx;
int q[N],d[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];
d[j]--;
if(d[j] == 0)
{
q[++tt] = j;
}
}
}
return tt == n-1;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
for(int i = 0;i < m;i++)
{
int a,b;
cin >> a >> b;
add(a,b);
d[b]++;
}
if(topsort())
{
for(int i = 0;i< n;i++)
{
cout << q[i] << " ";
}
}else{
cout << "-1" << endl;
}
}
Dijkstra
最短路分为 单源最短路 和 多源汇最短路
单源一般是求从一个点 到其他所有点的最短距离
源点 — 起点 汇点 — 终点
多源就是会有很多个询问，起点和终点都是不确定的
单源中又可以分为 所有边都是正数的 和 存在负权边的
朴素版
比方说我们有图如下
1–>2 距离为2
2–>3 距离为1
1–>3 距离为4
第一步我们初始化距离，d[1] = 0 其余所有点的距离都是正无穷
第二步找到所有未确定最短路的点中，距离最小的点（dist值最小） 那么也就是 dist[1]，因为其他所有都是正无穷
那么这个点的最短路径就确定了，一定是0
我们再用这个点去更新他到所有点的距离，那么 dist[2] = 2,dist[3] = 4
第二次迭代，继续找所有未确定最短路的点中最小的点—dist[2]
那么这个点的最短路确定了，是2
再用这个点更新其他所有点的距离，那么dist[3] = dist[2] + 1 比之前的 4 小，那么更新 dist[3] = 3
模板
int g[N][N]; // 存储每条边
int dist[N]; // 存储1号点到每个点的最短距离
bool st[N]; // 存储每个点的最短路是否已经确定
// 求1号点到n号点的最短路，如果不存在则返回-1
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;
// 用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];
}
例题
849. Dijkstra求最短路 I - AcWing题库
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n≤500,
1≤m≤105,
图中涉及边长均不超过10000。输入样例：
3 3 1 2 2 2 3 1 1 3 4输出样例：
3
#include <iostream>
#include <cstring>
#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; ++i) {
int t = -1;
for (int j = 1; j <= n ; j++) {
// 在所有 st == false 的点中，找一个 dist 最小的点
if (!st[j] && (t == -1 || dist[j] < dist[t]))
{
t = j;
}
}
if(t == n) break;
st[t] = true;
for (int j = 1; j <= n ; j++) {
dist[j] = min(dist[j],dist[t]+g[t][j]);
}
}
if (dist[n] == 0x3f3f3f3f)
{
return -1;
}else{
return dist[n];
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
// 0x3f = 1061109567
memset(g,0x3f,sizeof g);
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
g[a][b] = min(g[a][b],c);
}
int t = dijkstra();
cout << t << endl;
return 0;
}
堆优化版本
在找dist最小的数这个地方可以进行优化 == 在一堆数中找一个最小数 == 堆
我们用堆来存储所有点到起点的最短距离
模板
typedef pair<int, int> PII;
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])
{
int j = e[i];
if (dist[j] > distance + w[i])
{
dist[j] = distance + w[i];
heap.push({dist[j], j});
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
例题
850. Dijkstra求最短路 II - AcWing题库
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为非负值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
数据范围
1≤n,m≤1.5×105,
图中涉及边长均不小于 0，且不超过 10000。
数据保证：如果最短路存在，则最短路的长度不超过 109。输入样例：
3 3 1 2 2 2 3 1 1 3 4输出样例：
3
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
typedef pair<int,int> PII;
const int N = 1e6;
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]> distance + w[i])
{
dist[j] = distance + w[i];
heap.push({dist[j],j});
}
}
}
if (dist[n] == 0x3f3f3f3f)
{
return -1;
}else{
return dist[n];
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
add(a,b,c);
}
int t = dijkstra();
cout << t << endl;
return 0;
}
Bellman-Ford
循环 n 次，每一次循环所有边
这个算法的存边比较简单，只需要让我可以遍历到所有边就可以，那么可以直接开一个结构体
遍历所有边的时候，更新一下 dist 数组即可
Bellman-Ford 证明了在循环完之后一定满足
dist[b] <= dist[a] + w — 三角不等式
如果有负权回路的话，最短路是不一定存在的
如果迭代了 n 次 ，第 n 次还在更新的话，一定存在一个最短路径，他的路径是 >= n 的
也就是路径上一定存在环
模板
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次迭代仍然会松弛三角不等式，就说明存在一条长度是n+1的最短路径，由抽屉原理，路径中至少存在两个相同的点，说明图中存在负权回路。
for (int i = 0; i < n; i ++ )
{
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];
}
例题
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出
impossible。注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
点的编号为 1∼n。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出
impossible。数据范围
1≤n,k≤500,
1≤m≤10000,
1≤x,y≤n，
任意边长的绝对值不超过 10000。输入样例：
3 3 1 1 2 1 2 3 1 1 3 3输出样例：
3
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510,M = 10010;
int n,m,k;
int dist[N],backup[N];
struct Edge{
int a,b,w;
}edge[M];
bool bellman_ford()
{
memset(dist,0x3f,sizeof dist);
dist[1] = 0;
//题目要求不超过 k 次，所以外层循环 k 次
for (int i = 0; i < k; i++) {
// 保证我们更新的时候只用上一次迭代的结果，所以备份一个数组，backup数组中存的就是上一次迭代的数组
memcpy(backup,dist,sizeof dist);
for (int j = 0; j < m; j++) {
int a = edge[j].a,b = edge[j].b,w= edge[j].w;
dist[b] = min(dist[b],backup[a]+w);
}
}
if (dist[n] > 0x3f3f3f3f / 2) return false;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> k;
for (int i = 0; i < m; i++) {
int a,b,w;
cin >> a >> b >> w;
edge[i] = {a,b,w};
}
if(bellman_ford())
{
cout << dist[n] << endl;
}else{
cout << "impossible" << endl;
}
return 0;
}
SPFA
求最短路
其实就是队列优化的 bellman-ford
核心思想，用已经被更新过的点去更新其他点，通俗地讲–只有我变小了，我后面的人才会变小
队列里存的就是待更新的点
模板
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;
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];
if (!st[j]) // 如果队列中已存在j，则不需要将j重复插入
{
q.push(j);
st[j] = true;
}
}
}
}
if (dist[n] == 0x3f3f3f3f) return -1;
return dist[n];
}
例题
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出
impossible。数据保证不存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出
impossible。数据范围
1≤n,m≤105
图中涉及边长绝对值均不超过 10000。输入样例：
3 3 1 2 5 2 3 -3 1 3 4输出样例：
2
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1e6;
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++;
}
bool spfa()
{
std::memset(dist,0x3f,sizeof dist);
dist[1] = 0;
queue<int> q;
q.push(1);
st[1] = true; //st数组存的是当前这个点是不是在队列当中
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;
}
}
}
}
if (dist[n] == 0x3f3f3f3f)
{
return false;
}else{
return true;
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
add(a,b,c);
}
if (spfa())
{
cout << dist[n] << endl;
}else{
cout << "impossible" << endl;
}
return 0;
}
求负环
求负环的思路也是运用抽屉原理
我们额外维护一个 cnt 数组 cnt[x] 代表了当前最短路的边的个数
更新的时候 让 cnt[j] = cnt[t] + 1
那么如果 cnt[x] >= n 了代表着从 1-x 经过了至少 n 条边，也就是 n+1 个点 由抽屉原理可得 一定有两个点值是相同的
如果是正权的环是不会影响最短路的，所以一定是负环
模板
// 求负环
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数组
// 原理：如果某条最短路径上有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;
if (cnt[j] >= n) return true; // 如果从1号点到x的最短路中包含至少n个点（不包括自己），则说明存在环
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
例题
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你判断图中是否存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
如果图中存在负权回路，则输出
Yes，否则输出No。数据范围
1≤n≤2000,
1≤m≤10000,
图中涉及边长绝对值均不超过 10000。输入样例：
3 3 1 2 -1 2 3 4 3 1 -4输出样例：
Yes
#include <iostream>
#include <cstring>
#include <algorithm>
#include <queue>
using namespace std;
const int N = 1e6;
int n,m;
int h[N],w[N],e[N],ne[N],idx;
int dist[N],cnt[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++;
}
bool spfa()
{
queue<int> q;
for (int i = 0; i <= n; i++) {
st[i] = true;
q.push(i);
}
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];
cnt[j] = cnt[t]+1;
if (cnt[j] >= n) return true;
if (!st[j])
{
q.push(j);
st[j] = true;
}
}
}
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
add(a,b,c);
}
if (spfa())
{
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
return 0;
}
Floyd
是用来求多源汇最短路问题的，用邻接矩阵来存储图
三重 1-n 的循环，每次更新一遍
循环完之后，d[i,j]存的就是 从 i - j 的最短路
原理是基于动态规划
模板
初始化：
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]);
}
例题
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，边权可能为负数。
再给定 k 个询问，每个询问包含两个整数 x 和 y，表示查询从点 x 到点 y 的最短距离，如果路径不存在，则输出
impossible。数据保证图中不存在负权回路。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
接下来 k 行，每行包含两个整数 x,y，表示询问点 x 到点 y 的最短距离。
输出格式
共 k 行，每行输出一个整数，表示询问的结果，若询问两点间不存在路径，则输出
impossible。数据范围
1≤n≤200,
1≤k≤n2
1≤m≤20000,
图中涉及边长绝对值均不超过 10000。输入样例：
3 3 2 1 2 1 2 3 2 1 3 1 2 1 1 3输出样例：
impossible 1
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 210,INF = 1e9;
int n,m,k;
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()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m >> k;
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,w;
cin >> a >> b >> w;
d[a][b] = min(d[a][b],w);
}
floyd();
while(k--)
{
int x,y;
cin >> x >> y;
if (d[x][y] > INF / 2)
{
cout << "impossible" << endl;
}else{
cout << d[x][y] << endl;
}
}
}
Prim
先初始化距离，全部是正无穷，然后 n 次迭代，每次迭代执行：
1.找到 不在集合当中的 距离最小的点（这里的集合是 当前的生成树
2.用这个点更新其他点到集合的距离
举例，我们有如下图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-kOqyGwIK-1673580129657)(C:\Users\ShibuyaKanon\AppData\Roaming\Typora\typora-user-images\image-20230111092121285.png)]
第一步，让所有点到集合的距离变 +无穷
然后因为所有点的距离都是正无穷，所以我们随便挑一个点作为第一个点，把他加入集合
其他点到集合的距离，实际就是看看其他点能不能连一条线到集合内部
那么某个点到集合的距离就定义成，这个点到集合任意一条边最小的距离，如果这个点没有一条边连到集合，那么距离就被定义成正无穷
那么现在 2号点到集合的距离被更新成1
3号点到集合的距离被更新成2
4号点到集合的距离被更新成3
第二次迭代就找集合外 距离最近的点也就是 2 号点
重复上述过程，直到所有点进入集合
生成树是什么呢？就是每次选择的那个点指向集合的边就是我们生成树的一条边
模板
int n; // n表示点数
int g[N][N]; // 邻接矩阵，存储所有边
int dist[N]; // 存储其他点到当前最小生成树的距离
bool st[N]; // 存储每个点是否已经在生成树中
// 如果图不连通，则返回INF(值是0x3f3f3f3f), 否则返回最小生成树的树边权重之和
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;
}
例题
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。
求最小生成树的树边权重之和，如果最小生成树不存在则输出
impossible。给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|。
由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含三个整数 u,v,w，表示点 u 和点 v 之间存在一条权值为 w 的边。
输出格式
共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出
impossible。数据范围
1≤n≤500,
1≤m≤105,
图中涉及边的边权的绝对值均不超过 10000。输入样例：
4 5 1 2 1 1 3 2 1 4 3 2 3 2 3 4 4输出样例：
6
#include <cstring>
#include <algorithm>
#include <iostream>
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; //res 存的是最小生成树里所有边的长度之和
// n 次迭代
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];
for (int j = 1; j <= n ; j++) {
dist[j] = min(dist[j],g[t][j]);
}
st[t] = true;
}
return res;
}
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(g,0x3f,sizeof g);
while(m--)
{
int a,b,c;
cin >> a >> b >> c;
g[a][b] = g[b][a] = min(g[a][b],c);
}
int t = prim();
if (t == INF) cout << "impossible" << endl;
else cout << t << endl;
}
Kruskal
第一步 先将所有边 按照权重从小到大排序
第二步 枚举每条边 ab 权重为 c
如果 ab 不连通，将这条边加入集合中
模板
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;
return res;
}
例题
859. Kruskal算法求最小生成树 - AcWing题库
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环，边权可能为负数。
求最小生成树的树边权重之和，如果最小生成树不存在则输出
impossible。给定一张边带权的无向图 G=(V,E)，其中 V 表示图中点的集合，E 表示图中边的集合，n=|V|，m=|E|。
由 V 中的全部 n 个顶点和 E 中 n−1 条边构成的无向连通子图被称为 G 的一棵生成树，其中边的权值之和最小的生成树被称为无向图 G 的最小生成树。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含三个整数 u,v,w，表示点 u 和点 v 之间存在一条权值为 w 的边。
输出格式
共一行，若存在最小生成树，则输出一个整数，表示最小生成树的树边权重之和，如果最小生成树不存在则输出
impossible。数据范围
1≤n≤105,
1≤m≤2∗105,
图中涉及边的边权的绝对值均不超过 1000。输入样例：
4 5 1 2 1 1 3 2 1 4 3 2 3 2 3 4 4输出样例：
6
#include <cstring>
#include <algorithm>
#include <iostream>
using namespace std;
const int N = 2000010;
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()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int a,b,w;
cin >> 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;
}
}
染色法
一个图是二分图 当且仅当 她可以被2染色（不含有奇数环）
流程如下，先找到一个不在集合中的点 把他放在左边
然后遍历这个点有连接的点，把这些点放到右边，再依次遍历放到右边的点的邻点
模板
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)
{
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;
}
else if (color[j] == c) return false;
}
return true;
}
bool check()
{
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;
}
例题
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环。
请你判断这个图是否是二分图。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示点 u 和点 v 之间存在一条边。
输出格式
如果给定图是二分图，则输出
Yes，否则输出No。数据范围
1≤n,m≤105
输入样例：
4 4 1 3 1 4 2 3 2 4输出样例：
Yes
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010,M = 200010;
int n,m;
bool flag = true;
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()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b;
cin >> a >> b;
add(a,b);
add(b,a);
}
for (int i = 1; i <= n ; ++i) {
if (!color[i])
{
if (!dfs(i,1))
{
flag = false;
break;
}
}
}
if (flag)
{
cout << "Yes" << endl;
}else{
cout << "No" << endl;
}
}
匈牙利算法
可以求出，左边和右边匹配成功的最大数量是多少，成功是指不存在两条边是共用的两个点
例如如下图
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-m77K7Y76-1673580129659)(C:\Users\ShibuyaKanon\AppData\Roaming\Typora\typora-user-images\image-20230113104514394.png)]
我们从左一开始找，找到右二进行尝试，此时右二并没有配对，所以右二和左一配对成功
依次类推左二可以和右一配对
但是左三只能和右二配对但是右二已经和左一配对
这个时候我们找到右二配对的左一 是否有其他边，显然左一还可以和右四配对
这样最终匹配的数量就是 4
模板
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])
{
st[j] = true;
if (match[j] == 0 || find(match[j]))
{
match[j] = x;
return true;
}
}
}
return false;
}
// 求最大匹配数，依次枚举第一个集合中的每个点能否匹配第二个集合中的点
int res = 0;
for (int i = 1; i <= n1; i ++ )
{
memset(st, false, sizeof st);
if (find(i)) res ++ ;
}
例题
给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。
数据保证任意一条边的两个端点都不可能在同一部分中。
请你求出二分图的最大匹配数。
二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。
二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。
输入格式
第一行包含三个整数 n1、 n2 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示左半部点集中的点 u 和右半部点集中的点 v 之间存在一条边。
输出格式
输出一个整数，表示二分图的最大匹配数。
数据范围
1≤n1,n2≤500,
1≤u≤n1,
1≤v≤n2,
1≤m≤105输入样例：
2 2 4 1 1 1 2 2 1 2 2输出样例：
2
#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 100010,M = 200010;
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()
{
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n1 >> n2 >> m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b;
cin >> a >> b;
add(a,b);
}
int res = 0;
for (int i = 1; i <= n1; ++i) {
memset(st,false,sizeof st);
if (find(i))
{
res++;
}
}
cout << res << endl;
return 0;
}
扫一扫
140
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
