UVa Problem 10249 The Grand Dinner - 网络流解题

// The Grand Dinner （丰盛的晚餐）
// PC/UVa IDs: 111007/10249, Popularity: C, Success rate: high Level: 4
// Verdict: Accepted
// Submission Date: 2011-10-09
// UVa Run Time: 3.324s
//
// 版权所有（C）2011，邱秋。metaphysis # yeah dot net
//
// 网络流解法：源点 source 和每支参赛队伍之间弧的容量为参赛队伍人数，每支队伍到桌子之间弧的容量为
// 1，每张桌子到汇点 sink 弧的容量为桌子的座位数，然后使用网络流算法求最大流，如果最大流等于参赛队
// 伍总人数，则满足条件，输出方案，否则不满足条件，输出 0。此处使用宽度优先遍历的 Ford-Fullerson
// 增广路方法，又名 Edmonds-Karp 算法，算法效率为 O（V*E*E），对于顶点数和边数增加的题目，可以
// 使用最短扩增路 （Shortest Augment Path，SAP） 算法。

#include <iostream>
#include <cstring>
#include <queue>

using namespace std;

#define MAXTEAMS 71
#define MAXTABLES 51
#define MAXV 130	// 最大顶点数。
#define UNSOLVABLE 0	// 无安排方案。
#define SOLVABLE 1	// 存在安排方案。
#define DUMMY (-1)	// 表示顶点无父亲顶点。

struct edge
{
	int vertex;	// 相连的顶点。
	int capacity;	// 容量。
	int flow;	// 流量。
	int residual;	// 残余流量。
};

edge edges[MAXV][MAXV];		// 有向图的边。
int degree[MAXV];		// 有向图中顶点的度。
int parents[MAXV];		// 遍历标记，当前顶点的父亲顶点。
bool discovered[MAXV];		// 遍历标记，是否已发现。

// 使用宽度优先遍历找到一条从源点到汇点的剩余流量为正的通路。从源到汇的任意增广路都能增加总流量，因
// 此可以借用宽度优先遍历，需要注意的是，只能沿着“还能增广”（即残余容量为正数）的边走，因此需要在
// 遍历过程中判断残余容量是否为正，以帮助宽度优先遍历区分开饱和边和非饱和边。
void breadthFirstSearch(int source, int sink)
{
	queue < int > vertices;

	vertices.push(source);
	discovered[source] = true;

	while (!vertices.empty())
	{
		int v = vertices.front();
		vertices.pop();
		for (int i = 0; i < degree[v]; i++)
			// 检查是否为饱和边。
			if (edges[v][i].residual > 0)
				if (discovered[edges[v][i].vertex] == false)
				{
					vertices.push(edges[v][i].vertex);
					discovered[edges[v][i].vertex] = true;
					parents[edges[v][i].vertex] = v;

					// 遍历到汇点后说明已经找到一条增广路，可以退出。
					if (edges[v][i].vertex == sink)
						return;
				}
	}
}

// 找到顶点 x 与顶点 y 之间的有向边。
edge *findEdge(int x, int y)
{
	for (int i = 0; i < degree[x]; i++)
		if (edges[x][i].vertex == y)
			return &edges[x][i];
}

// 增广，注意对前向弧和反向弧的处理。
void augmentPath(int source, int sink, int volume)
{
	if (source == sink)
		return;

	edge *e = findEdge(parents[sink], sink);
	e->flow += volume;
	e->residual -= volume;

	e = findEdge(sink, parents[sink]);
	e->residual += volume;

	augmentPath(source, parents[sink], volume);
}

// 根据 BFS 的结果，从汇点 sink 到源点 source 计算通路的容量。增广的过程把尽量多的残余流量转
// 化为正流量。增广路的容量等于整条路中残余容量的最小值，正如车流的速度取决于最拥挤的路段。
int pathVolume(int source, int sink)
{
	if (parents[sink] == DUMMY)
		return 0;

	edge *e = findEdge(parents[sink], sink);
	if (source == parents[sink])
		return (e->residual);
	else
		return (min(pathVolume(source, parents[sink]), e->residual));
}

