poj 2516 Minimum Cost (费用流)

N个店主，M个供应商，K种商品，已知供求关系以及商品的运费，问能否满足需求，若能，求最小花费。

一、关于能否满足需求：直接根据输入进行判定即可。

二、在能满足需求的条件下，考虑某一种商品，即若只有一种商品，可以这样来建图：

       1、将店主、供应商都视为1个点。店主编号为1~N，供应商为N+1~N+M

       2、添加源点0，到所有店主连一条边，花费为0，容量为该商品的需求量

       3、添加汇点n+m+1，所有供应商到其连一条边，花费为0，容量为该商品的供应量

       4、店主和供应商之间连边，边权为该商品的运费，容量为商品需求量。

然后就可以用最小费用流算法求解了。

由于有k种商品，那么建立k次图，求k次最小费用，累加起来就是答案了。

#include<iostream>
#include<cstdio>
#include<cmath>
#include<map>
#include<set>
#include<algorithm>
#include<queue>
#include<stack>
#include<cstdlib>
#include<cstring>
#include<vector>
#pragma comment(linker, "/STACK:1024000000,1024000000")
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
typedef unsigned int uI;
typedef double db;
#define inf 0x3f3f3f3f
#define maxn 105
#define maxq 1005
#define maxm 60000
struct Edge{
    int to,next,cap,cost;
}edge[maxm];

int n,m,head[maxn],cnt,Q[maxq],qhead,qtail;
int cur[maxn],f[maxn],mcmf_cost,mcmf_flow;

inline void add(int u,int v,int cap,int cost)
{
    edge[cnt].to=v;
    edge[cnt].cap=cap;
    edge[cnt].cost=cost;
    edge[cnt].next=head[u];
    head[u]=cnt++;
    edge[cnt].to=u;
    edge[cnt].cap=0;
    edge[cnt].cost=-cost;
    edge[cnt].next=head[v];
    head[v]=cnt++;
}

int d[maxn];
bool vis[maxn];

inline bool spfa(int s,int e)
{
    int i;
    qhead=qtail=0;
    memset(d,inf,sizeof(d));
    memset(vis,0,sizeof(vis));
    d[s]=0;
    Q[qtail++]=s;
    cur[s]=-1;
    f[s]=inf;
    vis[s]=1;
    while(qtail>qhead)
    {
        int u=Q[qhead++];
        vis[u]=0;
        for(i=head[u];~i;i=edge[i].next)
        {
            int v=edge[i].to;
            if(edge[i].cap>0&&d[v]>d[u]+edge[i].cost)
            {
                d[v]=d[u]+edge[i].cost;
                f[v]=min(f[u],edge[i].cap);
                cur[v]=i;
                if(!vis[v])
                {
                    vis[v]=1;
                    Q[qtail++]=v;
                }
            }
        }
    }
    if(d[e]==inf) return 0;
    mcmf_flow+=f[e];
    for(i=cur[e];~i;i=cur[edge[i^1].to])
    {
        edge[i].cap-=f[e];
        edge[i^1].cap+=f[e];
        mcmf_cost+=f[e]*edge[i].cost;
    }
    return 1;
}

int C[maxn][maxn][maxn],need[maxn][maxn],pro[maxn][maxn];

int main()
{
    int i,j,k;
    while(~scanf("%d%d%d",&n,&m,&k)&&(n+m+k))
    {
        for(i=1;i<=k;++i) need[0][i]=pro[0][i]=0;
        for(i=1;i<=n;++i)
            for(j=1;j<=k;++j){
                scanf("%d",&need[i][j]);
                need[0][j]+=need[i][j];
            }
        for(i=1;i<=m;++i)
            for(j=1;j<=k;++j){
                scanf("%d",&pro[i][j]);
                pro[0][j]+=pro[i][j];
            }
        for(int p=1;p<=k;++p)
            for(i=1;i<=n;++i)
                for(j=1;j<=m;++j)
                    scanf("%d",&C[p][i][j]);
        for(i=1;i<=k&&need[0][i]<=pro[0][i];++i);
        if(i<=k) puts("-1");
        else{
            int ans=0;
            for(int p=1;p<=k;++p)
            {
                cnt=0;
                memset(head,-1,sizeof(head));
                mcmf_cost=mcmf_flow=0;
                for(i=1;i<=n;++i) add(0,i,need[i][p],0);
                for(i=1;i<=m;++i) add(i+n,n+m+1,pro[i][p],0);
                for(i=1;i<=n;++i)
                    for(j=1;j<=m;++j)
                        add(i,j+n,need[i][p],C[p][i][j]);
                while(spfa(0,n+m+1));
                ans+=mcmf_cost;
            }
            printf("%d\n",ans);
        }
    }
    return 0;
}