poj2516 - Minimum Cost

                              想看更多的解题报告:http://blog.csdn.net/wangjian8006/article/details/7870410
                                转载请注明出处：http://blog.csdn.net/wangjian8006

 

题目大意：有n个商店，m个提供商，k种商品
接下来n行，每行有k个数字，表示这个商店需要各个物品的个数。
再接下来m行，对于每一个提供商也有k个数字，表示这个提供商拥有各个物品的个数。
然后，对于每个物品k，都有n行m列的矩阵。
i行j列表示：
从j提供商向i商店运送一个k商品的代价是多少。
判断所有的仓库能否满足所有客户的需求，如果可以，求出最少的运输总费用。

解题思路：其实主要就是建图，只要图建好了就差不多对了

建图如下：对于每一种物品来处理：
开一个新的源点用0表示,指向所有的提供商,路径为0,容量为这个提供商能够提供这种物品的数量
每个提供商都指向商店,路径为单位费用,容量为MAXINT
每个商店都指向一个新的汇点,汇点用n+m+1表示,路径为0,容量为这个商店需要这种物品的数量
然后从源点到汇点求费用流，这样求k次费用流就是答案了

因为总运输费用为物品数*每个物品的相对代价，如果不能满足就是，用户的对某种物品的总需求大于这个物品能够提供的需求，那么就不能满足用户，则输出-1

 

/*
Memory 448K
Time  422MS
*/
#include <iostream>
#include <queue>
using namespace std;
#define INF INT_MAX
#define MAXV 160
#define min(a,b) (a>b?b:a)

int n,m,k,source,sink,maxflow,mincost;
int res[MAXV][MAXV],cost[MAXV][MAXV],nn[MAXV][MAXV],mm[MAXV][MAXV];
int parent[MAXV],d[MAXV];

void spfa(){
	queue <int>q;
	int i,v;
	bool vis[MAXV];
	memset(parent,-1,sizeof(parent));
	memset(vis,false,sizeof(vis));

	for(i=source;i<=sink;i++) d[i]=INF;
	d[source]=0;
	q.push(source);
	vis[source]=true;

	while(!q.empty()){
		v=q.front();q.pop();
		vis[v]=false;

		for(i=0;i<=sink;i++){
			if(res[v][i] && d[v]+cost[v][i]<d[i]){
				d[i]=d[v]+cost[v][i];
				parent[i]=v;
				if(!vis[i]){
					vis[i]=true;
					q.push(i);
				}
			}
		}
	}
}

void MCMF(){
	int v,minflow;
	maxflow=0;
	while(1){
		spfa();
		if(parent[sink]==-1) break;

		minflow=INF;			//找出最短路径的最小增广流
		v=sink;
		while(parent[v]!=-1){
			minflow=min(minflow,res[parent[v]][v]);
			v=parent[v];
		}

		v=sink;					//对增广路进行流增广
		while(parent[v]!=-1){
			res[parent[v]][v]-=minflow;
			res[v][parent[v]]+=minflow;
			v=parent[v];
		}
		maxflow+=minflow;
		mincost+=d[sink]*minflow;			//总的代价
	}
}

void build_gragh(int x){
	int i,j;
	memset(res,0,sizeof(res));
	
	for(i=1;i<=n;i++) res[i][sink]=nn[i][x];			//商店指向汇点
	for(i=1;i<=m;i++) res[source][i+n]=mm[i][x];		//源点指向提供商

	for(i=1;i<=m;i++){								//提供商对商店的流量为无限大
		for(j=1;j<=n;j++)
			res[i+n][j]=INF;
	}
}

int main(){
	int i,j,r,flag;
	int need[MAXV],have[MAXV];
	while(scanf("%d%d%d",&n,&m,&k) && n || m || k){
		memset(need,0,sizeof(need));
		memset(have,0,sizeof(have));
		source=0,sink=n+m+1,mincost=0;

		for(i=1;i<=n;i++){
			for(j=1;j<=k;j++){
				scanf("%d",&nn[i][j]);
				need[j]+=nn[i][j];
			}
		}

		for(i=1;i<=m;i++){
			for(j=1;j<=k;j++){
				scanf("%d",&mm[i][j]);
				have[j]+=mm[i][j];
			}
		}

		flag=0;
		for(i=1;i<=k;i++){
			if(need[i]>have[i]){			//如果某种物品的需求大于提供商能够提供的物品就输出-1
				flag=1;
				break;
			}
		}
		
		for(r=1;r<=k;r++){				//当然，我们要把数据都输完
			memset(cost,0,sizeof(cost));

			for(i=1;i<=n;i++){
				for(j=1;j<=m;j++){
					scanf("%d",&cost[j+n][i]);
					cost[i][j+n]=-cost[j+n][i];			//反向路径要设为负权值
				}
			}
			if(flag) continue;
			build_gragh(r);					//建图
			MCMF();							//费用流

			if(need[r]>maxflow) flag=1;    //比较最大流与这种物品所需要的总和
		}
		
		if(flag) printf("-1\n");
		else printf("%d\n",mincost);
	}
	return 0;
}