// 初始化搜索变量。
void initializeSearch()
{
	memset(discovered, false, sizeof(discovered));
	memset(parents, DUMMY, sizeof(parents));
}

// 网络流解题。每次从源到汇寻找一条可以增加总流量的路径，并且用它增广。当没有增广路存在时，算法终
// 止，此时的流就是最大流。注意需要将每条有向边 e = （i，j） 拆分成两条弧 （i，j） 和 （j，i），
// 其中 （i，j） 的初始残余容量为 e 的容量，（j，i） 的残余容量为 0，所有的弧的初始流均设为 0。
// 事实上，任意可行的流都可以作为算法的初始流，快速构造接近最大流的可行流能大大提高算法效率。
bool netflow(int source, int sink, int nTotal)
{
	// Edmonds-Karp 算法。
	int maxFlow = 0, volume;

	initializeSearch();
	breadthFirstSearch(source, sink);
	volume = pathVolume(source, sink);
	while (volume)
	{
		maxFlow += volume;
		augmentPath(source, sink, volume);
		initializeSearch();
		breadthFirstSearch(source, sink);
		volume = pathVolume(source, sink);
	}

	return maxFlow == nTotal;
}

int main(int ac, char *av[])
{
	int nTeams, nTables, nTotal;	// 队伍数，桌子数，总人数。
	int nCount, maxMembers;
	int source, sink;

	while (cin >> nTeams >> nTables, nTeams || nTables)
	{
		source = nTotal = maxMembers = 0;
		sink = nTeams + nTables + 1;

		memset(degree, 0, sizeof(degree));

		// 读入参赛队人数并找参赛队的最大人数。
		for (int i = 1; i <= nTeams; i++)
		{
			cin >> nCount;
			if (maxMembers < nCount)
				maxMembers = nCount;
			nTotal += nCount;

			// 源点 source 到参赛队伍的弧。
			edges[source][degree[source]++] = (edge){i, nCount, 0, nCount};
			edges[i][degree[i]++] = (edge){source, nCount, 0, 0};
		}

		// 读入桌子座位数量。
		for (int i = nTeams + 1; i <= (nTeams + nTables); i++)
		{
			cin >> nCount;

			// 参赛队伍到桌子的弧。
			for (int j = 1; j <= nTeams; j++)
			{
				edges[j][degree[j]++] = (edge){i, 1, 0, 1};
				edges[i][degree[i]++] = (edge){j, 1, 0, 0};
			}
			
			// 桌子到汇点 sink 的弧。
			edges[i][degree[i]++] = (edge){sink, nCount, 0, nCount};
			edges[sink][degree[sink]++] = (edge){i, nCount, 0, 0};
		}

		// 若参赛队伍数为 0，则直接输出存在，但是不用输出具体方案，因为所有桌子无人坐。
		if (nTeams == 0)
		{
			cout << SOLVABLE << "\n";
			continue;
		}

		// 若桌子数为 0 或者参赛队伍中某队人数超过桌子数，则无法安排。
		if (nTables == 0 || maxMembers > nTables)
		{
			cout << UNSOLVABLE << "\n";
			continue;
		}

		bool solvable = netflow(source, sink, nTotal);

		cout << (solvable ? SOLVABLE : UNSOLVABLE) << "\n";

		if (!solvable)
			continue;

		for (int i = 1; i <= nTeams; i++)
		{
			int blank = 0;
			for (int j = 0; j < degree[i]; j++)
			{
				if (edges[i][j].residual == 0)
				{
					cout << (blank++ ? " " : "");
					cout << (edges[i][j].vertex - nTeams);
				}
			}

			cout << "\n";
		}
	}

	return 0;
}