第三章 搜索与图论（三）

最小生成树

本节课大纲：

一般都是无向图的最小生成树
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(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;
}