POJ 2516 Minimum Cost(最小费用最大流)

题意：有n个商店，m个提供商，k种商品,接下来 n*k的矩阵，表示每个商店需要每个商品的数目；,再接下来m*k矩阵，表示每个提供商拥有每个商品的个数。

然后，对于每个物品k，都有n*m的矩阵。

i行j列表示：

从j提供商向i商店运送一个k商品的代价是多少。

判断所有的仓库能否满足所有客户的需求，如果可以，求出最少的运输总费用。

 

思路：关键是建图，建立一个源点是s = 0 和 汇点 t = n+m+1;源点到m个供应商，费用为0，容量是这个提供商能够提供这种物品的数量；每个供应商到每个商店，费用为输入的费用（添加双向边），容量为无穷大；每个商店到汇点，费用为0，容量为这个商店需要这种商品的数目。在输入K个矩阵时，一边输入，一边建图对每种商品求最大流。

 

还要考虑到供不应求的情况，当需求量大于供应量时，不能满足，输出-1.对于第r种商品，若它的需求量大于最大流量，也不能满足，输出-1；对每1个商品进行建图寻找增光路，最后累加输出最小费用；

 

#include<iostream>
#include<cstring>
#include<cstdio>
#include<queue>
#include<algorithm>
#include<vector>
using namespace std;
const int INF = 0x3f3f3f3f;
const int N = 220;
typedef pair<int, int> P;
struct node{
	int to, cap, cost, rev;
	node(int to, int cap, int cost, int rev) :to(to), cap(cap), cost(cost), rev(rev){}
};
vector<node> G[N];
int h[N];
int dis[N];
int prevv[N];
int preve[N];
void addNode(int from, int to, int cap, int cost){
	G[from].push_back(node(to, cap, cost, G[to].size()));
	G[to].push_back(node(from, 0, - cost, G[from].size() - 1));
}
int V;
int min_cost_max_flow(int s, int t, int &f){
	int ret = 0;
	memset(h, 0, sizeof(h));
	while(true){
		priority_queue<P, vector<P>, greater<P> > q;
		fill(dis, dis + N, INF);
		dis[s] = 0;
		q.push(P(0, s));
		while(!q.empty()){
			P p = q.top(); q.pop();
			int v = p.second;
			if(dis[v] < p.first) continue;
			for(int i = 0; i < G[v].size(); ++i){
				node &e = G[v][i];
				if(e.cap > 0 && dis[e.to] > dis[v] + e.cost + h[v] - h[e.to]){
					dis[e.to] = dis[v] + e.cost + h[v] - h[e.to];
					prevv[e.to] = v;
					preve[e.to] = i;
					q.push(P(dis[e.to], e.to));
				}
			}
		}
		if(dis[t] == INF)	break;
		for(int v = 0; v < V; ++v)	h[v] += dis[v];
		int d = INF;
		for(int v = t; v != s; v = prevv[v])	d = min(d, G[prevv[v]][preve[v]].cap);
		ret += d * h[t];
		f += d;
		for(int v = t; v != s; v = prevv[v]){
			node &e = G[prevv[v]][preve[v]];
			e.cap -= d;
			G[e.to][e.rev].cap += d;
		}
	}
	return ret;
}
int need[N][N], sup[N][N];
int r[N];
int main(){
	int n, m, k;
	while(~scanf("%d%d%d", &n, &m, &k), (n + m + k)){
		const int s = 0, t = n + m +1;
		V = t + 1;
		for(int i = 1; i <= n; ++i)
			for(int j = 1; j <= k; ++j)
				scanf("%d", &need[i][j]);
		memset(r, 0, sizeof(r));
		for(int i = 1; i <= m; ++i)
			for(int j = 1; j <= k; ++j){
				scanf("%d", &sup[i][j]);
				r[j] += sup[i][j];
			}
		int flag = 1, ret = 0;
		for(int c = 1; c <= k; ++c){
			int temp = 0;
			for(int i = 1; i <= n; ++i){
				addNode(s, i, need[i][c], 0);
				temp += need[i][c];
			}
			if(temp > r[c])	flag = 0;
			for(int i = 1; i <= n; ++i)
				for(int j = 1; j <= m; ++j){
					int x;
					scanf("%d", &x);
					addNode(i, n + j, INF, x);
				}
			for(int i = 1; i <= m; ++i)
				addNode(n + i, t, sup[i][c], 0);
			int f = 0;
			if(flag)
				ret += min_cost_max_flow(s, t, f);
			if(temp > f)	flag = 0;
			memset(G, 0, sizeof(G));
		}
		if(flag == 0)
			ret = -1;
		printf("%d\n", ret);
	}
	return 0;
}