最小生成树
本节课大纲:
一般都是无向图的最小生成树
Prim 算法和 Dijkstra 算法很像
如果是稠密图,一般选择朴素版 Prim,因为代码短,稀疏图一般用克鲁斯卡尔算法。
堆优化的 Prim 的优化方式和 Dijkstra 一样的,而且很少用到,所以不讲了。
朴素版Prim
例题:858. Prim算法求最小生成树
样例模拟:
i = 1时
1.选择距离集合最近的点,t = 2
2.st[2] = true;
3.用t更新其他点到集合的距离
3号点连向集合的边有两个,选距离小的,所以依然是2
4号点连向集合的边只有一个,所以依然是3
i = 2时
1.选择距离集合最近的点,t = 3
2.st[3] = true;
3.用t更新其他点到集合的距离
4号点连向集合的边有两个,选距离小的,所以依然是3
i = 3时
1.选择距离集合最近的点,只剩t = 4
2.st[4] = true;
3.用t更新其他点到集合的距离
没有其他点了
最终的生成树是啥样的呢?
每次选中的那个点,它距离集合最近的那条边就是树的边
红色的树就是最小生成树。
什么情况下不存在生成树呢?所有点不连通
在最小生成树中,边权的正负都无所谓。
需要注意的一点是,本题中有负权,prim算法中需要先累加距离, 再更新当前点的出边.
如果先更新当前点的出边, 因为有负的自环存在,
for (int j = 1; j <= n; j ++ ) dist[j] = min(dist[j], g[t][j])
当j = t的时候, dist[t] 会更新成负环, 随后res += dist[t]
, 会将负环距离计算进来.
而最小生成树是不包含负自环的.
code
#include <iostream>
#include <cstring>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;
int n, m;
int g[N][N];
bool st[N];
int dist[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; // 如果遍历到的点不是第1个点, 并且距离连通块INF;
if (i) res += dist[t]; // 如果不是第1个点, 则把距离加上
st[t] = true; // 标记为绿色点, 表示到连通块距离已经确定
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);
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 res = prim();
if (res == INF) puts("impossible");
else printf("%d\n", res);
return 0;
}
克鲁斯卡尔算法
步骤:
(1)将所有边按照权重从小到大排序
(2)枚举每条边 a–>b,权重是 c。如果 a, b 不连通,就将 a—>b这条边加入集合中。
第(2)步和“连通块中点的数量”那道题类似,只是第三个操作用不到,所以这道题就是并查集的一个简单应用。
AcWing 859. Kruskal算法求最小生成树
code
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5 + 10, M = 2e5 + 10, INF = 0x3f3f3f3f;
struct Edge{
int a, b, c;
bool operator < (const Edge& W) const{
return c < W.c;
}
}edges[M];
int n, m;
int p[N];
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, c = edges[i].c;
a = find(a), b = find(b);
if (a != b){
cnt ++;
res += c;
p[a] = b;
}
}
if (cnt < n - 1) return INF;
return res;
}
int main(){
cin >> n >> m;
for (int i = 0; i < m; i ++ ){
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
edges[i] = {a, b, c};
}
int t = kruskal();
if (t == INF) puts("impossible");
else cout << t << endl;
return 0;
}
二分图
染色法
二分图:可以把所有点划分到两个集合,使得所有边都是在两个集合之间的,集合内部没有边。
染色法:判定一个图是不是二分图
图论中的一个重要性质:一个图是二分图当且仅当图中不含奇数环。
证明➡️: 如果一个图中有奇数环, 起点染红, 起点的出边染黑, 因为边数为奇数, 可以推出起点可以被染黑, 矛盾
证明⬅️: 构造, 从前往后遍历每一个点, 不断二染色, 可以将整个图全部染色, 由于不存在奇数环, 染色过程不会矛盾.
命题: 由于不存在奇数环, 染色过程不会矛盾.
证明: 假设在染色过程中出现了矛盾, 那么说明除去矛盾的点, 其他点数总和为偶数, 因为矛盾点与已存在的点重合, 因此图中总的点数也为偶数, 边数就为奇数, 与不存在奇数环,矛盾!
奇数环:这个环中边的数量是奇数。
染色法:
for(i:1~n){
if(i未染色){
dfs(i, 1);
}
}
例题:860. 染色法判定二分图
code
#include <iostream>
#include <cstring>
using namespace std;
const int N = 1e5 + 10, M = N * 2;
int h[N], e[M], ne[M], idx;
int n, m;
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; i = ne[i]){
int j = e[i];
if (!color[j]){ // 忘了写
if (!dfs(j, 3 - c)) return false;
}
else if (color[u] == color[j]) return false;
}
return true;
}
int main(){
cin >> 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(nm)
一共考虑n个男生, 最坏情况下在这个男生的状态下, 将所有边遍历一遍*m. 实际运行时间远小于 O ( n m ) O(nm) O(nm)
例题:861. 二分图的最大匹配
code
st数组用来判重, 避免在某次匹配中重复遍历点和边
st数组用来防止重复搜索相同的点。当图中有环的时候,不加st数组可能会无限循环下去,就出现段错误了。
#include <iostream>
#include <cstring>
using namespace std;
const int N = 510, M = 1e5 + 10;
int h[N], e[M], ne[M], idx;
int match[N];
bool st[N];
int n1, n2, m;
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; 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(){
cin >> 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, 0, sizeof st);
if (!st[i]) // 不熟练
if (find(i)) res ++;
}
cout << res << endl;
return 0;
}