poj 2516 Minimum Cost（最小费用最大流）

http://poj.org/problem?id=2516

题目大意：

有n个商店，m个仓库，k种商品，给出每个商店对k种商品的需求和每个仓库储存的k种商店库存，要求求出满足供应要求的最小运输费用；

题目的输入：

第一行输入3个整数n，m，k分别代表商店仓库以及商品种类的数量；

接下来n行分别列出每个商店k种商品的需求数量；

接下来m行分别列出每个仓库k种商品的库存数量；

接下来k个n*m的矩阵；

第ki个矩阵的i行j列表示从第j个仓库到第i个商店的运输费用；

思路：

很明显的最小费用最大流，觉得这题亮点在于：

首先判断ki种商品的库存总数是否满足需求总数，如果满足的话，

分别对k种商品构造容量网络，求出最大流的最小费用取和即可；

需要注意的是，如果不满足要继续把接下来的数据输入，最后输出-1；

#include<iostream>
using namespace std;

const int Max=110;
const int inf=1<<30;

int cost[Max][Max];
int cap[Max][Max];
int que[10*Max];
int pre[Max];
int dist[Max];
bool vis[Max];
int s,t;
int min_cost;

bool spfa()
{
	int i;
	memset(vis,false,sizeof(vis));
	for(i=0;i<=t;i++)
		dist[i]=inf;

	int head=0;
	int tail=0;
	que[tail++]=s; 
	dist[s]=0;

	while(head<tail)
	{
		int u=que[head++];
		vis[u]=false;
		for(i=0;i<=t;i++)
		{
			if(cap[u][i]>0 && dist[i]>dist[u]+cost[u][i])
			{
				dist[i]=dist[u]+cost[u][i];
				pre[i]=u;

				if(!vis[i])
				{
                   vis[i]=true;
				   que[tail++]=i;
				}
			}
		}
	}
	if(dist[t]==inf) 
		return false;
	return true;
}

void argument_mincost()
{
	int i;
	int min_flow=inf;
    
	for(i=t;i!=0;i=pre[i])
		if(min_flow>cap[ pre[i] ][i])
			min_flow=cap[pre[i]][i];

    for(i=t;i!=0;i=pre[i])
	{
		cap[ pre[i] ][i] -= min_flow;
		cap[i][ pre[i] ] += min_flow;
		min_cost += min_flow*cost[ pre[i] ][i];
	}
	return ;
}

int main(int i,int j,int k)
{
	int N,M,K;
	int order[Max][Max],storage[Max][Max];
	int k_need[Max],k_supply[Max];

    while(~scanf("%d %d %d",&N,&M,&K) && N)
	{

		/*Initial*/
		memset(k_need,0,sizeof(k_need));
		memset(k_supply,0,sizeof(k_supply));

		t=N+M+1;   
		s=0;
		min_cost=0;

        for(i=1;i<=N;i++)
		{
			for(j=1;j<=K;j++)
			{
			   scanf("%d",&order[i][j]);
               k_need[j] += order[i][j];
			}
		}

		for(i=1;i<=M;i++)
		{
			for(j=1;j<=K;j++)
			{
				scanf("%d",&storage[i][j]);
				k_supply[j] += storage[i][j];
			}
		}

		bool flag=true;

		/*判断库存是否满足需求*/
		for(i=1;i<=K;i++)
		{
	        if(k_need[i]>k_supply[i])
			{
				flag=false;
				break;
			}
		}

		for(k=1;k<=K;k++)
		{
			memset(cap,0,sizeof(cap));

			for(i=1;i<=N;i++)
			{
				for(j=1;j<=M;j++)
				{
					scanf("%d",&cost[j][M+i]);

					cost[M+i][j]=-cost[j][M+i];
					cap[j][M+i]=inf;
				}
			}

			if(!flag) 
				continue;
			/*Structure Graph*/
            for(i=1;i<=M;i++)
			{
				cap[s][i]=storage[i][k];
				cost[s][i]=cost[i][s]=0;
			}
			for(i=1;i<=N;i++)
			{
				cap[i+M][t]=order[i][k];
				cost[i+M][t]=cost[t][i+M]=0;
			}

			while(spfa()) 
				argument_mincost();
		}

		if(flag) 
			printf("%d\n",min_cost);
		else  
			printf("-1\n");
	}
	return 0;
}