UVa 10806 费用流（入门）

这个题让我理解了为什么费用流偏偏也要有个专有名词。。。因为每段路径也有花费，找到能够运成一段流的最小花费。不过这道题体现的不明显，因为每一段的流量是1.不用考虑这么多。

题目大意：

给一段已知的路径，给出路径之间的花费，两个人在同在起点。问是否存在两条路径（允许点重复，但是每条边不能重复），求出花费。n个点，其中1为起点，n为终点；m条无向带权边，问是否能找出两条不重边的路径使得权值和最小

题目分析：

有两种方法：

①想一下，这道题不就是求两条最短路么，直接两次spfa（第一次从起点到终点，第二次从终点到起点，但中间要加一点改变），就是将走过的最短路径的值变成负数，并删除相反的边，避免重复。为什么不能直接将这条路径删掉呢？？？

原因详见下图：

代码参考：http://blog.csdn.net/L123012013048/article/details/41790879

②但是方法①我总感觉有些歧义。可以从网络流的角度看，用建模简化问题。建立超级源点s，假设从超级源点流出的flow为2，那么就可以转化为判断到超级终点t的flow是否为2了。

这道题是费用流的入门题，裸的费用流，建立超级源点，建边（s，1，2，0），对每一条边建边（u，v，1，w），（v，u，1，w）。最后跑一次最小费用最大流，如果flow == 2 输出cost，否则输出无解。

代码：

#include <stdio.h>  
#include <string.h>  
#include <algorithm>  
#define REP(I, X) for(int I = 0; I < X; ++I)  
#define FF(I, A, B) for(int I = A; I <= B; ++I)  
#define clear(A, B, SIZE) memset(A, B, sizeof(A[0]) * (SIZE + 1))  
#define copy(A, B, SIZE) memcpy(A, B, sizeof(A[0]) * (SIZE + 1))  
#define min(A, B) ((A) < (B) ? (A) : (B))  
#define max(A, B) ((A) > (B) ? (A) : (B))  
using namespace std;  
typedef long long ll;  
typedef long long LL;  
const int oo = 0x3f3f3f3f;  
const int maxE = 1000000;  
const int maxN = 105;  
const int maxQ = 10000;  
struct Edge{  
    int v, c, w, n;  
};  
Edge edge[maxE];  
int adj[maxN], cntE;  
int d[maxN], cur[maxN], a[maxN];  
int inq[maxN], Q[maxE], head, tail;  
int cost, flow, s, t;  
int n, m;  
void addedge(int u, int v, int c, int w){  
    edge[cntE].v = v; edge[cntE].c = c; edge[cntE].w =  w; edge[cntE].n = adj[u]; adj[u] = cntE++;  
    edge[cntE].v = u; edge[cntE].c = 0; edge[cntE].w = -w; edge[cntE].n = adj[v]; adj[v] = cntE++;  
}  
int SPFA(){  
    memset(d, oo, sizeof d);  
    memset(inq, 0, sizeof inq);  
    head = tail = 0;  
    d[s] = 0;  
    a[s] = oo;  
    cur[s] = -1;  
    Q[tail++] = s;  
    while(head != tail){  
        int u =  Q[head++];  
        inq[u] = 0;  
        for(int i = adj[u]; ~i; i = edge[i].n){  
            int v = edge[i].v;  
            if(edge[i].c && d[v] > d[u] + edge[i].w){  
                d[v] = d[u] + edge[i].w;  
                cur[v] = i;  
                a[v] = min(edge[i].c, a[u]);  
                if(!inq[v]){  
                    inq[v] = 1;  
                    Q[tail++] = v;  
                }  
            }  
        }  
    }  
    if(d[t] == oo) return 0;  
    flow += a[t];  
    cost += a[t] * d[t];  
    for(int i = cur[t]; ~i; i = cur[edge[i ^ 1].v]){  
        edge[i].c -= a[t];  
        edge[i ^ 1].c += a[t];  
    }  
    return 1;  
}  
int MCMF(){  
    flow = cost = 0;  
    while(SPFA());  
    return flow;  
}  
int read(){  
    int flag = 0, x = 0;  
    char ch = ' ';  
    while(ch != '-' && (ch > '9' || ch < '0')) ch = getchar();  
    if(ch == '-') flag = 1, ch = getchar();  
    while(ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();  
    return flag ? -x : x;  
}  
void work(){  
    int u, v, w;  
    clear(adj, -1, n + 1);  
    cntE = 0;  
    m = read();  
    s = 0; t = n;  
    addedge(s, 1, 2, 0);  
    while(m--){  
        u = read(); v = read(); w = read();  
        addedge(u, v, 1, w);  
        addedge(v, u, 1, w);  
    }  
    MCMF();  
    if(flow == 2) printf("%d\n", cost);  
    else printf("Back to jail\n");  
}  
int main(){  
    while(~scanf("%d", &n) && n) work();  
    return 0;  
}