AHU-835 FJ的旅行 【最小费用最大流】

Description

每当西瓜的朋友来西瓜家看他，西瓜总是喜欢带他们逛自己的豪宅。西瓜的豪宅有N幢楼（1<=N<=1000），用1到N的整数编号。1号楼是西瓜豪宅的大门，N号楼是西瓜的储藏室。西瓜的豪宅里总共有M条道路（1<=M<=10000）。每条道路连接两栋不同的楼房，道路的长度不超过35000。
为了最好地炫耀他的豪宅，西瓜准备从大门出发，经过一些楼房到达储藏室，再经过一些楼房回到自己的大门。
他要求他的路径越短越好，但是不能经过任意一条道路多于一次。请你计算这样的一条最短路径。西瓜保证这样的路径是存在的。

Input

第一行：N和M
第2..M+1行：每行三个整数表示一条道路（起点，终点，长度）

Output

一个整数，表示最短路径长度

Sample Input

4 5
1 2 1
2 3 1
3 4 1
1 3 2
2 4 2

 

Sample Output

6

---

题解：

一开始当成最短路做，发现有很多bug根本不能做，学了费用流发现可以做，设一个源点到1的费用为0容量为2，设一个汇点，从n到汇点的费用为0容量为2，其他弧费用为路径长度，容量为1，跑最小费用最大流算法可以过。

代码：

#include<bits/stdc++.h>
using namespace std;
#define INF 0x3f3f3f3f
#define M(a, b) memset(a, b, sizeof(a))
const int N = 1100;
struct Edge {
    int from, to, cap, flow, cost;
};

struct MCMF {
    int n, m;
    vector<Edge> edges;
    vector<int> G[N];
    int d[N], inq[N], p[N], a[N];

    void init(int n) {
        this->n = n;
        for (int i = 0; i <= n+1; ++i) G[i].clear();
        edges.clear();
    }

    void AddEdge(int from, int to, int cap, int cost) {
        edges.push_back((Edge){from, to, cap, 0, cost});
        edges.push_back((Edge){to, from, 0, 0, -cost});
        m = edges.size();
        G[from].push_back(m-2); G[to].push_back(m-1);
    }

    bool spfa(int s, int t, int &flow, int &cost) {
        M(inq, 0); M(d, INF);
        d[s] = 0; inq[s] = 1; p[s] = 0; a[s] = INF;
        queue<int> q;
        q.push(s);
        while (!q.empty()) {
            int x = q.front(); q.pop();
            inq[x] = 0;
            for (int i = 0; i < G[x].size(); ++i) {
                Edge &e = edges[G[x][i]];
                if (d[e.to] > d[x] + e.cost && e.cap > e.flow) {
                    d[e.to] = d[x] + e.cost;
                    p[e.to] = G[x][i];
                    a[e.to] = min(a[x], e.cap-e.flow);
                    if (inq[e.to]) continue;
                    q.push(e.to); inq[e.to] = 1;
                }
            }
        }
        if (d[t] == INF) return false;
        flow += a[t];
        cost += d[t] * a[t];
        int u = t;
        while (u != s) {
            edges[p[u]].flow += a[t];
            edges[p[u]^1].flow -= a[t];
            u = edges[p[u]].from;
        }
        return true;
    }

    int Mincost(int s, int t) {
        int flow = 0, cost = 0;
        while (spfa(s, t, flow, cost));
        return cost;
    }

}solver;

int main() {
    int n, m;
    while (~scanf("%d%d", &n, &m)) {
        solver.init(n);
        solver.AddEdge(0, 1, 2, 0);
        solver.AddEdge(n, n+1, 2, 0);
        int from, to, cost;
        for (int i = 0; i < m; ++i) {
            scanf("%d%d%d", &from, &to, &cost);
            solver.AddEdge(from, to, 1, cost);
            solver.AddEdge(to, from, 1, cost);
        }
        printf("%d
", solver.Mincost(0, n+1));
    }

    return 0;
}