二分图最大匹配

讲解：

http://www.renfei.org/blog/bipartite-matching.html

（该博客最大独立集）

补充定义和定理：

最大匹配数：最大匹配的匹配边的数目

最小点覆盖数：选取最少的点，使任意一条边至少有一个端点被选择

最大独立数：选取最多的点，使任意所选两点均不相连

最小路径覆盖数：对于一个 DAG（有向无环图），选取最少条路径，使得每个顶点属于且仅属于一条路径。路径长可以为 0（即单个点）。

定理1：最大匹配数 = 最小点覆盖数（这是 Konig 定理）

定理2：最大独立数 = 顶点数 - 最大匹配数 

定理3：最小路径覆盖数 = 顶点数 - 最大匹配数

手工模板：

http://paste.ubuntu.com/12192113/

//#include<bits/stdc++.h>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <cstring>
#include <string>
#include <vector>
#include <cmath>
#include <map>
#include <queue>
#include <stack>
#include <set>
#include <algorithm>

using namespace std;

#define For(i,a,b) for(int (i)=(a);(i) < (b);(i)++)
#define rof(i,a,b) for(int (i)=(a);(i) > (b);(i)--)
#define IOS ios::sync_with_stdio(false)
#define lson l,m,rt <<1
#define rson m+1,r,rt<<1|1
#define mem(a,b) memset(a,b,sizeof(a))

typedef long long ll;
typedef unsigned long long ull;


void RI (int& x){
    x = 0;
    char c = getchar ();
    while (c == ' '||c == '\n')    c = getchar ();
    bool flag = 1;
    if (c == '-'){
        flag = 0;
        c = getchar ();
    }
    while (c >= '0' && c <= '9'){
        x = x * 10 + c - '0';
        c = getchar ();
    }
    if (!flag)    x = -x;
}
void RII (int& x, int& y){RI (x), RI (y);}
void RIII (int& x, int& y, int& z){RI (x), RI (y), RI (z);}

/**************************************END define***************************************/
const int maxn = 2e3+10;//单侧顶点最大数目
const int INF =0x3f3f3f3f;
const int maxm = 2e4+10;
struct Side
{
    int from,to,next;
};
struct BPM{
    int n,m;    //左右n,m个点
    Side side[maxm];
    int top;
    int node[maxn];
    int left[maxn];       // left[i]为右边第i个点的匹配点编号，-1表示不存在
    bool T[maxn];           // T[i]为右边第i个点是否已标记

    /*求最小覆盖点集时用
    int right[maxn];    // right[i]为左边第i个点的匹配点编号，-1表示不存在
    bool S[maxn];       //左边第i个点,被标记为true时:为未盖点
    */

    void init(int nn,int mm)
    {
        n=nn,m=mm;
        top=0;
        mem(node,-1);
    }
    void add_side(int u,int v)
    {
        side[top]=(Side){u,v,node[u]};  node[u]=top++;
    }
    bool dfs(int u){
        /*S[u]=true;*/
        for(int i=node[u];i!=-1;i=side[i].next){
            int v=side[i].to;
            if(!T[v]){
                T[v]=true;
                if(left[v]==-1||dfs(left[v])){
                    left[v]=u;
                    /*right[u]=v;*/
                    return true;
                }
            }
        }
        return false;
    }

    //求最大匹配,匈牙利算法
    int hungarian()
    {
        int ans=0;
        mem(left,-1);
        /*mem(right,-1);*/
        // u 范围为0~n-1
        for(int u=0;u<n;u++){
            /*mem(S,0);*/
            mem(T,0);
            if(dfs(u)) ans++;
        }
        return ans;
    }
    /*
    //求最小覆盖。X和Y为最小覆盖中的点集
    int mincover(vector<int>& X,vector<int>& Y){
        int ans=hungarian();
        mem(S,0);
        mem(T,0);
        for(int u=0;u<n;u++)
            if(right[u]==-1) dfs(u);// 从所有X未盖点出发增广
        for(int u=0;u<n;u++)
            if(!S[u]) X.push_back(u);//S[u]为false为匹配点
        for(int v=0;v<m;v++)
            if(T[v])Y.push_back(v);//T[u]为true为匹配点
        return ans;
    }
    */
};
BPM solver;
int main()
{
    freopen("input.txt","r",stdin);
    int n,m;
    while(~scanf("%d%d",&n,&m)){
        solver.init(n,n);
        while(m--){
            int x,y;
            RII(x,y);
            x--;y--;
            solver.add_side(x,y);
        }
        int ans=solver.hungarian();
        printf("%d\n",ans);
    }

    return 0;
}