HDU 3313 Key Vertex

题意：给出一张有向图。如果一个节点在图中被删除后，就能使得从S->T不连通，则称这个点key vertex。问这张图中有多少个点是key vertex。

网上有两种说法，一种是网络流，就是拆点建图，求最小割，为了限制增广次数，把S、T拆点后的容量限制到2，这样一来跑最大流得到maxflow，如果maxflow=0，则说明全部的点都可以是key vertex，如果maxflow=2，则说明只有S、T是key vertex，如果maxflow=1的话，就需要到残量网络中去找了。怎么找呢？首先从S出发始寻找在残量网络中可以到达的所有的点，把它们保存在一个队列里，并记上vis标记，然后把这个队列里的点u，我们判断从u出发的所有已经满流的正向边指向的点是否在BFS的时候被访问过，如果没有被访问过，那这个点就是一个key vertex，找到一个key vertex以后就可以退出这轮循环了。然后以刚才找到的key vertex为src再做BFS，这样一直迭代下去，直到找到了一个为汇点T的key vertex。

另外一种说法比网络流好写多了，先找一条最短路，并记录路径。然后也是从S开始找，找一个距离S最远的且在最短路路径上的点K，这个K就是一个key vertex。然后继续，以K为src去找一个距离K最远的且在最短路路径上的点K'，直到找到T为止。

贴一下网络流写的代码：

#pragma comment(linker, "/STACK:1024000000,1024000000")
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define INF 1<<30
#define maxn 200010
#define maxm 1000000
using namespace std;

int v[maxm],next[maxm],w[maxm];
int first[maxn],d[maxn],work[maxn],q[maxn],vis[maxn];
int e,S,T,n,m,rear,cnt;

void init(){
    e = 0;
    memset(first,-1,sizeof(first));
}

void add_edge(int a,int b,int c){
    v[e] = b;next[e] = first[a];w[e] = c;first[a] = e++;
    v[e] = a;next[e] = first[b];w[e] = 0;first[b] = e++;
}

int bfs(){
    rear = 0;
    memset(d,-1,sizeof(d));
    d[S] = 0;q[rear++] = S;
    for(int i = 0;i < rear;i++){
        for(int j = first[q[i]];j != -1;j = next[j])
            if(w[j] && d[v[j]] == -1){
                d[v[j]] = d[q[i]] + 1;
                q[rear++] = v[j];
                if(v[j] == T)   return 1;
            }
    }
    return 0;
}

int dfs(int cur,int a){
    if(cur == T)    return a;
    for(int &i = work[cur];i != -1;i = next[i]){
        if(w[i] && d[v[i]] == d[cur] + 1)
            if(int t = dfs(v[i],min(a,w[i]))){
                w[i] -= t;w[i^1] += t;
                return t;
            }
    }
    return 0;
}

int dinic(){
    int ans = 0;
    while(bfs()){
        memcpy(work,first,sizeof(first));
        while(int t = dfs(S,INF))   ans += t;
    }
    return ans;
}

void bfs(int src){
    rear = 0;
    vis[src] = 1,q[rear++] = src;
    for(int i = 0;i < rear;i++){
        for(int j = first[q[i]];j != -1;j = next[j])
            if(w[j] && !vis[v[j]]){
                vis[v[j]] = 1;
                q[rear++] = v[j];
            }
    }
}

void solve(){
    memset(vis,0,sizeof(vis));
    w[first[S]] = 0,w[first[T-n]] = 0;
    int src = S;
    bool flag = 1;
    while(1){
        bfs(src);
        flag = 1;
        for(int i = 0;i < rear;i++){
            if(!flag)   break;
            for(int j = first[q[i]];j != -1;j = next[j]){
                if((!(j&1)) && (!w[j]) && (!vis[v[j]])){
                    cnt++;
                    src = v[j];
                    flag = 0;
                    if(src == T)    return;
                }
            }
        }
    }
}
int main()
{
    while(scanf("%d%d",&n,&m) == 2){
        init();
        for(int i = 0;i < m;i++){
            int a,b;
            scanf("%d%d",&a,&b);
            add_edge(a+n,b,INF);
        }
        scanf("%d%d",&S,&T);
        for(int i = 0;i < n;i++){
            if(i != S && i != T)    add_edge(i,i+n,1);
            else    add_edge(i,i+n,2);
        }
        T += n;
        int maxflow = dinic();
        if(maxflow == 2){
            printf("2
");
        }else if(maxflow == 0){
            printf("%d
",n);
        }else{
            cnt = 0;
            solve();
            printf("%d
",cnt);
        }
    }
    return 0;
}