Problem Description
Consider a network G=(V,E) with source s and sink t. An s-t cut is a partition of nodes set V into two parts such that s and t belong to different parts. The cut set is the subset of E with all edges connecting nodes in different parts. A minimum cut is the one whose cut set has the minimum summation of capacities. The size of a cut is the number of edges in the cut set. Please calculate the smallest size of all minimum cuts.

Input
The input contains several test cases and the first line is the total number of cases T (1≤T≤300).
Each case describes a network G, and the first line contains two integers n (2≤n≤200) and m (0≤m≤1000) indicating the sizes of nodes and edges. All nodes in the network are labelled from 1 to n.
The second line contains two different integers s and t (1≤s,t≤n) corresponding to the source and sink.
Each of the next m lines contains three integers u,v and w (1≤w≤255) describing a directed edge from node u to v with capacity w.

Output
For each test case, output the smallest size of all minimum cuts in a line.

Sample Input
2
4 5
1 4
1 2 3
1 3 1
2 3 1
2 4 1
3 4 2
4 5
1 4
1 2 3
1 3 1
2 3 1
2 4 1
3 4 3

Sample Output
2
3

Source
2017 ACM/ICPC Asia Regional Qingdao Online

無語自己，比賽結束一打程式碼就過了，裸的最小割最小割邊

用的第一種，比賽時用第二種一直超時和WA，哎！
對於第一種演算法：
最小割最小割邊的 建邊的時候每條邊權 w = w * (E + 1) + 1; //加上1之後跑出來的最大流必定是變數最小的。
這樣得到的最大流為max_flow/(E+1)，因為即使所以的邊都算上，也只是多個E，那麼除以(E+1)是完全不影響的，而最小的割邊數是max_flow % (E+1) 即把全部的1
算上也只有E，對E＋1取餘後就是最小的變數

而第二種演算法，可以過HDU3987 但其實是一種錯誤的演算法，在有些情況時跑出來的不是最小邊，如下圖，某位大神給我找到的反例，這個圖就可以搞掉第二種演算法，不過如果是用鏈式前向星存圖的話，可能是走1000那條邊的，就再修改一下：

紅線代表滿流邊，如果按照第二種演算法的話得到的是2，而實際是4.

#include<iostream>
#include<cstring>
#include<cmath>
#include<vector>
#include<string>
#include<queue>
#include<algorithm>

using namespace std;
const int MAX_V = 210;
const int MAX_E = 3010;
const int INF = 0x3f3f3f3f;

int V,E;
struct Edge{
    int to,cap,rev;
};
vector<Edge> G[MAX_V];
int level[MAX_V],iter[MAX_V];

void add(int u,int v,int cap){
    G[u].push_back((Edge){v,cap*(E+1)+1,(int)G[v].size()});
    G[v].push_back((Edge){u,0,(int)G[u].size()-1});
}

void bfs(int s){
    memset(level,-1,sizeof(level));
    queue<int> q;
    level[s] = 0;
    q.push(s);
    while(!q.empty()){
        int v = q.front();q.pop();
        for(int i=0;i<G[v].size();i++){
            Edge &e = G[v][i];
            if(e.cap > 0 && level[e.to] < 0){
                level[e.to] = level[v] + 1;
                q.push(e.to);
            }
        }
    }
}

int dfs(int s,int t,int f){
    if(s == t)  return f;
    for(int &i = iter[s];i < G[s].size();i++){
        Edge &e = G[s][i];
        if(e.cap > 0 && level[s] < level[e.to]){
            int d = dfs(e.to,t,min(e.cap,f));
            if(d > 0){
                e.cap -= d;
                G[e.to][e.rev].cap += d;
                return d;
            }
        }
    }
    return 0;
}

int max_flow(int s,int t){
    int res = 0;
    while(true){
        bfs(s);
        if(level[t] < 0)    return res;
        memset(iter,0,sizeof(iter));
        int f = 0;
        while((f = dfs(s,t,INF)) > 0)
            res += f;
    }
}
int main(void){
    int t;
    scanf("%d",&t);
    while(t--){
        scanf("%d %d",&V,&E);
        for(int i=1;i<=V;i++)
            G[i].clear();
        int a,b;
        scanf("%d %d",&a,&b);
        int x,y,z;
        for(int i=1;i<=E;i++){
            scanf("%d %d %d",&x,&y,&z);
            add(x,y,z);
        }
        int res = max_flow(a,b);
        printf("%d\n",res % (E+1));
    }


    return 0;
}