[ZJOI2011]最小割 & [CQOI2016]不同的最小割 分治求最小割

题面：

[ZJOI2011]最小割

[CQOI2016]不同的最小割

题解：

其实这两道是同一道题。。。。

最小割是用的dinic，不同的最小割是用的isap

其实都是分治求最小割

简单讲讲思路吧

就是首先全部的点都在一个集合里，然后随意定两个点为s和t，这里默认是第一个和最后一个。

然后找到最小割，最小割将整张图分为了s集和t集，于是我们再用这个最小割更新跨集合点对之间的最小割。

 这个很好理解，因为当前找到的最小割将s集和t集分开了，显然对于任意一组跨集合的点对而言，当前最小割都是一个可能的最小割。

然后我们再递归处理s集和t集（重复以上步骤）。

每次找到最小割后就更新跨集合点对。

本质上是分治吧。

之前看有些地方提到了最小割树，这里放个链接（这是我找到的写的最全的一篇了）

Gomory-Hu tree 最小割树

下面放代码吧，个人觉得看代码会更好理解，尤其是对分治不熟悉的人（比如我）

不同的最小割（isap）：

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define AC 900
#define ac 20000
#define inf 2139062143
#define D printf("line in %d
", __LINE__);
char READ[7000100], *o = READ;
int n, m, s, addflow, t, answer, tt;
int last[AC], c[AC], have[AC], a[AC], ans[AC][AC], good[AC];
int Head[AC], date[ac], Next[ac], haveflow[ac], tot = 1;
int q[AC], head, tail;
int ss[400000], cnt;
bool z[AC];

inline int read()
{
    int x = 0; char c = getchar();
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    return x;
}

inline void add(int f, int w, int S)
{
    date[++tot] = w, Next[tot] = Head[f], Head[f] = tot, haveflow[tot] = S;
    date[++tot] = f, Next[tot] = Head[w], Head[w] = tot, haveflow[tot] = S;
    //printf("%d ---> %d %d
", f, w, S);
}

inline void upmin(int &a, int b)
{
    if(b < a) a = b;
}

void pre()
{
    int u, v, e;
    n = read(), m = read();
    for(R i = 1; i <= n; i++) a[i] = i;
    for(R i = 1; i <= m; i++)
    {
        u = read(), v = read(), e = read();
        add(u, v, e);    
    }
    memset(ans, 127, sizeof(ans));
}

bool bfs()
{
    int x, now;
    memset(have, 0, sizeof(have));
    memset(c, 0, sizeof(c));
    have[1] = 1, c[t] = 1, x = t;
    head = tail = 0;
    q[++tail] = t;
    while(head < tail)
    {
        x = q[++head]; 
        for(R i = Head[x]; i ; i = Next[i])
        {
            now = date[i];
            if(haveflow[i] && !c[now])
            {
                c[now] = c[x] + 1;
                ++have[c[now]];//error...忘记统计了
                q[++tail] = now;
            }
        }
    }
    memcpy(good, Head, sizeof(Head));
    return c[s];
}

inline void aru()
{
    int x = t;
    while(x != s)
    {
        haveflow[last[x]] -= addflow;
        haveflow[last[x] ^ 1] += addflow;
        x = date[last[x] ^ 1];
    }
    tt += addflow;
}

void isap()
{
    int x = s, now; bool done;
    tt = 0, addflow = inf; 
    while(c[s] != 875)
    {
        if(x == t) aru(), addflow = inf, x = s;//忘记设置全局了，，，那在这里手动改一下吧
        done = false;
        for(R i = good[x]; i ; i = Next[i])
        {
            now = date[i];
            if(haveflow[i] && c[now] == c[x] - 1)
            {
                upmin(addflow, haveflow[i]);
                done = true;
                last[now] = i;
                good[x] = i;
                x = now;
                break;
            }
        }
        if(!done)
        {
            int go = 874;
            for(R i=Head[x]; i ; i = Next[i])
            {
                now = date[i];
                if(haveflow[i] && c[now]) upmin(go, c[now]);
            }
            good[x] = Head[x];
            if(!(--have[c[x]])) break;
            ++have[c[x] = go + 1];
            if(x != s) x = date[last[x] ^ 1];
        }
    }
}

void restore()//还原
{
    for(R i = 2; i <= tot; i += 2)//对于无向图而言，这还是非常妙的
        haveflow[i] = haveflow[i ^ 1] = (haveflow[i] + haveflow[i ^ 1]) / 2;
}

void dfs(int x)
{
    int now;
    z[x] = true;//....
    for(R i = Head[x]; i ; i = Next[i])
    {
        now = date[i];
        if(haveflow[i] && !z[now]) dfs(now);
    }
}

void solve(int l, int r)
{
    if(l == r) return ;
    s = a[l], t = a[r];
    restore();
    //printf("%d %d
", l, r);
    bfs();//重新定层次
    isap();
    memset(z, 0, sizeof(z));
    dfs(s);
    for(R i=1;i<=n;i++)//更新最小割
        if(z[i])
            for(R j=1;j<=n;j++)
                if(!z[j])
                    ans[i][j] = ans[j][i] = min(ans[i][j], tt);
    int ll = l - 1, rr = r + 1;
    for(R i = l; i <= r; i++)
        if(z[a[i]]) q[++ll] = a[i];
        else q[--rr] = a[i];//不知道取什么名字了，先借这个用一下吧
    for(R i = l; i <= r; i++) a[i] = q[i];
    solve(l, ll), solve(rr, r);
}

