Uva1660 (点联通度、边联通度问题)

题意：

给定一个n（n<=50）的无向图，问最小删去几个点，可以使得这个图不连通

解法：  

1.  基本概念

(1)一个具有 N 个顶点的图，在去掉任意 K-1 个顶点后 (1<=K<=N) 所得的子图仍连通，而去掉 K 个顶点后的图不连通则称 G 是连通的， 那么K 称作图 G 的点连通度

(2)相应地如果至少去掉 K 条边使这个图不连通，则 K 成为图的边连通度

2.  求解思路

• 对于求解边联通度的问题，为每条边赋权值为1，然后求确定一点作为源点，枚举此点外的每个点作为汇点求最大流。
• 点联通度问题可以转换到边联通度问题上来，具体转换方法如下

  • 若 G 为无向图，假设有n个点：

    (1) 原 G 图中的每个顶点 v 变成两个顶点 v' 和 v+n ，顶点 v 至 v+n 有一条弧（有向边）连接，弧容量为 1;

    (2) 原 G 图中的每条边  e ＝ uv ，连一条 u+n 到 v 的弧，再连一条 v+n 到 u 的弧，容量均为INF

    (3) A” 为源顶点， B' 为汇顶点

    注意：弧是有向边

  • 若 G 为有向图，假设有n个点：

    (1) 原 G 图中的每个顶点 v 变成两个顶点 v' 和 v+n ，顶点 v 至 v+n 有一条弧（有向边）连接，弧容量为 1;

    (2) 原 G 图中的每条弧  e ＝ uv 变成一条有向轨 u'u"v'v" ，其中轨上的弧 u"v' 的容量为 ∞;

    (3) A” 为源顶点， B' 为汇顶点

• 指定一个源点 A" ，枚举汇点B'，求 A" 到 B' 的最大流 F

 #include<bits/stdc++.h>
 #define REP(i, a, b) for(int i = (a); i < (b); i++)
 #define MEM(a,x) memset(a,x,sizeof(a))
 #define INF 0x3f3f3f3f
 #define MAXN 300+10
 using namespace std;
 struct Edge {
     int from, to, cap, flow;
 };
 struct Dinic {
     int n, m, s, t;
     vector<Edge>edges;
     vector<int>G[MAXN];
     bool vis[MAXN];
     int d[MAXN];
     int cur[MAXN];
     void init() {
         for (int i = ; i < MAXN; i++) G[i].clear();
         edges.clear();
         memset(d, , sizeof(d));
     }
     void AddEdge(int from, int to, int cap) {
         edges.push_back({ from, to, cap,  });
         edges.push_back({ to, from, ,  });
         m = edges.size();
         G[from].push_back(m - );
         G[to].push_back(m - );
     }
     bool BFS() {
         int x, i;
         memset(vis, , sizeof(vis));
         queue<int>Q;
         Q.push(s);
         d[s] = ;
         vis[s] = ;
         while (!Q.empty()) {
             x = Q.front(), Q.pop();
             for (i = ; i < G[x].size(); i++) {
                 Edge & e = edges[G[x][i]];
                 if (!vis[e.to] && e.cap > e.flow) {
                     vis[e.to] = ;
                     d[e.to] = d[x] + ;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }
     int DFS(int x, int a) {
         if (x == t || a == )
             return a;
         int flow = , f;
         for (int &i = cur[x]; i < G[x].size(); i++) {
             Edge & e = edges[G[x][i]];
             if (d[x] +  == d[e.to] && (f = DFS(e.to, min(a, e.cap - e.flow))) > ) {
                 e.flow += f;
                 edges[G[x][i] ^ ].flow -= f;
                 flow += f;
                 a -= f;
                 if (a == )
                     break;
             }
         }
         return flow;
     }
     int Maxflow(int s, int t) {
         this->s = s, this->t = t;
         int flow = ;
         while (BFS()) {
             memset(cur, , sizeof(cur));
             flow += DFS(s, INF);
         }
         return flow;
     }
 }Men;
 int c[][];
 int main() {
     int n, m;
     while (scanf("%d%d", &n, &m) != EOF) {
         if (n == ) { puts(""); continue; }
         else if (n == ) { puts(""); continue; }
         else if (m == ) { puts(""); continue; }
         Men.init();
         int u, v, uu, vv;
         MEM(c, );
         REP(i, , n) Men.AddEdge(i, i + n, );
         REP(i, , m) {
             scanf(" (%d,%d)", &u, &v);
             uu = u + n; vv = v + n;
             Men.AddEdge(uu, v, INF); Men.AddEdge(vv, u, INF);
         }
         int ans = INF;
         vector<Edge>o=Men.edges;
         REP(i, , n) {
             Men.edges = o;
             ans = min(ans, Men.Maxflow(n, i));
         }
         printf("%d\n", ans == INF ? n: ans);
     }
     return ;
 }