USACO-Section 4.2 The Perfect Stall （二分图最大匹配[匈牙利算法[DFS]||网络流[Ford-Fulkerson]]）

此处有 目录↑

描述

农夫约翰上个星期刚刚建好了他的新牛棚，他使用了最新的挤奶技术。不幸的是，由于工程问题，每个牛栏都不一样。第一个星期，农夫约翰随便地让奶牛们进入牛栏，但是问题很快地显露出来：每头奶牛都只愿意在她们喜欢的那些牛栏中产奶。上个星期，农夫约翰刚刚收集到了奶牛们的爱好的信息（每头奶牛喜欢在哪些牛栏产奶）。一个牛栏只能容纳一头奶牛，当然，一头奶牛只能在一个牛栏中产奶。

给出奶牛们的爱好的信息，计算最大分配方案。

格式

PROGRAM NAME: stall4

INPUT FORMAT:

(file stall4.in)

第一行 两个整数，N (0 <= N <= 200) 和 M (0 <= M <= 200) 。N 是农夫约翰的奶牛数量，M 是新牛棚的牛栏数量。

第二行到第N+1行 一共 N 行，每行对应一只奶牛。第一个数字 (Si) 是这头奶牛愿意在其中产奶的牛栏的数目 (0 <= Si <= M)。后面的 Si 个数表示这些牛栏的编号。牛栏的编号限定在区间 (1..M) 中，在同一行，一个牛栏不会被列出两次。

OUTPUT FORMAT:

(file stall4.out)

只有一行。输出一个整数，表示最多能分配到的牛栏的数量.

SAMPLE INPUT

5 5
2 2 5
3 2 3 4
2 1 5
3 1 2 5
1 2

SAMPLE OUTPUT

4

解法一：匈牙利算法[DFS] O(nm)

匈牙利算法专门用于部图的匹配，所以速度极快，全部test都是0.00s

大致思路：枚举n头奶牛为起点，若找到一条增广路径（终点为未匹配，且奇数边均不在原匹配中，偶数边均在原匹配中），则答案+1

DFS实现找增广路径：dfs参数是i表示奶牛，枚举奶牛喜欢的牛棚，若牛棚不在当前增广路径中，则将其“纳入”增广路径（不一定出现在增广路径中，失败时不必再除去，因为当前状况下就失败，后面的状况不会更好，算作剪枝），若枚举的牛棚未被占据 或 以占据该牛棚的牛为起点时存在一条增广路径，则将牛棚与当前牛匹配，并返回true，表示成功找到一条增广路径

dfs和bfs找增广路径在稠密图时，速度相差不大，稀疏图时，bfs非常快，dfs差一点，由于dfs简单易懂，所以bfs就放弃了吧

/*
ID: your_id_here
PROG: stall4
LANG: C++
*/
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

int n,m;
int adj[205][205],match[205];//adj[i][k]表示奶牛i喜欢牛棚adj[i][k]，adj[i][0]表示奶牛i喜欢的牛棚的个数
bool onPath[205];//onPath[j]表示牛棚是否在增广路径上；match[j]表示牛棚j被奶牛match[j]占据

bool dfs(int i) {
    int j,k;
    for(k=adj[i][0];k>=1;--k) {
        j=adj[i][k];
        if(!onPath[j]) {//若牛棚j不在本次增广路径上
            onPath[j]=true;
            if(0==match[j]||dfs(match[j])) {//若牛棚j未被占据 或者 有一条以 奶牛match[j]为起点的增广路径
                match[j]=i;//牛棚j被奶牛i占据
                return true;
            }//即使匹配失败，也不需要将onPath[j]重置为false，因为当前状况下就失败，后面的状况不会更好，算是一种剪枝吧
        }
    }
    return false;
}

int hungary() {
    int ans=0;
    memset(match,0,sizeof(match));
    for(int i=1;i<=n;++i) {
        memset(onPath,false,sizeof(onPath));
        if(dfs(i))//若有一条以奶牛i为起点的增广路径
            ++ans;
    }
    return ans;
}

int main() {
    freopen("stall4.in","r",stdin);
    freopen("stall4.out","w",stdout);

    int num;
    memset(adj,0,sizeof(adj));
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i) {
        scanf("%d",&num);
        adj[i][0]=num;
        while(num>0) {
            scanf("%d",&adj[i][num--]);
        }
    }
    printf("%d\n",hungary());

    return 0;
}

解法二：网络流 O(m*n^2)

添加一个源点和汇点，并且源点到每头牛有一条权为1的有向边，每个牛棚到汇点有一条权值为1的有向边，牛到其喜爱的牛棚有1条权值为1的有向边，就转换成源点到汇点的最大网络流了

最慢的test跑了0.043s

/*
ID: your_id_here
PROG: stall4
LANG: C++
*/
#include <cstdio>
#include <cstring>
#include <queue>
#include <algorithm>

using namespace std;

const int INF=0x3f3f3f3f;

int n,m,g[405][405],pre[405];
bool vis[405];

struct Node {
    int pre,u,mn;//u表示当前节点，mn表示从源点到改点的流量上限中最小的

    Node(int ppre=0,int uu=0,int mmn=INF):pre(ppre),u(uu),mn(mmn) {}

    bool operator < (const Node& a) const {
        return mn<a.mn;
    }
}cur;

int bfs(int sta,int des) {//用bfs找到流量最大的一条增广路径，并返回这条增广路径的流量
    memset(vis,false,sizeof(vis));
    priority_queue<Node> q;
    q.push(Node(0,sta));
    while(!q.empty()) {
        do {
            cur=q.top();
            q.pop();
        } while(!q.empty()&&vis[cur.u]);
        if(vis[cur.u])//如果无法到达汇点，返回0
            return 0;

        vis[cur.u]=true;
        pre[cur.u]=cur.pre;
        if(cur.u==des)
            return cur.mn;
        for(int i=1;i<=n;++i) {//枚举可流向的下一个点
            if(!vis[i]&&g[cur.u][i]!=0) {
                q.push(Node(cur.u,i,min(cur.mn,g[cur.u][i])));
            }
        }
    }
    return 0;
}

int Ford_Fulkerson(int sta,int des) {
    int mn,e,ans=0;
    while(mn=bfs(sta,des),mn!=0) {//当可增加的流量不为0时，继续算法
        ans+=mn;
        e=des;
        while(e!=sta) {
            g[pre[e]][e]-=mn;//正向的边减去相应的流量
            g[e][pre[e]]+=mn;//反向的边加上相应的流量
            e=pre[e];
        }
    }
    return ans;
}

int main() {
    freopen("stall4.in","r",stdin);
    freopen("stall4.out","w",stdout);

    int num,e,tot;
    memset(g,0,sizeof(g));
    scanf("%d%d",&n,&m);
    tot=n+m+2;
    for(int i=1;i<=n;++i) {
        g[tot-1][i]=1;//源点为n+m+1
        scanf("%d",&num);
        while(num-->0) {
            scanf("%d",&e);
            g[i][n+e]=1;
        }
    }
    for(int i=n+1;i<=tot-2;++i)
        g[i][tot]=1;//源点为n+m+2
    n=tot;
    printf("%d\n",Ford_Fulkerson(n-1,n));

    return 0;
}