poj2135（*最小费用最大流）

/*
translation:
    给出一张图，求从1~n再从n~1的最短路径是多少？注意同一条路径不能走两次！
solution:
    最小费用最大流
    这个问题可以转化为求2条从1~n不相交的路径，进而就是直接求从1~n的流量为2的最小费用流。
note:
    * 本质上是求从1~n的流量为2的最小费用流
    # 不能直接用两次dijkstra来求。（将第一次走过的路删掉再跑第二次）
    研究问题模型的时候别被题意牵着走，要看出本质的模型。
*/
#include <iostream>
#include <cstdio>
#include <vector>
#include <cstring>
#include <queue>
#include <utility>

using namespace std;
const int maxn = 1000 + 5;
const int INF = 0x3f3f3f3f;

typedef pair<int,int> P;
struct Edge
{
    int to, cap, cost, rev;
    Edge(int to_, int cap_, int cost_, int rev_):to(to_),cap(cap_),cost(cost_),rev(rev_){}
};
vector<Edge> G[maxn];
int V, n, m;
int h[maxn], dist[maxn], prevv[maxn], preve[maxn];

void add_edge(int from, int to, int cap, int cost)
{
    G[from].push_back(Edge(to, cap, cost, G[to].size()));
    G[to].push_back(Edge(from, 0, -cost, G[from].size()-1));
}

int min_cost_flow(int s, int t, int f)
{
    int res = 0;
    memset(h, 0, sizeof(h));
    while(f > 0) {
        priority_queue<P, vector<P>, greater<P> > pq;
        fill(dist, dist + V, INF);
        dist[s] = 0;
        pq.push(P(0, s));
        while(!pq.empty()) {
            P p = pq.top(); pq.pop();
            int v = p.second;
            if(dist[v] < p.first)   continue;
            for(int i = 0; i < G[v].size(); i++) {
                Edge& e = G[v][i];
                if(e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
                    dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
                    prevv[e.to] = v;
                    preve[e.to] = i;
                    pq.push(P(dist[e.to], e.to));
                }
            }
        }
        if(dist[t] == INF)  return -1;

        for(int v = 0; v < V; v++)  h[v] += dist[v];

        int d = f;
        for(int v = t; v != s; v = prevv[v]) {
            d = min(d, G[prevv[v]][preve[v]].cap);
        }
        f -= d;
        res += d * h[t];
        for(int v = t; v != s; v = prevv[v]) {
            Edge& e = G[prevv[v]][preve[v]];
            e.cap -= d;
            G[v][e.rev].cap += d;
        }
    }
    return res;
}

int main()
{
    //freopen("in.txt", "r", stdin);
    while(~scanf("%d%d", &n, &m)) {
        for(int i = 0; i < maxn; i++)   G[i].clear();

        int u, v, c;
        for(int i = 0; i < m; i++) {
            scanf("%d%d%d", &u, &v, &c);
            add_edge(u - 1, v - 1, 1, c);
            add_edge(v - 1, u - 1, 1, c);
        }
        int s = 0, t = n - 1;   V = n;
        printf("%d\n", min_cost_flow(s, t, 2));
    }
    return 0;
}