紫书 例题11-8 UVa 11082（网络流最大流）

这道题的建模真的非常的秀， 非常牛逼。

先讲建模过程。源点到每一行连一条弧， 容量为这一行的和减去列数， 然后每一列到汇点连一条弧， 容量为这一列

的和减去行数， 然后每一行和列之间连一条弧， 容量为19。然后求最大流， 最后矩阵中每一个元素的值就是其所在

列和行所连的弧的容量加1.

让我来解释一下。设每一个行为xi， 每一列为yi。在网络流中， 每一个xi都有多条弧连到所有的yi， 在矩形当中

每一行的每一个元素都是每一列的一部分。在网络流中，对于一个yi来说，  所有的xi都有一条弧连到这个yi， 而

在矩阵中， 每一列都是由每一行的一部分构成的。发现了什么？矩阵这个模型和建出来的图其实是等价的。

那么如果要满足题目条件， 那就意味着每一行的和和每一列的和都是题目给出的和， 也就是说， 所有源点

到xi的弧都是满载的， 也就是流量等于容量， yi到汇点也是满载的， 这样才满足题目的条件。

那么什么时候是满载的呢？显然， 当满载的时候显然是网络流的最大流， 这个时候流量肯定是最大的。

因此， 我们求一波最大流， 然后每一条xi到yi的弧的流量加1就是矩阵中（xi， yi）元素的值。

另外， 因为网络流中会有0流， 而题目要求的是1到20， 直接做的话可能导致某些元素值为0.

为了避免这种情况， 把每一个元素减去1， 范围成了0到19， 就即使有0流也不怕了。

所以建图的时候每一列的和减去行数（列中每一个元素减去1）， 行的和减去列数。

最后输出答案的时候加1就ok了。

#include<cstdio>
#include<vector>
#include<queue>
#include<algorithm>
#include<cstring> 
#define REP(i, a, b) for(int i = (a); i < (b); i++)
using namespace std;

const int MAXN = 112;
struct Edge
{
	int from, to, cap, flow;
	Edge(int from, int to, int cap, int flow) : from(from), to(to), cap(cap), flow(flow) {};
};
vector<Edge> edges;
vector<int> g[MAXN];
int h[MAXN], cur[MAXN], id[MAXN][MAXN], n, m, s, t;

void AddEdge(int from, int to, int cap)
{
	edges.push_back(Edge(from, to, cap, 0));
	edges.push_back(Edge(to, from, 0, 0));
	g[from].push_back(edges.size() - 2);
	g[to].push_back(edges.size() - 1);
}

bool bfs()
{
	memset(h, 0, sizeof(h));
	queue<int> q;
	q.push(s);
	h[s] = 1;
	
	while(!q.empty())
	{
		int u = q.front(); q.pop();
		REP(i, 0, g[u].size())
		{
			Edge& e = edges[g[u][i]];
			if(!h[e.to] && e.cap > e.flow)
			{
				h[e.to] = h[u] + 1;
				q.push(e.to);
			}
		}
	}
	
	return h[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(h[x] + 1 == h[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;
			if((a -= f) == 0) break;
		}
	}
	return flow;
}

int solve()
{
	int ret = 0;
	while(bfs()) memset(cur, 0, sizeof(cur)), ret += dfs(s, 1e9);
	return ret;
}

int main()
{
	int T;
	scanf("%d", &T);
	
	REP(kase, 1, T + 1)
	{
		scanf("%d%d", &n, &m);
		REP(i, 0, m + n + 2) g[i].clear();
		edges.clear();
		s = n + m, t = n + m + 1;
		
		int last = 0;
		REP(i, 0, n)
		{
			int x;
			scanf("%d", &x);
			AddEdge(s, i, x - last - m);
			last = x;
		}
		last = 0;
		REP(i, 0, m)
		{
			int x;
			scanf("%d", &x);
			AddEdge(n + i, t, x - last - n);
			last = x;
		}
		REP(i, 0, n)
			REP(j, 0, m)
			{
				AddEdge(i, n + j, 19);
				id[i][j] = edges.size() - 2;
			}
		
		solve();
		printf("Matrix %d\n", kase);
		REP(i, 0, n)
		{
			REP(j, 0, m)
				printf("%d ", edges[id[i][j]].flow + 1);
			puts("");
		}

		puts("");
	}

	return 0;	
}