POJ1274-The Perfect Stall

裸的二分图匹配问题。
两种做法，第一种是建图转换成最大流流的问题求解，另一种直接用二分图匹配模板。
最大流：

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
#include <algorithm>

using namespace std;

const int maxn = 400 + 5;
const long long INF = 3;

struct edge {
    int to, cap, rev;
};

vector<edge> G[maxn];
int level[maxn];
int iter[maxn];

void add_edge(int from, int to, int cap) {
    G[from].push_back((edge){to, cap, G[to].size()});
    G[to].push_back((edge){from, 0, G[from].size() - 1});
}

void bfs(int s) {
    memset(level, -1, sizeof(level));
    queue<int> q;
    level[s] = 0;
    q.push(s);
    while (!q.empty()) {
        int v = q.front();
        q.pop();
        for (int i = 0; i < G[v].size(); i++) {
            edge &e = G[v][i];
            if (e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                q.push(e.to);
            }
        }
    }
}

int dfs(int v, int t, int f) {
    if (v == t) {
        return f;
    }
    for (int &i = iter[v]; i < G[v].size(); i++) {
        edge &e = G[v][i];
        if (e.cap > 0 && level[v] < level[e.to]) {
            int d = dfs(e.to, t, min(f, e.cap));
            if (d > 0) {
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int Dinic(int s, int t) {
    int flow = 0;
    for ( ; ; ) {
        bfs(s);
        if (level[t] < 0) {
            return flow;
        }
        memset(iter, 0, sizeof(iter));
        int f;
        while ((f = dfs(s, t, INF)) > 0) {
            flow += f;
        }
    }
}

int main() {
    int n, m;
    while (scanf("%d%d", &n, &m) == 2) {
        int s = n + m, t = s + 1;
        for (int i = 0; i < n; i++) {
            int c;
            scanf("%d", &c);
            for (int j = 0; j < c; j++) {
                int stall;
                scanf("%d", &stall);
                add_edge(i, n + stall - 1, 1);
            }
        }
        for (int i = 0; i < n; i++) {
            add_edge(s, i, 1);
        }
        for (int i = 0; i < m; i++) {
            add_edge(n + i, t, 1);
        }
        printf("%d\n", Dinic(s, t));
        for (int i = 0; i < t + 1; i++) {
            G[i].clear();
        }
    }

    return 0;
}

二分图：

#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;

const int maxv = 400 + 5;

int V;
vector<int> G[maxv];
int match[maxv];
bool used[maxv];

void add_edge(int u, int v) {
    G[u].push_back(v);
    G[v].push_back(u);
}

bool dfs(int v) {
    used[v] = true;
    for (int i = 0; i < G[v].size(); i++) {
        int u = G[v][i], w = match[u];
        if (w < 0 || (!used[w] && dfs(w))) {
            match[u] = v;
            match[v] = u;
            return true;
        }
    }
    return false;
}

int Hungarian() {
    int res = 0;
    memset(match, -1, sizeof(match));
    for (int v = 0; v < V; v++) {
        if (match[v] < 0) {
            memset(used, 0, sizeof(used));
            if (dfs(v)) {
                res++;
            }
        }
    }
    return res;
}

int main() {
    int n, m;
    while (scanf("%d%d", &n, &m) == 2) {
        V = n + m;
        for (int i = 0; i < n; i++) {
            int c;
            scanf("%d", &c);
            for (int j = 0; j < c; j++) {
                int stall;
                scanf("%d", &stall);
                add_edge(i, n + stall - 1);
            }
        }
        printf("%d\n", Hungarian());
        for (int i = 0; i < V; i++) {
            G[i].clear();
        }
    }
    return 0;
}