【网络流】最大流：PIGS【EK模板、建图题】

# include<stdio.h>
# include<string.h>
# include<queue>
using namespace std;


# define N 103 //点数
# define M 1003 //边数

# define INF 99999999

int n,m; //点数和边数
int cap[N][N]; //保存每个边的容量
int pathPreNode[N]; //保存增广路径上，每个节点的前一个节点

//BFS寻找增广路径（本质就是在图中找一个从start到end的路径）
int BFS(int start, int end) 
{
	memset(pathPreNode,-1,sizeof(pathPreNode));
	pathPreNode[start]=start; //起始标不标记都无所谓
	
	int curNode,i,preNode;
	int pathMinFlow=INF; //增广路径上所有边中容量最小的值
	queue<int> q;
	q.push(start);
	while(!q.empty())
	{
		curNode=q.front();
		q.pop(); //注意，别忘
		if(curNode==end) //找到了增广路径
		{
			for(curNode=end;curNode!=start;curNode=preNode) //构造剩余图
			{
				preNode=pathPreNode[curNode];
				pathMinFlow= pathMinFlow<=cap[preNode][curNode]? pathMinFlow: cap[preNode][curNode]; //更新增广路径上de最小流量
			}
			return pathMinFlow;
		}
		for(i=0;i<=n+1;i++) //对于本题，需要从0到n+1扫描
		{
			//如果节点i没被访问过，且剩余图中edge(curNode,i)还有容量，那么这些点都是BFS可以访问的候选节点
			if(pathPreNode[i]==-1 && cap[curNode][i]>0)
			{
				q.push(i); //队列中加入候选节点
				pathPreNode[i]=curNode; //记录前一个节点
				//pathMinFlow= pathMinFlow<=cap[curNode][i]? pathMinFlow: cap[curNode][i]; //更新增广路径上de最小流量
				//注意，这里找到的是带有回溯的最小流量，实际上在执行过程中，某个路径并能到达终点end，所以这里计算的pathMinFlow是有问题的！
				//但是，为什么有些题目这样写还能刷过去呢？因为正确的pathMinFlow'【大于】这里计算的pathMinFlow，我们想要每次增广pathMinFlow'，
				//而不是pathMinFlow，如果每次只增广pathMinFlow，只不过是【需要增广的次数增加了，而不影响最终结果】，所以，如果测试数据比较小，
				//某些题目可以刷过，但是如果测试数据比较大，这种每次只增广一点点流量（pathMinFlow）的办法会使EK函数的执行次数大大增加，进而超时！
				//分析比较USACO 93【Drainage Ditches】和Croatia OI 2002 Final Exam - First day【PIGS】就明白了
				//【正确的做法】是，将计算pathMinFlow的代码放在找到增广路径之后，即，在上面的if语句中添加for循环！
			}
		}
	}
	return -1;
}

int EK(int start, int end)
{
	int oneFlow,maxFlow=0,curNode,preNode;
	while(true)
	{
		oneFlow=BFS(start,end); //BFS寻找增广路径
		if(oneFlow==-1) //找不到增广路径
		{
			break;
		}
		else
		{
			maxFlow+=oneFlow;
			for(curNode=end;curNode!=start;curNode=preNode) //构造剩余图
			{
				preNode=pathPreNode[curNode];
				cap[preNode][curNode]-=oneFlow; //正向边减
				cap[curNode][preNode]+=oneFlow; //反向边加
			}
		}
	}
	return maxFlow;
}


/*
思路：网络流，重在构图。将每个顾客当做一个节点来表示，再加入超级源点和超级汇点。
1. 对于每个猪圈的第一个顾客，从源点向他连一条边，容量为猪圈里的猪的数量。
2. 对于每个猪圈，如果不是第一个顾客，则上一个打开这个猪圈的顾客向这个顾客连一条边，容量为 +∞。
3. 每个顾客到汇点连一条边，容量为各个顾客能买的数量。
*/


int main()
{
	int a,k,i,j;
	int pigNumber[M];
	int preCustomer[M]; //注意这里是N不是M！读清题意，还是导师给我把bug找出来的，太惭愧了。。。

	scanf("%d%d",&m,&n);
	memset(pigNumber,0,sizeof(pigNumber));
	memset(preCustomer,0,sizeof(preCustomer));
	memset(cap,0,sizeof(cap));
	for(i=1;i<=m;i++)
	{
		scanf("%d", &pigNumber[i]);
	}
	for(i=1;i<=n;i++)
	{
		scanf("%d", &a);
		for(j=1;j<=a;j++)
		{
			scanf("%d", &k);
			if(preCustomer[k]==0)//第k个猪圈的第一个顾客，从源点向他连一条边，容量为猪圈里的猪的数量。
			{
				cap[0][i]+=pigNumber[k];
			}
			else//不是第一个顾客，上一个开这个猪圈的顾客向他连一条边，容量为 +∞。
			{
				cap[preCustomer[k]][i]+=INF;
			}
			preCustomer[k]=i;//维护pre[k]。
		}
		scanf("%d", &cap[i][n+1]);//每个顾客到汇点连一条边，容量为各个顾客能买的数量。
	}
	printf("%d\n",EK(0,n+1));

	return 0;
}