【图论专题】二分图

二分图匹配的话都是先循环左部点，每一个左部点与所有的右部点匹配

同样放一些yxc老师的讲课笔记

A、AcWing 257. 关押罪犯（二分 + 二分图染色判断）

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

using namespace std;

const int N = 50007, M = 500007;


int n, m;
int color[N];
int ver[M], nex[M], edge[M], head[M], tot;

void add(int x,int y, int z){
    ver[tot] = y;
    edge[tot] = z;
    nex[tot] = head[x];
    head[x] = tot ++ ;
}

bool find(int x, int col, int limit){
    color[x] = col;
    for(int i = head[x];~i;i = nex[i]){
        int y = ver[i], z = edge[i];
        if(z <= limit)continue;//所有大于limit的能建成二分图,那么大于它的都不取,答案也就是limit
        
        if(color[y]){
            if(color[y] == col)return false;//染色失败不存在二分图.
        }
        else if(!find(y, -col, limit))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(!find(i, 1, x))
               return false;
    }
    return true;
}

int main(){
    memset(head,-1,sizeof head);
    scanf("%d%d",&n,&m);
    for(int i = 1; i <= m;++i){
        int x,y,z;
        scanf("%d%d%d",&x,&y,&z);
        add(x,y,z);add(y,x,z);
    }
    
    
    int l = 0, r = 1e9;
    while(l < r){
        int mid = l + r >> 1;
        if(check(mid))r = mid;
        else l = mid + 1;
    }
    printf("%d\n",l);
    return 0;
}

B、AcWing 372. 棋盘覆盖 （二分图最大匹配）

棋盘黑白染色

每一个格子当作一个点，相邻两个格子连一条边，
问最多能取多少条边，并且所选出的边无公共点
偶点
奇点

#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<cstdio>

#define x first
#define y second
using namespace std;

const int N = 507, M = 5007;
typedef pair<int ,int > PII;

int n;
int vis[N][N];
int g[N][N];
PII match[N][N];//存的是坐标为x,y的点匹配的点pair类型的{a,b}
int dx[4] = {0, 1, 0, -1};
int dy[4] = {-1, 0, 1, 0};
int t;

bool find(int x,int y){
    for(int i = 0;i < 4;++i){
            int nx = x + dx[i];
            int ny = y + dy[i];
            if(nx <= 0 || nx > n || ny <= 0 || ny > n || g[nx][ny] || vis[nx][ny])
                continue;
            
            vis[nx][ny] = true;
            PII t = match[nx][ny];
            
            if(t.x == -1 || find(t.x, t.y))//如果对象没有匹配过或者匹配的哥们愿意换
            {
                match[nx][ny] = {x,y};
                return true;//匹配成功,方案数+1
            }
        }
    return false;
}

int main(){
    scanf("%d%d",&n,&t);
    for(int i = 1;i <= t;++i){
        int x,y;
        scanf("%d%d",&x,&y);
        g[x][y] = true;
    }
    
    memset(match, -1, sizeof  match);
    int res = 0;
    
    for(int i = 1;i <= n;++i)
        for(int j = 1;j <= n;++j){
            if((i + j) & 1 && !g[i][j]){
                
                memset(vis,0,sizeof vis);
                if(find(i,j))res ++ ;//如果匹配成功方案+1
            }
        }
    printf("%d\n",res);
    return 0;
}

C、AcWing 376. 机器任务（最小点覆盖问题、最基础的匈牙利模板）

最小点覆盖问题

本题中每一个任务要么在A机器上以$a[i]$执行，要么在B机器上以$b[i]$执行，二者比选其一。
因此我们可以将A机器的N种模式作为N个左部点，机器B的M种模式作为M个右部点，每一个任务以一个无向边连接$a[i]$和$b[i]$，意味着左右两部选一即可。
那么这张图很显然就是一张二分图，我们直接求出它的最小点覆盖，也就是用尽可能少的点覆盖每一条边，既是用尽可能少的点完成所有的任务，也就是用尽量少的模式（等价于最少的重启次数）来完成所有的任务。
因为数据较小，我们可以直接跑一个匈牙利算法求最大匹配数，最大匹配数 = 最小点覆盖

