搜索与图论（三）——最小生成树、二分图

前言

算法基础课-3.4
第三章 搜索与图论（三）

共4题，知识点如下：
最小生成树：
Prim算法求最小生成树、
Kruskal算法求最小生成树。
二分图：
染色法判定二分图、
匈牙利算法—二分图的最大匹配。

掌握模版的最核心部分是：记住算法思路

不能纯记模版，效率很低，一定要记思路

可以想到啥算法，就自己把算法流程描述一遍

最小生成树

稠密图一般用朴素版Prim（主要是代码较短）

稀疏图一般用Kruskal算法（思路更简单而且代码也比堆优化版Prim少）

堆优化版Prim一般不会用到（也是适用于稀疏图）

堆优化版Prim和堆优化版Dijkstra，优化方式是一样的

所以略过，只讲朴素版Prim 和 Kruskal（实用主义，用到再学，用不到就暂时不学）

朴素版prim算法

朴素版Prim算法和Dijkstra非常相似

Dijkstra

先初始化，迭代n次，每次都找距离最近的点t(不在集合中的)，然后用它更新其他点，再把它放到集合里去。
集合：（已经确定最短距离的点）

Prim

集合s：在当前连通块里的所有点

区别：

Dijkstra 是用 t 更新到起点的距离
Prim 是用 t 更新到集合的距离
t：不在集合中的距离最近的点

模板

时间复杂度是 O(n²+m), n 表示点数，m 表示边数

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

模板题 AcWing 858. Prim算法求最小生成树

初始

随便挑一个更新到其他点的距离，然后将该点加入集合

用 2（离集合最近的点）更新其他所有点，距离没有更短，没变化，加入到集合中

然后用3更新，最后用4，距离都没有变短，保持不变

最小生成树，最短的几条边（相等的任选一条即可）

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;
// 点500，边10w，稠密图，用邻接矩阵存
const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N];
int dist[N]; // 点到集合的距离
bool st[N];

int prim() {
    // 1.初始化
    memset(dist, 0x3f, sizeof dist);
    // 2.n次迭代
    int res = 0; // 存最小生成树的树边权重之和
    for (int i = 0; i < n; i++) {
        // 1) 每次找到集合外的所有点中距离最小的点
        int t = -1;
        for (int j = 1; j <= n; j++) {
            // !st[j]：集合外，t == -1：还没找到任何点, dist[t] > dist[j] : t的距离比j大
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        }
        
        // i!=0&&dist[t] == INF 当前距离最近的点到集合距离都是+∞，说明图是不连通的
        if (i && dist[t] == INF) return INF;
        // 只要不是第一个点,就把答案加上
        if (i) res += dist[t]; // 需要先累加再更新,防止把自环的加进去了
        
        // 2)用t更新其他点到集合的记录
        for (int j = 1; j <= n; j++) dist[j] = min(dist[j], g[t][j]);

        // 3) 
        st[t] = true;
    }
    return res;
}

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);
        // 无向图其实是特殊的有向图，对每个边 建一个从a到b的和从b到a的即可
        g[a][b] = g[b][a] = min(g[a][b], c); // 有重边就取最小的
    }
    
    int t = prim();
    
    // 所有点都不连通的时候，就不存在最小生成树
    if (t == INF) puts("impossible"); 
    else printf("%d\n", t);
    
    return 0;
}

代码不能死记硬背，一定要把思路搞清楚

一般来说只要思路搞清楚了，写代码就顺理成章了

对比一下Dijkstra和Prim代码，基本一样的

Prim

Dijkstra

Kruskal算法

先对边从小到大排序，时间主要花在排序上

O(mloogm)

从小到大枚举（排完序后），连通操作对应并查集的题目：连通块中点的数量
if 对应操作 2
将 边加入集合 对应操作1

所以实际上是并查集的简单应用

模板

时间复杂度是 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;
}

模板题 AcWing 859. Kruskal算法求最小生成树

#include <iostream>
#include <algorithm>

using namespace std;

const int N = 200010;

int n, m;
int p[N];

struct Edge {
    int a, b, w;
    // 重载 < 方便排序(按权重排序)
    bool operator< (const Edge &W) const {
        return w < W.w;
    }
}edge[N];

// 并查集模板,返回x的祖宗节点
int find(int x) {
    if (p[x] != x) p[x] = find(p[x]);
    return p[x];
}