void work()
{
    for(R i=1;i<=n;i++)
        for(R j=1;j<i;j++)
            ss[++cnt] = ans[i][j];
    sort(ss + 1, ss + cnt + 1);
    for(R i=1;i<=cnt;i++)
        if(ss[i] != ss[i + 1]) ++answer;
    printf("%d
", answer); 
}

int main()
{
//    freopen("in.in","r",stdin);
    pre();
    solve(1, n);
    work();
//    fclose(stdin);
    return 0;
}

最小割（dinic）：

#include<bits/stdc++.h>
using namespace std;
#define R register int
#define LL long long
#define inf 2139062143
#define getchar() *o++
#define AC 155
#define ac 101000
#define D printf("line in %d
", __LINE__);

char READ[7001000], *o = READ;
int s, t, T, Q, n, m;
int last[AC], ans[AC][AC], a[AC], tmp[AC], c[AC];
int date[ac], Next[ac], haveflow[ac], Head[AC], tot;
int q[AC], head, tail;
bool z[AC];

inline int read()
{
    int x = 0;char c = getchar();bool z = false;
    while(c > '9' || c < '0') c = getchar();
    while(c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
    if(!z) return x;
    else return -x;
}

inline void add(int f, int w, int S)
{//因为是双向边，所以反向边就可以省掉了
    date[++tot] = w, Next[tot] = Head[f], Head[f] = tot, haveflow[tot] = S;
    date[++tot] = f, Next[tot] = Head[w], Head[w] = tot, haveflow[tot] = S;
//    printf("%d ---> %d %d
", f, w, S);
}

bool bfs()
{
    int now, x;
    head  = tail = 0;
    memset(c, 0, sizeof(c));
    c[s] = 1, q[++tail] = s;
    while(head < tail)
    {
        x = q[++head];
        for(R i = Head[x]; i ; i = Next[i])
        {
            now = date[i];
            if(haveflow[i] && !c[now])
            {
                c[now] = c[x] + 1;
                q[++tail] = now;
            }
        }
    }
    return c[t];
}

int dfs(int x, int flow)
{
    if(x == t) return flow;
    int addflow, used = 0, now;
    for(R i=Head[x]; i ; i = Next[i])
    {
        now = date[i];
        if(c[now] == c[x] + 1)
        {//流到下一个点去的流量在haveflow和剩余流量中取最小值
            addflow = dfs(now, min(haveflow[i], flow - used));
            haveflow[i] -= addflow;
            haveflow[i^1] += addflow;
            used += addflow;
            if(used == flow) return flow;
        }
    }
    if(!used) c[x] = 0;
    return used;
}

int dinic()
{
    int rnt = 0;
    while(bfs()) rnt += dfs(s, inf);
    return rnt;
}

void DFS(int x)//标记能到的点，便于区分
{
    int now;
    z[x]= 1;
    for(R i = Head[x]; i ; i = Next[i])
    {
        now = date[i];
        if(haveflow[i] && !z[now]) DFS(now); 
    }
}

void restore()//挺妙的还原流量的方法，因为这两条边即是双向边，又可以当反向边
{//因此总流量肯定是不会变的，所以加起来取个平均值就相当于还原了
    for(R i = 2; i <= tot; i += 2)
        haveflow[i] = haveflow[i+1] = (haveflow[i] + haveflow[i+1]) / 2;
}

void solve(int l, int r)
{
    if(l == r) return ;
    restore();
    s = a[l], t = a[r];//随便选两个作为s和t
    int tt = dinic();//跑最小割
    memset(z, 0, sizeof(z));
    DFS(s);//查看哪些点是能到的(即没有被割断）
    for(R i=1;i<=n;i++)//这里是在每次找到一个最小割的时候，就对跨集合点对的割进行更新，
        if(z[i])//因此每次是需要枚举所有点对的。不然的话因为i是枚举的s集里面的东西，可能会导致某些点对没有被统计到
            for(R j=1;j<=n;j++)//获取跨集合点对的割的大小
                if(!z[j]) ans[i][j] = ans[j][i] = min(ans[i][j], tt);
    int ll = l - 1, rr = r + 1;
    for(R i = l; i <= r; i++)
        if(z[a[i]])//如果这个点可以属于s集
            tmp[++ll] = a[i];//加入左边（从左边开始塞）
        else tmp[--rr] = a[i];//不然就放在右边
    for(R i=l;i<=r;i++) a[i] = tmp[i];//类似于归并排序的，，，放回数组内
    solve(l, ll), solve(rr, r);
}

void pre()
{
    int u, v, k;
    tot  = 1;
    memset(ans, 127, sizeof(ans));
    memset(Head, 0, sizeof(Head));
    n = read(), m = read();
    for(R i=1;i<=n;i++) a[i] = i;//先把点按顺序放进来
    for(R i=1;i<=m;i++)
    {
        u = read(), v = read(), k = read();
        add(u, v, k);
    }
    solve(1, n);//找出所有最小割
}

void work()
{
    int k, cnt;
    Q = read();
    while(Q--)
    {
        k = read(), cnt = 0;
        for(R i=1;i<=n;i++)
            for(R j=1;j<i;j++)//不能一个点对重复统计了
                if(ans[i][j] <= k) ++cnt;
        printf("%d
", cnt);
    }
    printf("
");
}

int main()
{
//    freopen("in.in","r",stdin);
    fread(READ, 1, 7000000, stdin);
    T = read();
    while(T--)
    {
        pre();
        work();
    }
//    fclose(stdin);
    return 0;
}