POJ2516Minimum Cost

转载请注明出处：優YoU http://blog.csdn.net/lyy289065406/article/details/6742534 

 

大致题意：

       有N个供应商，M个店主，K种物品。每个供应商对每种物品的的供应量已知，每个店主对每种物品的需求量的已知，从不同的供应商运送不同的货物到不同的店主手上需要不同的花费，又已知从供应商Mj送第kind种货物的单位数量到店主Ni手上所需的单位花费。

问：供应是否满足需求？如果满足，最小运费是多少？

 

解题思路：

费用流问题。

 

（1）输入格式

在说解题思路之前，首先说说输入格式，因为本题的输入格式和解题时所构造的图的方向不一致，必须要提及注意。以样例1为例：

 

 

 

（2）题目分析和拆解：

A、首先处理“供应是否满足需求”的问题。

       要总供应满足总需求，就必须有 每种物品的供应总量都分别满足其需求总量，只要有其中一种物品不满足，则说明供不应求，本组数据无解，应该输出-1。但是要注意这里判断无解后，只能做一个标记，但还要继续输入，不然一旦中断输入，后面的几组数据结果就全错了。

       而要知道“每种物品的供应总量都分别满足其需求总量”，对所有供应商第kind种物品的供应量求和ksupp[kind]，对所有店主第kind种物品的需求量求和kneed[kind]，然后比较ksupp[kind]与kneed[kind]就可以了。

                     而最小费用流的计算是建立在“供等于求”或“供过于求”的基础上的。

 

       B、最小费用问题

       要直接求出“把所有物品从所有供应商运送到所有店主的最小费用MinTotalCost”是不容易的。但是求出“把第kind种物品从所有供应商运送到所有店主的最小费用MinCost[kind]”却简单得多，这就转化为经典的多源多汇的费用流问题，而最后只需要把K种物品的最小费用求和 MinCost[kind]，就能得到运送所有物品的最小费用MinTotalCost。

其实题目的输入方式最后要输入K个矩阵已经暗示了我们要拆解处理。

 

       C、构图

                 那么对于第kind种物品如何构图呢？

解决多源多汇网络问题，必须先构造与其等价的单源单汇网络。构造超级源s和超级汇t，定义各点编号如下：

 超级源s编号为0，供应商编号从1到M，店主编号从M+1到M+N，超级汇t编号为M+N+1。

令总结点数Nump=M+N+2，申请每条边的“花费”空间cost[Nump][ Nump]和“容量”空间cap[Nump][ Nump]，并初始化为全0。

超级源s向所有供应商M建边，费用为0，容量为供应商j的供应量。

       每个供应商都向每个店主建边，正向弧费用为输入数据的第kind个矩阵（注意方向不同），容量为供应商j的供应量；反向弧费用为正向弧费用的负数，容量为0。

所有店主向超级汇t建边，费用为0，容量为店主i的需求量。

 

注意：1、其他没有提及的边，费用和容量均为0，容量为0表示饱和边或不连通。

   2、计算每种物品的最小费用都要重复上述工作重新构图，不过存储空间cost和cap不必释放，可重新赋值再次利用。

      

       D、求解

       对于第kind种物品的图，都用spfa算法求解最小费用路径（增广链），再利用可分配最大流调MaxFlow整增广链上的容量，正向弧容量减去MaxFlow，反向弧容量减去MaxFlow，费用为单位花费乘以MaxFlow。

       具体的算法流程可参考我POJ2195的解题报告，基本一样。但注意的导致本题无可行解的原因只有“供不应求”，由输入数据知显然各边的容量均>=0，因此并不会出现负权环，spfa仍然用while循环直至无增广链为止足矣。

//Memory Time 
//596K  1188MS 

#include<iostream>
#include<queue>
using namespace std;

