文章目录
- 概述
- P r i m Prim Prim 算法 - 稠密图 - O ( n 2 ) O(n^2) O(n2)
- 思路概述
- 时间复杂度分析
- AcWing 858. Prim算法求最小生成树
- CODE
- K r u s k a l Kruskal Kruskal 算法 - 稀疏图 - O ( m l o g m ) O(mlogm) O(mlogm)
- 思路解析
- 时间复杂度分析
- AcWing 859. Kruskal算法求最小生成树
- CODE
- 染色法判定二分图 - O ( m + n ) O(m + n) O(m+n)
- 何为二分图?
- 二分图满足什么条件?
- 思路介绍
- AcWing 860. 染色法判定二分图
- CODE
- 匈牙利算法 - 二分图的最大匹配 - O ( m n ) O(mn) O(mn)
- 具体思路解析
- 时间复杂度分析
- AcWing 861. 二分图的最大匹配
- CODE
概述
P r i m Prim Prim 算法 - 稠密图 - O ( n 2 ) O(n^2) O(n2)
思路概述
跟 D i j k s t r a Dijkstra Dijkstra 算法很相近,都是每个点轮一遍然后贪心找最小值,同样, P r i m Prim Prim 也可以用堆优化,但是不如 K r u s k a l Kruskal Kruskal 算法,所以不用。
- 用到三个数组:
g[][]
邻接矩阵存边,st[]
用于标记那些节点在生成树中,dist[]
存储每个节点到生成树的最小距离。 - 首先,初始化每个点到生成树的距离,在一开始,除了根节点是 0 0 0,其他都是 I N F INF INF;
- 然后每个点轮一遍(因为生成树要每个点都在)
- 再次遍历,寻找到生成树最小的边连接的点,如果遍历完了发现最小值是 I N F INF INF,说明这个图不联通,没有最小生成树。
- 将这个点更新到生成树里去,累计生成树的边长,然后用这个点的值再更新一遍
dist[]
数组。
时间复杂度分析
外层循环 n n n 次,内层是 2 n 2n 2n 次,所以是 O ( n ⋅ 2 n ) O(n·2n) O(n⋅2n),也就是 O ( n 2 ) O(n^2) O(n2)
AcWing 858. Prim算法求最小生成树
题目链接:https://www.acwing.com/activity/content/problem/content/924/。
CODE
#include <iostream> // 引入输入输出流库
#include <cstring> // 引入字符串处理库
#include <algorithm> // 引入算法库using namespace std; // 使用标准命名空间const int N = 520, INF = 0x3f3f3f3f; // 定义常量N和INF
int g[N][N]; // 定义邻接矩阵g
int dist[N]; // 定义距离数组dist
bool st[N]; // 定义状态数组st
int n, m; // 定义顶点数n和边数mint prim(){ // 定义prim算法函数memset(dist, 0x3f, sizeof dist); // 初始化dist数组dist[1] = 0; // 将起点的距离设为0int res = 0; // 初始化结果resfor(int i = 0; i < n; ++i){ // 遍历所有顶点int t = -1; // 初始化tfor(int j = 1; j <= n; ++j) // 遍历所有顶点if(!st[j] && (t == -1 || dist[t] > dist[j])) // 找到未被访问且距离最小的顶点t = j;if(dist[t] == INF) return INF; // 如果找不到顶点,返回INFres += dist[t]; // 更新结果st[t] = true; // 标记顶点t已被访问for(int j = 1; j <= n; ++j) dist[j] = min(dist[j], g[j][t]); // 更新距离}return res; // 返回结果
}int main() // 主函数
{memset(g, 0x3f, sizeof g); // 初始化邻接矩阵gcin >> n >> m; // 输入顶点数和边数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(); // 调用prim算法if(t == INF) puts("impossible"); // 如果返回INF,输出"impossible"else printf("%d\n", t); // 否则输出结果
}
K r u s k a l Kruskal Kruskal 算法 - 稀疏图 - O ( m l o g m ) O(mlogm) O(mlogm)
思路解析
- 首先,将所有边按权值排序,这一步是 K r u s k a l Kruskal Kruskal 的瓶颈,复杂度是 O ( m ⋅ l o g m ) O(m·logm) O(m⋅logm)
- 接着初始化并查集,再把排序好的边轮一遍。
- 如果边的两个点的根节点不是同一个(两个节点没有全在树中),那就将两个点连起来,然后节点数和权重累积。
- 最后判断,如果生成树的边不是 n − 1 n - 1 n−1 条的话,说明图不联通,没有最小生成树。
时间复杂度分析
由上知排序瓶颈复杂度,然后是后面遍历每一条边的复杂度 O ( m ) O(m) O(m),最后累计就是 O ( m l o g m ) O(mlogm) O(mlogm)
但是由于排序的常数很小,所以实际运行时间比公式算出来要少的多。
AcWing 859. Kruskal算法求最小生成树
题目链接:https://www.acwing.com/activity/content/problem/content/925/
CODE
#include <iostream> // 引入输入输出流库
#include <cstring> // 引入字符串处理库
#include <algorithm> // 引入算法库using namespace std; // 使用标准命名空间const int N = 1e5 + 10, M = 2e5 + 10, INF = 0x3f3f3f3f; // 定义常量N、M和INF
int n, m; // 定义顶点数n和边数m
int p[N]; // 定义并查集数组pstruct edge{ // 定义边的结构体int a, b, w;
}edges[M];int find(int x){ // 定义并查集的查找函数if(x != p[x]) p[x] = find(p[x]);return p[x];
}bool cmp(edge a, edge b){ // 定义比较函数,用于排序return a.w < b.w;
}int kruskal(){ // 定义kruskal算法函数sort(edges, edges + m, cmp); // 对所有边按权值进行排序for(int i = 1; i <= n; ++i) p[i] = i; // 初始化并查集int res = 0, cnt = 0; // 初始化结果res和计数器cntfor(int i = 0; i < m; ++i){ // 遍历所有边int a = find(edges[i].a), b = find(edges[i].b), w = edges[i].w; // 找到边的两个顶点的根节点和权值if(a != b){ // 如果两个顶点不在同一个集合中p[a] = b; // 合并两个集合cnt++; // 计数器加1res += w; // 更新结果}}if(cnt < n - 1) return INF; // 如果生成树的边数小于n-1,返回INFelse return res; // 否则返回结果
}int main() // 主函数
{cin >> 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(); // 调用kruskal算法if(t == INF) puts("impossible"); // 如果返回INF,输出"impossible"else printf("%d\n", t); // 否则输出结果
}
染色法判定二分图 - O ( m + n ) O(m + n) O(m+n)
何为二分图?
- 二分图即指一张图的所有节点可以用两种颜色涂上,且相邻节点必是不同颜色。
- 对应到集合的映射关系上就是,可以通过移动把节点分为两个集合,左集合只能连右集合,右集合只连左集合。
二分图满足什么条件?
二分图不能出现奇数环。
- 充分性:有奇数环就一定不是二分图。
- 若存在奇数环,那么从某一点开始分配颜色,分配到最后开始节点又会被分配到另一种颜色,冲突了,所以得证充分性。
- 必要性:没有奇数环就一定是二分图。
- 没有了奇数环,那么每个点都会被分配到有且仅有的那一种颜色,必要性得证。
- 反证法,如果没有奇数环,还有颜色分配冲突,那么说明存在一个偶数环,使得环上的两个相邻节点被分配了相同的颜色。然而,这与我们的颜色分配策略(即相邻节点分配不同颜色)是矛盾的。
- 没有了奇数环,那么每个点都会被分配到有且仅有的那一种颜色,必要性得证。
- 因此,如果一个图没有奇数环,那么它一定可以被成功地二分,即它是一个二分图。
思路介绍
当我们用染色法判断二分图时,大概分为以下几步:
- 遍历所有未被染色的点,将其染色,并对它连接的点染上不同颜色。
- 如果发现这个点之前染过色,这次染的色跟上次的不同,说明存在奇数环,非二分图。
AcWing 860. 染色法判定二分图
题目链接:https://www.acwing.com/activity/content/problem/content/926/
CODE
#include <iostream>
#include <cstring>
#include <algorithm>using namespace std;const int N = 1e5 + 10, M = 2e5 + 10;
int n, m;
int e[M], ne[M], h[N], 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]){ // 如果节点j未着色if(!dfs(j, 3 - c)) return false; // 递归着色,如果失败则返回false}else if(color[j] == c) return false; // 如果节点j的颜色与节点u相同,返回false}return true; // 所有节点都成功着色,返回true
}int main()
{memset(h, -1, sizeof h); // 初始化邻接表cin >> n >> m; // 读入节点数和边数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]){ // 如果节点i未着色if(!dfs(i, 1)){ // 尝试从节点i开始着色,如果失败则设置flag为false并跳出循环flag = false;break;}}}if(flag) puts("Yes"); // 如果所有节点都成功着色,输出"Yes"else puts("No"); // 否则输出"No"return 0;
}
匈牙利算法 - 二分图的最大匹配 - O ( m n ) O(mn) O(mn)
具体思路解析
- 跟找对象一样,将所有男生集合遍历一遍,每个男生遍历一遍心动对象,找一个没对象的牵手。
- 如果某一个男生的心动对象已经跟别的男生牵手了,那这个男生就会问上个男生:能不能换一个?于是上一个男生就开始从其他心动对象里面找:
- 如果找到了,皆大欢喜,上一个男的换对象,这个男的跟心动女生牵手;
- 没找到,那么后面这个男生继续在其他心动对象里面找一个能牵手的。
- 如果某一个男生的心动对象已经跟别的男生牵手了,那这个男生就会问上个男生:能不能换一个?于是上一个男生就开始从其他心动对象里面找:
时间复杂度分析
先遍历一个集合里的所有点,再遍历点对应的所有边,所以是: O ( m n ) O(mn) O(mn)但是一般来说,常数很小,所以实际耗时比公式算出来的要小很多。
AcWing 861. 二分图的最大匹配
题目链接:https://www.acwing.com/activity/content/problem/content/927/
CODE
#include<cstdio>
#include <iostream>
#include <cstring>
#include <algorithm>using namespace std;const int N = 520, M = 1e5 + 10;
int h[N], e[M], ne[M], idx;
int n1, n2, m;
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]){ // 如果节点j未被搜索过st[j] = true;if(match[j] == 0 || find(match[j])){ // 如果节点j未被匹配或者节点j的匹配可以被改变match[j] = x; // 更新匹配情况return true;}}}return false; // 找不到可增广的路径
}int main()
{memset(h, -1, sizeof h); // 初始化邻接表cin >> n1 >> n2 >> m; // 读入节点数和边数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;
}