二分图匹配

对于二分图匹配的理解

我用的是匈牙利算法 网络流什么的太变态了好吗

想学习网络流的去这个博客 我的人生导师的博客

首先匹配就是找对象（你要牵线）

二分图一般是找最大匹配（牵最多的红线）

因为有增广路的性质我们可以知道：反选一条增广路可以多一个匹配（就是优先给新人牵线不惜打散旧情侣，可以保证cp数量最多）

不多说直接上代码，二分图匹配的考点一般不在这里，后面会提到

#include<iostream>
#include<cstring>
#include<vector>
using namespace std;
const int maxn = 1010;
int na,nb,nr;
bool used[maxn];
int mb[maxn];
vector<int>G[maxn];

bool match(int u){//给u找cp
    for(int j = 0;j < G[u].size();j++){
        int v = G[u][j];
        if(used[v] == false){
            used[v] = true;
            if(mb[v] == 0 || match(mb[v])){//v还没cp旧直接牵了，v有cp就看看能不能换cp使u和v是cp【一个递归的过程】
                mb[v] = u;
                return true;
                }
            }
        }
    return false;
    }
int main(){
    cin>>na>>nb>>nr;
    int u,v;
    for(int i = 1;i <= nr;i++){
        cin>>u>>v;
        if(v > nb)continue;
        G[u].push_back(v);
        }
    int ans = 0;
    for(int i = 1;i <= na;i++){
        memset(used,0,sizeof(used));//一定不要忘记这个！！！！
        if(match(i))ans += 1;
        }
    cout<<ans<<endl;
    return 0;
    }

P2756 飞行员配对方案问题

板题，这里就不给代码了

二分图匹配的真正考点

板子大家都会，所以不会只考板子的，二分图匹配的重点是建图

P1129 [ZJOI2007]矩阵游戏

题目描述

小Q是一个非常聪明的孩子，除了国际象棋，他还很喜欢玩一个电脑益智游戏――矩阵游戏。矩阵游戏在一个N*N黑白方阵进行（如同国际象棋一般，只是颜色是随意的）。每次可以对该矩阵进行两种操作：

行交换操作：选择矩阵的任意两行，交换这两行（即交换对应格子的颜色）

列交换操作：选择矩阵的任意两列，交换这两列（即交换对应格子的颜色）

游戏的目标，即通过若干次操作，使得方阵的主对角线(左上角到右下角的连线)上的格子均为黑色。

对于某些关卡，小Q百思不得其解，以致他开始怀疑这些关卡是不是根本就是无解的！！于是小Q决定写一个程序来判断这些关卡是否有解。

输入输出格式

输入格式：
第一行包含一个整数T，表示数据的组数。

接下来包含T组数据，每组数据第一行为一个整数N，表示方阵的大小；接下来N行为一个N*N的01矩阵（0表示白色，1表示黑色）。

输出格式：
包含T行。对于每一组数据，如果该关卡有解，输出一行Yes；否则输出一行No。

---

好了核心考点来了：建图

通俗的来讲，怎么建立对应关系呢？（怎么知道哪两个（狗）男女可以被牵线呢？）

其实吧也没有什么卵方法、、、做题做多了才有感觉。。

我们要对题目进行具体分析：

首先最终状态肯定是有n个点满足行序号 == 列序号

即最终状态是（1,1）（2，2）...(n,n)都有一个点

我们把点看成匹配边的话，就是每行和每列都做到了匹配

原图中的行序号我们记为i，我们期望得到的图中的行序号记为j

枚举原图中的行i，如果在我们期望的图中它放到第j行是合法的（对角线为黑子即为a[i][j]=true）

那就让j--i连一条边

这样我们就得到了一个二分图

所以剩下的就是裸二分图匹配了

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
const int maxn = 2100;
int len,nask;
vector<int>G[maxn];//
bool used[maxn];//
int mat[maxn];//
int map[maxn][maxn];//

bool match(int x){
    for(int j = 0;j < G[x].size();j++){
        int v = G[x][j];
        if(used[v] == false){
            used[v] = true;
            if(mat[v] == 0 || match(mat[v])){
                mat[v] = x;
                return true;
                }
            }
        }
    return false;
    }

int main(){
    cin>>nask;
    for(int t = 1;t <= nask;t++){
        cin>>len;
        //初始化！！！！！
        int ans = 0;
        for(int i = 1;i <= maxn;i++){G[i].clear();}
        memset(mat,0,sizeof(mat));
        memset(map,0,sizeof(map));
        
        for(int i = 1;i <= len;i++){
            for(int j = 1;j <= len;j++){
                cin>>map[i][j];
                }
            }//图的输入
        for(int i = 1;i <= len;i++){
            for(int j = 1;j <= len;j++){
                if(map[i][j] == 1){
                    G[j].push_back(i);
                    }
                }
            }
        for(int j = 1;j <= len;j++){
            memset(used,false,sizeof(used));
            if(match(j)){
                ans++;
                }
            }
        if(ans == len)cout<<"Yes"<<endl;
        else cout<<"No"<<endl;
        }
    return 0;
    }