class solve
{
public:
	solve(int n,int m,int k):N(n),M(m),K(k)
	{
		MinTotalCost=0;
		Nump=N+M+2;
		s=0;
		t=N+M+1;
		Err=false;

		AppRoom();
		Input();
		Compute();
	}
	~solve()
	{
		if(Err)
			cout<<-1<<endl;
		else
			cout<<MinTotalCost<<endl;

		Relax();
	}

	int inf() const{return 0x7FFFFFFF;}
	int min(int a,int b) {return a<b?a:b;}
	bool check(int kind) const{return ksupp[kind]>=kneed[kind];}

	void AppRoom(void);			//申请存储空间
	void Input(void);			//输入
	void Compute(void);			//计算MinTotalCost
	void Initial(int kind);		//初始化数据，重新构造第kind种物品的流量图
	bool spfa(void);			//对当前图求最小费用流(增广链)
	void AddFlow(int kind);		//对最小费用流增流，调整增广链上的流量和费用，并累计第kind种物品的费用MinCost[kind]
	void Relax(void);			//释放空间

protected:
	int N;				//店主数
	int M;				//供货商数
	int K;				//商品种数
	int s,t;			//超级源s 与 超级汇t 的编号
	int Nump;			//N+M+超级源s+超级汇t (即总结点数量)
	int** supply;		//supply[j][k]:供货商j对第k种物品的供货量
	int** need;			//need[i][k]: 店主i对第k种物品的需求量
	int*** InputCost;	//InputCost[kind][N][M] 对应输入的K的花费矩阵
	int* MinCost;		//所有供货商运送第k种货物给所有店主的最小花费
	int MinTotalCost;	//所有供货商运送所有物品给所有店主的最小总花费

	/*构图时各点编号-- 超级源s:0 , 供应商M:1~M , 店主N:M+1~M+N , 超级汇t:N+M+1*/
	int** cost;			//任意两点之间的花费
	int** cap;			//任意两点之间的容量
	int* dist;			//超级源到各点的距离
	int* vist;			//判断某点是否在队列中

	int* pre;			//记录前驱. u->v，pre[v]=u
	bool Err;			//标记供不应求
	int* ksupp;			//第k种物品的总供应量
	int* kneed;			//第k种物品的总需求量
};

void solve::AppRoom(void)
{
	int i,k;

	/*申请构图与解题必要空间*/

	MinCost=new int[K+1];
	ksupp=new int[K+1];
	kneed=new int[K+1];
	dist=new int[Nump];
	vist=new int[Nump];
	pre=new int[Nump];

	cost=new int*[Nump];
	cap=new int*[Nump];
	for(i=0;i<Nump;i++)
	{
		cost[i]=new int[Nump];
		cap[i]=new int[Nump];
	}

	/*申请输入空间*/

	supply=new int*[M+1];
	for(i=1;i<=M;i++)
		supply[i]=new int[K+1];

	need=new int*[N+1];
	for(i=1;i<=N;i++)
		need[i]=new int[K+1];

	InputCost=new int**[K+1];	//K个矩阵
	for(k=1;k<=K;k++)
	{
		InputCost[k]=new int*[N+1];
		for(i=1;i<=N;i++)
			InputCost[k][i]=new int[M+1];
	}


	return;
}

void solve::Input(void)
{
	int i,j,k;

	for(i=1;i<=N;i++)
		for(k=1;k<=K;k++)
			cin>>need[i][k];

	for(j=1;j<=M;j++)
		for(k=1;k<=K;k++)
			cin>>supply[j][k];
	
	for(k=1;k<=K;k++)
		for(i=1;i<=N;i++)
			for(j=1;j<=M;j++)
				cin>>InputCost[k][i][j];

	/*计算第k种物品的供应总量和需求总量*/

	for(k=1;k<=K;k++)
	{
		ksupp[k]=0;
		for(j=1;j<=M;j++)
			ksupp[k]+=supply[j][k];

		kneed[k]=0;
		for(i=1;i<=N;i++)
			kneed[k]+=need[i][k];
	}

	return;
}

