HDU 5294Tricks Device(最短路+最大流)

链接:http://acm.hdu.edu.cn/showproblem.php?pid=5294

题意挺裸的，就是A，B两个人，B要到A那里去，A不想让B过来，问，(1) A至少要切断多少道路才能成功阻止B。(2)A最多切掉多少条路，B还能到达。（双向边）

先看第二问，第二问比较简单，就是求B到A的最短路，然后求一下最少用几条路，除了这几条不切断，剩下的都可以切断。所以答案就是：总边数减去（1->n的最短路边数）。

第一问是求最小割，也就是第二问求出来的最短路中的最小割。根据最大流最小割定理，最大流的容量就是最小割的容量。要求多少条道路，那就把所有边的容量变成1。扫描所有边，如果满足（d[u]==d[v]+w）那么这条边就是最短路中可能使用的。把所有边找出来重新建图。然后跑一次最大流就是答案。

代码:

#include<cstdio>
#include<cstring>
#include<queue>
#include<map>
#include<iostream>
#include<vector>
#include<cstdlib>
#include<cmath>
#include<stack>
#include<ctime>
#include<cctype>
#include<algorithm>
using namespace std;
const int INF=1e9+7;
struct EE{
    int t,v,next;
    EE(){}
    EE(int a,int b,int c):t(a),v(b),next(c){}
}edge[120010];
int Ecnt,n,m,head[2010],d[2010],edgecnt[2010];
bool vis[2010];
inline void addedge(int a,int b,int c){
    edge[Ecnt]=EE(b,c,head[a]);
    head[a]=Ecnt++;
    edge[Ecnt]=EE(a,c,head[b]);
    head[b]=Ecnt++;
}
int SPFA(){
    queue<int> Q;
    for(int i=1;i<=n;i++)vis[i]=false,d[i]=edgecnt[i]=INF;
    vis[1]=true;d[1]=edgecnt[1]=0;
    Q.push(1);
    while(!Q.empty()){
        int s=Q.front();Q.pop();
        vis[s]=false;
        for(int i=head[s];i!=-1;i=edge[i].next){
            int to=edge[i].t,v=edge[i].v;
            if(d[to]>d[s]+v){
                d[to]=d[s]+v;
                edgecnt[to]=edgecnt[s]+1;
                if(!vis[to]){
                    vis[to]=true;
                    Q.push(to);
                }
            }
            else if(d[to]==d[s]+v&&edgecnt[to]>edgecnt[s]+1){
                edgecnt[to]=edgecnt[s]+1;
                if(!vis[to]){
                    vis[to]=true;Q.push(to);
                }
            }
        }
    }
    return edgecnt[n];    
}
vector<EE> fedge[2010];
int DFS(int s,int t,int f){
    if(s==t)return f;
    vis[s]=true;
    for(int i=0;i<fedge[s].size();i++){
        EE &e=fedge[s][i];
        if(!vis[e.t]&&e.v){
            int next=DFS(e.t,t,min(f,e.v));
            if(next){
                e.v-=next;
                fedge[e.t][e.next].v+=next;
                return next;
            }
        }
    }
    return 0;
}
inline void build(){
    for(int i=1;i<=n;i++)fedge[i].clear();
    for(int i=1;i<=n;i++){
        for(int j=head[i];j!=-1;j=edge[j].next){
            int to=edge[j].t,v=edge[j].v;
            if(d[to]==d[i]+v){
                fedge[i].push_back(EE(to,1,fedge[to].size()));//next的值是反向边的位置，便于查找当前边的反向边
                fedge[to].push_back(EE(i,0,fedge[i].size()-1));
            }
        }    
    }
}
int max_flow(){
    build();
    int ans=0;
    while(1){
        memset(vis,false,sizeof(vis));
        int now=DFS(1,n,INF);
        if(now)ans+=now;
        else return ans;
    }
}
int main(){
//    freopen("input.txt","r",stdin);
    while(scanf("%d%d",&n,&m)!=EOF){
        int a,b,c;
        Ecnt=0;memset(head,-1,sizeof(head));
        for(int i=0;i<m;i++){
            scanf("%d%d%d",&a,&b,&c);
            addedge(a,b,c);
        }
        int ans2=m-SPFA();
        int ans1=max_flow();
        printf("%d %d\n",ans1,ans2);
    }
//    printf("%.3f\n",(double)clock()/CLOCKS_PER_SEC);
       return 0;
}