要注意的是由于刚开始两个机器的模式都是0，因此所有可以用模式0完成的任务就可以直接不重启完成，也就是不用加这种的边计算了。
时间复杂度：$O(NM)$

/*最小点覆盖问题*/

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

using namespace std;

const int N = 207, M = 5007;

int n, m, k;
int match[N];
int g[N][N];
bool vis[N];

bool find(int x){
    for(int i= 1;i <= m;++ i){
        if(!vis[i] && g[x][i]){
            vis[i] = true;
            int t = match[i];
            if(t == -1 || find(t)){
                match[i] = x;
                return true;
            }
        }
    }
    return false;
}

int main(){
    while(~scanf("%d%d%d",&n, &m, &k) && n){
        memset(g,0,sizeof g);
        for(int i = 1;i <= k;++ i){
            int t,a,b;
            scanf("%d%d%d",&t, &a,&b);
            if(a == 0 || b == 0)continue;
            g[a][b] = true;
        }
    
        int res = 0;
        memset(match, -1, sizeof match);
        for(int i = 0;i < n;++ i){
            memset(vis,0,sizeof vis);
            if(find(i))
            res ++ ;
        }
        printf("%d\n",res);
    }
    return 0;
}

D、AcWing 378. 骑士放置 （最大独立集）

首先本题建图跟“棋盘覆盖”类似，对棋盘进行黑白染色，黑，白格子分别作为二分图的左右部结点。
若两个棋子是“日”字的对角，则它们之间连边，代表之间有冲突，不能同时存在
我们放一个棋子，就会有一圈的棋子不能放，要最多放多少个，也就是最终每一个放置了棋子的点之间都不能有连边（没有连边就没有冲突），很明显这就是二分图的最大独立集

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#define x first
#define y second
using namespace std;

const int N = 507, M = 5007;

typedef pair<int, int> PII;

int n, m, t;
PII match[N][N];
bool g[N][N];
bool vis[N][N];
int dx[8] = {1, 2, 2, 1, -1, -2, -2, -1};
int dy[8] = {-2, -1, 1, 2, 2, 1, -1, -2};

bool find(int x, int y){
    for(int i = 0;i < 8;++i){
        int a = x + dx[i];
        int b = y + dy[i];
        if(a <= 0 || b <= 0 || a > n || b > m || vis[a][b] || g[a][b])continue;
        vis[a][b] = true;
        PII t = match[a][b];
        if(t.x == -1 || find(t.x, t.y)){
            match[a][b] = {x,y};
            return true;
        }
    }
    return false;
}

int main(){
    scanf("%d%d%d",&n,&m,&t);
    for(int i = 1;i <= t;++i){
        int x,y;
        scanf("%d%d",&x,&y);
        g[x][y] = true;
    }
    
    memset(match, -1, sizeof match);
    
    int res = 0;
    for(int i = 1;i <= n;++i)
    for(int j = 1;j <= m;++j){
        if(i + j & 1 && !g[i][j])//反正就是一半一半
        {
            memset(vis,0,sizeof vis);
            if(find(i, j))res ++ ;
        }
    }

    printf("%d\n",n * m - t - res);
    return 0;
}

E、AcWing 379. 捉迷藏（最小路径可重复覆盖）

最小路径覆盖：针对一个有向无环图(DAG),用最少条互不相交路径，覆盖所有点。（其中互不相交是指点不重复）
结论：最小路径点覆盖（最小路径覆盖） = 总点数 - 最大匹配
证明：
1.建图
求最小路径覆盖用到拆点，一个点分成两个点，分别表示出点和入点，
那么从点i->j的一条边就用，从左边的出点i连到右边的入点j’表示，
于是得到的图是一个二分图，因为所有的边都是在左部和右部之间的，内部没有点。
2.转化
此时将原图中的每一条路径转化到新图中，因为原图中的路径互不相交，所以每一个点最多只有一个出度和入度，
这就意味着在新图中，左部每一个点最多只会向右部连一条边，右部的点最多只会有一条边连入，每个点最多只会属于一条边。
①原图中的一条路径<=>新图中的一组匹配（新图中每一个点最多只会属于一条边）
②原图中每一条路径的终点（没有出边）<=>新图左部的非匹配点
3.推导
求原图中互不相交路径数<=>求路径终点数最少<=>求左部非匹配点最少<=>求最大匹配

