POJ 1149 PIGS (最大流Dinic)

题意：话说一个猪圈管理员，他本身没有猪圈的钥匙。每天会有许多顾客来买猪，这些顾客自己带着某些猪圈的钥匙。每当一个顾客来买猪，这些打开的猪圈里的猪可以随意流动，买完猪之后打开的猪圈全部关闭。现在已知每个猪圈里猪的的数量，每一名顾客拥有的钥匙以及他想购买的猪的数量。求管理员可以卖出的最大数量。

题解：构图是难点在于猪的流动。我是这样想的，假设顾客A可以打开了猪圈1,3,5，他需要购买numA头猪，由于每次被打开的猪圈之间的猪可以自由分配，那么猪圈1,3,5就可以视作一个集合X，当顾客A买完猪之后，集合X剩下的值为X-numA；如果下一次有一位顾客B可以打开猪圈2,4,5，他需要买numB头猪，将2,4,5其视作集合Y。由于X,Y之间有一个公共点5，那么集合Y的最大数量等于Y+X-numA。这样就比较清晰了。所有到达顾客A的流分作两部分，一部分流向汇点（numA）。另一部分流向顾客B（X-numA）。所以从A至B有一条边。
#include <iostream>
using namespace std;

#define MAX 2000
#define INF 999999999
#define min(a,b) (a<b?a:b)

struct Edge
{
int st, ed;
int next;
int flow;
} edge[MAX*10];

bool key[101][1001]; // key[i][j] == true 表示第i名顾客拥有猪圈j的钥匙
int head[MAX], out[MAX];
int que[MAX], stk[MAX];
int leve[MAX], house[MAX];
int E, M, N, src, dest;

void add_edge ( int u, int v, int val )
{
edge[E].st = u;
edge[E].ed = v;
edge[E].flow = val;
edge[E].next = head[u];
head[u] = E++;

edge[E].st = v;
edge[E].ed = u;
edge[E].flow = 0;
edge[E].next = head[v];
head[v] = E++;
}

bool dinic_bfs ()
{
int front, rear, u, v, i;
memset(leve,-1,sizeof(leve));
front = rear = 0;
que[rear++] = src;
leve[src] = 0;
while ( front != ( rear + 1 ) % MAX )
{
u = que[front];
front = ( front + 1 ) % MAX;
for ( i = head[u]; i != -1; i = edge[i].next )
{
v = edge[i].ed;
if ( leve[v] == -1 && edge[i].flow > 0 )
{
leve[v] = leve[u] + 1;
que[rear] = v;
rear = ( rear + 1 ) % MAX;
}
}
}
return leve[dest] >= 0;
}

int Dinic ()
{
int top, u, i;
int maxFlow = 0, minf;
while ( dinic_bfs () )
{
top = 0; u = src;
for ( i = src; i <= dest; i++ )
out[i] = head[i];

while ( out[src] != -1 )
{
if ( u == dest )
{
minf = INF;
for ( i = top - 1; i >= 0; i-- )
minf = min ( edge[stk[i]].flow, minf );

maxFlow += minf;
for ( i = top - 1; i >= 0; i-- )
{
edge[stk[i]].flow -= minf;
edge[stk[i]^1].flow += minf;
if ( edge[stk[i]].flow == 0 ) top = i;
}
u = edge[stk[top]].st;
}
else if ( out[u] != -1 && leve[u] + 1 == leve[edge[out[u]].ed] && edge[out[u]].flow > 0 )
{
stk[top++] = out[u];
u = edge[out[u]].ed;
}
else
{
while ( top > 0 && u != src && out[u] == -1 )
u = edge[stk[--top]].st;
out[u] = edge[out[u]].next;
}
}
}
return maxFlow;
}

int main()
{
scanf("%d%d",&M,&N);
src = E = 0;
dest = M + N + 1;
memset(key,0,sizeof(key));
memset(head,-1,sizeof(head));

int i, j, k, A, B;
for ( i = 1; i <= M; i++ )
{
scanf("%d",&house[i]);
add_edge ( src, i, house[i] );
}

for ( i = 1; i <= N; i++ )
{
scanf("%d",&A);
for ( j = 1; j <= A; j++ )
{
scanf("%d",&k);
key[i][k] = true;
add_edge ( k, i+M, house[k] );
}

for ( j = 1; j < i; j++ ) //枚举第i名顾客之前的顾客
{
for ( k = 1; k <= M; k++ )
if ( key[j][k] && key[i][k] ) //若j,i有相同的钥匙，则可以连接一条从j到i的边，容量为无穷
add_edge ( j+M, i+M, INF );
}

scanf("%d",&B);
add_edge ( i+M, dest, B );
}

printf("%d\n",Dinic());
return 0;
}