HDU 5294 Tricks Device （最短路，最大流）

题意：给一个无向图（连通的），张在第n个点，吴在第1个点，‘吴’只能通过最短路才能到达‘张’，两个问题：（1）张最少毁掉多少条边后，吴不可到达张（2）吴在张毁掉最多多少条边后仍能到达张。

思路：注意是最短路才可达，但是最短路径可能有多条（即权值相等的）！！

　　第二个问题好回答，来次最短路，记录下到达每个点在最低权值的情况下的最少次用边。

　　第一个问题，同样只要砍掉最短路的某些边即可。要根据第2个问题所跑的SSSP，将不是最短路的边的剔除，重新建图，跑最大流，得到结果。

　　当然要考虑重边！

 #include <bits/stdc++.h>
 #define LL long long
 #define pii pair<int,int>
 #define INF 0x7f7f7f7f
 using namespace std;
 const int N=;
 vector<int> vect[], vect2[];
 int g[][];
 struct node
 {
     int from,to,cap,flow;
     node(){};
     node(int from,int to,int cap,int flow):from(from),to(to),cap(cap),flow(flow){};
 }edge[N*];
 struct node2//跑最短路用的
 {
     int from,to,cost;
     node2(){};
     node2(int from,int to,int cost):from(from),to(to),cost(cost){};
 }oldedge[N*];
 
 int edge_cnt,edge_cnt2, n, m;
 void add_node(int from,int to,int cap,int flow)
 {
     edge[edge_cnt]=node(from, to, cap, flow);
     vect[from].push_back(edge_cnt++);
 }
 void add_node2(int from,int to,int cost)//跑最短路用的
 {
     oldedge[edge_cnt2]=node2(from, to, cost);
     vect2[from].push_back(edge_cnt2++);
 }
 
 int flow[], path[];
 int cost[], inq[], times[];
 
 int BFS(int s,int e)
 {
     deque<int> que(,s);
     flow[s]=INF;
     while(!que.empty())
     {
         int x=que.front();
         que.pop_front();
         for(int i=; i<vect[x].size(); i++)
         {
             node e=edge[vect[x][i]];
             if(!flow[e.to] && e.cap>e.flow)
             {
                 flow[e.to]=min(flow[e.from], e.cap-e.flow);
                 path[e.to]=vect[x][i];
                 que.push_back(e.to);
             }
         }
         if(flow[e]) return flow[e];
     }
     return flow[e];
 }
 int max_flow(int s,int e)
 {
     int ans_flow=;
     while(true)
     {
         memset(path,,sizeof(path));
         memset(flow,,sizeof(flow));
 
         int tmp=BFS(s,e);
         if(!tmp)    return ans_flow;
         ans_flow+=tmp;
 
         int ed=e;
         while(ed!=s)
         {
             int t=path[ed];
             edge[t].flow+=tmp;
             edge[t^].flow-=tmp;
             ed=edge[t].from;
         }
     }
 }
 
 int spfa(int s,int e)
 {
     memset(cost,0x7f,sizeof(cost));
     memset(inq,,sizeof(inq));
     memset(times,0x7f,sizeof(times));//记录到达每个点的最少用边，前提是权最少
 
     deque<int> que(,s);
     cost[s]=;
     times[s]=;
     while(!que.empty())
     {
         int x=que.front();que.pop_front();
         inq[x]=;
         for(int i=; i<vect2[x].size(); i++)
         {
             node2 e=oldedge[vect2[x][i]];
             if(cost[e.to]>=cost[e.from]+e.cost)
             {
                 if( cost[e.to]>cost[e.from]+e.cost) times[e.to]=times[e.from]+;
                 else   times[e.to]=min(times[e.to],  times[e.from]+);
 
                 cost[e.to]=cost[e.from]+e.cost;
                 if(!inq[e.to])
                 {
                     inq[e.to]=;
                     que.push_back(e.to);
                 }
             }
         }
     }
     return times[e];
 }
 
 void build_graph()
 {
     for(int i=; i<=n; i++)
     {
         for(int j=; j<vect2[i].size(); j++)
         {
             node2 e=oldedge[vect2[i][j]];
             if(cost[e.to]==cost[e.from]+e.cost)
             {
                 add_node(e.from,e.to,,);
                 add_node(e.to,e.from,,);
             }
         }
     }
 }
 
 int main()
 {
     freopen("input.txt", "r", stdin);
     int a, b, c;
     while(~scanf("%d%d", &n, &m))
     {
         edge_cnt=;
         edge_cnt2=;
         memset(edge,,sizeof(edge));
         memset(oldedge,,sizeof(oldedge));
         for(int i=n; i>=; i--)   vect[i].clear(),vect2[i].clear();
 
         for(int i=; i<m; i++)
         {
             scanf("%d %d %d", &a, &b, &c);
             add_node2(a,b,c);
             add_node2(b,a,c);
         }
         int ans2=spfa(,n);
         build_graph();//重新建图
         int ans1=max_flow(,n);
         printf("%d %d\n", ans1, m-ans2);
     }
     return ;
 }

AC代码