二分图最大匹配，最小点覆盖，最小路径覆盖，二分图最大独立集

1） ）数 一个二分图中的最大匹配数等于这个图中的最小点覆盖数
König 定理是一个二分图中很重要的定理，它的意思是，一个二分图中的最大匹配数等于这个图中的最小
点覆盖数。如果你还不知道什么是最小点覆盖，我也在这里说一下：假如选了一个点就相当于覆盖了以它
为端点的所有边，你需要选择最少的点来覆盖所有的边

UVA11419最小点覆盖，打印匹配位置。

#include<bitset>
#include<map>
#include<vector>
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<stack>
#include<queue>
#include<set>
#define inf 0x3f3f3f3f
#define mem(a,x) memset(a,x,sizeof(a))
#define F first
#define S second
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;

inline int in()
{
    int res=0;char c;int f=1;
    while((c=getchar())<'0' || c>'9')if(c=='-')f=-1;
    while(c>='0' && c<='9')res=res*10+c-'0',c=getchar();
    return res*f;
}
const double eps = 1e-8;
const double PI = acos(-1.0);
const int maxn = 1000 + 5;
struct BPM{
    int n,m; //左右顶点个数
    vector<int>G[maxn]; //邻接表
    int left[maxn] ;//left[i] 右边第i个点的匹配点编号，-1不存在
    bool T[maxn]; //右边第i个点是否已标记