int main() {
    scanf("%d%d", &n, &m);
    
    for (int i = 0; i < m; i ++) {
        int a, b, w;
        scanf("%d%d%d", &a, &b, &w);
        edge[i] = {a, b, w};
    }
    // 排序
    sort(edge, edge + m);
    // 初始化并查集
    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 = edge[i].a, b = edge[i].b, w = edge[i].w;
        
        a = find(a), b = find(b); // 赋值为a和b的祖宗节点
        if (a != b) {
            p[a] = b; // 将a加到b上(a的父节点赋值为b)
            res += w;
            cnt ++;
        }
    }
    // 如果加的边数小于n-1,说明该树是不连通的
    if (cnt < n - 1) puts("impossible");
    else printf("%d\n", res);
    
    return 0;
}

二分图：

二分图：可以把所有点分成两个集合。

内部没有边，所有边都是在两个集合间的

如果存在奇数环就一定不是二分图

染色法：确定某个点后，将相邻的点染成不同颜色。（可以确定该点下的所有点）

如果有矛盾，环内点数一定是奇数，所以反证成立

染色法判别二分图

模板

时间复杂度是 O(n+m), n 表示点数，m 表示边数

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

模板题 AcWing 860. 染色法判定二分图

O（n+m）

只要图在染色法过程出现了矛盾，就说明存在奇数环，即不是二分图

深度优先遍历不需要自己写队列，代码短一些

#include <cstring>
#include <iostream>
#include <algorithm>

using namespace std;

const int N = 100010, M = 200010; //无向图, 边要两倍
// 邻接表方式存储图
int n, m;
int h[N], e[M], ne[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; // 记录当前点的颜色为c
    
    // 从前往后遍历当前点的邻点
    for (int i = h[u]; i != -1; i = ne[i]) {
        int j = e[i]; // 用j来存当前点的编号
        // 如果未染色
        if (!color[j]) { 
            // 如果是1就染成2，如果是2就染成1
            if (!dfs(j, 3 - c)) return false;
        }
        // 已染色的话，判断一下与当前点是否相等
        else if (color[j] == c) return false;
    }
    return true;
}

int main() {
    scanf("%d%d", &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; // flag表示染的时候是不是染失败了
    for (int i = 0; i <= n; i++) {
        if (!color[i]) { // 如果color[i]等于0，没被染过色
            if (!dfs(i, 1)) { // 如果dfs等于false，说明有矛盾发生
                flag = false;
                break;
            }
        }
    }
    
    if (flag) puts("Yes"); // 等于true表示没矛盾发生，是二分图
    else puts("No");
    
    return 0;
}

匈牙利算法

非常常用
理论时间复杂度O（mn），m边数，n点数

实际运行时间一般远小于O（mn）【也可能是线性的】

类似的算法还有很多

如：最大流算法（笔试面试一般不考这个）

模板

时间复杂度是 O(nm)， n 表示点数，m 表示边数

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

模板题 AcWing 861. 二分图的最大匹配

#include <iostream>
#include <algorithm>
#include <cstring>

using namespace std;

const int N = 510, M = 100010;

int n1, n2, m;
int h[N], e[M], ne[M], idx; // 如果数组越界什么错误都有可能（不止TLE）
int match[N]; // 右边点对应的点（每个妹子现在和谁在一块）
bool st[N]; // 判重，每次不要重复搜一个点

void add(int a, int b) {
    e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}

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] == 0 || find(match[j])) {
                match[j] = x; // 与当前男生配对
                return true;
            }
        }
    }
    return false;
}

int main() {
    scanf("%d%d%d", &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, false, sizeof st);
        if (find(i)) res ++;
    }
    
    printf("%d\n", res);
    
    return 0;
}

图论算法讲完了，后面的数学会着重讲原理和证明
图论着重点在于代码

课后一定要把这几个算法好好写一下

图论题难点在于建图（很难将原题抽象成一个图论题）

一旦抽象出来之后，其实就是默写模版了

能把模版快速写出来就超过70-80%的人了

要掌握模版，需要理解思路再背，还得多写代码

只要在挑战模式的时间限制内将算法写出来，（该模式不能粘贴，纯手打）
该算法基本就没什么问题了，主要是锻炼熟练度
只要熟练度提高了，水平自然就提高了