ZOJ 3792 Romantic Value（最小割，最大流）

这道题让我意识到了自己以前的关于最小割的困惑之处。这道题简直很神奇。

最小割的割边怎么求呢？

割边一定是残留网络中零流的边！但零流不一定是割边。

有位大神很轻松的就把这个问题解决了。不就是求边的个数么，那么将所有关键边容量设为1，其余的容量设为无穷，再跑一边最大流，容量即为最小割的边

这道题就很好的体现了这一点。

Romantic Value

---

Time Limit: 2 Seconds      Memory Limit: 65536 KB

---

Farmer John is a diligent man. He spent a lot of time building roads between his farms. From his point of view, every road is romantic because the scenery along it is very harmonious and beautiful. Recently, John is immersed in poetry, he wants stay alone and enjoy the wonderful words. But his little brother always disturbs him. This night, fortunately, his little brother does not stay the same farm with him. So, he wants to destroy some roads to keep himself quiet for a few days(then no route exist between John and his brother). Of course, John love his romantic roads, so he want to separate him and his brother with least romantic cost.

There are N farms(numbered from 1 to N) and M undirected roads each with a romantic value c(indicate how much Farmer John loves it). Now John stays in farm p and his little brother stay in farm q. John wants to first minimize the romantic value lost, then to destroy as few roads as possible. Help him to calculate the ratio of [sum of the remainder roads' value]/[the amount of removed roads](not necessary to maximisation this ratio) when he achieves his goal.

Input

The first line is a single integer T, indicate the number of testcases. Then follows T testcase. For each testcase, the first line contains four integers N M p q(you can assume p and q are unequal), then following M lines each contains three integer a b c which means there is an undirected road between farm a and farm b with romantic value c. (2<=N<=50, 0<=M<=1000, 1<=c<1000, 1<=p,q<=N)

Output

For each test case, print the ratio in a single line(keep two decimal places). If p and q exist no route at the start, then output "Inf".

Sample Input

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

Sample Output

2.50

题目大意：哥哥想切断几条最少的边，使得代价最小，与弟弟之间的路隔断（没有路线可走）。

约翰想先把失去的浪漫价值降到最低，然后尽可能少地破坏道路。当他达到目标的时候，帮助他计算出(剩余道路的价值总和)/(去掉道路的数量)(不需要最大化这个比例)的比率。

题目分析：给你一个无向图，有源点汇点，求最小割，再求最小割中，边最少的最小割。

思路分析：跑一遍最大流，如果不存在s到t的路径，则输出inf。

存在的话，将所有关键边容量设为1，其余的容量设为无穷，再跑一边最大流，容量即为最小割中的最小边。

代码如下：

#include <stdio.h>  
#include <string.h>  
#include <algorithm>  
#define clear(A, X) memset(A, X, sizeof A)  
#define copy(A, B) memcpy(A, B, sizeof A)  
const int maxE = 1000000;  
const int maxN = 100;  
const int oo = 0x3f3f3f3f;  
struct Edge{  
    int v, c, n;  
};  
Edge edge[maxE];  
int adj[maxN], cntE;  
int d[maxN], num[maxN], cur[maxN], pre[maxN];  
int Q[maxE], head, tail;  
int s, t, nv;  
int n, m;  
void addedge(int u, int v, int c)
{  
    edge[cntE].v = v; edge[cntE].c = c; edge[cntE].n = adj[u]; adj[u] = cntE++;  
    edge[cntE].v = u; edge[cntE].c = c; edge[cntE].n = adj[v]; adj[v] = cntE++;  
}  
void REV_BFS()
{  
    clear(num, 0);  
    clear(d, -1);  
    d[t] = 0;  
    num[0] = 1;  
    head = tail = 0;  
    Q[tail++] = t;  
    while(head != tail)
    {  
        int u = Q[head++];  
        for(int i = adj[u]; ~i; i = edge[i].n)
        {  
            int v = edge[i].v;  
            if(~d[v]) continue;  
            d[v] = d[u] + 1;  
            num[d[v]]++;  
            Q[tail++] = d[v];  
        }  
    }  
}  
int ISAP(){  
    copy(cur, adj);  
    REV_BFS();  
    int flow = 0, u = pre[s] = s, i;  
    while(d[s] < nv){  
        if(u == t){  
            int f = oo, neck;  
            for(i = s; i != t; i = edge[cur[i]].v){  
                if(f > edge[cur[i]].c){  
                    f = edge[cur[i]].c;  
                    neck = i;  
                }  
            }  
            for(i = s; i != t; i = edge[cur[i]].v){  
                edge[cur[i]].c -= f;  
                edge[cur[i] ^ 1].c += f;  
            }  
            flow += f;  
            u = neck;  
        }  
        for(i = cur[u]; ~i; i = edge[i].n) 
            if(edge[i].c && d[u] == d[edge[i].v] + 1) break;  
        if(~i){  
            cur[u] = i;  
            pre[edge[i].v] = u;  
            u = edge[i].v;  
        }  
        else{  
            if(0 == (--num[d[u]])) break;  
            int mind = nv;  
            for(i = adj[u]; ~i; i = edge[i].n){  
                if(edge[i].c && mind > d[edge[i].v]){  
                    cur[u] = i;  
                    mind = d[edge[i].v];  
                }  
            }  
            d[u] = mind + 1;  
            num[d[u]]++;  
            u = pre[u];  
        }  
    }  
    return flow;  
}  
void work(){  
    int u, v, c, sum = 0;  
    clear(adj, -1);  
    cntE = 0;  
    scanf("%d%d%d%d", &n, &m, &s, &t);  
    nv = n + 1;  
    for(int i = 0; i < m; ++i){  
        scanf("%d%d%d", &u, &v, &c);  
        addedge(u, v, c);  
        sum += c;//在这里求出所有道路的价值总和
    }  
    int flow = ISAP();  
    if(!flow){  
        printf("Inf\n");  
        return;  
    }  
    sum -= flow;  
    for(int i = 0; i < cntE; i += 2){  
        if(edge[i].c == 0)//
        {  
            edge[i].c = 1;  
            edge[i ^ 1].c = oo;  
        }  
        else if(edge[i ^ 1].c == 0)
        {  
            edge[i].c = oo;  
            edge[i ^ 1].c = 1;  
        }  
        else{  
            edge[i].c = edge[i ^ 1].c = oo;  
        }  
    }  
    int d = ISAP();  
    printf("%.2f\n", 1.0 * sum / d);  
}  
int main(){  
    int t;  
    scanf("%d", &t);  
    while(t--) work();  
    return 0;  
}