HDU 6214 最小割边

双倍经验题：HDU 6214，3987

求最小割的最小边。

方案一：

首先跑最大流，这个时候割上都满载了，于是将满载的边 cap = 1，其他 inf ，再跑最大流，这个时候限定这个网络的关键边就是那个最少边的那个割。

方案二：

奇技淫巧，将每条边 cap* A + 1，最大流 = flow / A ，最小割边 = fow % A；

原理：每条边容量扩大 到 cap * A + 1，那么最大流也一定扩大到 *A + 1，原图是多解，但是新图，

例如最少边的个是2条边，那么他就扩大到了 *A + 2，其他的就更大，那么就变成唯一解了。

#include <bits/stdc++.h>

using namespace std;

const int maxn = ;
const long long INF = 0x3f3f3f3f3f3f3f3f;

struct Edge
{
    int from,to;
    long long cap,flow;
};

struct Dinic
{
    int n,m,s,t;
    vector<Edge> edge;
    vector<int> G[maxn];
    bool vis[maxn];
    int d[maxn];
    int cur[maxn];

    void init()
    {
        for(int i=;i<maxn;i++)
            G[i].clear();
        edge.clear();
    }

    void AddEdge (int from,int to,long long cap)
    {
        edge.push_back((Edge){from,to,cap,});
        edge.push_back((Edge){to,from,,});
        m = edge.size();
        G[from].push_back(m-);
        G[to].push_back(m-);
    }

    bool BFS()
    {
        memset(vis,,sizeof(vis));
        queue<int> Q;
        Q.push(s);
        d[s] = ;
        vis[s] = ;
        while(!Q.empty())
        {
            int x = Q.front();
            Q.pop();
            for(int i=; i<(int)G[x].size(); i++)
            {
                Edge & e = edge[G[x][i]];
                if(!vis[e.to]&&e.cap>e.flow)
                {
                    vis[e.to] = ;
                    d[e.to] = d[x] + ;
                    Q.push(e.to);
                }
            }
        }
        return vis[t];
    }

    long long DFS(int x,long long a)
    {
        if(x==t||a==) return a;
        long long flow = ,f;
        for(int & i = cur[x]; i<(int)G[x].size(); i++)
        {
            Edge & e = edge[G[x][i]];
            if(d[x] + ==d[e.to]&&(f=DFS(e.to,min(a,e.cap-e.flow)))>)
            {
                e.flow +=f;
                edge[G[x][i]^].flow -=f;
                flow +=f;
                a-=f;
                if(a==) break;
            }
        }
        return flow;
    }

    long long Maxflow (int s,int t) {
        this->s = s;this->t = t;
        long long flow = ;
        while(BFS()) {
            memset(cur,,sizeof(cur));
            flow+=DFS(s,INF);
        }
        return flow;
    }
}sol;

int main()
{
    int T;
    scanf("%d",&T);

    for(int z = ; z <= T; z++) {
        int n,m;
        scanf("%d%d",&n,&m);
        int s,t;
        scanf("%d%d",&s,&t);
        s--;
        t--;
        sol.init();
        for(int i = ; i < m; i++) {
            int u,v;

            long long c;
            scanf("%d%d%I64d",&u,&v,&c);
            u--;
            v--;
            sol.AddEdge(u,v,c*+);
        }

        printf("%lld\n",sol.Maxflow(s,t)%);
    }

    return ;
}