void solve::Compute(void)
{
	for(int kind=1;kind<=K;kind++)
	{
		Initial(kind);
		if(!check(kind))	//检查第k种物品的供求情况
		{
			Err=true;
			return;
		}

		while(spfa())
			AddFlow(kind);

		MinTotalCost+=MinCost[kind];
	}

	return;
}

void solve::Initial(int kind)
{
	int i,j;

	MinCost[kind]=0;
	memset(pre,0,sizeof(int)*Nump);

	for(i=0;i<Nump;i++)		//目的是处理不属于当前所构造的图的边
	{
		memset(cap[i],0,sizeof(int)*Nump);
		memset(cost[i],0,sizeof(int)*Nump);
	}

	/*初始化超级源s到各个供货商的容量*/

	for(j=1;j<=M;j++)
		cap[s][j]=supply[j][kind];	//s到供货商j的容量为供货商j的供应量
		

	/*初始化各个店主到超级汇t的容量*/

	for(i=M+1;i<t;i++)
		cap[i][t]=need[i-M][kind];	//店主i到t的容量为店主i的需求量

	/*初始化各个供应商到各个店主的容量和费用*/

	for(i=M+1;i<t;i++)
		for(j=1;j<=M;j++)
		{
			cost[j][i]=InputCost[kind][i-M][j];	//注意这里的费用存储方式与输入的存储方式相反
			cost[i][j]=-cost[j][i];				//反向弧费用
			cap[j][i]=supply[j][kind];			//供应商j到店主i的容量为供货商j的供应量
		}

	return;
}

bool solve::spfa(void)
{
	for(int i=s;i<=t;i++)
	{
		dist[i]=inf();
		vist[i]=false;
	}
	dist[s]=0;

	queue<int>q;
	q.push(s);
	vist[s]=true;

	while(!q.empty())
	{
		int u=q.front();
		for(int v=s;v<=t;v++)
		{
			if(cap[u][v] && dist[v]>dist[u]+cost[u][v])
			{
				dist[v]=dist[u]+cost[u][v];
				pre[v]=u;

				if(!vist[v])
				{
					q.push(v);
					vist[v]=true;
				}
			}
		}

		q.pop();
		vist[u]=false;
	}

	if(dist[t]<inf())
		return true;		//dist[t]被修正，说明找到增广链

	return false;	//已无增广链，spfa结束
}

void solve::AddFlow(int kind)
{
	int MaxFlow=inf();		//可分配最大流
	int i;
	for(i=t;i!=s;i=pre[i])
		MaxFlow=min(MaxFlow,cap[pre[i]][i]);	//可分配最大流=增广链上的最小容量

	for(i=t;i!=s;i=pre[i])
	{
		cap[pre[i]][i]-=MaxFlow;	//正向弧容量调整
		cap[i][pre[i]]+=MaxFlow;	//反向弧容量调整
		MinCost[kind]+=cost[pre[i]][i]*MaxFlow;		//最小费用=单位费用*可分配最大流
	}

	return;
}

void solve::Relax(void)
{
	int i,k;

	delete[] MinCost;
	delete[] dist;
	delete[] vist;
	delete[] pre;
	delete[] ksupp;
	delete[] kneed;

	for(i=0;i<Nump;i++)
	{
		delete[] cost[i];
		delete[] cap[i];
	}

	for(i=1;i<=M;i++)
		delete[] supply[i];

	for(i=1;i<=N;i++)
		delete[] need[i];

	for(k=1;k<=K;k++)
	{
		for(i=1;i<=N;i++)
			delete[] InputCost[k][i];

		delete[] InputCost[k];
	}

	return;
}

int main(void)
{
	int n,m,k;
	while(cin>>n>>m>>k && (n+m+k))
		solve poj2516(n,m,k);

	return 0;
}