最小生成树和二分图

关于最小生成树和二分图的几个算法

关于最小生成树的prim算法和kruskal算法的b站优质视频讲解链接

1 Prim

1.1 Prim算法求最小生成树

问题描述

解题思路

prim 算法干的事情是：给定一个无向图，在图中选择若干条边把图的所有节点连起来。要求边长之和最小。在图论中，叫做求最小生成树。

prim 算法采用的是一种贪心的策略。

每次将离连通部分的最近的点和点对应的边加入的连通部分，连通部分逐渐扩大，最后将整个图连通起来，并且边长之和最小。

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510, INF = 0x3f3f3f3f;

int n, m;
int g[N][N]; //稠密图采用邻接矩阵建图
int dist[N]; // dist数组的含义是第i个到连通块的最短距离
bool st[N];  //判断第i个点是否在连通块中

int prim()
{
    memset(dist, 0x3f, sizeof dist); //初始化dist数组中的每一个点到连通块的距离为正无穷

    int res = 0; // res用来存储当前连通块（最小生成树）中的边权和
    dist[1] = 0; //初始时将1号点加入到连通块中

    for (int i = 0; i < n; i++) //迭代n次
    {
        int t = -1;                  // t是每次迭代需要找的点
        for (int j = 1; j <= n; j++) //通过枚举每一个不在连通块中的点，找到当前点到连通块中距离最短的点
        {
            if (!st[j] && (t == -1 || dist[t] > dist[j]))
                t = j;
        }
        //如果是孤立点，直接返回INF
        if (dist[t] == INF)
            return INF;
        //将点加入到连通块中
        st[t] = true;
        //更新res
        res += dist[t];
        //接下来用新加入的点去更新其他非连通块中的点的dist的值
        for (int j = 1; j <= n; j++)
        {
            if (!st[j] && dist[j] > g[t][j])
                dist[j] = g[t][j];
        }
    }
    // n次迭代后，连通块就是最小生成树，res就是树的边权和
    return res;
}

int main()
{
    cin >> n >> m;
    memset(g, 0x3f, sizeof g);
    while (m--)
    {
        int a, b, w;
        cin >> a >> b >> w;
        //无向图建图时当作有向图来建图
        g[a][b] = min(g[a][b], w);
        g[b][a] = min(g[b][a], w);
    }
    int t = prim();
    if (t == INF)
        puts("impossible");
    else
        cout << t << endl;

    return 0;
}

2 Kruskal

2.1 Kruskal算法求最小生成树

问题描述

解题思路

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 2e5 + 5, INF = 0x3f3f3f3f;

int n, m;
int p[N];

//结构体用于存储每条边的起点终点和权值
struct Edge
{
    int a, b, w;
    //重载小于号运算符，以w来排序
    bool operator<(const Edge &W) const
    {
        return w < W.w;
    }
} edge[N];

int find(int x) //并查集模板
{
    if (p[x] != x)
        p[x] = find(p[x]);
    return p[x];
}

int kruskal()
{
    sort(edge + 1, edge + m + 1); // kruskal算法的第一步以边权来进行排序

    for (int i = 1; i <= n; i++)
        p[i] = i;         //并查集的初始化工作
    int res = 0, cnt = 0; // res表示最小生成树的边权和，cnt表示目前已经连了几条边

    for (int i = 1; i <= m; i++)
    {
        int a = edge[i].a, b = edge[i].b, w = edge[i].w; //提取每条边的各元素

        a = find(p[a]), b = find(p[b]); //并查集求得a和b的祖宗节点

        if (a != b) //如果祖宗节点不同，说明不在一个集合中，不构成环，可以将该点添加进来
        {
            p[a] = b; //将其放到一个集合中
            cnt++;
            res += w;
        }
    }
    if (cnt < n - 1)
        return INF; //如果最终最小生成树的边数小于n-1，说明不能构成最小生成树
    else
        return res;
}

int main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        int a, b, w;
        cin >> a >> b >> w;
        edge[i] = {a, b, w};
    }
    int t = kruskal();

    if (t == INF)
        puts("impossible");
    else
        cout << t << endl;

    return 0;
}

3 染色法判定二分图

3.1 染色法判定二分图

问题描述

解题思路

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 2e5 + 5;

int n, m;
int h[N], ne[N], e[N], idx;
int color[N]; // color数组表示第i个点的颜色，0表示未染色，1和2分别表示不同的颜色

//加边的模板
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 != -1; i = ne[i]) //枚举与该点邻接的所有边
    {
        int j = e[i];
        if (!color[j]) //如果没有被染色
        {
            //将该点染成与u相反的颜色并进行递归
            if (!dfs(j, 3 - c))
                return false;
        }
        //否则如果该点染色了并且与u同色，那么返回false
        else if (color[j] == c)
            return false;
    }
    //都通过就返回true
    return true;
}

int main()
{
    cin >> n >> m;
    memset(h, -1, sizeof h);
    for (int i = 1; i <= m; i++)
    {
        int a, b;
        cin >> a >> b;
        //无向图建图加边
        add(a, b);
        add(b, a);
    }
    //初始化一个flag变量
    bool flag = true;
    for (int i = 1; i <= n; i++) //枚举每一个点
    {
        if (!color[i]) //如果该点未被染色，那么就用dfs染一下
        {
            if (!dfs(i, 1)) //如果对于这个点返回的false，说明产生了矛盾，不是二分图
            {
                flag = false;
                break;
            }
        }
    }

    if (flag)
        puts("Yes");
    else
        puts("No");
    return 0;
}

4.匈牙利算法

4.1 二分图的最大匹配

问题描述

解题思路

这里有一个转载的例子讲解了匈牙利算法的工作流程

AC代码

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 510, M = 100010;

int n1, n2, m;
int h[N], e[M], ne[M], idx;
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)
{
    //遍历与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;
            }
        }
    }
    //最后实在没有办法了，那么就返回false，表示不能配对成功
    return false;
}

int main()
{
    cin >> n1 >> n2 >> m;
    memset(h, -1, sizeof h);
    while (m--)
    {
        int a, b;
        cin >> a >> b;
        //无向图建图加边
        add(a, b);
    }
    int res = 0;
    for (int i = 1; i <= n1; i++) //枚举每一个男孩
    {
        memset(st, false, sizeof st); //每次枚举一个男孩时都要初始化女孩，让每个女孩都没有被预定
        if (find(i))
            res++; //每成功配对一组，答案数+1
    }
    cout << res << endl;
    return 0;
}