poj 1274 The Perfect Stal - 网络流

二分匹配传送门[here]

原题传送门[here]

---

　　题意大概说一下，就是有N头牛和M个牛棚，每头牛愿意住在一些牛棚，求最大能够满足多少头牛的要求。

　　很明显就是一道裸裸的二分图最大匹配，但是为了练练网络流（做其它的题的时候，神奇地re掉了，于是就写基础题了）的最大流算法，就做做这道题。

　　每一个牛都可一看成是个源点，每一个牛棚都可以看成是个汇点，但是一个网络应该只有一个汇点和一个源点才对，于是构造一个连接每个牛的超级源点，一个连接每个牛棚的超级汇点，每条边的容量为1，然后最大流Dinic算法（其它最大流算法也行）就行了。

Code_{极其不简洁的代码}

/**
 * poj.org
 * Problem#1274
 * Accepted
 * Time:16ms
 * Memory:1980k
 */
#include<iostream>
#include<sstream>
#include<cstdio>
#include<cmath>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<ctime>
#include<queue>
#include<set>
#include<map>
#include<stack>
#include<vector>
#include<algorithm>
using namespace std;
typedef bool boolean;
#define smin(a, b) (a) = min((a), (b))
#define smax(a, b) (a) = max((a), (b))
#define INF 0xfffffff
template<typename T>
inline boolean readInteger(T& u){
    char x;
    int aFlag = 1;
    while(!isdigit((x = getchar())) && x != '-' && ~x);
    if(!(~x))    return false;
    if(x == '-'){
        aFlag = -1;
        x = getchar();
    }
    for(u = x - '0'; isdigit((x = getchar())); u = u * 10 + x - '0');
    ungetc(x, stdin);
    u *= aFlag;
    return true;
}
///map template starts
typedef class Edge{
    public:
        int end;
        int next;
        int cap;
        int flow;
        Edge(const int end = 0, const int next = 0, const int cap = 0, const int flow = 0):end(end), next(next), cap(cap), flow(flow){}
}Edge;

typedef class MapManager{
    public:
        int ce;
        int *h;
        Edge *edge;
        MapManager(){}
        MapManager(int points, int limit):ce(0){
            h = new int[(const int)(points + 1)];
            edge = new Edge[(const int)(limit + 1)];
            memset(h, 0, sizeof(int) * (points + 1));
        }
        inline void addEdge(int from, int end, int cap, int flow){
            edge[++ce] = Edge(end, h[from], cap, flow);
            h[from] = ce;
        }
        inline void addDoubleEdge(int from, int end, int cap){
            addEdge(from, end, cap, 0);
            addEdge(end, from, cap, cap);
        }
        Edge& operator [](int pos){
            return edge[pos];
        }
        inline int reverse(int pos){        //反向边 
            return (pos & 1) ? (pos + 1) : (pos - 1);
        }
        inline void clear(){
            delete[] edge;
            delete h;
            ce = 0;
        }
}MapManager;

#define m_begin(g, i)     (g).h[(i)]
#define m_end(g, i)     (g).edge[(i)].end
#define m_next(g, i)     (g).edge[(i)].next
#define m_cap(g, i)     (g).edge[(i)].cap
#define m_flow(g, i)     (g).edge[(i)].flow
///map template ends

int n, m;
int t;
MapManager g;

inline boolean init(){
    if(!readInteger(n))    return false;
    readInteger(m);
    t = n + m + 1; 
    g = MapManager(t + 1, (n + 1) * (m + 1) * 2);
    for(int i = 1, a, b; i <= n; i++){
        readInteger(a);
        while(a--){
            readInteger(b);
            g.addDoubleEdge(i, b + n, 1);
        }
    }
    for(int i = 1; i <= n; i++)
        g.addDoubleEdge(0, i, 1);
    for(int i = 1; i <= m; i++)
        g.addDoubleEdge(i + n, t, 1);
    return true;
}

boolean *visited;
int* divs;
queue<int> que;

inline boolean getDivs(){
    memset(visited, false, sizeof(boolean) * (t + 1));
    divs[0] = 1;
    visited[0] = true;
    que.push(0);
    while(!que.empty()){
        int e = que.front();
        que.pop();
        for(int i = m_begin(g, e); i != 0; i = g[i].next){
            int& eu = g[i].end;
            if(!visited[eu] && g[i].flow < g[i].cap){
                divs[eu] = divs[e] + 1;
                visited[eu] = true;
                que.push(eu);
            }
        }
    }
    return visited[t];
}

int blockedflow(int node, int minf){
    if(node == t || minf == 0)    return minf;
    int f, flow = 0;
    for(int i = m_begin(g, node); i != 0; i = m_next(g, i)){
        int& e = g[i].end;
        if(divs[e] == divs[node] + 1 && visited[e] && (f = blockedflow(e, min(minf, g[i].cap - g[i].flow))) > 0){
            flow += f;
            g[i].flow += f;
            g[g.reverse(i)].flow -= f;
            minf -= f;
            if(minf == 0)    return flow;
        }
    }
    return flow;
}

inline int maxflow(){
    visited = new boolean[(const int)(t + 1)];
    divs = new int[(const int)(t + 1)];
    int res = 0;
    while(getDivs()){
        res += blockedflow(0, INF); 
    }
    return res;
}

inline void solve(){
    int res = maxflow();
    cout << res << endl;
}

inline void clear(){
    delete[] visited;
    delete[] divs;
    g.clear();
}

int main(){
    while(init()){
        solve();
        clear();
    }
    return 0;
}