poj2526 Minimum Cost （费用流）

题意：有M个供应商，N个售货商和K种商品。给出每个售货商需要的每种商品的数量，每个供应商拥有的每种商品的数量以及将第k种商品从第i个供应商运到第j个销售商所需的费用。若销售商的需求能得到满足，输出所需的最小费用；否则，输出-1。

刚开始，我把每个供应商和销售商拆成2K个点，结果超时了。后来，对于每种商品分别建图和求最小费用，累加既得所需总费用，最终AC。

首先，先统计每种商品的供应量和需求量。若某种商品供小于求，则直接输出-1；否则，按如下方法建图：

对于第k种商品：

1.添加一条从源点S到第i个供应商的边，容量为第i个供应商所能提供的第k种商品的量，费用为0；

2.添加一条从第j个销售商到汇点T的边，容量为第j个销售商所需的第k种商品的量，费用为0；

3.添加一条从第i个供应商到第j个销售商的边，容量为oo，费用为所需运费。

然后，求最小费用即可。

#include <iostream>
#include <cstring>
#include <cstdio>
#include <algorithm>
#include <queue>

using namespace std;

const int maxn = 11111;
const int maxm = 270000;
const int oo = 1 << 30;
int n, m, k, idx;
int source, sink, vn;
int dis[maxn], pre[maxn], head[maxn];
bool vis[maxn];

struct Node
{
	int u;
	int v;
	int cap;
	int cost;
	int next;
}edge[maxm];

void addEdge(int u, int v, int cap, int cost)
{
	edge[idx].u = u;
	edge[idx].v = v;
	edge[idx].cap = cap;
	edge[idx].cost = cost;
	edge[idx].next = head[u];
	head[u] = idx++;
	
	edge[idx].u = v;
	edge[idx].v = u;
	edge[idx].cap = 0;
	edge[idx].cost = -cost;
	edge[idx].next = head[v];
	head[v] = idx++;
}

bool spfa(int s, int t, int n)
{
	int cur, i, j;
	memset(vis, false, sizeof(vis));
	memset(pre, -1, sizeof(pre));
	for (i = 0; i <= n; ++i) dis[i] = oo;
	queue<int> Q;
	dis[s] = 0;
	vis[s] = true;
	Q.push(s);

	while (!Q.empty())
	{
		cur = Q.front();
		Q.pop();
		vis[cur] = false;
		for (i = head[cur]; i != -1; i = edge[i].next)
		{
			j = edge[i].v;
			if (edge[i].cap > 0 && dis[cur] + edge[i].cost < dis[j])
			{
				dis[j] = dis[cur] + edge[i].cost;
				pre[j] = i;
				if (!vis[j])
				{
					vis[j] = true;
					Q.push(j);
				}
			}
		}
	}
	return dis[t] != oo;
}

int minCost(int s, int t, int n)
{
	int ret = 0, flow = oo;
	
	while (spfa(s, t, n))
	{
		int i = t;
		while (pre[i] != -1)
		{
			flow = min(flow, edge[pre[i]].cap);
			i = edge[pre[i]].u;
		}
		i = t;
		while (pre[i] != -1)
		{
			ret += edge[pre[i]].cost * flow;
			edge[pre[i]].cap -= flow;
			edge[pre[i]^1].cap += flow;
			i = edge[pre[i]].u;
		}
	}
	return ret;
}

int have[55], need[55];
int Have[55][55], Need[55][55], Cost[55][55][55];

bool ok()
{
	memset(have, 0, sizeof(have));
	memset(need, 0, sizeof(need));

	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= k; ++j)
		{
			scanf("%d", &Need[i][j]);
			need[j] += Need[i][j];
		}
	}
	for (int i = 1; i <= m; ++i)
	{
		for (int j = 1; j <= k; ++j)
		{
			scanf("%d", &Have[i][j]);
			have[j] += Have[i][j];
		}
	}
	for (int i = 1; i <= k; ++i)
	{
		for (int j = 1; j <= n; ++j)
		{
			for (int t = 1; t <= m; ++t)
			{
				scanf("%d", &Cost[i][j][t]);
			}
		}
	}

	for (int i = 1; i <= k; ++i)
	{
		if (have[i] < need[i])
			return false;
	}
	return true;
}

int main()
{
	while (scanf("%d %d %d", &n, &m, &k))
	{
		if (n == 0 && m == 0 && k == 0) break;
		if (!ok()) printf("-1\n");
		else
		{
			int vn = m + n + 2;
			int source = 0;
			int sink = m + n + 1;
			int ans = 0;

			for (int i = 1; i <= k; ++i)
			{
				idx = 0;
				memset(head, -1, sizeof(head));
				for (int j = 1; j <= n; ++j)
				{
					addEdge(m + j, sink, Need[j][i], 0);
				}
				for (int j = 1; j <= m; ++j)
				{
					addEdge(source, j, Have[j][i], 0);
				}
				for (int j = 1; j <= m; ++j)
				{
					for (int t = 1; t <= n; ++t)
					{
						addEdge(j, m + t, oo, Cost[i][t][j]);
					}
				}
				ans += minCost(source, sink, vn);
			}
			printf("%d\n", ans);
		}
	}
	return true;
}