最小生成树算法与二分图算法

---

---

概述

---

$Prim$ 算法 - 稠密图 - $O(n^2)$

思路概述

跟 $Dijkstra$ 算法很相近，都是每个点轮一遍然后贪心找最小值，同样，$Prim$ 也可以用堆优化，但是不如 $Kruskal$ 算法，所以不用。

• 用到三个数组：g[][]邻接矩阵存边，st[]用于标记那些节点在生成树中，dist[]存储每个节点到生成树的最小距离。
• 首先，初始化每个点到生成树的距离，在一开始，除了根节点是 $0$，其他都是 $INF$;
• 然后每个点轮一遍（因为生成树要每个点都在）
  • 再次遍历，寻找到生成树最小的边连接的点，如果遍历完了发现最小值是 $INF$，说明这个图不联通，没有最小生成树。
  • 将这个点更新到生成树里去，累计生成树的边长，然后用这个点的值再更新一遍dist[]数组。

---

时间复杂度分析

外层循环 $n$ 次，内层是 $2n$ 次，所以是 $O(n\cdot 2n)$，也就是$$O(n^2)$$

---

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和边数m

int prim(){  	// 定义prim算法函数
    memset(dist, 0x3f, sizeof dist); 	// 初始化dist数组
    dist[1] = 0; 	// 将起点的距离设为0
    
    int res = 0; 	// 初始化结果res
    for(int i = 0; i < n; ++i){ 	// 遍历所有顶点
        int t = -1; 	// 初始化t
        
        for(int j = 1; j <= n; ++j) 	// 遍历所有顶点
            if(!st[j] && (t == -1 || dist[t] > dist[j])) // 找到未被访问且距离最小的顶点
                t = j;
        
        if(dist[t] == INF) return INF; 	// 如果找不到顶点，返回INF
        
        res += 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); 	// 初始化邻接矩阵g
    
    cin >> 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); 			// 否则输出结果
}

---

---

$Kruskal$ 算法 - 稀疏图 - $O(mlogm)$

思路解析

• 首先，将所有边按权值排序，这一步是 $Kruskal$ 的瓶颈，复杂度是$O(m\cdot logm)$
• 接着初始化并查集，再把排序好的边轮一遍。
  • 如果边的两个点的根节点不是同一个（两个节点没有全在树中），那就将两个点连起来，然后节点数和权重累积。
• 最后判断，如果生成树的边不是 $n-1$ 条的话，说明图不联通，没有最小生成树。

---

时间复杂度分析

由上知排序瓶颈复杂度，然后是后面遍历每一条边的复杂度 $O(m)$，最后累计就是$$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]; 	// 定义并查集数组p

struct 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和计数器cnt
    for(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++; 		// 计数器加1
            res += w; 	// 更新结果
        }
    }
    
    if(cnt < n - 1) return INF; 	// 如果生成树的边数小于n-1，返回INF
    else 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)$

何为二分图？

• 二分图即指一张图的所有节点可以用两种颜色涂上，且相邻节点必是不同颜色。
• 对应到集合的映射关系上就是，可以通过移动把节点分为两个集合，左集合只能连右集合，右集合只连左集合。
  

---

二分图满足什么条件？

二分图不能出现奇数环。

• 充分性：有奇数环就一定不是二分图。
  • 若存在奇数环，那么从某一点开始分配颜色，分配到最后开始节点又会被分配到另一种颜色，冲突了，所以得证充分性。
• 必要性：没有奇数环就一定是二分图。
  • 没有了奇数环，那么每个点都会被分配到有且仅有的那一种颜色，必要性得证。
    • 反证法，如果没有奇数环，还有颜色分配冲突，那么说明存在一个偶数环，使得环上的两个相邻节点被分配了相同的颜色。然而，这与我们的颜色分配策略（即相邻节点分配不同颜色）是矛盾的。
• 因此，如果一个图没有奇数环，那么它一定可以被成功地二分，即它是一个二分图。

---

思路介绍

当我们用染色法判断二分图时，大概分为以下几步：

• 遍历所有未被染色的点，将其染色，并对它连接的点染上不同颜色。
  • 如果发现这个点之前染过色，这次染的色跟上次的不同，说明存在奇数环，非二分图。

---

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(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;
}