网络流三·二分图多重匹配

描述

学校的秋季运动会即将开始，为了决定参赛人员，需要统计分配比赛选手。

已知班级一共有N名学生，编号依次为1..N。

运动会一共有M项不同的比赛，编号为1..M。第i项比赛每个班需要派出m[i]名选手参加。

根据统计，编号为i的学生表示最多同时参加a[i]项比赛，并且给出他所擅长的b[i]项比赛的编号。

希望将每个学生都安排到他所擅长的比赛项目，以增加夺冠的可能性。同时又要考虑满足每项比赛对人数的要求，当然给一个学生安排的比赛项目也不能超过他愿意参加的比赛项目数量。

根据统计的结果，想知道能否有一个合适的安排，同时满足这些条件。

输入

第1行：1个整数T，表示一共有T(2≤T≤5)组数据，每组数据按如下格式给出：

第1行：2个正整数N,M。1≤N≤100，1≤M≤100。

第2行：M个整数，第i个数表示第i个项目需要的选手数量m[i]。1≤m[i]≤N。

第3..N+2行：若干整数，第i+2行表示编号为i的学生的信息。先是a[i],b[i]，接下来b[i]个整数，表示其所擅长的b[i]个项目。1≤a[i]≤M

输出

第1..T行：第i行表示第i组数据能否满足要求，若能够输出"Yes"，否则输出"No"。

样例输入

2
4 3
1 2 2
1 2 1 2
2 2 1 3
1 1 2
1 2 2 3
4 3
2 2 2
1 2 1 2
2 2 1 3
1 1 2
1 2 2 3

样例输出

Yes
No

提示：二分图多重匹配

我们仍然将学生看作A部，比赛项目看作B部：

接下来，根据每个学生的意愿我们将对应的A[i]和B[j]连起来。比如编号为i的学生擅长编号为j的项目，那么就连接A[i]-B[j]：

我们需要对之前的二分图进行进一步扩展。首先虚拟一个源点s和汇点t：

接下来我们根据a[i]，在s和A[i]之间连接一条容量为a[i]的边。

同时将原来A[i]-B[j]直接的边都改造为从A[i]到B[j]的容量为1的边。

最后我们还要连接所有的B[j]-t。由于比赛项目B[j]最多只需要m[j]名选手参加，所以我们不妨限制B[j]-t的容量为m[j]。

这就是我们最后的网络流图。

在完成最大流后，这个网络流图的流量情况直接对应了一个分配方案：

s-A[i]：这一类边的流量表示了A[i]参加的项目数量。

A[i]-B[j]：这一类边的流量表示了A[i]是否参加项目B[j]，若参加则流量为1，否则流量为0。

B[j]-t：这一类边的流量表示了参加比赛项目B[j]的选手数量。

由于流网络会自动调整去满足最大流量，所以它会自动调整每个A[i]-B[j]的流量来使得B[j]-t尽可能大。

若每个项目都能够满足人数的话，网络流会自己调整为所有B[j]-t都满流的情况。

我们只需要最后判断一下每一条B[j]-t的边是否满流，就可以知道能否满足需求。同时还可以根据A[i]-B[j]的情况，计算出每个选手所参加的比赛项目。

#include 
#include 
#include 
#include 
#include 
#define MAX 205
#define MAXCF 101
#define min(a,b) (a)>(b)?(b):(a)
using namespace std;

int cf[MAX][MAX];//存储图
int queue[MAX];//搜索队列
int path[MAX];//保存路径
int capacity[MAX];//流量数组，保存经过该点的最小流量
bool visited[MAX];//记录访问数组

int findAugmentPath(int T)
{
	int i = 0, tail = 0;
	memset(visited, 0, sizeof(visited));

	queue[tail] = 1;//将源点加入队列
	capacity[1] = MAXCF;
	visited[1] = true;
	while (i <= tail)
	{
		int u = queue[i];
		if (u == T)
			return capacity[T];//找到一条增广路径，返回该路径最小流量
		for (int v = 2; v <= T; v++)
		{
			if (!visited[v] && cf[u][v] > 0)
			{
				path[v] = u;
				capacity[v] = min(cf[u][v], capacity[u]);//记录路径上的最小残余流量
				visited[v] = true;
				tail++;
				queue[tail] = v;
			}
		}
		i++;
	}
	return 0;
}

void modifyGraph(int T)
{
	int flow = capacity[T];
	int now = T;
	while (now != 1)
	{
		int fa = path[now];
		cf[fa][now] -= flow;
		cf[now][fa] += flow;
		now = fa;
	}
}

int main()
{
	int T;
	int N, M;
	int i,j;
	int temp;
	int m[MAX];
	int a[MAX], b[MAX];
	cin >> T;

	while (T--)
	{
		cin >> N >> M;
		int S = 1;
		int E = S + N + M + 1;
		int result = 0;
		memset(cf, 0, sizeof(cf));
		for (i = 0; i < M; ++i)
		{
			cin >> m[i];
			cf[S + N + i + 1][E] = m[i];
			result += m[i];
		}

		for (i = 0; i < N; ++i)
		{
			cin >> a[i] >> b[i];
			cf[S][S + i + 1] = a[i];
			for (j = 0; j < b[i]; ++j)
			{
				cin >> temp;
				cf[S + i + 1][S + N + temp] = 1;
			}
		}
		int maxFlow = 0;
		int delta = 0;
		while (delta = findAugmentPath(E))
		{
			maxFlow += delta;
			modifyGraph(E);
		}
		if (maxFlow == result)
			cout << "Yes" << endl;
		else
			cout << "No" << endl;

	}
	return 0;
}