POJ2516 最小费用最大流算法

题意：有N个店主， M个供应商和K种物品，已知N个店主需要的K种物品的数量以及M个供应商可提供的K种物品的数量，以及将K种物品从供应商运送到店主所需的花费，

求满足所有店主需求的最小的运送花费。

 

题目的输入比较难以理解，需要仔细考虑边的方向关系。

 

解题思路：一共有K种物品，每种物品互不影响

1.如果出现某种物品的总需求>总供应量，则直接输出不能满足要求。

2.依次考虑每种物品构图，转化成求K次多源多汇的最小费用最大流，总的最小花费就是所有物品的最小花费和。

建模方法： 对每种物品，建立一个超级源点S，和超级汇点E，

增加S到每个供应商的边，容量为供应商提供的物品数量，值为0.

增加每个每个供应商到每个店主的边，容量为容量也正无穷，值为运送K物品从j供应商到i店主的费用。

增加每个店主至E的边，容量为店主的需求数量，值为0

 

注意建正向边的同时不要忘了建立反向边，反向边容量为0，值为正向边的相反数。

 

最小费用最大流算法：

即多次寻找可增广路径至不能够再增广

通过最短路的SPFA算法找到单位容量费用最小的一条增广路，记录下条路径，反向得出最大流，更新残余网络，总的费用+=该条路径最大流*该条路径总费用

再重复寻找增广路，最后得出的就是满足运送第K件物品的最小费用最大流。

 

/*
对每一种商品分别进行最小费用最大流；
由于数据读入不是分开的，先保存数据 
*/ 
#include<stdio.h>
#include<string.h>
#define INF 1000000000
#define Min(a,b) (a<b?a:b)

typedef struct{
	int v,w;
	int flow;
	int val;
}Edge;

Edge E[10000];
int EdgeNum=0;
int Head[200],Next[10000],Pre[10000];
int Sup[51][51],Dem[51][51],Val[51][51][51],SumDem[51];  
int N,M,K,Ans;

void AddEdge(int v,int w,int flow,int val){
	E[EdgeNum].v=v;
	E[EdgeNum].w=w;
	E[EdgeNum].flow=flow;
	E[EdgeNum].val=val;
	Next[EdgeNum]=Head[v];
	Head[v]=EdgeNum++;
	E[EdgeNum].v=w;
	E[EdgeNum].w=v;
	E[EdgeNum].flow=0;
	E[EdgeNum].val=-val;
	Next[EdgeNum]=Head[w];
	Head[w]=EdgeNum++;
		
}

int SPFA(int start,int end){
	int i,V,e;
	int Queue[200],Front,Rear;
	int InQ[200],Dist[200];
	memset(InQ,0,sizeof(InQ));
	memset(Pre,-1,sizeof(Pre));
	Front=Rear=0;
	for(i=0;i<N+M+2;i++)
		Dist[i]=INF;
	Dist[start]=0;
	Queue[Rear++]=start;
	while(Front!=Rear){
		V=Queue[Front++];
		Front%=200;
		InQ[V]=0;
		for(e=Head[V];e!=-1;e=Next[e]){
			if(E[e].flow>0&&Dist[E[e].w]>Dist[V]+E[e].val){
				Pre[E[e].w]=e;
				Dist[E[e].w]=Dist[V]+E[e].val;
				if(!InQ[E[e].w]){
					InQ[E[e].w]=1;
					Queue[Rear++]=E[e].w;
					Rear%=200;
				}
			}
		}
	}
	if(Dist[end]==INF)
		return 0;
	else 
		return 1;	
}

int Count(int ith){     //计算第i种商品的最小费用最大流 
	int i,j,e,sum=0;
	int start,end,MaxFlow=0,Flow=INF;
	EdgeNum=0;
	memset(Head,-1,sizeof(Head));
	memset(Next,-1,sizeof(Next));
	start=N+M;
	end=start+1;
	for(i=0;i<M;i++)
		AddEdge(start,i,Sup[i][ith],0);
	for(j=0;j<N;j++)
			AddEdge(M+j,end,Dem[j][ith],0);
	for(i=0;i<M;i++)
		for(j=0;j<N;j++)
			AddEdge(i,M+j,INF,Val[ith][i][j]);
	while(SPFA(start,end)){      //只要存在s,e的最短路径（最小费用），对路径进行增广
		e=Pre[end];
		 while(e!=-1){
 			Flow=Min(E[e].flow,Flow);
 			e=Pre[E[e].v];
 		}
 		e=Pre[end];
 		while(e!=-1){
		 	E[e].flow-=Flow;
		 	E[e^1].flow+=Flow;
		 	sum+=Flow*E[e].val;
			e=Pre[E[e].v];		 	
		 }
		 MaxFlow+=Flow;
	} 
	if(MaxFlow!=SumDem[ith])
		return -1;
	return sum;
}
int main(){
	int i,j,k,a,temp;
	while(~scanf("%d %d %d",&N,&M,&K)){
		memset(SumDem,0,sizeof(SumDem));
		if(N==0&&M==0&&K==0)
			break;
		Ans=0;
		for(i=0;i<N;i++)
			for(j=0;j<K;j++){
				scanf("%d",&Dem[i][j]);
				SumDem[j]+=Dem[i][j];   //用于判断是否满足需求 
			}
		for(i=0;i<M;i++)
			for(j=0;j<K;j++)
				scanf("%d",&Sup[i][j]);
		for(i=0;i<K;i++)
			for(j=0;j<N;j++)
				for(k=0;k<M;k++)
					scanf("%d",&Val[i][k][j]);
		//数据读入完毕
		//还要增加一个判断是否能满足需求，如果不满足输出-1 
		for(i=0;i<K;i++){
			if((temp=Count(i))==-1)
				break;
			else
				Ans+=temp;
		}
		if(i==K)
			printf("%d\n",Ans);
		else
			printf("-1\n");
	}
	return 0;	
}