伊基的故事 I - 道路重建（最大流之关键边）

伊基是一个小国 – 凤凰国的国王。

凤凰国是如此之小，以至于只有一个城市负责日常商品的生产，并使用公路网将商品运送到首都。

伊基发现本国最大的问题在于运输速度太慢了。

因为伊基以前是 ACM/ICPC 的参赛者，他意识到这其实是一个最大流问题。

他编写了一个最大流程序，并计算出了当前运输网络的最大运输能力。

他对运输速度的现状十分不满，并希望能够提高国家的运输能力。

提高运输能力的方法很简单，伊基将在运输网络中重建一些道路，以使这些道路具有更高的运输能力。

但是不幸的是，凤凰国的财力有限，道路建设经费只够重建一条道路。

伊基想要知道共有多少条道路可以纳入重建道路候选名单。

这些道路需要满足，将其重建后，国家的总运输能力能够增加。

输入格式

第一行包含 $N$ 和 $M$，分别表示城市和道路的数量。

接下来 $M$ 行，每行包含三个整数 $a,b,c$，表示存在一条道路从城市 $a$ 通往城市 $b$，且运输能力为 $c$。

所有道路都是有方向的。

城市编号从 $0$ 到 $N-1$。

生产日常商品的城市为 $0$ 号城市，首都为 $N-1$ 号城市。

输出格式

输出一个整数 $K$，表示存在 $K$ 条道路，对其中每条道路进行重建都会增加运输网络的运输能力。

数据范围

$1\le N\le 500$,

$1\le M\le 5000$,

$0\le a,b\le N$

$0\le c\le 100$

输入样例：

2 1
0 1 1

输出样例：

1

思路

• 首先，我们分析一下：本题要我们将某一条边的容量变大，使得整个图的最大流变大。其实就是让我们找该流网络的关键边。

• 拓展：什么是关键边呢？顾名思义，只给其扩大容量之后整个流网络的最大流能够变大，对于这样的边我们称之为关键边。

• 那么我们该怎么去找关键边呢？我们可以分情况讨论。

  • 我们就是先求最大可行流 $f$，为什么呢？因为本道题跟最大运输量有关。
  • 当$f(u,v)<c(u,v)$ 不去找这样的边，因为你流量已经是那么多了，你增加容量没有意义。
    就比如这张图，我们发现我们给红色的边增加容量，此时就会存在从 $S->T$ 的一条增广路，有增广路此时就会使得最大流增加。反之，你给别的路增加容量都不会使得最大流增加。
    
  • 当 $f(u,v)=c(u,v)$ 在残留网络中存在 $s->u$ 的路也同时存在 $v->t$ 的路。

• 然后，我们发现了这些性质了之后，因此我们梳理一下总的思路：注意到这样一个性质，在原图上增加某条边的容量后最大流变大时，在残量网络上增加这条边的容量后应该会存在一条从源点到汇点的增广路。所以我们可以想出这样一个做法：先对原图跑一次最大流，求出原图的残量网络（个人感觉最大流往往跟残留网络有关）；再依次增加残量网络上每条边的容量，判断增加容量后是否存在从源点到汇点的增广路，如果存在说明它就是关键边。

• 接着，对于判断增加容量后是否存在从源点到汇点的增广路，我们可以：用 $dfs$ 来判断，特别的，如下图所示，我们是从 S 往 u 遍历，从 T 往 v 遍历。最后判断的时候，我们肯定得判断它是满流，即（!f[i]）且从u能否到s点，我们是看反向边，也就是 vis_s[e[i^1]]，还要就是从 v 能否到 T 我们看正向边，也就是 vis_t[e[i]]。

• 

代码

#include<iostream>
#include<algorithm>
#include<cstring>
#include<queue>

using namespace std;

const int N = 510,M = 10010,INT=1e8;

int e[M],ne[M],f[M],h[N],idx;
int d[N],cur[N];
int n,m,S,T;
bool vis_s[N],vis_t[N];//从起点开始看，和从终点开始看
int ans;

void add(int a,int b,int c){
    e[idx]=b,f[idx]=c,ne[idx]=h[a],h[a]=idx++;
    e[idx]=a,f[idx]=0,ne[idx]=h[b],h[b]=idx++;
}

bool bfs(){
    queue<int>q;
    memset(d,-1,sizeof d);
    
    d[S]=0;
    cur[S]=h[S];
    q.push(S);
    
    while(q.size()){
        int t=q.front();
        q.pop();
        
        for(int i=h[t];~i;i=ne[i]){
            int ver=e[i];
            
            if(d[ver]==-1&&f[i]){
                d[ver]=d[t]+1;
                cur[ver]=h[ver];
                if(ver==T)return true;
                q.push(ver);
            }
        }
    }
    return false;
}

int find(int u,int lim){
    if(u==T)return lim;
    
    int flow=0;
    
    for(int i=cur[u];~i&&flow<lim;i=ne[i]){
        int ver=e[i];
        
        cur[u]=i;
        
        if(d[ver]==d[u]+1&&f[i]){
            int t=find(ver,min(f[i],lim-flow));
            if(!t)d[ver]=-1;
            f[i]-=t,f[i^1]+=t,flow+=t;
        }
    }
    return flow;
}

int dinic(){
    int r=0,flow;
    
    while(bfs())while((flow=find(S,INT)))r+=flow;
    
    return r;
}

void dfs(int u,bool st[],int t){//t来区分正边还是反边
    
    st[u]=true;
    
    for(int i=h[u];~i;i=ne[i]){
        int j=i^t;
        int ver=e[i];
        //j是区别正反边
        if(f[j]&&!st[ver]){
            dfs(ver,st,t);
        }
    }
    
}

int main(){
    cin>>n>>m;
    
    memset(h,-1,sizeof h);
    
    S=0,T=n-1;
    
    for(int i=0;i<m;i++){
        int a,b,c;
        cin>>a>>b>>c;
        add(a,b,c);
    }
    
    dinic();
    dfs(S,vis_s,0);
    dfs(T,vis_t,1);
    
    for(int i=0;i<m*2;i+=2){//原图的所有边
        if(!f[i]&&vis_s[e[i^1]]&&vis_t[e[i]]){//!f[i]表示满流
            ans++;
        }
    }
    
    
    cout<<ans;
    
    return 0;
    
}