二分图匹配模板

匈牙利算法：

typedef long long ll;
const int N = 110;
struct edge
{
    int to, next;
}g[N*N*2];
int cnt, head[N];
int nx, ny, match[N]; //nx,ny分别是左点集和右点集点数
bool vis[N];
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
void add_edge(int v, int u)
{
    g[cnt].to = u, g[cnt].next = head[v], head[v] = cnt++;
}
bool dfs(int v)
{
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(! vis[u])
        {
            vis[u] = true;
            if(match[u] == -1 || dfs(match[u]))
            {
                match[u] = v;
                return true;
            }
        }
    }
    return false;
}
int hungary()
{//点下标从1开始
    int ans = 0;
    memset(match, -1, sizeof match);
    for(int i = 1; i <= nx; i++)
    {
        memset(vis, 0, sizeof vis);
        if(dfs(i)) ans++;
    }
    return ans;
}

hopcroft_karp算法:

//hopcroft_karp算法，复杂度O(sqrt(n)*m)
const int N = 320, INF = 0x3f3f3f3f;
struct edge
{
    int to, next;
}g[N*N];
int match[N], head[N];
bool vis[N];
int p, n;
int nx, ny, cnt, dis; //nx,ny分别是左点集和右点集的点数
int dx[N], dy[N], cx[N], cy[N]; //dx,dy分别维护左点集和右点集的标号
//cx表示左点集中的点匹配的右点集中的点，cy正好相反
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
}
void add_edge(int v, int u)
{
    g[cnt].to = u, g[cnt].next = head[v], head[v] = cnt++;
}
bool bfs() //寻找增广路径集，每次只寻找当前最短的增广路
{
    queue<int> que;
    dis = INF;
    memset(dx, -1, sizeof dx);
    memset(dy, -1, sizeof dy);
    for(int i = 1; i <= nx; i++)
        if(cx[i] == -1) //将未遍历的节点入队，并初始化次节点距离为0
            que.push(i), dx[i] = 0;
    while(! que.empty())
    {
        int v = que.front(); que.pop();
        if(dx[v] > dis) break;
        for(int i = head[v]; i != -1; i = g[i].next)
        {
            int u = g[i].to;
            if(dy[u] == -1)
            {
                dy[u] = dx[v] + 1;
                if(cy[u] == -1) dis = dy[u]; //找到了一条增广路，dis为增广路终点的标号
                else dx[cy[u]] = dy[u] + 1, que.push(cy[u]);
            }
        }
    }
    return dis != INF;
}
int dfs(int v)
{
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(! vis[u] && dy[u] == dx[v] + 1) //如果该点没有被遍历过并且距离为上一节点+1
        {
            vis[u] = true;
            if(cy[u] != -1 && dy[u] == dis) continue; //u已被匹配且已到所有存在的增广路终点的标号，再递归寻找也必无增广路，直接跳过
            if(cy[u] == -1 || dfs(cy[u]))
            {
                cy[u] = v, cx[v] = u;
                return 1;
            }
        }
    }
    return 0;
}
int hopcroft_karp()
{
    int res = 0;
    memset(cx, -1, sizeof cx);
    memset(cy, -1, sizeof cy);
    while(bfs())
    {
        memset(vis, 0, sizeof vis);
        for(int i = 1; i <= nx; i++)
            if(cx[i] == -1) res += dfs(i);
    }
    return res;
}
int main()
{
    int t, a, b;
    scanf("%d", &t);
    while(t--)
    {
        cnt = 0;
        memset(head, -1, sizeof head);
        scanf("%d%d", &p, &n);
        for(int i = 1; i <= p; i++)
        {
            scanf("%d", &a);
            for(int j = 0; j < a; j++)
            {
                scanf("%d", &b);
                add_edge(i, b);//建单向边，跟匈牙利算法基本一样
            }
        }
        nx = p, ny = n;
        if(hopcroft_karp() == p) printf("YES\n");
        else printf("NO\n");
    }
    return 0;
}

二分图最大全匹配：

有N个部队和M个任务（M>=N），每个部队完成每个任务有一点的效率，效率越高越好。但是部队已经安排了一定的计划，需要尽量用最小的变动，使得所有部队效率之和最大。求最小变动的数目与变动后和变动前效率之差。

//点下标从1开始，求最大权匹配，若要求最小权，把边权取反求最大权，答案再取反就是最小权
const int N = 60;
const int INF = 0x3f3f3f3f;
int nx, ny;
int lx[N], ly[N], slack[N], match[N], s[N][N];
bool visx[N], visy[N];
bool hungary(int v)
{
    visx[v] = true;
    for(int i = 1; i <= ny; i++)
    {
        if(visy[i]) continue;
        if(lx[v] + ly[i] == s[v][i])
        {
            visy[i] = true;
            if(match[i] == -1 || hungary(match[i]))
            {
                match[i] = v;
                return true;
            }
        }
        else slack[i] = min(slack[i], lx[v] + ly[i] - s[v][i]);
    }
    return false;
}
void km()
{
    memset(match, -1, sizeof match);
    memset(ly, 0, sizeof ly);
    for(int i = 1; i <= nx; i++) lx[i] = -INF;
    for(int i = 1; i <= nx; i++)
        for(int j = 1; j <= ny; j++)
            lx[i] = max(lx[i], s[i][j]);
    for(int i = 1; i <= nx; i++)
    {
        memset(slack, 0x3f, sizeof slack);
        while(true)
        {
            memset(visx, 0, sizeof visx);
            memset(visy, 0, sizeof visy);
            if(hungary(i)) break;
            else
            {
                int d = INF;
                for(int j = 1; j <= ny; j++)
                    if(!visy[j]) d = min(d, slack[j]);
                for(int j = 1; j <= nx; j++)
                    if(visx[j]) lx[j] -= d;
                for(int j = 1; j <= ny; j++)
                    if(visy[j]) ly[j] += d;
                    else slack[j] -= d;
            }
        }
    }
}
int main()
{
    int n, m;
    while(~ scanf("%d%d", &n, &m))
    {
        for(int i = 1; i <= n; i++)//输入任务矩阵
            for(int j = 1; j <= m; j++)
            {
                scanf("%d", &s[i][j]);
                s[i][j] *= 100;
            }
        int a, tmp = 0;
        for(int i = 1; i <= n; i++) //输入原本第i个部队分配的任务
        {
            scanf("%d", &a);
            tmp += s[i][a];
            s[i][a] += 1;
        }
        nx = n, ny = m;
        km();
        int res = 0;
        for(int i = 1; i <= ny; i++)
            if(match[i] != -1)
                res += s[match[i]][i];
        printf("%d %d\n", n - res % 100, res / 100 - tmp / 100);
    }
    return 0;
}