poj2516Minimum Cost

最新推荐文章于 2019-10-13 10:08:34 发布

flyljg

最新推荐文章于 2019-10-13 10:08:34 发布

阅读量424

点赞数

分类专栏：最小费用最大流

本文链接：https://blog.csdn.net/flyljg/article/details/38711941

版权

最小费用最大流专栏收录该内容

3 篇文章 0 订阅

订阅专栏

Online Judge

Problem Set

Authors

Online Contests

User

Web Board
Home Page
F.A.Qs
Statistical Charts

Current Contest
Past Contests
Scheduled Contests
Award Contest

13110572105 Log Out
Mail:2(1)
Login Log Archive

Language:

Minimum Cost

Time Limit: 4000MS		Memory Limit: 65536K
Total Submissions: 13538		Accepted: 4640

Description

Dearboy, a goods victualer, now comes to a big problem, and he needs your help. In his sale area there are N shopkeepers (marked from 1 to N) which stocks goods from him.Dearboy has M supply places (marked from 1 to M), each provides K different kinds of goods (marked from 1 to K). Once shopkeepers order goods, Dearboy should arrange which supply place provide how much amount of goods to shopkeepers to cut down the total cost of transport.

It's known that the cost to transport one unit goods for different kinds from different supply places to different shopkeepers may be different. Given each supply places' storage of K kinds of goods, N shopkeepers' order of K kinds of goods and the cost to transport goods for different kinds from different supply places to different shopkeepers, you should tell how to arrange the goods supply to minimize the total cost of transport.

Input

The input consists of multiple test cases. The first line of each test case contains three integers N, M, K (0 < N, M, K < 50), which are described above. The next N lines give the shopkeepers' orders, with each line containing K integers (there integers are belong to [0, 3]), which represents the amount of goods each shopkeeper needs. The next M lines give the supply places' storage, with each line containing K integers (there integers are also belong to [0, 3]), which represents the amount of goods stored in that supply place.

Then come K integer matrices (each with the size N * M), the integer (this integer is belong to (0, 100)) at the i-th row, j-th column in the k-th matrix represents the cost to transport one unit of k-th goods from the j-th supply place to the i-th shopkeeper.

The input is terminated with three "0"s. This test case should not be processed.

Output

For each test case, if Dearboy can satisfy all the needs of all the shopkeepers, print in one line an integer, which is the minimum cost; otherwise just output "-1".

Sample Input

Sample Output

4
-1

Source

POJ Monthly--2005.07.31, Wang Yijie

[Submit] [Go Back] [Status] [Discuss]

题目大意：

有N个店铺，M个供货商，K种商品。给出每个供货商的仓库里每种商品的数量、每种商品给每个店铺供货的费用，每个店铺需要的各种商品的数量，求最小费用。

输入一开始是N，M，K。

然后 N行，每行 K列，第I行第J个数代表第I个店铺需要第J种物品多少件。

然后 M行，每行 K列，第I行第J个数代表第I个供货商有第J种物品多少件。

然后是K个矩阵，每个N行M列，第I个矩阵的第J行第D列代表着第D个供货商给第J个店铺发第I种货物一件需要的花费。

题目膜拜大神的代码：

代码整理如下：

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cstdio>
#include <queue>
#define LL long long
#define INF 0x3f3f3f3f
using namespace std;

const int M=105,inf=1<<30;
int need[M][M],have[M][M],cost[M][M][M],n,m,k;