    int right[maxn] ;
    bool S[maxn];
    void init(int _n,int _m){
        n = _n; m = _m;
        for(int i=0;i<n;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(){
        mem(left,-1); mem(right,-1);
        int ans =0;
        for(int u=0;u<n;u++){
            mem(S,0); mem(T,0);
            if(match(u)) ans++;
        }
        return ans;
    }
      // 求最小覆盖。X和Y为最小覆盖中的点集
    int mincover(vector<int>& X, vector<int>& Y){
        int ans = solve();
        mem(S,0);mem(T,0);
        for(int u=0;u<n;u++)
            if(right[u] == -1) match(u);// 从所有X未盖点出发增广
        for(int u=0;u<n;u++)
            if(!S[u]) X.push_back(u);// X中的未标记点
        for(int u=0;u<m;u++)
            if(T[u]) Y.push_back(u); // Y中的已标记点
        return ans;
    }
}solver;
int R,C,N;

int main(){
    while(scanf("%d%d%d",&R,&C,&N) == 3&&R &&C &&N){
        solver.init(R,C);
        for(int i=0;i<N;i++){
            int r,c;scanf("%d%d",&r,&c); r--;c--;
            solver.addEdge(r,c);
        }
        vector<int>X,Y;
        int ans = solver.mincover(X,Y);
        printf("%d",ans);
        for(int i=0;i<X.size();i++) printf(" r%d",X[i]+1);
        for(int i=0;i<Y.size();i++) printf(" c%d",Y[i]+1);
        puts("");
    }
    return   0;
}

3） ）集 二分图最大独立集= 顶点数- 二分图最大匹配
独立集：图中任意两个顶点都不相连的顶点集合

独立集和点覆盖正好是互补的。

LA3415最大独立集。

给出一些学生，有一些冲突关系，问最多可以选出多少学生，使得两两之间没有冲突。

分成男女两个集合建立，冲突的建边，形成了二分图。

然后用学生总数 - 二分图最大匹配数就得到了最大独立集数。

#include<bitset>
#include<map>
#include<vector>
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<stack>
#include<queue>
#include<set>
#define inf 0x3f3f3f3f
#define mem(a,x) memset(a,x,sizeof(a))
#define F first
#define S second
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;

inline int in()
{
    int res=0;char c;int f=1;
    while((c=getchar())<'0' || c>'9')if(c=='-')f=-1;
    while(c>='0' && c<='9')res=res*10+c-'0',c=getchar();
    return res*f;
}
const int maxn = 500 + 5;
//邻接矩阵写法
struct BPM{
    int n,m;
    int G[maxn][maxn];
    int left[maxn];
    bool T[maxn];
    void init(int _n,int _m){
        n = _n; m = _m;
        mem(G,0);
    }
    bool match(int u){
        for(int v=0;v<m;v++)
        if(G[u][v] && !T[v]){
            T[v] = true;
            if(left[v] == -1 || match(left[v])){
                left[v] = u;
                return true;
            }
        }
        return false;
    }
    //求最大匹配
    int solve(){
        mem(left,-1);
        int ans = 0;
        for(int u=0;u<n;u++){
            mem(T,0);
            if(match(u)) ans++;
        }
        return ans;
    }


}solver;
struct Student{
    int h;
    string music,sport;
    Student(int _h,string _music,string _sport){
        h = _h; music = _music; sport = _sport;
    }

};
bool conflict(const Student&a,const Student&b){
    return abs(a.h - b.h)<=40&& a.music == b.music &&
    a.sport != b.sport;
    //有一个不满足，就是有冲突，可以建边；
}
int main(){
    int T;
    cin>>T;
    while(T--){
        int n;cin>>n;
        vector<Student> male,female;
        for(int i=0;i<n;i++){
            int h;
            string gender,music,sport;
            cin>>h>>gender>>music>>sport;
            if(gender[0] == 'M')male.push_back(Student(h,music,sport));
            else female.push_back(Student(h,music,sport));

        }
        int x = male.size();
        int y = female.size();
        solver.init(x,y);
        //只去建立有冲突的边，将集合分成男女构造出了二分图。
        //男女之间可能有冲突的情况，进行建边
        for(int i=0;i<x;i++)
            for(int j=0;j<y;j++)
                if(conflict(male[i],female[j])) solver.G[i][j] = 1;
        printf("%d\n",x+y-solver.solve());

    }
    return 0;
}

2） ）｜ 最小路径覆盖＝｜G ｜－最大匹配数
在一个 N*N 的有向图中，路径覆盖就是在图中找一些路经，使之覆盖了图中的所有顶点，且任何一个顶点
有且只有一条路径与之关联；（如果把这些路径中的每条路径从它的起始点走到它的终点，那么恰好可以经
过图中的每个顶点一次且仅一次）；如果不考虑图中存在回路，那么每每条路径就是一个弱连通子集．
由上面可以得出：
1.一个单独的顶点是一条路径；
2.如果存在一路径 p1,p2,......pk，其中 p1 为起点，pk 为终点，那么在覆盖图中，顶点 p1,p2,......pk 不再
与其它的
顶点之间存在有向边．
最小路径覆盖就是找出最小的路径条数，使之成为 G 的一个路径覆盖．
路径覆盖与二分图匹配的关系：最小路径覆盖＝｜G｜－最大匹配数；

最小路径覆盖=总节点数-最大匹配数

LA3126

#include<bitset>
#include<map>
#include<vector>
#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<stack>
#include<queue>
#include<set>
#define inf 0x3f3f3f3f
#define mem(a,x) memset(a,x,sizeof(a))
#define F first
#define S second
using namespace std;

typedef long long ll;
typedef pair<int,int> pii;

inline int in()
{
    int res=0;char c;int f=1;
    while((c=getchar())<'0' || c>'9')if(c=='-')f=-1;
    while(c>='0' && c<='9')res=res*10+c-'0',c=getchar();
    return res*f;
}
const int maxn = 500 + 5;
//邻接矩阵写法
struct BPM{
    int n,m;
    int G[maxn][maxn];
    int left[maxn];
    bool T[maxn];
    void init(int _n,int _m){
        n = _n; m = _m;
        mem(G,0);
    }
    bool match(int u){
        for(int v=0;v<m;v++)
        if(G[u][v] && !T[v]){
            T[v] = true;
            if(left[v] == -1 || match(left[v])){
                left[v] = u;
                return true;
            }
        }
        return false;
    }
    //求最大匹配
    int solve(){
        mem(left,-1);
        int ans = 0;
        for(int u=0;u<n;u++){
            mem(T,0);
            if(match(u)) ans++;
        }
        return ans;
    }


}solver;
int X1[maxn],Y1[maxn],X2[maxn],Y2[maxn],t1[maxn],t2[maxn];
inline int dist(int a,int b,int c,int d){
    return abs(a-c) + abs(b-d);
}
int main(){
    int T;scanf("%d",&T);
    while(T--){
        int n;scanf("%d",&n);
        for(int i=0;i<n;i++){
            int h,m;
            scanf("%d:%d%d%d%d%d",&h,&m,&X1[i],&Y1[i],&X2[i],&Y2[i]);
            t1[i] = h*60+m;
            t2[i] = t1[i] + dist(X1[i],Y1[i],X2[i],Y2[i]);
        }
        solver.init(n,n);
        for(int i=0;i<n;i++)
            for(int j=i+1;j<n;j++)
                if(t2[i] + dist(X2[i],Y2[i],X1[j],Y1[j]) < t1[j])
                    solver.G[i][j] = 1;
        printf("%d\n",n - solver.solve());
    }
}