C版搜索与图论算法
C++版搜索与图论算法
搜索与图论
有些题目不是完整的题目，如需查看完整的题目请移步到acwing的算法基础课中
DFS
DFS树的图示表明（来自acwing）：
𝐷𝐹𝑆（深度优先搜索）：
是沿源点持续向下遍历，直到无法拓展当前状态，返回上一层（回溯），再找到其他状态继续向下遍历。
根据y总形容：这是一个执着的小盆友。
DFS一定对应一棵搜索树。搜索的顺序构成一棵树，也就是搜索树。
排列数字
题目：给定一个整数 n，将数字 1∼n 排成一排，将会有很多种排列方法。现在，请你按照字典序将所有的排列方法输出
完整题目：（https://www.acwing.com/problem/content/description/844/） acwing算法基础课
思路：
- 维护一个数组记录当前排列，以及一个数组标记数字是否已使用。
- 从 1 开始，按从小到大顺序，依次选取未使用的数字加入当前排列，若排列长度达到 n，就输出该排列；若未达到，继续递归选取下一个数字。
- 当当前数字尝试完后，回溯，取消该数字的使用标记，以便后续尝试其他组合，这样就能生成并按字典序输出所有排列。
实现代码：
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 10;
int n;
bool st[N];
int a[N];
void dfs(int u)
{
if(u == n)
{
for(int i = 0;i < n;i++)
printf("%d ",a[i]);
puts("");
return ;
}
for(int i = 1;i <= n;i++)
{
if(!st[i])
{
a[u] = i;
st[i] = true;
dfs(u + 1);
st[i] = false;
}
}
}
int main()
{
cin>>n;
dfs(0);
return 0;
}BFS
题目：
给定一个 n×m 的二维整数数组，用来表示一个迷宫，数组中只包含 0 或 1，其中 0 表示可以走的路，1 表示不可通过的墙壁。
最初，有一个人位于左上角 (1,1) 处，已知该人每次可以向上、下、左、右任意一个方向移动一个位置。
请问，该人从左上角移动至右下角 (n,m) 处，至少需要移动多少次。
数据保证 (1,1) 处和 (n,m) 处的数字为 0，且一定至少存在一条通路。
输入格式
第一行包含两个整数 n 和 m。
接下来 n 行，每行包含 m 个整数（0 或 1），表示完整的二维数组迷宫。
输出格式
输出一个整数，表示从左上角移动至右下角的最少移动次数。
思路：
从起点开始，往前走第一步，记录下所有第一步能走到的点，然后从所第一步能走到的点开始，往前走第二步，记录下所有第二步能走到的点，重复下去，直到走到终点。输出步数即可。
实现代码：
#include<algorithm>
#include<iostream>
#include<cstdio>
#include<cstring>
using namespace std;
typedef pair<int,int>PII;
const int N = 110;
int n,m;
int d[N][N]; //存储地图
int g[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[] = {-1,0,1,0},dy[] = {0,1,0,-1};
while(hh <= tt)
{
PII 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 && d[x][y] == -1 && g[x][y] == 0)
{
d[x][y] = d[t.first][t.second] + 1;
q[++tt] = {x,y};
}
}
}
return d[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;
}树与图的深度优先遍历
树与图的存储：
树是一种特殊的图，与图的存储方式相同。
对于无向图中的边ab，存储两条有向边a->b, b->a。
因此我们可以只考虑有向图的存储。
题目：
给定一颗树，树中包含 n 个结点（编号 1∼n）和 n−1 条无向边。
请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。
重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。
输入格式
第一行包含整数 n，表示树的结点数。
接下来 n−1 行，每行包含两个整数 a 和 b，表示点 a 和点 b 之间存在一条边。
输出格式
输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最大值。
思路：
对树中的每个点都求出:把这个点删掉之后,其余所有连通块的点数的最大值,以打擂台的方式求出其中最小的那一个
实现代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 1e5 + 10;
const int M = N * 2;
int h[N],ne[M],e[M],idx;
int n;
bool st[N];
int ans = M;
void add(int a,int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
int dfs(int u)
{
int res = 0;
st[u] = true; //标记访问过u节点
int sum = 1; //存储 以u为根的树 的节点数
for(int i = h[u];i != -1;i = ne[i])
{
int j = e[i];
if(!st[j])
{
int s = dfs(j);
res = max(res,s);
sum += s;
}
}
res = max(res,n - sum); // 选择u节点为重心，最大的 连通子图节点数
ans = min(res,ans); //遍历过的假设重心中，最小的最大联通子图的 节点数
return sum;
}
int main()
{
cin>>n;
memset(h,-1,sizeof h);
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;
}树与图的遍历算法模板：
深度优先遍历O(n+m)，n表示点数，m表示边数
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 个点 m 条边的有向图，图中可能存在重边和自环。
所有边的长度都是 1，点的编号为 1∼n。
请你求出 1 号点到 n 号点的最短距离，如果从 1 号点无法走到 n 号点，输出 −1。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 a 和 b，表示存在一条从 a 走到 b 的长度为 1 的边。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
思路：
广度就是一层一层的，与深度（一头到底）的不一样
用BFS遍历图，先在队列中加入源点，然后对于每次取出队头，拓展与队头节点有相邻连边的节点，记得判重。如果还没有到达过，这个点则可以拓展。
图的存储：邻接表
实现代码：
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
const int N = 1e5 + 10;
int n,m;
int d[N];
int idx;
int h[N],ne[N],e[N];
void add(int a,int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
int bfs()
{
memset(d,-1,sizeof d);
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]; //通过索引i得到t能到的节点编号
if(d[j] == -1)
{
d[j] = d[t] + 1; //更新距离
q.push(j); //加到队列里面去
}
}
}
return d[n];
}
int main()
{
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;
}算法模板（acwing–y总的）：
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);
}
}
}拓扑排序
拓扑排序的定义：
一个有向图，如果图中有入度为0的点，就把这个点删掉，同时也删除掉这个点它所连接的边，一直处理这个操作，如果所有的点都能被删掉，则这个图可以进行拓扑排序。
题目：
给定一个 n 个点 m 条边的有向图，点的编号是 1 到 n，图中可能存在重边和自环。
请输出任意一个该有向图的拓扑序列，如果拓扑序列不存在，则输出 −1。
若一个由图中所有点构成的序列 A 满足：对于图中的每条边 (x,y)，x 在 A 中都出现在 y 之前，则称 A 是该图的一个拓扑序列。
题目来自acwing：完整题目链接( )
思路：
记录各点的入度
将入度为0的点放入队列中
将队列的点依次出队，然后找到所有出队列这个点发出的边，删除掉，同时边的另一侧的点入度 - 1
如果所有点都进过队列，则可以拓扑排序，输出所有的顶点。否则输出“-1”，则表示为不可以进行拓扑排序。
实现代码：
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 100010;
int n,m;
//邻接表存储图
int ne[N],e[N],h[N],idx;
int d[N],q[N],hh = 0, tt = -1;
void add(int a,int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
void topsort()
{
for(int i = 1;i <= n;i++)
{
if(d[i] == 0)
q[++tt] = i;
}
while(tt >= hh)
{
int a = q[hh++];
for(int i = h[a];i != -1;i = ne[i])
{
int j = e[i];
d[j]--;
if(d[j] == 0)
q[++tt] = j;
}
}
if(tt == n - 1) //如果队列中的点的个数与图中点的个数相同，则可以进行拓扑排序
{
for(int i = 0;i < n;i++)
{
cout<<q[i]<<" ";
}
}
else
cout<<-1;
}
int main()
{
cin>>n>>m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b;
cin>>a>>b;
d[b]++;
add(a,b);
}
topsort();
return 0;
}算法模板 （acwing–y总的） ：
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;
}Dijkstra
题目：
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环，所有边权均为正值。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 −1。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 −1。
思路：
–朴素版
集合S为已经确定最短路径的点集。
- 初始化距离:一号结点的距离为零，其他结点的距离设为无穷大
- 循环n次，每一次将集合S之外距离最短X的点加入到S中去。然后用点X更新X邻接点的距离。
实现代码：
#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
const int N = 510;
int n,m;
int dist[N];
int g[N][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++)
if(!st[j] && (t == -1 || dist[t] > dist[j]))
t = j;
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;
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);
}
int t = Dijkstra();
printf("%d\n",t);
return 0;
}–优化版：
堆优化版的dijkstra是对朴素版dijkstra进行了优化，在朴素版dijkstra中时间复杂度最高的寻找距离
最短的点O(n^2)可以使用最小堆优化。
- 一号点的距离初始化为零，其他点初始化成无穷大。
- 将一号点放入堆中。
- 不断循环，直到堆空。每一次循环中执行的操作为：
弹出堆顶（与朴素版diijkstra找到S外距离最短的点相同，并标记该点的最短路径已经确定）。
用该点更新临界点的距离，若更新成功就加入到堆中。
实现代码：
#include<iostream>
#include<cstring>
#include<algorithm>
#include<queue>
using namespace std;
typedef pair<int,int> PII;
const int N = 100010, M = 200010;
const int INF = 0x3f3f3f3f;
int n,m;
int dist[N];
int idx, h[N], ne[M], e[M], w[M];
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);
memset(st, 0, sizeof st);
dist[1] = 0;
priority_queue<PII, vector<PII>, greater<PII>> heap;
heap.push({0, 1});
while(heap.size())
{
PII k = heap.top();
heap.pop();
int ver = k.second, distance = k.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] == INF) return -1;
else return dist[n];
}
int main()
{
memset(h, -1, sizeof h);
scanf("%d%d", &n, &m);
while(m--)
{
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
add(a, b, c);
}
int t = Dijkstra();
printf("%d\n", t);
return 0;
}bellman-ford
定义：
Bellman - ford 算法是求含负权图的单源最短路径的一种算法，效率较低，代码难度较小。其原理为连续进行松弛，在每次松弛时把每条边都更新一下，若在 n-1 次松弛后还能更新，则说明图中有负环，因此无法得出结果，否则就完成。
题目：
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出从 1 号点到 n 号点的最多经过 k 条边的最短距离，如果无法从 1 号点走到 n 号点，输出 impossible。
注意：图中可能 存在负权回路 。
输入格式
第一行包含三个整数 n,m,k。
接下来 m 行，每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
点的编号为 1∼n。
输出格式
输出一个整数，表示从 1 号点到 n 号点的最多经过 k 条边的最短距离。
如果不存在满足条件的路径，则输出 impossible。
思路：
for n次
for 所有边 a,b,w 松弛操作
dist[b] = min(dist[b],dist[a] + w)
dits[b] <= dist[a] + w实现代码：
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 510,M = 10010;
int n,m,k;
int dist[N];
int backup[N]; //备份数组
struct Edge
{
int a,b,w;
}edge[M]; //把每个边保存下来
int ballman_ford()
{
memset(dist,0x3f,sizeof dist);
dist[1] = 0;
for(int i = 0;i < k;i++)
{
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 -1;
else return dist[n];
}
int main()
{
scanf("%d%d%d",&n,&m,&k);
for(int i = 0;i < m;i++)
{
int a,b,w;
scanf("%d%d%d",&a,&b,&w);
edge[i] = {a,b,w};
}
int t = ballman_ford();
if(dist[n]>0x3f3f3f3f/2) printf("impossible");
else printf("%d\n", t);
return 0;
}spfa
什么是spaf算法：
SPFA（Shortest Path Faster Algorithm）是Bellman-Ford 算法的优化版本，核心用于求解带权有向图（或无向图）的单源最短路径问题，尤其适用于存在负权边但无负权回路的场景，时间效率通常优于原始 Bellman-Ford 算法。
Bellman-Ford 算法会重复遍历所有边以松弛（更新最短路径），存在大量无效操作；SPFA 通过队列（或双端队列，优化版） 筛选 “有效边”—— 仅当某个节点的最短路径被更新时，才将其入队，后续仅用该节点松弛其邻接节点，减少冗余计算。
松弛:
松弛操作的逻辑是：如果 dist[v] > dist[u] + w，则更新 dist[v] = dist[u] + w。所谓松弛操作，就是看一看distv和distu+u到v的距离哪个大一点。
spfa算法的适用场景：
- 含负权边但无负权回路的图；
- 稀疏图的单源最短路径；
- 需检测负权回路的场景。
题目：
给定一个 n 个点 m 条边的有向图，图中可能存在重边和自环， 边权可能为负数。
请你求出 1 号点到 n 号点的最短距离，如果无法从 1 号点走到 n 号点，则输出 impossible。
数据保证不存在负权回路。
输入格式
第一行包含整数 n 和 m。
接下来 m 行每行包含三个整数 x,y,z，表示存在一条从点 x 到点 y 的有向边，边长为 z。
输出格式
输出一个整数，表示 1 号点到 n 号点的最短距离。
如果路径不存在，则输出 impossible。
数据范围
1 ≤ n,m ≤ 105,
图中涉及边长绝对值均不超过 10000。
思路：
实现代码：
#include<iostream>
#include<queue>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 100010;
int n,m;
bool st[N];
int dist[N];
int h[N],ne[N],idx,e[N],w[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,0x3f3f3f3f,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;
}算法模板（acwing–y总的）：
时间复杂度 平均情况下 O(m)，最坏情况下 O(nm), n表示点数，m表示边数
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];
}Floyd
多源最短路问题-Floyd算法O(n3)O(n^3)O(n3)-动态规划
题目：
定一个 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。
思路：
实现代码：
#include<algorithm>
#include<iostream>
#include<cstring>
using namespace std;
const int N = 210,INF = 1e9;
int n,m,k;
int a,b,c;
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>>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--)
{
cin>>a>>b>>c;
d[a][b] = min(d[a][b],c);
//注意保存最小的边
}
floyd();
while(k--)
{
cin>>a>>b;
if(d[a][b] > INF / 2) puts("impossible"); //由于有负权边存在所以约大过INF/2也很合理
else
cout<<d[a][b]<<endl;
}
return 0;
}算法模板（acwing–y总的）：
时间复杂度是 O(n3)O(n^3)O(n3), n 表示点数
初始化：
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]);
}Prim
给定一个无向图，在图中选择若干条边把图的所有节点连起来。要求边长之和最小。在图论中，叫做求最小生成树。
prim 算法采用的是一种贪心的策略。
每次将离连通部分的最近的点和点对应的边加入的连通部分，连通部分逐渐扩大，最后将整个图连通起来，并且边长之和最小。
题目：
给定一个 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。
思路：
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cstdio>
using namespace std;
const int N = 510;
const int INF = 0x3f3f3f3f;
int n,m;
int dist[N],g[N][N];
bool st[N];
int res = 0;
int prim()
{
memset(dist,0x3f,sizeof dist);
for(int i = 0;i < n;i++)
{
int t = -1;
for(int j = 1;j <= n;j++)
{
if(!st[j] && (t == -1 || dist[j] < dist[t]))
{
t = j;
}
}
if(i && dist[t] == INF) return INF;
st[t] = true;
if (i) res += dist[t];
for(int j = 1;j <= n;j++)
{
dist[j] = min(dist[j],g[t][j]);
}
}
return res;
}
int main()
{
cin>>n>>m;
memset(g,0x3f,sizeof g);
for(int i = 0;i < m;i++)
{
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) puts("impossible");
else
cout<<t<<endl;
return 0;
}算法模板（acwing–y总的）：
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;
}Kruskal
**题目：**给定一个 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。
思路：
- 将所有边按照权值的大小进行升序排序，然后从小到大一一判断。
- 如果这个边与之前选择的所有边不会组成回路，就选择这条边分；反之，舍去。
- 直到具有 n 个顶点的连通网筛选出来 n-1 条边为止。
- 筛选出来的边和所有的顶点构成此连通网的最小生成树。
判断是否会产生回路的方法为：使用并查集
实现代码：
#include<iostream>
#include<algorithm>
using namespace std;
const int N = 100010,M = N * 2,INF = 0x3f3f3f3f;
int n,m;
int p[N];
struct Edge{
int a,b,w;
bool operator < (const Edge &W)const
{
return w < W.w;
}
}edge[M];
int find(int x)
{
if(p[x] != x)
p[x] = find(p[x]);
return p[x];
}
int kruskal()
{
sort(edge,edge + 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 = edge[i].a,b = edge[i].b,w = edge[i].w;
a = find(a),b = find(b);
if(a != b)
{
p[a] = b;
res += w;
cnt++;
}
}
if(cnt < n-1)
return INF;
else
return res;
}
int main()
{
cin>>n>>m;
for(int i = 0;i < m;i++)
{
int a,b,w;
cin>>a>>b>>w;
edge[i] = {a,b,w};
}
int t = kruskal();
if(t == INF) puts("impossible");
else
{
cout<<t<<endl;
}
return 0;
}算法模板（acwing–y总的）：
时间复杂度是 O(mlogm), n 表示点数，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;
return res;
}染色图判定二分图
题目：
给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环。
请你判断这个图是否是二分图。
输入格式
第一行包含两个整数 n 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示点 u 和点 v 之间存在一条边。
输出格式
如果给定图是二分图，则输出 Yes，否则输出 No。
思路：
首先得先明白什么是二分图；
简单来说，图中点通过移动能分成左右两部分，左侧的点只能和右侧的点相连，右侧的点只和左侧的点相连
- 二分图：一定不含有奇数环，可能包含长度为偶数的环， 不一定是连通图
实现代码–用dfs实现：
#include<iostream>
#include<algorithm>
#include<cstring>
using namespace std;
const int N = 100010,M = N * 2;
int n,m;
int h[N],ne[M],e[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;
//遍历和 u 相邻的点
for(int i = h[u];i != -1;i = ne[i])
{
int j = e[i];
if(!color[j]) //相邻的点没有颜色,则递归处理这个相邻点
{
if(!dfs(j,3 - c)) return false; //（3 - 1 = 2， 如果 u 的颜色是2，则和 u 相邻的染成 1）
//（3 - 2 = 1， 如果 u 的颜色是1，则和 u 相邻的染成 2）
}
else if(color[j] == c) return false;
}
return true;
}
int main()
{
cin>>n>>m;
memset(h,-1,sizeof h);
while(m--)
{
int a,b;
cin>>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("No");
else puts("Yes");
return 0;
}算法模板（acwing–y总的）：
时间复杂度是 O(n+m), n表示点数，𝑚表示边数
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;
}匈牙利算法
题目：
给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。
数据保证任意一条边的两个端点都不可能在同一部分中。
请你求出二分图的最大匹配数。
二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。
二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。
输入格式
第一行包含三个整数 n1、 n2 和 m。
接下来 m 行，每行包含两个整数 u 和 v，表示左半部点集中的点 u 和右半部点集中的点 v 之间存在一条边。
输出格式
输出一个整数，表示二分图的最大匹配数。
思路：
- 匹配：在图论中，一个「匹配」是一个边的集合，其中任意两条边都没有公共顶点。
- 最大匹配：一个图所有匹配中，所含匹配边数最多的匹配，称为这个图的最大匹配。
实现代码：
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
const int N = 510,M = 100010;
int n1,n2,m;
int h[N],ne[M],e[M],idx;
bool st[N];
int match[N];
void add(int a,int b)
{
e[idx] = b;
ne[idx] = h[a];
h[a] = idx++;
}
void init()
{
memset(h,-1,sizeof h);
}
int 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] || find(match[j]))
{
match[j] = x;
return true;
}
}
}
return false;
}
int main()
{
init();
cin>>n1>>n2>>m;
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;
}算法模板（acwing–y总的）：
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 ++ ;
}