P2055 [ZJOI2009]假期的宿舍

题目描述

学校放假了 · · · · · · 有些同学回家了，而有些同学则有以前的好朋友来探访，那么住宿就是一个问题。比如 A 和 B 都是学校的学生，A 要回家，而 C 来看B，C 与 A 不认识。我们假设每个人只能睡和自己直接认识的人的床。那么一个解决方案就是 B 睡 A 的床而 C 睡 B 的床。而实际情况可能非常复杂，有的人可能认识好多在校学生，在校学生之间也不一定都互相认识。我们已知一共有 n 个人，并且知道其中每个人是不是本校学生，也知道每个本校学生是否回家。问是否存在一个方案使得所有不回家的本校学生和来看他们的其他人都有地方住。

输入输出格式

输入格式：
第一行一个数 T 表示数据组数。接下来 T 组数据，每组数据第一行一个数n 表示涉及到的总人数。接下来一行 n 个数，第 i 个数表示第 i 个人是否是在校学生 (0 表示不是，1 表示是)。再接下来一行 n 个数，第 i 个数表示第 i 个人是否回家 (0 表示不回家，1 表示回家，注意如果第 i 个人不是在校学生，那么这个位置上的数是一个随机的数，你应该在读入以后忽略它)。接下来 n 行每行 n 个数，第 i 行第 j 个数表示 i 和 j 是否认识 (1 表示认识，0 表示不认识，第 i 行 i 个的值为 0，但是显然自己还是可以睡自己的床)，认识的关系是相互的。

输出格式：
对于每组数据，如果存在一个方案则输出 “^_”(不含引号) 否则输出“T_T”(不含引号)。(注意输出的都是半角字符，即三个符号的 ASCII 码分别为94,84,95)

---

考点也是建图：把需要床的人和能用的床连一条边，最后枚举需要床的人，若 需要人数 == 最大匹配数 ，则所有人都有床睡

#include<iostream>
#include<vector>
#include<cstring>
using namespace std;
const int maxn = 1000100;
int num,T;
vector<int>G[maxn];
int mat[maxn];
bool used[maxn];
bool stu[maxn];
bool unneed[maxn];

bool match(int x){
    for(int j = 0;j < G[x].size();j++){
        int v = G[x][j];
        if(used[v] == false){
            used[v] = true;
            if(mat[v] == 0 || match(mat[v])){
                mat[v] = x;
                return true;
                }
            }
        }
    return false;
    }
    

int main(){
    cin>>T;
    while(T--){
        //初始化！！！
        cin>>num;
        memset(mat,0,sizeof(mat));
        memset(stu,false,sizeof(stu));
        memset(unneed,false,sizeof(unneed));
        for(int i = 1;i <= num;i++){G[i].clear();}
        int ans = 0,cnt = 0;
        int a;
        
        for(int i = 1;i <= num;i++){
            cin>>a;
            if(a == 1){stu[i] = true;}//有床位
            else{cnt++;}
            }
        
        for(int i = 1;i <= num;i++){
            cin>>a;
            if(stu[i] == true){
                if(a == 1){unneed[i] = true;}//不需要的打个标记
                else cnt++;//需要的话记个数
                }
            
            }
        
        for(int i = 1;i <= num;i++){
            for(int j = 1;j <= num;j++){
                cin>>a;
                if(i == j && stu[i] == true){
                    G[i].push_back(j);
                    }
                if(a == 1 && stu[j] == true){
                    G[i].push_back(j);//如果是朋友且有床位
                    }
                }
            }
        for(int i = 1;i <= num;i++){
            if(unneed[i] == false){
                memset(used,false,sizeof(used));
                if(match(i)){
                    ans++;
                    }
                }
            }
        if(ans == cnt){cout<<"^_^"<<endl;}
        else cout<<"T_T"<<endl;
        }
    return 0;
    }

P1640 [SCOI2010]连续攻击游戏

题目描述

lxhgww最近迷上了一款游戏，在游戏里，他拥有很多的装备，每种装备都有2个属性，这些属性的值用[1,10000]之间的数表示。当他使用某种装备时，他只能使用该装备的某一个属性。并且每种装备最多只能使用一次。游戏进行到最后，lxhgww遇到了终极boss，这个终极boss很奇怪，攻击他的装备所使用的属性值必须从1开始连续递增地攻击，才能对boss产生伤害。也就是说一开始的时候，lxhgww只能使用某个属性值为1的装备攻击boss，然后只能使用某个属性值为2的装备攻击boss，然后只能使用某个属性值为3的装备攻击boss……以此类推。现在lxhgww想知道他最多能连续攻击boss多少次？

输入输出格式

输入格式：
输入的第一行是一个整数N，表示lxhgww拥有N种装备接下来N行，是对这N种装备的描述，每行2个数字，表示第i种装备的2个属性值

