二分图（最小顶点覆盖、最大匹配、最大独立集）

最新推荐文章于 2024-08-29 16:36:58 发布

逃夭丶

最新推荐文章于 2024-08-29 16:36:58 发布

阅读量972

点赞数

分类专栏： # 图论训练

本文链接：https://blog.csdn.net/qq_43724031/article/details/102920975

版权

图论训练专栏收录该内容

13 篇文章 0 订阅

订阅专栏

本文参考于：https://www.cnblogs.com/czsharecode/p/9777533.html

一、二分图的基本概念

二分图又称为二部图，是图论的一种特殊模型。
设 G=(V,E)是一个无向图，如果顶点 V 可以分割为两个互不相交的子集 (A,B)，并且图中的每条边 (i,j) 所关联的顶点 i 和 j 分别属于这两个不同的顶点集（i in A,j in B) ，则称图 G 为一个二分图。

也就是说，只要这两个点之间有边，那么这两个点就不能同属一个集合，必须分在两边。
这也就带来一个问题，并不是所有的无向图 G 都能转化为二分图。

二、二分图的判定

定理：无向图 G 为二分图的充要条件是，G 至少有两个顶点，且其所有回路的长度均为偶数。
判定方法：根据定义比根据定理更好判断，只需要从第一个点开始，将其染成颜色1，则与其所有相连的所有顶点都染成颜色2，如果与其相连的点已经被染成颜色1，则图G不是二分图。
模板题目：https://www.acwing.com/problem/content/862/
把该点的所有终点当作新的起点，重复以上过程。很显然，既可以用 dfs 染色，有可以用 dfs 染色。

vector<int> G[maxn];  //图
int n,m;  //顶点数
int col[maxn];    //顶点的颜色 1|-1
//把顶点染成1或者-1
bool DFS(int v,int c)
{
    col[v] = c;   //把顶点v染成颜色c
    for(int i=0;i<G[v].size();i++){
        int to = G[v][i];
        //如果相邻顶点同色，则返回false
        if(col[to] == c) return false;
        //如果相邻顶点没有染色，则染成 -c
        if(col[to]==0&&!DFS(to,-c)) return false;
    }
    //如果所有顶点都染过色，就返回true
    return true;
}
bool solve()
{
    for(int i=1;i<=n;i++){
        if(col[i]==0){
            //如果顶点i还没被染色，则染成 1
            if(!DFS(i,1)){
                return false;
            }
        }
    }
    return true;
}

bfs染色代码

int n,m;
vector<int> G[maxn];
int col[maxn] ;
bool bfs(int s)
{
    col[s] = 1;
    queue<int> que;
    que.push(s);
    while(!que.empty()){
        int from = que.front();
        que.pop();
        for(int i=0;i<G[from].size();i++){
            int to = G[from][i];
            if(to==from)    continue;
            // 如果相邻的点没有上色就给这个点上色
            if(col[to]==0){
                que.push(to);
                col[to] = -col[from];
            }
            // 如果相邻的颜色相同则返回false
            if(col[to]==col[from])
                return false;
        }
    }
    // 如果所有的点都被染过色，且相邻的点颜色都不一样，返回true
    return true;
}
bool solve(){
    for(int i=1; i<=n; i++){
        if(col[i] == 0)
            if(!bfs(i)){
                return false;
            }
    }
    return true;
}

二分图的最大匹配

定义：在一个无向图中，定义一条边覆盖的点为这条边的两个端点。
找到一条边集 S 包含最多的边，使得这个边覆盖到所有顶点中的每一个点只被一条边覆盖。 S 的大小叫做图的最大匹配。

通俗地讲，比如说有一场宴会，男孩和女孩跳舞，并且他们必须相互喜欢才能在一起跳舞，一个男孩可能喜欢 0 个或多个女孩，一个女孩也可能喜欢 0 个或多个男孩，但一个男号和他喜欢的女孩跳舞之后就不能和其它他喜欢的女孩跳舞，女孩也是如此。请问最多可以多少对男孩女孩一起跳舞。

很显然，互相喜欢的男孩女孩建边得到一个二分图，求一个一个边集 S 包含最多的边，使得这个边覆盖到所有顶点中的每个顶点只被一条边覆盖，即求二分图的最大匹配。

