poj 3281 Dining（最大流）

poj 3281 Dining

Description

Cows are such finicky eaters. Each cow has a preference for certain foods and drinks, and she will consume no others.

Farmer John has cooked fabulous meals for his cows, but he forgot to check his menu against their preferences. Although he might not be able to stuff everybody, he wants to give a complete meal of both food and drink to as many cows as possible.

Farmer John has cooked F (1 ≤ F ≤ 100) types of foods and prepared D (1 ≤ D ≤ 100) types of drinks. Each of his N (1 ≤ N ≤ 100) cows has decided whether she is willing to eat a particular food or drink a particular drink. Farmer John must assign a food type and a drink type to each cow to maximize the number of cows who get both.

Each dish or drink can only be consumed by one cow (i.e., once food type 2 is assigned to a cow, no other cow can be assigned food type 2).

Input

Line 1: Three space-separated integers: N, F, and D

Lines 2.. N+1: Each line i starts with a two integers Fi and Di, the number of dishes that cow i likes and the number of drinks that cow i likes. The next Fi integers denote the dishes that cow i will eat, and the Di integers following that denote the drinks that cow i will drink.

Output

Line 1: A single integer that is the maximum number of cows that can be fed both food and drink that conform to their wishes

Sample Input

4 3 3

2 2 1 2 3 1

2 2 2 3 1 2

2 2 1 3 1 2

2 1 1 3 3

Sample Output

3

题目大意：有n头牛，F种食物，D种饮品。每种牛都有自己的喜好（只吃第i种食物，吃第j种饮品）。问，最多有多少只牛可以吃到自己喜欢的食物和饮品。

解题思路：重点在拆点。一开始一直想要怎么拆食物和饮品，后来发现不管怎么拆都有漏洞，最后还是去看了别人的题解，才知道是拆牛的点。拆成 食物?1?牛?1?牛?饮品。最后求最大流就行了。

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <cstdlib>
#include <queue>
using namespace std;

const int N = 1005;
const int INF = 0x3f3f3f3f;
const int OF = 100;
const int OOF = 300;
const int FIN = 500;
typedef long long ll;
int n, F, D, s, t;
struct Edge{
    int from, to, cap, flow;
};

vector<Edge> edges;
vector<int> G[N];

void init() {
    s = 0, t = FIN;
    for (int i = 0; i < n * (n / 2); i++) G[i].clear();
    edges.clear();
}

void addEdge(int from, int to, int cap, int flow) {
    edges.push_back((Edge){from, to, cap, 0});
    edges.push_back((Edge){to, from, 0, 0});
    int m = edges.size();
    G[from].push_back(m - 2);
    G[to].push_back(m - 1);
}
void input() {
    scanf("%d %d %d", &n, &F, &D);
    for (int i = 1; i <= n; i++) {
        addEdge(i, i + OOF, 1, 0);
    }
    for (int i = 1; i <= F; i++) {
        addEdge(0, i + OF, 1, 0);
    }
    for (int i = 1; i <= D; i++) {
        addEdge(i + 2 * OF, t, 1, 0);
    }
    int a, b, c;
    for (int i = 1; i <= n; i++) {
        scanf("%d %d", &a, &b);
        for (int j = 0; j < a; j++) {
            scanf("%d", &c);
            addEdge(c + OF, i, 1, 0);
        }
        for (int j = 0; j < b; j++) {
            scanf("%d", &c);
            addEdge(i + OOF, c + 2 * OF, 1, 0);
        }
    }
}
int vis[N], d[N];
int BFS() {
    memset(vis, 0, sizeof(vis));
    queue<int> Q;
    Q.push(s);
    d[s] = 0;
    vis[s] = 1;
    while (!Q.empty()) {
        int u = Q.front(); Q.pop();
        for (int i = 0; i < G[u].size(); i++) {
            Edge &e = edges[G[u][i]];
            if (!vis[e.to] && e.cap > e.flow) {
                vis[e.to] = 1;
                d[e.to] = d[u] + 1;
                Q.push(e.to);
            }
        }
    }
    return vis[t];
}

int cur[N];
int DFS(int u, int a) {
    if (u == t || a == 0) return a;
    int flow = 0, f;
    for (int &i = cur[u]; i < G[u].size(); i++) {
        Edge &e = edges[G[u][i]];
        if (d[u] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > 0) {
            e.flow += f;
            edges[G[u][i]^1].flow -= f;
            flow += f;
            a -= f;
            if (a == 0) break;
        }
    }
    return flow;
}
int MF() {
    int ans = 0;
    while (BFS()) {
        memset(cur, 0, sizeof(cur));
        ans += DFS(s, INF);
    }
    return ans;
}
int main() {
    init();
    input();
    printf("%d\n", MF());
    return 0;
}

版权声明：本文为博主原创文章，未经博主允许不得转载。