POJ 1815 Friendship

链接：http://poj.org/problem?id=1815

题目：在现代社会，每个人都有自己的朋友。由于每个人都很忙，他们只通过电话联系。你可以假定A 可以和B 保持联系，当且仅当：

(1) A 知道B 的电话号码，或

(2) A 知道C 的号码，而C 能联系上B。

如果A 知道B 的电话号码，则B 也知道A 的电话号码。有时，有人可能会碰到比较糟糕的事情，导致他与其他人失去联系。例如，他可能会丢失了电话簿，或者换了电话号码。

在本题中，告知N 个人之间的两两联系，这N 个人的编号为1～N。给定两个人，比如S 和T，如果有些人碰到糟糕的事情，S 可能会与T 失去联系。你的任务是计算至少多少人碰到糟糕的事情，会导致S 与T 失去联系。假定S 和T 不会碰到糟糕的事情。

思路：给定一个无向图、两个点。问至少删去多少个点才能使得两个点不再连通。S和T不能删去，所以如果S和T相连，答案为no answer。当S和T不相连时，所求为无向图的顶点连通度：

无向图的点连通度：

1. 将每个点u拆为u‘, u‘‘.顶点u‘到u‘‘连一条弧，容量为1。

2. 将图中的每条边(u, v)拆成<u‘‘, v‘>和<v‘‘, u‘>两条边，每条边的容量为INF。

3. 选一个源点A‘‘, 枚举汇点B‘. 求出最大流的最小值即为点连通度。

4. 所有具有流量1的弧(v‘, v‘‘)对应的顶点v构成了一个割点集。

至此，我们可以得到最少要删去多少点了。但是题目还要求字典序最小的割点集。做法是从小大一一枚举每个点，如果该点删去之后，最大流变小了，那么该点一定属于割点集。

代码：

/*
ID: [email protected]
PROG:
LANG: C++
*/
#include<map>
#include<set>
#include<queue>
#include<stack>
#include<cmath>
#include<cstdio>
#include<vector>
#include<string>
#include<fstream>
#include<cstring>
#include<ctype.h>
#include<iostream>
#include<algorithm>
using namespace std;
#define INF (1<<30)
#define PI acos(-1.0)
#define mem(a, b) memset(a, b, sizeof(a))
#define rep(i, a, n) for (int i = a; i < n; i++)
#define per(i, a, n) for (int i = n - 1; i >= a; i--)
#define eps 1e-6
#define debug puts("===============")
#define pb push_back
#define mkp make_pair
#define all(x) (x).begin(),(x).end()
#define fi first
#define se second
#define SZ(x) ((int)(x).size())
#define POSIN(x,y) (0 <= (x) && (x) < n && 0 <= (y) && (y) < m)
typedef long long ll;
typedef unsigned long long ULL;
const int maxn = 500;
const int maxm = 222222;
struct node {
    int v;    // vertex
    int cap;    // capacity
    int flow;   // current flow in this arc
    int nxt;
} e[maxm * 2];
int g[maxn], cnt;
int st, ed, n, N, s, t;
int mp[maxn][maxn];
void add(int u, int v, int c) {
    e[++cnt].v = v;
    e[cnt].cap = c;
    e[cnt].flow = 0;
    e[cnt].nxt = g[u];
    g[u] = cnt;

    e[++cnt].v = u;
    e[cnt].cap = 0;
    e[cnt].flow = 0;
    e[cnt].nxt = g[v];
    g[v] = cnt;
}

void init() {
    memset(g, 0, sizeof(g));
    cnt = 1;
    for (int i = 1; i <= N; i++) add(i, i + N, 1);
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) if (mp[i][j]) {
            add(i + N, j, INF);
            //add(j + N, i, INF);
        }
    }
    st = s + N, ed = t;
    n = 2 * N + 3;
}
int is[maxn];
void change(int x) {
    memset(g, 0, sizeof(g));
    cnt = 1;
    for (int i = 1; i < x; i++) if (!is[i]) add(i, i + N, 1);
    for (int i = x + 1; i <= N; i++) add(i, i + N, 1);
    for (int i = 1; i <= N; i++) {
        for (int j = 1; j <= N; j++) if (mp[i][j]) {
            add(i + N, j, INF);
            //add(j + N, i, INF);
        }
    }
    st = s + N, ed = t;
    n = 2 * N + 3;
}
int dist[maxn], numbs[maxn], q[maxn];
void rev_bfs() {
    int font = 0, rear = 1;
    for (int i = 0; i <= n; i++) { //n为总点数
        dist[i] = maxn;
        numbs[i] = 0;
    }
    q[font] = ed;
    dist[ed] = 0;
    numbs[0] = 1;
    while(font != rear) {
        int u = q[font++];
        for (int i = g[u]; i; i = e[i].nxt) {
            if (e[i ^ 1].cap == 0 || dist[e[i].v] < maxn) continue;
            dist[e[i].v] = dist[u] + 1;
            ++numbs[dist[e[i].v]];
            q[rear++] = e[i].v;
        }
    }
}
int maxflow() {
    rev_bfs();
    int u, totalflow = 0;
    int curg[maxn], revpath[maxn];
    for(int i = 0; i <= n; ++i) curg[i] = g[i];
    u = st;
    while(dist[st] < n) {
        if(u == ed) {   // find an augmenting path
            int augflow = INF;
            for(int i = st; i != ed; i = e[curg[i]].v)
                augflow = min(augflow, e[curg[i]].cap);
            for(int i = st; i != ed; i = e[curg[i]].v) {
                e[curg[i]].cap -= augflow;
                e[curg[i] ^ 1].cap += augflow;
                e[curg[i]].flow += augflow;
                e[curg[i] ^ 1].flow -= augflow;
            }
            totalflow += augflow;
            u = st;
        }
        int i;
        for(i = curg[u]; i; i = e[i].nxt)
            if(e[i].cap > 0 && dist[u] == dist[e[i].v] + 1) break;
        if(i) {   // find an admissible arc, then Advance
            curg[u] = i;
            revpath[e[i].v] = i ^ 1;
            u = e[i].v;
        } else {    // no admissible arc, then relabel this vertex
            if(0 == (--numbs[dist[u]])) break;    // GAP cut, Important!
            curg[u] = g[u];
            int mindist = n;
            for(int j = g[u]; j; j = e[j].nxt)
                if(e[j].cap > 0) mindist = min(mindist, dist[e[j].v]);
            dist[u] = mindist + 1;
            ++numbs[dist[u]];
            if(u != st)
                u = e[revpath[u]].v;    // Backtrack
        }
    }
    return totalflow;
}
int ans[maxn], tot = 0;
int main () {
    scanf("%d%d%d", &N, &s, &t);
    for (int i = 1; i <= N; i++)
        for (int j = 1; j <= N; j++) scanf("%d", &mp[i][j]);
    if (mp[s][t]) puts("NO ANSWER!");
    else {
        init();
        int mx = maxflow();
        if (mx == 0) {
            puts("0");
            return 0;
        }
        for (int i = 1; i <= N; i++) {
            change(i);
            int dd = maxflow();
            if (dd < mx) {
                is[i] = 1;
                ans[tot++] = i;
                mx = dd;
            }
            if (!mx) break;
        }
        printf("%d\n", tot);
        for (int i = 0; i < tot; i++) printf("%d%c", ans[i], i == tot - 1 ? '\n' : ' ');
    }
    return 0;
}