[匈牙利算法]
把二分图分为 A，B 两个集合，依次枚举 A 中的每个点，尝试在 B 集合中找到一个匹配。

对于一个 A 集合中一个 x，假设 B 集合有一个与其相连的点 y，若 y 暂时还没有匹配点，那么 x 可以和 y 匹配，找到；

否则，设 y 已经匹配到点 z，（显然 z 是 A 集合中的一个点），那么，我们将尝试为 z 找一个除了 y之外的匹配点，若找到，那么 x 可以和 y 匹配，否则 x 和 y 不匹配。

【图解】
我们以下图为例说明匈牙利匹配算法
在这里插入图片描述
st1：从 1 开始，找到右侧的点 4，发现点 4没有被匹配。得到下图：

st2：接下来，从 2 开始，试图在右边找到一个它的匹配点，我们枚举 5，发现 5 还没有被匹配，于是找到了 2 的匹配点为 5，得到如下图：
在这里插入图片描述
st3：接下来，我们找 3 的匹配点。我们枚举了 5，发现 5 已经有了匹配点 2。此时，我们试图找到 2 除 5 以外的另一个匹配点，我们发现，我们可以找到 7，于是 2 可以匹配到 7，所以 5 可以匹配给 3，得到下图：
在这里插入图片描述
此时，结束，我们得到最大匹配为 3。

【算法核心】

每次寻找可以匹配 A 点的一个点 B，如果这个点 B 还没有被匹配，暂时就把这个点 B 当作 A 的匹配点；如果这个 B 在之前已经匹配了 C，那就看 C 能不能匹配除了 B 以外的未匹配点，如果找不到则重复以上过程直到找到或者枚举所有可能点还找不到，结束点A的匹配；如果找到，则把 B 匀给 A（本来 B 是 C 的，现在 C 说我还有其他舞伴，B 就让给 A 了）。这样就能多出一个匹配，相当于找到一条“增广路径”。
【复杂度】
时间复杂度：邻接矩阵：最坏为O(n³)，邻接表：O(nm)
空间复杂度：邻接矩阵：O(n²)，邻接表：O（n+m)

int G[maxn][maxn],mh[maxn];
bool vis[maxn];
int m,n;	// m代表图左边一列，n代表图右边一列
bool dfs(int x)
{
    for(int y=1;y<=n;y++){
        if(G[x][y]==0) continue;
        if(!vis[y]){
            vis[y] = true;
            if(!mh[y]||dfs(mh[y])){
                mh[y] = x;
                return true;
            }
        }
    }
    return false;
}

int ans = 0;
for(int i=1;i<=m;i++){
	memset(vis,false,sizeof(vis));
	if(dfs(i))  ans++;
}

POJ 1469 COURSES
已知，有N个学生和P门课程，每个学生可以选0门，1门或者多门课程，要求在N个学生中选出P个学生使得这P个学生与P门课程一一对应。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cctype>
#include<vector>
#include<stack>
#include<queue>
#include<ctime>
#include<map>
#define ll long long
#define ld long double
#define ull unsigned long long
using namespace std;
const int maxn = 510;
int G[maxn][maxn];
int match[maxn];
bool vis[maxn];
int n,m;
bool dfs(int x)
{
    for(int y=1;y<=m;y++){
        if(G[x][y]==0) continue;
        if(!vis[y]){
            vis[y] = true;
            if(!match[y]||dfs(match[y])){
                match[y] = x;
                return true;
            }
        }
    }
    return false;
}
int main(void)
{
    int t,p;
    scanf("%d",&t);
    for(int k=1;k<=t;k++){
        scanf("%d%d",&m,&n);
        memset(G,0,sizeof(G));
        memset(match,0,sizeof(match));
        int x;
        for(int y=1;y<=m;y++){
            scanf("%d",&p);
            while(p--){
                scanf("%d",&x);
                G[x][y] = 1;
            }
        }
        int ans = 0;
        for(int i=1;i<=n;i++){
            memset(vis,false,sizeof(vis));
            if(dfs(i))  ans++;
        }
        if(ans==m)  printf("YES\n");
        else    printf("NO\n");
    }
    return 0;
}