poj 3281 Dining (最大流)

传送门：http://poj.org/problem?id=3281

 

题意：

  有n头牛，有各自喜欢的食物和饮料。农夫准备了f种食物和d种饮料，每种只有一份，问怎么分配能使最多的牛得到自己喜欢的食物和饮料。

 

思路：

  利用网络流来解决。

  首先是建图，建立一个超级源点S和超级汇点T，S连向所有食物，所有饮料连向T，每头牛连接对应的食物和饮料。这样最原始的图就建完了。但不难发现这样的话一头牛可能可以拿到多份食物饮料，因此将牛的结点拆分成2个，中间连一条容量为1的边，就可以限制最多只能拿一份了。

  之后跑一边最大流就可以了。

 

AC代码：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<cstdlib>
#include<utility>
#include<algorithm>
#include<utility>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<cmath>
#include<map>
#include<ctime>
#include<functional>
#define P pair<int,int>
#define ll long long
#define ull unsigned long long
#define lson id*2,l,mid
#define rson id*2+1,mid+1,r
#define ls id*2
#define rs id*2+1
#define Mod(a,b) a<b?a:a%b+b 
using namespace std;

const int maxn = 100010;
const ll M = 1e9 + 7;
const ll INF = 1e9;
const int N = 510;
const double e = 10e-6;
const int dx[4] = { 0,0,1,-1 }, dy[4] = { 1,-1,0,0 };

struct edge { int to; ll cap; int rev; };
vector<edge>G[N];
int level[N], iter[N];
void addEdge(int from, int to, ll cap)
{
	G[from].push_back(edge{ to,cap,(int)G[to].size() });
	G[to].push_back(edge{ from,0,(int)G[from].size() - 1 });
}
void init()
{
	for (int i = 0; i < N; i++)
		G[i].clear();
}
void bfs(int s)
{
	memset(level, -1, sizeof(level));
	queue<int> que;
	level[s] = 0; que.push(s);
	while (!que.empty()) {
		int v = que.front(); que.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;
				que.push(e.to);
			}
		}
	}
}
ll dfs(int v, int t, ll 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]) {
			ll 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;
}
ll maxFlow(int s, int t)
{
	ll flow = 0;
	while (1) {
		bfs(s);
		if (level[t] < 0) return flow;
		memset(iter, 0, sizeof(iter));
		ll f;
		while ((f = dfs(s, t, INF)) > 0)
			flow += f;
	}
}

int n, f, d, x;

int fid(int id)
{
	return id + 100;
}
int did(int id)
{
	return id + 200;
}
int cid1(int id)
{
	return id + 300;
}
int cid2(int id)
{
	return id + 400;
}

int main() {
	
	int S = 0, T = 1;
	while (~scanf("%d%d%d", &n, &f, &d)) {
		init();
		for (int i = 1; i <= f; i++) 
			addEdge(S, fid(i), 1);
		for (int i = 1; i <= d; i++)
			addEdge(did(i), T, 1);
		for (int i = 1; i <= n; i++) {
			scanf("%d%d", &f, &d);
			addEdge(cid1(i), cid2(i), 1);
			for (int j = 1; j <= f; j++) {
				scanf("%d", &x);
				addEdge(fid(x), cid1(i), 1);
			}
			for (int j = 1; j <= d; j++) {
				scanf("%d", &x);
				addEdge(cid2(i), did(x), 1);
			}
		}
		printf("%lld\n", maxFlow(S, T));
	}
	return 0;
}