1660 - Cable TV Network（最大流最小割）

该题又是一道经典的最小割问题，不过不是割边而是割点 。问题是：最少删除几个点可以让图不连通 。 我们都知道最大流对应着最小割，所以重点在于建模 。

为了形成割，那么必须让点具有“流量”的性质，怎么做呢？ 对，拆点 。 和例题1658类似的方法，我们将每个点拆成两个点，连一条容量为1的边，那么每个点就被赋予了流量的性质，这次我们反而要令边的容量为无穷大，因为要删除点而不是边 。 

另外因为我们不知道要割哪两个集合才能使得最大流最小，所以我们可以枚举源点和汇点 。  不过不需要两个点都枚举，只枚举0和剩下的点就可以了，取得的最小的最大流就是使得图不连通的最小割 。 当然，不要忘了令源点和汇点的容量为无穷大，因为我们是不删除这两个点的 。 

细节参见代码：

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int INF = 1000000000;
const int maxn = 50 * 50 + 55 + 55;
int T,cnt,n,m,u,v,dd,ff,bb,t,k,vis[maxn],cur[maxn],d[maxn];
char s[maxn][maxn];
struct Edge {
  int from, to, cap, flow;
};
bool operator < (const Edge& a, const Edge& b) {
  return a.from < b.from || (a.from == b.from && a.to < b.to);
}
struct Dinic {
  int n, m, s, t;
  vector<Edge> old;
  vector<Edge> edges;    // 边数的两倍
  vector<int> G[maxn];   // 邻接表，G[i][j]表示结点i的第j条边在e数组中的序号
  bool vis[maxn];        // BFS使用
  int d[maxn];           // 从起点到i的距离
  int cur[maxn];         // 当前弧指针
void init(int n) {
    for(int i = 0; i < n; i++) G[i].clear();
    edges.clear();
}
void AddEdge(int from, int to, int cap) {
    edges.push_back((Edge){from, to, cap, 0});
    edges.push_back((Edge){to, from, 0, 0});
    m = edges.size();
    G[from].push_back(m-2);
    G[to].push_back(m-1);
}
bool BFS() {
    memset(vis, 0, sizeof(vis));
    queue<int> Q;
    Q.push(s);
    vis[s] = 1;
    d[s] = 0;
    while(!Q.empty()) {
      int x = Q.front(); Q.pop();
      for(int i = 0; i < G[x].size(); i++) {
        Edge& e = edges[G[x][i]];
        if(!vis[e.to] && e.cap > e.flow) {
          vis[e.to] = 1;
          d[e.to] = d[x] + 1;
          Q.push(e.to);
        }
      }
    }
    return vis[t];
}
int DFS(int x, int a) {
    if(x == t || a == 0) return a;
    int flow = 0, f;
    for(int& i = cur[x]; i < G[x].size(); i++) {
      Edge& e = edges[G[x][i]];
      if(d[x] + 1 == d[e.to] && (f = DFS(e.to, min(a, e.cap-e.flow))) > 0) {
        e.flow += f;
        edges[G[x][i]^1].flow -= f;
        flow += f;
        a -= f;
        if(a == 0) break;
      }
    }
    return flow;
}
int Maxflow(int s, int t) {
    this->s = s; this->t = t;
    int flow = 0;
    while(BFS()) {
      memset(cur, 0, sizeof(cur));
      flow += DFS(s, INF);
    }
    return flow;
  }
};
Dinic g;
char ss[maxn];
int main() {
    while(~scanf("%d%d",&n,&m)) {
        g.init(maxn-2);
        for(int i=0;i<n;i++) {
            g.AddEdge(i,i+n,1);//拆点
        }
        int a,b; char c;
        for(int i=0;i<m;i++) {
            while(c=getchar(), c!='(' );
                 scanf("%d%c%d%c",&a,&c,&b,&c);
            g.AddEdge(a+n,b,INF);//由假结点向真结点连边
            g.AddEdge(b+n,a,INF);
        }
        int ans = INF  ;
        g.old = g.edges;
        for(int i=0;i<g.old.size();i++) {
            if(g.old[i].from == 0 && g.old[i].to == n && g.old[i].cap > 0) {
                g.old[i].cap = INF; break;//修改源点
            }
        }
        for(int t=1; t<n; t++) {
            g.edges = g.old;
            for(int i=0;i<g.edges.size();i++) {
                if(g.edges[i].from == t && g.edges[i].to == t + n && g.edges[i].cap > 0) {
                    g.edges[i].cap = INF; break;//修改汇点
                }
            }
            ans = min(ans,g.Maxflow(0,t+n));
        }
        if(ans == INF) printf("%d\n",n);说明任意一个和0相连的点都无法形成割，只能删除所有点
        else printf("%d\n",ans);
    }
    return 0;
}