POJ 1149 PIGS（网络流）

第一想法是以猪圈为节点建图，但是这样点数过多，而且无法控制顺序。

看到消费者数量很少，想办法以这个为节点建图。

建图方法为，用pre[i]记录最近一个可以访问第i猪圈的消费者是哪个。

处理每个消费者时，对于他能打开的每个猪圈i，都查询pre[i]，如果之前没有，就从原点连一条边到这个人，容量为猪圈i初始猪数（从该猪圈最多取这么多）。

如果之前有，pre[i]=k，那么连一条k到当前人的边，容量为无穷，因为第k人可以不拿，并且把所有自己能拿的猪圈中的猪都放到第i猪圈中，让当前人拿，这就是无穷的意义。

最后连一条当前人到汇点，流量为当前人购买力的边。

代码：

#include <iostream>
#include <cstdio>
#include <cstring>
using namespace std;
#include <vector>
#include <algorithm>
#include <queue>
#define maxn 500
#define maxm 1000
#define INF 10000000
int N,M,s,t;
int a[1005];
int pre[1005];
struct Edge{
	int from,to,cap,flow;
	Edge(){}
	Edge(int s,int t,int c,int f):from(s),to(t),cap(c),flow(f){}
};

vector <Edge> edges;
vector <int> G[maxn];
bool vis[maxn];
int d[maxn];
int cur[maxn];

void init(){
	edges.clear();
	for(int i=0;i<=N;i++){
		G[i].clear();
	}
}

void addedge(int from,int to,int cap){
	edges.push_back(Edge(from,to,cap,0));
	edges.push_back(Edge(to,from,0,0));
	M=edges.size();
	G[from].push_back(M-2);
	G[to].push_back(M-1);
}

bool bfs(){
	memset(vis,0,sizeof(vis));
	queue<int> Q;
	Q.push(s);
	d[s]=0;
	vis[s]=1;
	while(!Q.empty()){
		int x=Q.front();Q.pop();
		for(int i=0;i<G[x].size();i++){
			Edge &e=edges[G[x][i]];
			if(!vis[e.to]&&e.cap>e.flow){
				vis[e.to]=1;
				d[e.to]=d[x]+1;
				Q.push(e.to);
			}
		}
	}
	return vis[t];
}

int dfs(int x,int a){
	if(x==t||a==0) return a;
	int flow=0,f;
	for(int &i=cur[x];i<G[x].size();i++){
		Edge &e=edges[G[x][i]];
		if(d[x]+1==d[e.to]&&(f=dfs(e.to,min(a,e.cap-e.flow)))>0){
			e.flow+=f;
			edges[G[x][i]^1].flow-=f;
			flow+=f;
			a-=f;
			if(a==0) break;
		}
	}
	return flow;
}


int Maxflow(){
	int flow=0;
	while(bfs()){
		memset(cur,0,sizeof(cur));
		flow+=dfs(s,INF);
	}
	return flow;
}

int main(){
	memset(pre,-1,sizeof(pre));
	int n,m;
	scanf("%d%d",&m,&n);
	N=n;
	init();
	s=0;t=N+1;
	for(int i=1;i<=m;i++){
		scanf("%d",&a[i]);
	}
	for(int i=1;i<=n;i++){
		int k;
		scanf("%d",&k);
		for(int j=0;j<k;j++){
			int cur;
			scanf("%d",&cur);
			if(pre[cur]==-1){
				addedge(0,i,a[cur]);
				pre[cur]=i;
			}
			else{
				addedge(pre[cur],i,INF);
				pre[cur]=i;
			}
		}
		scanf("%d",&k);
		addedge(i,N+1,k);
	}
	printf("%d\n",Maxflow());
	return 0;
}