有线电视网络（割的应用：拆点）：快读模板

给定一张 $n$ 个点 $m$ 条边的无向图，求最少去掉多少个点，可以使图不连通。

如果不管去掉多少个点，都无法使原图不连通，则直接返回 $n$。

输入格式

输入包含多组测试数据。

每组数据占一行，首先包含两个整数 $n$ 和 $m$，接下来包含 $m$ 对形如 $(x,y)$ 的数对，形容点 $x$ 与点 $y$ 之间有一条边。

数对 $(x,y)$ 中间不会包含空格，其余地方用一个空格隔开。

输出格式

每组数据输出一个结果，每个结果占一行。

数据范围

$0\le n\le 50$

输入样例：

0 0
1 0
3 3 (0,1) (0,2) (1,2)
2 0
5 7 (0,1) (0,2) (1,3) (1,2) (1,4) (2,3) (3,4)

输出样例：

0
1
3
0
2

---

思路

本道题强调的是删除点使得割的 $S$ 和 $T$ 不连通。但我们割强调的是割边，我们怎么转化呢？

此时我们就想到点化成边，常用的技巧是拆点。

那么我们此时连边的话就可以如上图所示了。

那么此时的割边就是在点里面，也就是入点和出点里面。（因为最后的割边是在点里面的割边）

因此我们在内部的边设为有限制，外部的边设为无穷就可以实现了。

如果最开始源点跟汇点之间是没有边的话，那么任何一条边都会经过某点的内部，也就是说源点和汇点不直接相连的话，那么对于从源点到汇点必然会经过某点的内部，因此流量就是有限值，那么从源点到汇点的流量是有限制，那么说明最大流是有限值那么最小割也是有限值。所以我们的割是简单割。

要推导这个，很容易，因为点割集是删掉那些点 $s$ 到 $t$ 就不连通。此时你把割边删了那么此时 $s$ 跟 $t$ 就不连通了，因此满足点割集。（前提：按照我们刚刚的建图方式）

那么反过来也很好证明，因为点割集是删掉使得 $s$ 与 $t$ 不联通，因此割边在点内，按照我们的建图方式，此时就是对应着简单割。（也可以这么理解就是我们从 $s$ dfs一遍，如果遇到点割集的话，我们就停下来不走了，这样肯定能使得 $s$ 和 $t$ 不连通，此时就可以证明是简单割了）

总结：个人感觉割的证明都是从 $s$ 开始 dfs 一遍，如果xxx，最后 $s$ 和 $t$ 不连通。

总结：个人还认为把容量设为 $1$ 。很适合求xxx个数。对于求点的个数，我们可以拆点。

反证法更好写。

大总结：割的套路：

• 构造流网络。

• 证明简单割和原问题中的性质具有一一对应关系（元素对应）。

• 证明其数值对应关系，一般都要跟最小割对应起来。

最小割模型的通用分析方式：

1. 通过原图构造一个流网络。
2. 证明流网络的割集合和原题要求的集合一一对应。
3. 可以设置一个“简单割”（割边是有限值）的定义辅助自己证明。

注意

这个地方是对称的，所以只需要枚举一半就可以了。

强力推荐

对于有其他字符，我们要抽取内部的数字的时候，我们可以用如下快读模板：

int read(){//快读
    int x=0;
    char ch=getchar();
    
    while(!('0'<=ch&&ch<='9')){
        ch=getchar();
    }
    
    while('0'<=ch&&ch<='9'){
        x=(x<<3)+(x<<1)+ch-'0';
        ch=getchar();
    }
    //here
    return x;
}

这个是基本模板，往后要新增什么只读一行等功能可以在 here 位置增加。

---

AC 代码

//我们可以枚举源点和汇点，然后我们拆点，拆成入点和出点，并把入点和出点的容量设置为1
//把其他的边设为无穷，这样就能保证割边在点内

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 210,M = (N+1000)*4+10,INT = 1e8;

int e[M],ne[M],f[M],h[N],idx;
int d[N],cur[N];
int n,m,S,T;

int read(){//快读
    int x=0;
    char ch=getchar();
    
    while(!('0'<=ch&&ch<='9')){
        ch=getchar();
    }
    
    while('0'<=ch&&ch<='9'){
        x=(x<<3)+(x<<1)+ch-'0';
        ch=getchar();
    }
    return x;
}

void add(int a,int b,int c){
    e[idx]=b,f[idx]=c,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=0,ne[idx]=h[b],h[b]=idx++;
}

bool bfs(){
    queue<int>q;
    
    memset(d,-1,sizeof d);
    
    d[S]=0,cur[S]=h[S];
    q.push(S);
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            if(d[ver]==-1&&f[i]){
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver==T)return true;
                q.push(ver);
            }
        }
    }
    return false;
}

int find(int u,int lim){
    if(u==T)return lim;
    
    int flow=0;
    
    for(int i=cur[u];~i&&flow<lim;i=ne[i]){
        int ver=e[i];
        
        cur[u]=i;
        
        if(d[ver]==d[u]+1&&f[i]){
            int t=find(ver,min(f[i],lim-flow));
            if(!t)d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

int dinic(){
    int r=0,flow;
    
    while(bfs())while(flow=find(S,INT))r+=flow;
    
    return r;
}

int main(){
    while(cin>>n>>m){
        memset(h,-1,sizeof h);
        
        for(int i=0;i<n;i++)add(i,i+n,1);
        
        for(int i=1;i<=m;i++){
            int a,b;
            // scanf(" (%d,%d)",&a,&b);
            a=read();
            b=read();
            add(a+n,b,INT);
            add(b+n,a,INT);
        }
        
        int res=n;
        
        for(int i=0;i<n;i++){
            for(int j=0;j<i;j++){
                //因为是对称的，所以只需枚举一半就可以了
                S=n+i,T=j;
                
                for(int k=0;k<idx;k+=2){
                    f[k]+=f[k^1];
                    f[k^1]=0;
                }
                
                res=min(res,dinic());
            }
        }
        cout<<res<<endl;
    }
    
    return 0;
}