输出格式：
输出一行，包括1个数字，表示lxhgww最多能连续攻击的次数。

---

同理我们思考怎么建图：因为需要连续攻击，二每个武器只能用一遍，所以我们把武器属性和武器序号连边，保证了每个序号只能用一次，然后将攻击值从1开始枚举，进行二分图匹配，直到不能连续攻击或者武器已用完为止

#include<iostream>
#include<vector>
using namespace std;
const int maxn = 1000100;
int num;
vector<int>G[maxn];
int mat[maxn];
bool used[maxn];

bool match(int x){
    for(int j = 0;j < G[x].size();j++){
        int v = G[x][j];
        if(used[v] == false){
            used[v] = true;
            if(mat[v] == 0 || match(mat[v])){
                mat[v] = x;
                return true;
                }
            }
        }
    return false;
    }
    

int main(){
    cin>>num;
    int a,b;
    for(int i = 1;i <= num;i++){
        cin>>a>>b;
        G[a].push_back(i);
        G[b].push_back(i);
        }
    for(int i = 1;i <= num;i++){
        if(!match(i)){
            cout<<i - 1<<endl;
            return 0;
            }
        }
    cout<<num<<endl;
    return 0;
    }

多个集合的匹配

P1402 酒店之王

题目描述

XX酒店的老板想成为酒店之王，本着这种希望，第一步要将酒店变得人性化。由于很多来住店的旅客有自己喜好的房间色调、阳光等，也有自己所爱的菜，但是该酒店只有p间房间，一天只有固定的q道不同的菜。

有一天来了n个客人，每个客人说出了自己喜欢哪些房间，喜欢哪道菜。但是很不幸，可能做不到让所有顾客满意（满意的条件是住进喜欢的房间，吃到喜欢的菜）。

这里要怎么分配，能使最多顾客满意呢？

输入输出格式

输入格式：
第一行给出三个正整数表示n,p,q(<=100)。

之后n行，每行p个数包含0或1，第i个数表示喜不喜欢第i个房间（1表示喜欢，0表示不喜欢）。

之后n行，每行q个数，表示喜不喜欢第i道菜。

输出格式：
最大的顾客满意数。

---

介绍一下一集合匹配多集合的匈牙利做法

匈牙利算法的核心在于找增广路，那么同理，我们跑两次匈牙利，若同时满足找到增广路则ans += 1;

不过注意：因为判断函数不是同时进行的而是顺序进行 (【if(a && b)】是先判断a，不成立就直接不运行下面的，然后不判断b的) 的，所以满足第一个集合找到增广路不代表第二个集合有增广路，所以我们需要对前一步的状态做一个保存，如果最终不满足条件则恢复为之前的状态

#include<iostream>
#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
int RD(){
    int out = 0,flag = 1;char c = getchar();
    while(c < '0' || c >'9'){if(c == '-')flag = -1;c = getchar();}
    while(c >= '0' && c <= '9'){out = out * 10 + c - '0';c = getchar();}
    return flag * out;
    }
const int maxn = 119;
int num,numr,numf;
int room[maxn][maxn],food[maxn][maxn];
int matr[maxn],matf[maxn];
int tmatr[maxn];
bool used[maxn];
bool vis[maxn];

bool matchr(int x){//两个集合分别找增广路
    for(int i = 1;i <= num;i++){
        if(room[x][i]){
            if(used[i] == false){
                used[i] = true;
                if(matr[i] == 0 || matchr(matr[i])){
                    matr[i] = x;//注意：第二个函数还没运行时这里的数据就已经修改了
                    return true;
                    }
                }
            }
        }
    return false;
    }
    
bool matchf(int x){//两个集合分别找增广路
    for(int i = 1;i <= num;i++){
        if(food[x][i]){
            if(vis[i] == false){
                vis[i] = true;
                if(matf[i] == 0 || matchf(matf[i])){
                    matf[i] = x;
                    return true;
                    }
                }
            }
        }
    return false;
    }

int main(){
    int ans = 0;
    num = RD();numr = RD();numf = RD();
    for(int i = 1;i <= num;i++){
        for(int j = 1;j <= numr;j++){
            room[i][j] = RD();
            }
        }
    for(int i = 1;i <= num;i++){
        for(int j = 1;j <= numf;j++){
            food[i][j] = RD();
            }
        }
        for(int i = 1;i <= num;i++){
                memset(used,false,sizeof(used));
                memset(vis,false,sizeof(vis));//记得初始化
                for(int j = 1;j <= num;j++){
                    tmatr[j] = matr[j];//保存数据
                    }
                if(matchr(i) && matchf(i)){//这里是先后运行两个函数的
                    ans++;
                    continue;
                    }
                for(int j = 1;j <= num;j++){
                    matr[j] = tmatr[j];//不满足就复原改变了的
                    }
                }
    cout<<ans<<endl;
    return 0;
    }