拓展：
最小路径重复点覆盖：在最小路径覆盖问题的基础上，去掉互不相交。
结论：记原图G，求传递闭包后的图G’，则G的最小路径重复点覆盖=G’的最小路径覆盖

在该题中，记最小路径重复点覆盖数为cnt，该题的答案就是cnt
证明：
①k<=cnt
这cnt条路径覆盖了所有的点，所以所求的k个点一定要从这cnt条路径中的点选，
并且每条路径上最多选一个点，所以k<=cnt
②k>=cnt
构造：将cnt条路径的终点都放到一个集合E中，记next(E)返回的是从E中的每个点出发能到的所有点的集合
分类讨论：
i)E ∩ next(E) = Ø ，此时E内的点不能相互到达，说明E中所有的点就是一种k=cnt的方案
ii)E ∩ next(E) ≠ Ø ， 对于E中的任何一个点p，让这个点反向走，直到这个点走到一个不在next(E-p)中的点，可证当这个点走到起点时肯定不在next(E-p)中。
反证法：如果这个点走到起点，仍在next(E-p)中，说明p所在的路径的起点可以被其他路径到达，那么这条路径就没有存在的意义可以省去，不满足最小路径重复点覆盖。
所以此时同样可以在每一条路径中选出一个点，使得这些点之间两两不可到达，即k=cnt

/*最小路径可重复覆盖*/
/*传递闭包->最小路径覆盖*/

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

using namespace std;

const int N = 507;
int n,m;
bool g[N][N];
int match[N];
int hide[N];
bool vis[N], succ[N];
int cnt;

bool Find(int x){
    for(int i = 1;i <= n;++i){//n * n
        if(g[x][i] && !vis[i]){
            vis[i] = true;
            int t = match[i];
            if(t == -1 || Find(t)){
                match[i] = x;
                return true;
            }
        }
    }
    return false;
}

int main(){
    scanf("%d%d",&n,&m);
    for(int i = 1;i <= m;++i){
        int x,y;
        scanf("%d%d",&x,&y);
        g[x][y] = true;
    }
    //Floyd
    for(int i = 1; i <= n;++i)//initialization Floyd
        g[i][i] = true;

    for(int k = 1;k <= n;++k)
        for(int i = 1;i <= n;++i)
            for(int j = 1;j <= n;++j)
                g[i][j] |= g[i][k] && g[k][j];

    for(int i = 1;i <= n;++i)//remember to reset
        g[i][i] = false;
    //have the biggest pair in the double graph
    //在拆点二分图上求最大匹配
    int res = 0;
    memset(match, -1, sizeof match);
    for(int i = 1;i <= n;++i){
        memset(vis,0,sizeof vis);
        if(Find(i))
            res ++ ;
    }

    //the first question
    printf("%d\n", n - res);
    int ans = n - res;
    //the second question
    //构造方案，先把所有路径终点（左部非匹配点）作为藏身点
    for(int i = 1;i <= n;++i)
        succ[match[i]] = true;
    for(int i = 1;i <= n;++i)
        if(!succ[i])hide[ ++ cnt] = i;
    memset(vis, 0, sizeof vis);
    bool modify = true;
    while(modify){
        modify = false;
        //求出next(hide)
        for(int i = 1;i <= ans ;++i)
            for(int j = 1;j <= n;++j)
                if(g[hide[i]][j])vis[j] = true;
        for(int i = 1;i <= ans;  ++ i){
            if(vis[hide[i]]){
                modify = true;
                //不断向上移动
                while(vis[hide[i]])
                    hide[i] = match[hide[i]];
            }
        }
    }
    for(int i = 1;i <= ans; ++ i)
        printf("%d\n",hide[i]);
    cout << endl;
    return 0;
}