acwing----二分图与匈牙利算法

一.什么是二分图？：

引用了这个大佬的话：https://www.acwing.com/solution/content/105874/

       

              有两顶点集且图中每条边的的两个顶点分别位于两个顶点集中，每个顶点集中没有边直接相连接！

 

              说人话的定义：图中点通过移动能分成左右两部分，左侧的点只和右侧的点相连，右侧的点只和左侧的点相连。

 

             下图就是个二分图：

 

 

                如果判断一个图是不是二分图？

                开始对任意一未染色的顶点染色。

                判断其相邻的顶点中，若未染色则将其染上和相邻顶点不同的颜色。

                若已经染色且颜色和相邻顶点的颜色相同则说明不是二分图，若颜色不同则继续判断。

                bfs和dfs可以搞定！

具体例子：

给定一个 n 个点 m 条边的无向图，图中可能存在重边和自环。

请你判断这个图是否是二分图。

输入格式
第一行包含两个整数 n 和 m。

接下来 m 行，每行包含两个整数 u 和 v，表示点 u 和点 v 之间存在一条边。

输出格式
如果给定图是二分图，则输出 Yes，否则输出 No。

数据范围
1≤n,m≤10^5 
输入样例：
4 4
1 3
1 4
2 3
2 4
输出样例：
Yes

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 1e5 + 10, M = 2 * 1e5 + 10;
int e[M], ne[M], h[N], idx = 0; //链表保存;
/* int st[N] */                 //其实不用st[N]，因为color[N]可以计入;
int color[N];
void add(int a, int b)
{
    e[idx] = b, ne[idx] = h[a], h[a] = idx++;
}
bool dfs(int x, int num) // dfs的作用是将x点染色,并把它能到达的点染成不同颜色；
{//x代表正在看的点，num表示要染成的颜色：
    color[x] = num;
    for (int i = h[x]; i != -1; i = ne[i])
    {
        int j = e[i];
        if (!color[j])
        {
            if (!dfs(j, 3 - num))//当前这个点染成1，那邻接的点染成2,正好可以用3-1表示，3-2同理：
                return false;
        }
        else if (color[j] == num) //这说明有相邻的点的颜色相同，即不是二分图
            return false;
    }
    return true;
}
int main()
{
    memset(h, -1, sizeof(h));
    int n, m;
    scanf("%d%d", &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])//即当这个点没有看过
        {
            if (!dfs(i, 1))
            {
                flag = false;
                break;
            }
        }
    }
    if (flag)
        printf("Yes\n");
    else
        printf("No\n");
    return 0;
}

二. 二分图的应用--匈牙利算法

时间复杂度O（n*m）n 为点数，m为边数

   二分图的最大匹配：

接下来我将用y总的“找妹子”的思想表达一下算法的想法:

 如图，我将两个点集分别设为 男，女，他们之间有如上的关系（用线连起来了），用线连起来的男女表示相互之间有好感，

现在我的任务是月老，要最大的使男女之间形成恋爱关系，（当然一定是一男一女才是配对了，不能一对多或多对一）如何作呢？：

以这个图为例：我们只看男生：

第一个男生 (一)他的第一个在意的女生是（2），且这个女生没有与其他男生建立关系，那么我就将他们匹配。

第一个男生匹配完成，接下来看下一个男生（二）,他在意的第一个女生是（1），这个女生也没有与其他男生建立关系，匹配；

第三个男生（三），发现他喜欢的第一个女生（2）以及匹配了，关键来了:

这个时候，男生（三）不会善罢甘休，他会找到与女生（2）匹配的男生（一）商谈一下，看一下男生（一）能否与其他女生去匹配，把女生（2）让给男生（三）。

巧了，男生（一）正好可以与另一个女生（4）匹配，那么这时男生（三）就可以与女生（2）在一起了。

然后男生（四）与女生（3）在一起。

匹配结束，最大匹配为4；

下面给出具体例子：

给定一个二分图，其中左半部包含 n1 个点（编号 1∼n1），右半部包含 n2 个点（编号 1∼n2），二分图共包含 m 条边。

数据保证任意一条边的两个端点都不可能在同一部分中。

请你求出二分图的最大匹配数。

二分图的匹配：给定一个二分图 G，在 G 的一个子图 M 中，M 的边集 {E} 中的任意两条边都不依附于同一个顶点，则称 M 是一个匹配。

二分图的最大匹配：所有匹配中包含边数最多的一组匹配被称为二分图的最大匹配，其边数即为最大匹配数。

输入格式
第一行包含三个整数 n1、 n2 和 m。

接下来 m 行，每行包含两个整数 u 和 v，表示左半部点集中的点 u 和右半部点集中的点 v 之间存在一条边。

输出格式
输出一个整数，表示二分图的最大匹配数。

数据范围
1≤n1,n2≤500,
1≤u≤n1,
1≤v≤n2,
1≤m≤105
输入样例：
2 2 4
1 1
1 2
2 1
2 2
输出样例：
2

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 500 + 10, M = 1e5 + 10;
int e[M], ne[M], h[N], idx = 0;
int match[N]; //表示女生i,与男生match[i]匹配；
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])
        {
            st[j]=true;
            if (match[j] == 0 || find(match[j]))//这里如果match[j]!=0说明这个女生有男生了
               //find(match[j])是为了看一下，match[j]这个男生能否找其他女生,用st[j]记录一下找过女生j了，当match[j]再找时不能找这个女生了
            {
                match[j] = x;
                return true;
            }
        }
    }
    return false;
}
int main()
{
    int n1, n2, m;
    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 ans = 0;
    for (int i = 1; i <= n1; i++)
    {
        memset(st, false, sizeof(st));//必须每一次都初始化为false,这个妹子有男朋友，并不影响当前这个男生去尝试
        if (find(i))
            ans++;
    }
    printf("%d", ans);
    return 0;
}

