POJ 3921 Destroying the bus stations 最大流

题意：给出一张有向图，问至少删除几个节点，使从节点1到节点N的最短路径大于K。

思路：在上一篇文章中，我们用迭代加深搜索完成了这个问题。但是这个问题有更高效的解法。

            在图论中，我们用点的连通度描述对于一张图，删除最少的点使整个图不连通。

            我们有以下概念：1.内点：非源点和汇点的点称为内点。2.独立轨：是源点到汇点的一条路径，不同的独立轨是不相交的，即没有公共的内点。

            在以上定义下，最小割定理可以有新的描述：在网络中选择一个最小的内点集合并删去，使得源汇之间的所有独立轨都被破坏。这样，我们就能用最大流算法来求独立轨的个数了。

           从独立轨的定义可以看到，独立轨要求每个内点只能经过一次，这样，我们就能用网络流模型来解决点连通度问题。只需加上点的限制即可。

           而对于这道题，我们需要消除长度小于等于K的独立轨，而不是消除所有的独立轨。同时，长度大于K的独立轨是不用考虑的。

           首先，我们利用floyd求出所有的独立轨的长度，对于长度小于等于K的独立轨，我们将其加入流网络。

           同时对于每个点拆成入点和出点，为了满足独立轨的定义。这样，我们求出1的出点到N的入点的最大流就是需要删除的点的个数。

代码如下：

#include <cstdio>
#include <algorithm>
#include <cstring>

using namespace std;

struct edge{
    int from,to;
    int cap,flow;
    edge(int u =0,int v =0,int c=0,int f=0):from(u),to(v),cap(c),flow(f){}
};

struct ISAP{
    static const int INF = 0x3f3f3f3f;
    static const int MAX = 10000;//边的大小
    int head[MAX];//每个节点对应链表的开始位置
    int next[MAX];//链表的下一个节点在edges数组的位置
    int tot;//edges数组的大小
    edge edges[2 * MAX];//储存边的数组,两倍大小
    int que[MAX],front,tail;//队列，保存节点
    int d[MAX];//距离标号
    bool vis[MAX];//访问标记
    int num[MAX];//gap优化
    int pre[MAX];//增广路中，节点X的前面一个弧的标号
    int cur[MAX];//对于每个节点的，处理的当前弧。
    int s,t,n;//s源点标号，t汇点标号，n节点总数
    edge cut[2 * MAX]; //保存割的数组
    int cut_cnt;
    void init(int n){
        this->n = n;//注意此处的下标问题
        memset(head,-1,sizeof(head));
        tot = cut_cnt =  0;//
    }
    void addedge(int from,int to, int cap){
        edges[tot] = edge(from,to,cap,0);//注意无向边和有向边
        next[tot] = head[from], head[from] = tot++;
        edges[tot] = edge(to,from,0,0);
        next[tot] = head[to],head[to] = tot++;
    }
    void bfs(){
        memset(vis,0,sizeof(vis));
        front = tail = 0;
        d[t] = 0;
        vis[t] = true;
        que[tail++] = t;
        while(front < tail){
            int u = que[front++];
            for(int v = head[u]; v != -1; v = next[v]){
                edge & e = edges[v^1];
                if(e.cap > e.flow && !vis[e.from]){//对处于残余网络中的弧且没访问过的节点处理
                    d[e.from] = d[u] + 1;
                    vis[e.from] = true;
                    que[tail++] = e.from;
                }
            }
        }
    }
    int augment(){
        int x = t,a = INF;
        while(x != s){
            edge& e = edges[pre[x]];
            a = min(a,e.cap - e.flow);
            x = e.from;
        }

        x = t;
        while(x != s){
            edges[pre[x]].flow += a;
            edges[pre[x]^1].flow -= a;
            x = edges[pre[x]].from;
        }
        return a;
    }
    int maxflow(int s, int t){
        this->s = s, this->t = t;
        memset(num,0,sizeof(num));
        int flow = 0;
        bfs();
        for(int i = 0; i < n; ++i){//注意此处的下标问题
            num[d[i]]++,cur[i] = head[i];
        }
        int x = s;
        while(d[s] < n){
            if(x == t){//前进到t,进行增广
                flow += augment();
                x = s;
            }
            bool ok = false;
            for(int &v = cur[x]; v != -1; v = next[v]){
                edge& e = edges[v];
                if(e.cap > e.flow && d[x] == d[e.to] + 1){
                    ok = true;
                    pre[x = e.to] = v;//能增广，前进，记录
                    break;
                }
            }
            if(!ok){//不能增广，重新计算距离
                int m = n - 1;
                for(int v = head[x]; v != -1; v = next[v]){
                    edge & e = edges[v];
                    if(e.cap > e.flow) m = min(m,d[e.to]);
                }
                if(--num[d[x]] == 0) break;//gap优化
                num[d[x]=m+1]++;
                cur[x] = head[x];
                if(x != s) x = edges[pre[x]].from;//能回退，回退
            }
        }
        return flow;
    }
    void mincut(){
        bfs();//重新标记，被标记的是t可达的顶点
        for(int i = 0 ;i < tot; ++i){
            edge & e = edges[i];
            if(!vis[e.from] && vis[e.to] && e.cap > 0)
                cut[cut_cnt++] = e;
        }
    }
    void print(){
        printf("Graph:\n");
        for(int i = 0 ; i < tot; ++i){
            edge & e = edges[i];
            printf("%d->%d c:%d f:%d\n",e.from,e.to,e.cap,e.flow);
        }
    }
} solver;

int d[55][55];
int u[5000];
int v[5000];
const int INF = 0x3f3f3f3f;

int main(void)
{
    //freopen("in","r",stdin);
    int N,M,K;
    while(scanf("%d %d %d", &N,&M,&K),N||M||K){
        memset(d,0x3f,sizeof(d));
        for(int i = 1; i <= N; ++i)
            d[i][i] = 0;
        for(int i = 1; i <= M; ++i){
            scanf("%d %d", &u[i],&v[i]);
            d[u[i]][v[i]] = 1;
        }
        for(int k = 1; k <= N; ++k)
            for(int i = 1; i <= N; ++i)
                for(int j = 1; j <= N; ++j)
                    d[i][j] = min(d[i][j],d[i][k] + d[k][j]);
        solver.init(2 * N + 2);
        for(int i = 1; i <= N; ++i)
            solver.addedge(i,i+N,1);
        for(int i = 1; i <= M; ++i){
            if((d[1][u[i]] + d[v[i]][N])< K)
                solver.addedge(u[i]+N,v[i],INF);
           // printf("%d\n",d[1][u[i]] + d[v[i]][N]);
        }
        int s = 1 + N, t = N;
        printf("%d\n",solver.maxflow(s,t));
        //solver.print();
    }
    return 0;
}