POJ 2315 最小费用最大流

从1走到N然后从N走回来的最短路程是多少? 转换为费用流来建模.

/**
因为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
    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);
    }

    /// 一定需要初始化的是 src, sink
    void solve()
    {
        int N,M;
        while(scanf("%d%d", &N , &M)!= EOF)
        {
            e=0;
            memset(head, -1,sizeof(head));
            for(int i=0; i<M; i++)
            {
                int a, b, c;
                scanf("%d%d%d", &a, &b, &c);
                addedge(a, b,1,c);
                addedge(b, a,1, c);
            }
            src = 0;
            sink = N+1;
            addedge(src,1, 2, 0);
            addedge(N, sink, 2, 0);
            pair<int,int> ret = MCMF();
            cout<<ret.second<<endl;
        }
    }
} mcmf;

int main()
{
    mcmf.solve();
    return 0;
}