对st[N]的理解有一位网友的：https://www.acwing.com/user/myspace/index/49357/

disheng  
对于st数组的理解：1.必须要存在，不存在就会出现find无限递归同一个女孩；2.必须每次要全部更新为false，否则男孩无法挖墙脚，从而会得不到最大匹配 (欢迎纠正)

 《二分图染色判断》

 

 

 

 从图的角度看：从集合的角度看：

如果染色失败，即有边的相邻点是同一种颜色，这种情况只有当图中出现奇数环的情况才会出现（奇数环即环的点数是奇数）

上述就是二分图染色的原理，具体运用：257. 关押罪犯

 通过题目描述可知：我们要将冲突大的罪犯尽量分开，十分符合二分图的特点

我们可以通过二分求出最大值mid，然后通过二分图染色，即将边（冲突）权值大于mid的两个点分开，

通过是否能够将全部边（冲突）权值大于mid的两个点分开（即二分图染色是否可以成功）判断这个最大值是否可行；

#include <iostream>
#include <algorithm>
#include <vector>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
const int N = 2 * 1e4 + 5, M = 1e5 + 5;
int n, m;
vector<PII> sides[N];
//-1表示染色为黑色，1表示染色为白色，0表示还没有染色
int color[N];
bool dfs(int x, int s, int mid)
{
    color[x] = s;
    for (int i = 0; i < sides[x].size(); i++)
    {
        int to = sides[x][i].first, w = sides[x][i].second;
        // 判断是否大于mid的都可以被分开
        if (w > mid)
        {
            if (color[to] == 0)
            {
                if (!dfs(to, -s, mid))
                    return false;
            }
            else if (color[to] == s)
                return false;
        }
    }
    return true;
}
bool check(int x)
{
    memset(color, 0, sizeof(color));
    for (int i = 1; i <= n; i++)
    {
        if (color[i] == 0)
            if (!dfs(i, -1, x))
                return false;
    }
    return true;
}
int main()
{
    cin >> n >> m;
    for (int i = 1; i <= m; i++)
    {
        int a, b, c;
        scanf("%d%d%d", &a, &b, &c);
        sides[a].push_back({b, c}), sides[b].push_back({a, c});
    }
    int l = 0, r = 1e9, ans;
    while (l <= r)
    {
        int mid = l + r >> 1;
        if (check(mid))
        {
            r = mid - 1;
            ans = mid;
        }
        else
            l = mid + 1;
    }
    cout << ans;
    return 0;
}

 《最大匹配的运用》

首先在二分图中有结论：二分图最大匹配时，不存在增广路径

所谓增广路径是什么？

 

 这个P就是我们说的增广路径，

M表示已经匹配好的两个点之间的边，在写代码的时候我们都将M设为变量match[]

 

 当前已有边(1,1')和(4,3')属于M

 

然后我们将属于M的路径与不属于M的路径取反，即如下：

 

 发现会有比原先更大匹配数的出现

运用：匈牙利算法

这个算法中的find（）函数即是用来找增广路径并且进行M反转，从而找到最大匹配数的算法

 

 

 

 同时我们发现规律，上面的图中，白格子的x+y必定是偶数，染色的格子x+y必定是奇数

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
typedef pair<int, int> PII;
const int N = 101;
// 记录不能放置格子的位置;
int g[N][N], n, t;
// 记录黑格子匹配的白格子是(x,y)；
PII match[N][N];
// 看在一次匹配中黑格子是否被匹配；
bool st[N][N];
int dy[] = {0, 1, 0, -1}, dx[] = {-1, 0, 1, 0};
bool find(int x, int y)
{
    for (int i = 0; i < 4; i++)
    {
        // 枚举白格子身边的每一个黑格子
        int nx = x + dx[i], ny = y + dy[i];
        if (nx > 0 && nx <= n && ny > 0 && ny <= n && g[nx][ny] == 0 && !st[nx][ny])
        {
            st[nx][ny] = true;
            if ((match[nx][ny].first == 0 && match[nx][ny].second == 0) ||
                find(match[nx][ny].first, match[nx][ny].second))
            {
                match[nx][ny] = {x, y};
                return true;
            }
        }
    }
    return false;
}
int main()
{
    cin >> n >> t;
    for (int i = 1; i <= t; i++)
    {
        // 第 x 行第 y 列
        int x, y;
        scanf("%d%d", &x, &y);
        g[x][y] = 1;
    }
    int ans = 0;
    for (int i = 1; i <= n; i++)
        for (int j = 1; j <= n; j++)
        {
            // 这里是枚举每一个白格子，将其一个一个匹配；
            memset(st, false, sizeof(st));
            if ((i + j) % 2 == 0 && g[i][j] == 0)
                if (find(i, j))
                    ans++;
        }
    cout << ans;
    return 0;
}