hdu HDU 5294 - Tricks Device(最短路+最小割)

题意：

n个点，m条边，构建有权无向图。

求出删去最少条边数可以使得图没有最短路径，以及删出最多条边使得图仍有最多条路径。

思路：

最短路处理出最短路径图，做法是使用dis数组，若若dis[v]-dis[u] = w(u,v)，则该路在最短路径中。

建出最短路径之后 跑一次网络流，得到第一个答案。

在跑最短路中记录最短路的最少路数，ans2 = m - minb.

#include <iostream>
#include<stdio.h>
#include<string.h>
#include<vector>
#include<algorithm>
#include<cmath>
#include<map>
#include<queue>
using namespace std;
const int N=2005;
const int MAXN=(1<<31)-1;
int INF=0x7f7f7f7f;
 int T,n,m,k,tot;
 int cas=1;
 int head[N];
 struct Edge{
    int to,w,next;
 }edge[60005*2];
 void addedge(int u,int v,int w){
    edge[tot].to=v;
    edge[tot].w=w;
    edge[tot].next=head[u];
    head[u]=tot++;

    edge[tot].to=u;
    edge[tot].w=w;
    edge[tot].next=head[v];
    head[v]=tot++;
 }

 int dis[N],vis[N];
 int minb[N];
 int spfa(int s){
    memset(dis,0x3f,sizeof dis);
    memset(vis,0,sizeof vis);
    memset(minb,0x3f,sizeof minb);

    queue<int> q;
    dis[s]=0;
    minb[s]=0;
    vis[s]=1;
    q.push(s);

    while(!q.empty()){
        int u=q.front();q.pop();
        vis[u]=0;

        for(int i=head[u];~i;i=edge[i].next){
           int v=edge[i].to,w=edge[i].w;
           if(dis[v]==dis[u]+w){
                minb[v]=min(minb[v],minb[u]+1);
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
           }

           if(dis[v]>dis[u]+w){
                dis[v]=dis[u]+w;
                minb[v]=minb[u]+1;
                if(!vis[v]){
                    vis[v]=1;
                    q.push(v);
                }
           }


        }
    }
 }
 struct Eg{
    int u,cap,rev;
    Eg(int uu,int cc,int rr){
        u=uu;cap=cc;rev=rr;
    }
 };
 vector<Eg> G[N];
 void add(int u,int v,int cap){
    G[u].push_back(Eg(v,cap,G[v].size()));
    G[v].push_back(Eg(u,0,G[u].size()-1));
 }


 void build(){
    for(int i=1;i<=n;i++){
        for(int j=head[i];~j;j=edge[j].next){
            int v=edge[j].to,w=edge[j].w;
            if(dis[v]==dis[i]+w){
                add(i,v,1);

            }
        }
    }
 }
 bool used[N];
 int dfs(int v,int t,int f){
    if(v==t) return f;
    used[v]=true;
    for(int i=0;i<G[v].size();i++){
        Eg &e=G[v][i];
        if(!used[e.u] && e.cap>0){
            int d=dfs(e.u,t,min(f,e.cap));
            if(d>0){
                e.cap-=d;
                G[e.u][e.rev].cap+=d;
                return d;
            }
        }
    }
    return 0;
 }
 int max_flow(int s,int t){
  int flow=0;
  while(1){
    memset(used,0,sizeof used);
    int f=dfs(s,t,INF);
    if(f==0) return flow;
    flow+=f;
  }
 }
  void init(){
    tot=0;
    memset(head,-1,sizeof head);
    for(int i=0;i<N;i++) G[i].clear();
 }
int main()
{
#ifndef  ONLINE_JUDGE
   freopen("aaa","r",stdin);
#endif


    while(~scanf("%d%d",&n,&m)){
        init();
        for(int i=0;i<m;i++){
            int u,v,w;
            scanf("%d %d %d",&u,&v,&w);
            addedge(u,v,w);
        }
        spfa(1);

        build();
        int ans=max_flow(1,n);
        printf("%d %d\n",ans,m-minb[n]);
    }



    return 0;
}