洛谷 P4123 [CQOI2016]不同的最小割 网络流+最小割树

版权声明：2333 https://blog.csdn.net/liangzihao1/article/details/81952059

题目描述
学过图论的同学都知道最小割的概念：对于一个图，某个对图中结点的划分将图中所有结点分成两个部分，如果结点 $s,t$ 不在同一个部分中，则称这个划分是关于 $s,t$ 的割。对于带权图来说，将所有顶点处在不同部分的边的权值相加所得到的值定义为这个割的容量，而 $s,t$ 的最小割指的是在关于 $s,t$ 的割中容量最小的割。

而对冲刺 NOI 竞赛的选手而言，求带权图中两点的最小割已经不是什么难事了。我们可以把视野放宽，考虑有 $N$ 个点的无向连通图中所有点对的最小割的容量，共能得到 $N(N−1)/2$ 个数值。这些数值中互不相同的有多少个呢？这似乎是个有趣的问题。

输入输出格式

输入格式：
第一行包含两个数 $N,M$，表示点数和边数。

接下来 MM 行，每行三个数 $u,v,w$，表示点 $u$ 和点 $v$ (从 $1$ 开始标号) 之间有一条权值是 $w$ 的边。

输出格式：
第一行为一个整数，表示不同的最小割容量的个数。

输入输出样例

输入样例#1：
4 4
1 2 3
1 3 6
2 4 5
3 4 4
输出样例#1：
3
说明
$1≤N≤850,1≤M≤8500,1≤w≤100000$。

分析：
由于函数名有点长，设$f(i,j)=mincut(i,j)$，即两个点的最小割。
对于任意三个点$a,b,c$，一定有

$$f(a,c)>=min(f(a,b),f(b,c))$$
证明：我们考虑割断 $a,c$，假设 $b$在 $c$集中（ $a$集同理），那么这种割法一定割断了 $a,b$，一定有 $f(a,c)>=f(b,c)$。
那么我们换元，有
$$f(a,b)>=min(f(a,c),f(c,b))$$
那么一定有 $f(a,c)=min(f(a,b),f(b,c))$。
这就说明了这个东西具有传递性，不必查询所有的最小割。
我们随便选一个点 $s$和 $t$，跑它们的最小割；然后把图分成两个集，然后再递归这个集，一个点最好设为上一个选过的点，另一个选集合内的点，这样就可以完美的连成一棵树。

而本题无需这么麻烦，因为是询问最小割的数量，其实就是这棵树上的边权的不同个数，每次得到树边权（跑出来的最小割值）插入一个$map$即可。

代码：

// luogu-judger-enable-o2
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstring>
#include <vector>
#include <queue>
#include <map>

const int maxn=1e3+7;
const int maxe=2e4+7;
const int inf=0x3f3f3f3f;

using namespace std;

int n,m,cnt,x,y,w,s,t,ans;
int ls[maxn],dis[maxn],p[maxn],vis[maxn];

struct edge{
    int y,w,op,next,rew;
}g[maxe];

queue <int> q;
map <int,int> mincut;

void add(int x,int y,int w)
{
    g[++cnt]=(edge){y,w,cnt+1,ls[x],w};
    ls[x]=cnt;
    g[++cnt]=(edge){x,w,cnt-1,ls[y],w};
    ls[y]=cnt;
}

void clean()
{
    for (int i=1;i<=cnt;i++) g[i].w=g[i].rew;
}

bool bfs()
{   
    for (int i=1;i<=n;i++) dis[i]=inf;
    q.push(s);
    dis[s]=0;
    while (!q.empty())
    {
        int x=q.front();
        q.pop();
        for (int i=ls[x];i>0;i=g[i].next)
        {
            int y=g[i].y;
            if ((g[i].w) && (dis[y]>dis[x]+1))
            {
                dis[y]=dis[x]+1;
                q.push(y);
            }
        }
    }
    return (dis[t]!=inf);
}

int dfs(int x,int maxf)
{
    if ((x==t) || (!maxf)) return maxf;
    int ret=0;
    for (int i=ls[x];i>0;i=g[i].next)
    {
        int y=g[i].y;
        if ((g[i].w) && (dis[y]==dis[x]+1))
        {
            int f=dfs(y,min(maxf-ret,g[i].w));
            if (!f) dis[y]=-1;
            ret+=f;
            g[i].w-=f;
            g[g[i].op].w+=f;
        }
    }
    return ret;
}

void find()
{
    q.push(s);
    vis[s]=1;
    while (!q.empty())
    {
        int x=q.front();
        q.pop();
        for (int i=ls[x];i>0;i=g[i].next)
        {
            int y=g[i].y;
            if ((g[i].w) && (!vis[y]))
            {
                vis[y]=1;
                q.push(y);
            }
        }
    }
}

int dinic()
{
    clean();
    int flow=0; 
    while (bfs()) flow+=dfs(s,inf);
    memset(vis,0,sizeof(vis));
    find();
    return flow;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=m;i++)
    {
        scanf("%d%d%d",&x,&y,&w);
        add(x,y,w);
    }   
    for (int i=1;i<=n;i++) p[i]=1;                          
    for (int i=2;i<=n;i++)
    {
        s=i; t=p[i];
        int d=dinic();
        if (!mincut[d]) ans++,mincut[d]=1;
        for (int j=i;j<=n;j++)
        {
            if ((p[j]==t) && (vis[j])) p[j]=s;
        }
    }
    printf("%d",ans);
}