POJ 1966 Cable TV Network（顶点连通度）

题意：给一个无向图，求至少去掉多少个点可以将其变成不连通的。

一道求无向图点割集的入门题。

先看一下点割集和顶点连通度的定义：

点连通度：一个具有N个点的图G中，在去掉任意k-1个顶点后（1<=k<=N），所得的子图仍然连通，去掉k个顶点后不连通，则称图G是k连通图。k称作G的连通度，记作K(G)。

独立轨：A，B是图G（有向无向均可）的两个顶点，我们称为从A到B的两两无公共内顶点的轨为独立轨，其最大条数记作P（A，B）。

设A和B是无向连通图G两个不相邻的顶点，那么最少要删除多少个点可以使A、B不连通呢？P（A，B）。

下面是Menger定理：

无向图G的顶点连通度K（G）和顶点间最大独立轨数目之间存在如下关系式：K(G) = |V(G) - 1|(当G为完全图时），K(G) = min{ P(A,B) }(当G不是完全图且AB∉E）。

其实可以把A、B看做源点和汇点。。那么点连通度就变为至少删多少个点才无法从源点到达汇点。。想到了什么呢？最小割。可是最小割割的是有容量的边，而这里却是点。稍微转换一下思路就好了，把所有用到的点v变成两个点v'和v''，并且这两点建边<v', v''>且容量为1，那么显然，删这条边就是删了点v。那么对其他边呢？由于我们所要求的是要删顶点数，所以不用关心边，那么对于原来边，由于每个点分化成了两个点，所以对原来的边e = <u, v>，要新建成两条变 e' = <u'', v'> 和 e'' = <v'', u'>，由于我们不关心这些边，所以直接容量设为无限大。这样这道题其实就变成了求这个网络图的最小割，也就是求这个新建的网络图的最大流。

由于求的是最小的点割集，所以要枚举所有的源点和汇点。由于是无向图，所以从A到B和从B到A实际是一样的，那么其实只要固定一个源点，枚举剩下的汇点，再一次求出其中最小的最大流，就得到了答案。

代码：

// Header.
#include <algorithm>
#include <iostream>
#include <sstream>
#include <cstring>
#include <cstdio>
#include <vector>
#include <string>
#include <bitset>
#include <queue>
#include <stack>
#include <cmath>
#include <ctime>
#include <set>
#include <map>
using namespace std;

// Macro
typedef long long LL;
#define mem(a, n) memset(a, n, sizeof(a))
#define rep(i, n) for(int i = 0; i < (n); i ++)
#define REP(i, t, n) for(int i = (t); i < (n); i ++)
#define FOR(i, t, n) for(int i = (t); i <= (n); i ++)
#define ALL(v) v.begin(), v.end()
#define put(a) printf("%d\n", a)
#define ss(a) scanf("%s", a)
#define si(a) scanf("%d", &a)
#define sii(a, b) scanf("%d%d", &a, &b)
#define siii(a, b, c) scanf("%d%d%d", &a, &b, &c)
#define VI vector<int>
#define pb push_back
const int inf = 1e2, N = 1e2 + 5, MOD = 1e9 + 7;
// Macro end

int T, cas = 0;
int n, m;
int c[N][N];

// EK
int Maxflow(int s, int t) {
    int fa[N], min_flow[N], cap[N][N];
    int flow = 0;
    mem(cap, 0);
    while(true) {
        queue<int> que;
        mem(fa, -1);
        fa[s] = -2;
        min_flow[s] = inf;
        que.push(s);
        while(!que.empty()) {
            int u = que.front(); que.pop();
            rep(v, 2 * n) {
                if(fa[v] == -1 && cap[u][v] < c[u][v]) {
                    que.push(v);
                    fa[v] = u;
                    min_flow[v] = min(min_flow[u], c[u][v] - cap[u][v]);
                }
            }
            if(fa[t] != -1) {
                int k = t;
                while(fa[k] >= 0) {
                    cap[fa[k]][k] += min_flow[t];
                    cap[k][fa[k]] -= min_flow[t];
                    k = fa[k];
                }
                break;
            }
        }
        if(fa[t] == -1) break;
        flow += min_flow[t];
    }
    return flow;
}
int main(){
    
    while(sii(n, m) != EOF) {
        mem(c, 0);
        int u, v;
        rep(i, n) c[i][i+n] = c[i+n][i] = 1;
        rep(i, m) {
            scanf(" (%d,%d)", &u, &v);
            c[u+n][v] = c[v+n][u] = inf;
        }
        int ans = inf;
        REP(i, 1, n) ans = min(ans, Maxflow(n, i));
        if(ans == inf) ans = n;
        printf("%d\n", ans);
    }
    
    return 0;
}