POJ 2516 Minimum Cost (费用流)

 

第一行是三个数字:N,M,K
分别表示有N个商店，M个供货商，K中货物

接下来是N行，每行K个整数
对于第i行第j列，表示的是第i个商店对于货物j的需求

再接着，M行，每行K个整数
对于第i行第j列，表示的是第i个供货商对于货物j的存货

接下来有K个N*M的矩形
第X个矩形的第i行第j列表示的是
从供货商j 运送一个单位的 货物X 到商店i的 花费

最后要求的是
在满足 所有商店的供应的 情况下的 最小花费
如果无法满足，则输出-1

题解：
首先弄清楚题目的意思
考虑k种货物都是独立的，因此只需要考虑k遍最小的费用然后求和
对于每一次的最小费用，显然直接求解最小费用流即可，
对于图的构建并不难，
但是要考虑清楚每条边的容量
从汇点向每个供货商连接一条容量为存货数量，费用为0的边
然后从每个供货商向每个商店连接一条容量为INF，费用为花费的边（容量连接成存货数量也行）
从商店向汇点连接一条容量为需求，费用为0的边
求解K次最小费用流累加答案即可。

参考链接：https://blog.csdn.net/qq_30974369/article/details/76648579

 

代码:

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <cmath>
using namespace std;
const int maxn = 210;
const int maxm = 1000;
const int INF = 0x3f3f3f3f;
struct edge
{
    int v, next, cap, flow, cost;
    int x, y;
} e[maxn*maxn];
struct shudui
{
    int s[55];
}p1[55],p2[55];
int c[55][55][55];
int head[maxn],tol;
int pre[maxn],dis[maxn];
bool vis[maxn];
void init()
{
    tol = 0;
    memset(head, -1, sizeof(head));
}
void add_edge(int x,int y,int cap,int cost)
{
    e[tol].v=y;
    e[tol].cap=cap;
    e[tol].flow=0;
    e[tol].cost=cost;
    e[tol].next=head[x];
    head[x]=tol++;

    e[tol].v=x;
    e[tol].cap=0;
    e[tol].flow=0;
    e[tol].cost=-cost;
    e[tol].next=head[y];
    head[y]=tol++;
}
int spfa(int s,int t)
{
    queue<int>r;
    for(int i=0;i<maxn;++i)
    {
        vis[i]=0;
        dis[i]=INF;
        pre[i]=-1;
    }
    dis[s]=0;
    vis[s]=1;
    r.push(s);
    while(!r.empty())
    {

        int u=r.front();
        r.pop();
        vis[u]=0;
        for(int i=head[u];i!=-1;i=e[i].next)
        {
            int v=e[i].v;
            if(e[i].cap>e[i].flow && dis[v]>dis[u]+e[i].cost)
            {
                dis[v]=dis[u]+e[i].cost;
                pre[v]=i;
                if(!vis[v])
                {
                    vis[v]=1;
                    r.push(v);
                }
            }
        }
    }
    if(pre[t]==-1) return 0;
    else return 1;
}
int MincostMaxflow(int s,int t,int &cost)
{
    int flow=0;
    cost=0;
    while(spfa(s,t))
    {
        int minn=INF;
        for(int i=pre[t];i!=-1;i=pre[e[i^1].v])
        {
            if(minn>e[i].cap-e[i].flow)
            {
                minn=e[i].cap-e[i].flow;
            }
        }
        for(int i=pre[t];i!=-1;i=pre[e[i^1].v])
        {
            e[i].flow+=minn;
            e[i^1].flow-=minn;
            cost+=e[i].cost*minn;
        }
        flow+=minn;
    }
    return flow;
}

int main()
{
    int n,m,k,st,en;
    char s[105][105];
    while(~scanf("%d%d%d",&n,&m,&k) && n+m+k)
    {
        for(int i=1;i<=n;++i)
        {
            for(int j=1;j<=k;++j)
                scanf("%d",&p1[i].s[j]);
        }
        for(int i=1;i<=m;++i)
        {
            for(int j=1;j<=k;++j)
                scanf("%d",&p2[i].s[j]);
        }
        for(int ii=1;ii<=k;++ii)
        {
            for(int i=1;i<=n;++i)
            {
                for(int j=1;j<=m;++j)
                {
                    scanf("%d",&c[ii][i][j]);
                }
            }
        }
        st=0;
        en=n+m+1;
        int sum=0,flag=0;

        for(int ii=1;ii<=k;++ii)
        {
            init();
            int ans1=0,ans2=0;
            for(int i=1;i<=n;++i)
            {
                add_edge(st,i,p1[i].s[ii],0);
                ans1+=p1[i].s[ii];
            }
            for(int i=1;i<=n;++i)
            {
                for(int j=1;j<=m;++j)
                {
                    add_edge(i,n+j,INF,c[ii][i][j]);
                }
            }
            for(int i=1;i<=m;++i)
            {
                add_edge(n+i,en,p2[i].s[ii],0);
                ans2+=p2[i].s[ii];
            }
            if(ans1>ans2)
            {
                flag=1;
                break;
            }
            int ans=0;
            MincostMaxflow(st,en,ans);
            sum+=ans;
            //printf("-----------------
");
        }
        if(flag)
            printf("-1
");
        else
            printf("%d
",sum);
    }
    return 0;
}