int c[M][M];//针对某种物品的最大容量
int f[M][M];//流量
int w[M][M];//费用
int dis[M];//最短路算法中的距离数组，记录原点到其他点的距离
int pre[M];  //最短路中的记录数组，记录最短路径
bool vis[M]; //最短路算法中的标记数组  标记是否被访问过
int min(int a,int b)
{
    if(a>b)
    {
        a=b;
    }
    return a;
}
bool spfa() //最少的费用，最短路算法
{
    int i,j;
    for(i=0;i<=n+m+1;i++)  //初始化
    {
        dis[i]=inf;
        pre[i]=-1;
        vis[i]=false;
    }
    dis[0]=0;
    vis[0]=true;
    queue <int > q;
    q.push(0);  //初始化完成
    while(!q.empty())
    {
        int t=q.front();
        q.pop();
        vis[t]=false;
        for(i=1;i<=n+m+1;i++)
        {
            if(c[t][i]>f[t][i]&&dis[i]>dis[t]+w[t][i])  //如果流量没有到最大且超级原点经过点t到i的费用比直接到i小
            {
                dis[i]=dis[t]+w[t][i]; //更新到i点的最小花费
                pre[i]=t; //更新最短路径中点i的前驱为t
                if(!vis[i]) //如果点i没在队列中
                {
                    q.push(i);   //将点i放入队列
                    vis[i]=true; //标记已在队列中
                }
            }
        }
    }
    if(pre[n+m+1]==-1)//如果超级汇点没有在对短路中 （因为没有前驱）
    {
        return false;//返回寻找最短路失败
    }
    return true;  //返回最短路寻找成功
}
void getMaxflow()  //寻找增广路
{
    while(spfa())//如果最最小费用增广路寻找成功
    {
        int maxflow=inf;//初始化为最大值
        int p=n+m+1;
        while(pre[p]!=-1) //遍历最小费用增广路
        {
            maxflow=min(maxflow,c[pre[p]][p]-f[pre[p]][p]);//寻找关键流量，及最短路上的最小流量
            p=pre[p];
        }
        p=n+m+1; //再次初始化；
        while(pre[p]!=-1)  //再次遍历最小费用增广路
        {
            f[pre[p]][p]+=maxflow;
            f[p][pre[p]]=-f[pre[p]][p];  //调整流量
            p=pre[p];
        }
    }
}
int main()
{
    int i,j,d,ans;
    while(scanf("%d%d%d",&n,&m,&k),n||m||k)
    {
        ans=0;
        bool flat=false;
        for(i=1;i<=n;i++) //输入部分
        {
            for(j=1;j<=k;j++)
            {
                scanf("%d",&need[i][j]);
            }
        }
        for(i=1;i<=m;i++)
        {
            for(j=1;j<=k;j++)
            {
                scanf("%d",&have[i][j]);
            }
        }
        for(i=1;i<=k;i++)
        {
            for(j=1;j<=n;j++)
            {
                for(d=1;d<=m;d++)
                {
                    scanf("%d",&cost[i][d][j]);
                }
            }
        } //输入部分完成
        for(i=1;i<=k;i++)//对于每一种货物来说
        {
            memset(c,0,sizeof(c));
            memset(f,0,sizeof(f));
            memset(w,0,sizeof(w));
            for(j=1;j<=m;j++)
            {
                c[0][j]=have[j][i];//超级远点到每个仓库的流量应该是仓库的存货量
            }
            for(j=1;j<=n;j++)
            {
                c[m+j][m+n+1]=need[j][i];//每个商店到超级汇点的容量应该是这个商店的需求量
            }
            for(j=1;j<=m;j++)
            {
                for(d=1;d<=n;d++)
                {
                    c[j][d+m]=have[j][i];//每个仓库到商店的容量应该是仓库的存货量
                }
            }
            for(j=1;j<=m;j++)
            {
                for(d=1;d<=n;d++)
                {
                    w[j][d+m]=cost[i][j][d];  //供货商到商店的花费
                    w[d+m][j]=-cost[i][j][d]; //花费的负值，用于回流时
                }
            }
            getMaxflow();//对第i种商品寻找最小费用流
            for(j=1;j<=n;j++) //对于每一个商店来说
            {
                if(c[j+m][n+m+1]!=f[j+m][n+m+1]) //如果供货量不等于需求量
                {
                    flat=true;
                    break;
                }
            }
            if(flat)  //出现供货不足    跳出
            {
                break;
            }
            for(j=1;j<=m;j++)
            {
                for(d=1;d<=n;d++)
                {
                    ans+=f[j][d+m]*w[j][d+m];//计算总费用
                }
            }
        }
        if(flat)//出现供货不足
        {
            printf("-1\n");
        }
        else
        {
            printf("%d\n",ans);
        }
    }
    return 0;
}