UVa——11419（二分图最大匹配——二分图最小覆盖——构造最小覆盖的解）

题目链接：https://vjudge.net/problem/UVA-11419

白书上二分图匹配很经典的一道题，相似模型都可以向这个建模方向思考。将每一行和每一列作为一个节点，如果某一行与某一列的交点处是目标，则将这一行与这一列建边，我们的目标就转换成将这么多条边用最少的端点覆盖掉，也就是每个边至少有一个端点被选择，而且最终答案是最小的点。所以这很明显是二分图最小覆盖模型，可以证明二分图最小覆盖数等于二分图最大匹配数，调用匈牙利算法或者更快的HK算法就可以直接得到解。

但是这个题还有个比较坑的地方，就是输出解的问题，因为我们只得到了匹配关系，比如r1,r2,r3都与c1有点，那么我们调用算法之后只能得到他们的匹配关系，但标准答案肯定是只输出c1，我们该怎么输出呢？

二分图最小覆盖解的构造：还需要借助我们之前已经完成的匈牙利树，从左端点未被覆盖的点出发，遍历匈牙利树（就是代码中match函数的功能，也是扩展增广路），标记沿途的所有点，则所有X中未被标记的点和Y中所有标记的点，就组成了一个二分图的最小覆盖集。如果要看为什么的话，看这里：https://www.cnblogs.com/xcw0754/p/4738688.html我觉得说的很不错，就不发表自己的愚见了~

代码：匈牙利算法

#include <cstdio>
#include <string>
#include <cstring>
#include <queue>
#include <algorithm>
#include <iostream>
using namespace std;

const int maxn = 1000 + 5;

struct BPM{
    int n,m;
    vector<int > G[maxn];
    int left[maxn];
    bool T[maxn];

    int right[maxn];
    bool S[maxn];

    void init(int n,int m){
        this -> n = n;
        this -> m = m;
        for(int i = 0;i < maxn;i++) G[i].clear();
    }

    void AddEdge(int u,int v){
        G[u].push_back(v);
    }

    bool match(int u){
        S[u] = true;
        for(int i = 0;i < G[u].size();i++){
            int v = G[u][i];
            if(!T[v]){
                T[v] = true;
                if(left[v] == -1 || match(left[v])){
                    left[v] = u;
                    right[u] = v;
                    return true;
                }
            }
        }
        return false;
    }

    int solve(){
        memset(left,-1,sizeof(left));
        memset(right,-1,sizeof(right));
        int ans = 0;
        for(int u = 0;u < n;u++){
            memset(S,0,sizeof(S));
            memset(T,0,sizeof(T));
            if(match(u))    ans++;
        }
        return ans;
    }

    int mincover(vector<int>& X,vector<int>& Y){
        int ans = solve();
        memset(S,0,sizeof(S));
        memset(T,0,sizeof(T));
        for(int u = 0;u < n;u++)
            if(right[u] == -1)  match(u);
        for(int u = 0;u < n;u++)
            if(!S[u])   X.push_back(u);
        for(int v = 0;v < n;v++)
            if(T[v])   Y.push_back(v);
        return  ans;
    }
};

BPM solver;

int main(){
    int n,r,c;

    while(scanf("%d%d%d",&r,&c,&n)){
        if(r == 0 && c == 0 && n == 0)  break;
        solver.init(r,c);
        while(n--){
            int x,y;
            scanf("%d%d",&x,&y);x--;y--;//模版中编号是从0开始的
            solver.AddEdge(x,y);
        }
        vector<int> X,Y;
        printf("%d",solver.mincover(X,Y));
        for(int i = 0;i < X.size();i++)
            printf(" r%d",X[i]+1);//最后别忘了加回来
        for(int j = 0;j < Y.size();j++)
            printf(" c%d",Y[j]+1);
        printf("\n");
    }
    return 0;
}