POJ 2516 最小费用最大流

每一种货物都是独立的,分成k次最小费用最大流即可!

/**
因为e ==0 所以 pe[v]   pe[v]^1 是两条相对应的边
E[pe[v]].c -= aug;            E[pe[v]^1].c += aug;

*/
#include <queue>
#include <iostream>
#include <string.h>
#include <stdio.h>
#include <map>
using namespace std;
#define V 30010      // vertex
#define E 150010      // edge
#define INF 0x3F3F3F3F
struct MinCostMaxFlow
{
    struct Edge
    {
        int v, next, cap, cost;  // cap 为容量, cost为单位流量费用
    } edge[E];

    int head[V], pe[V], pv[V];            // 每个节点的第一条edge[idx]的编号.
    int  dis[V];            // the shortest path to the src
    bool vis[V];            // visted
    // pe[v]  存放在增广路上到达v的边(u,v) 在edge[]的位置
    // pv[u]  存放在增广路上从u出发的边(u,v) 在edge[]中的位置
    int e, src, sink;            // the index of the edge
    int VertexNum;               // N the num of the vertex. M the num of edges
    void addedge(int  u, int v, int cap, int cost)
    {
        edge[e].v = v, edge[e].cap = cap;
        edge[e].cost = cost,edge[e].next = head[u], head[u] = e++;
        edge[e].v = u, edge[e].cap = 0;
        edge[e].cost = -1*cost, edge[e].next = head[v], head[v] = e++;
    }
    // 求最短路,不存在负环的时候,比 DFS快
    int SPFABFS()
    {
        memset(vis, 0 ,sizeof(vis));
        memset(pv, -1, sizeof(pv));
        for(int i=0; i<V; i++) dis[i] = INF;
        queue<int> Q;
        Q.push(src);
        vis[src] = 1, dis[src] = 0;
        while(!Q.empty())
        {
            int u = Q.front();
            Q.pop();
            vis[u] = 0;
            for(int i=head[u]; i!=-1; i=edge[i].next)
            {
                int v = edge[i].v;
                if(edge[i].cap > 0 &&  dis[v] > dis[u] + edge[i].cost  )
                {
                    dis[v] = dis[u] + edge[i].cost;
                    if(!vis[v])
                    {
                        Q.push(v);
                        vis[v] = 1;
                    }
                    pv[v] = u;
                    pe[v] = i;
                }
            }
        }
        if(dis[sink] == INF) return -2;          // can't from src to sink.
        return dis[sink];
    }

    pair<int,int> MCMF()
    {
        int maxflow = 0, mincost = 0;
        while(SPFABFS())
        {
            if(pv[sink] == -1) break;
            int aug = INF;
            for(int i= sink; i!= src; i = pv[i])
                aug =min(aug, edge[pe[i]].cap);
            maxflow += aug;
            mincost += aug * dis[sink];
            for(int i = sink; i!= src; i = pv[i])
            {
                edge[pe[i]].cap -= aug;
                edge[pe[i]^1].cap += aug;
            }
        }
        return make_pair(maxflow, mincost);
    }
    int solve()
    {
        int N,M,K;
        while(scanf("%d%d%d", &N , &M, &K) && N!=0 && M!=0 && K!=0)
        {
            int tmp;
            vector<int> need[55];
            for(int i=0; i<N; i++)
            {
                for(int j=0; j<K; j++)
                {
                    scanf("%d", &tmp);
                    need[i].push_back(tmp);
                }
            }
            vector<int> supply[55];
            for(int i =0; i<M; i++)
            {
                for(int j=0; j<K; j++)
                {
                    scanf("%d", &tmp);
                    supply[i].push_back(tmp);
                }
            }
            vector<vector<vector<int> > > cost;
            for(int i=0; i<K; i++)
            {
                vector<vector<int> > y;
                for(int j=0; j<N; j++)
                {
                    vector<int> x;
                    for(int k = 0; k<M; k++)
                    {
                        scanf("%d", &tmp);
                        x.push_back(tmp);
                    }
                    y.push_back(x);
                }
                cost.push_back(y);
            }
            int ret = 0;
            bool flag = true;
            for(int k = 0; k < K; k++)
            {
                e=0;
                memset(head, -1,sizeof(head));
                // M suppliers
                src = 0;
                sink = M+N+1;
                VertexNum = M+N+2;
                for(int i=0; i<M; i++)
                {
                    addedge(src,i+1,supply[i][k],0);
                }
                int x = 0;
                for(int i=0; i<N; i++)
                {
                    x+= need[i][k];
                    addedge(M+i+1,sink, need[i][k], 0);
                }
                for(int j=0; j<M; j++)
                {
                    for(int i=0; i<N; i++)
                    {
                        addedge(j+1, M+i+1,INF,cost[k][i][j]);
                    }
                }
                pair<int,int> res = MCMF();
                if(res.first < x)
                {
                    flag = 0;
                    break;
                }
                ret += res.second;
            }
            if(flag) cout<<ret<<endl;
            else cout<<-1<<endl;
        }
    }
} mcmf;


int main()
{
    freopen("1.txt","r",stdin);
    mcmf.solve();
    return 0;
}