poj 2516 Minimum Cost （最小费用流 ）

题意：有N个客户，M个仓库，和K种货物。已知每个客户需要每种货物的数量，每个仓库存储每种货物的数量，每个仓库运输各种货物去各个客户的单位费用。判断所有的仓库能否满足所有客户的需求，如果可以，求出最少的运输总费用。

 

思路：最小费用最大流。先判断是否每种货物的存储总量都足够，足够的话，对每一种货物进行一次最小费用最大流求出完成这种货物运输的最小总费用，所有的总费用相加就是结果了。

 

思路：最小费用最大流。先判断是否每种货物的存储总量都足够，

     足够的话，对每一种货物进行一次最小费用最大  流求出完成这种货物运输的最小总费用，所有的总费用相加就是结果了。

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

#include<stdio.h>
#define maxn 200
#define inf 0x7fffffff
#include<string.h>
int  need[maxn][maxn],needk[maxn],have[maxn][maxn],havek[maxn],cap[maxn][maxn],map[maxn][maxn];
int que[maxn],ans,pre[maxn];
int n,m,k,max;
int dis[maxn],vis[maxn];
int min(int x,int y)
{
    if(x<y)return x;
    else  return y;
}
int SPFA()
{
    int i,head=0,tail=0;
    for(i=0;i<=max;i++)
    {
        dis[i]=inf;
        vis[i]=0;
    }
    dis[0]=0;
    vis[0]=1;
    que[head]=0;
    tail++;
    while(head!=tail)
    {

        int u=que[head];
        vis[u]=0;
        for(i=0;i<=max;i++)
        {
            if(cap[u][i]&&dis[i]>dis[u]+map[u][i])
            {

                dis[i]=dis[u]+map[u][i];
                pre[i]=u;
                if(!vis[i])
                {
                    vis[i]=1;
                    que[tail++]=i;
                    if(tail==maxn)tail=0;
                }
            }
        }
        head++;
        if(head==maxn)head=0;
    }
    if(dis[max]==inf)return 0;
    else return 1;
}
void Update()
{
    int i,sum=inf;
    for(i=max;i!=0;i=pre[i])
    {
        sum=min(sum,cap[pre[i]][i]);//寻找（最短）增广路经上的最小 流量
    }

    for(i=max;i!=0;i=pre[i])
    {
        cap[pre[i]][i]-=sum;
        cap[i][pre[i]]+=sum;
        ans+=map[pre[i]][i]*sum;

    }

}
int main()
{
    int i,j,l;
  while(scanf("%d%d%d",&n,&m,&k)!=EOF)
  {
      if(n==0&&m==0&&k==0)break;
      memset(needk,0,sizeof(needk));
      memset(havek,0,sizeof(havek));
      for(i=1;i<=n;i++)
      {
          for(j=1;j<=k;j++)
          {
              scanf("%d",&need[i][j]);
              needk[j]+=need[i][j];
          }
      }

      for(i=1;i<=m;i++)
      {
          for(j=1;j<=k;j++)
          {
              scanf("%d",&have[i][j]);
              havek[j]+=have[i][j];
          }
      }
      int f=0;
      ans=0;
      for(i=1;i<=k;i++)
      {
          if(needk[i]>havek[i])
          {
              f=1;
              break;
          }
      }

      max=n+m+1;
      for(i=1;i<=k;i++)
      {
          memset(cap,0,sizeof(cap));
          for(j=1;j<=n;j++)
          {
              for(l=1;l<=m;l++)
              {
                  scanf("%d",&map[l][j+m]);
                  map[j+m][l]=-map[l][j+m];
                  cap[l][j+m]=inf;

              }
          }

          for(j=1;j<=m;j++)
          {
              cap[0][j]=have[j][i];
              map[0][j]=map[j][0]=0;

          }
          for(j=1;j<=n;j++)
          {
              cap[j+m][max]=need[j][i];
              map[j+m][max]=map[max][j+m]=0;
          }

          while(SPFA())Update();//最小费用算法

      }
      if(!f)printf("%d\n",ans);
      else printf("-1\n");
  }
}