hdu 5294 Tricks Device（2015多校第一场第7题）最大流+最短路

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

 

题意：给你n个墓室，m条路径，一个人在1号墓室（起点），另一个人在n号墓室（终点），起点的那个人只有通过最短路径才能追上终点的那个人，而终点的那个人能切断任意路径。

第一问——终点那人要使起点那人不能追上的情况下可以切的最少的路径数，输出最少的路径数

第二问——起点那人能追上终点那人的情况下，终点那人能切断的最多的路径数，输出最多的路径数

思路：要使起点那人无法追上，只要使他的最短路径不存在就好了，那么只要在最短路径上使每条路的流量为1，并球出1-n的最大流就是，能切断的最少的路径数；

要是起点那人能追上，那么只要他的最短路径存在就可以了，并在这些最短路径中求出路径数最少的那条，那么最多的路径数就是m-路径数最少的那条的路径数。

代码：

 #include <cstdio>
 #include <cstdlib>
 #include <cmath>
 #include <cstring>
 #include <iostream>
 #include <queue>
 #include <algorithm>
 #include <vector>
 using namespace std;
 #define LL __int64
 #define INF 0x3f3f3f3f
 const int MAXN=;
 struct qnode
 {
     int v;
     int c;
     qnode(int _v=,int _c=):v(_v),c(_c){}
     bool operator <(const qnode &r)const
     {
         return c>r.c;
     }
 };
 bool vis[];
 int dist[];
 int mp[][];
 void Dijkstra(int n,int start)//求最短路径大小
 {
     memset(vis,false,sizeof(vis));
     for(int i=;i<=n;i++)dist[i]=INF;
     priority_queue<qnode>que;
     while(!que.empty())que.pop();
     dist[start]=;
     que.push(qnode(start,,));
     qnode tmp;
     while(!que.empty())
     {
         tmp=que.top();
         que.pop();
         int u=tmp.v;
         if(vis[u])continue;
         vis[u]=true;
         for(int i=;i<=n;i++)
         {
             if(!vis[i]&&mp[u][i]<INF&&dist[i]>dist[u]+mp[u][i])
             {
                 dist[i]=dist[u]+mp[u][i];
                 que.push(qnode(i,dist[i]));
             }
         }
     }
 }

 int mp2[][];
 void Dijkstra1(int n,int start)//求最短的路数
 {
     memset(vis,false,sizeof(vis));
     for(int i=;i<=n;i++)dist[i]=INF;
     priority_queue<qnode>que;
     while(!que.empty())que.pop();
     dist[start]=;
     que.push(qnode(start,,));
     qnode tmp;
     while(!que.empty())
     {
         tmp=que.top();
         que.pop();
         int u=tmp.v;
         int gg=tmp.flag+;
         if(vis[u])continue;
         vis[u]=true;
         for(int i=;i<=n;i++)
         {
             if(!vis[i]&&mp2[u][i]<INF&&dist[i]>dist[u]+mp2[u][i])
             {
                 dist[i]=dist[u]+mp2[u][i];
                 que.push(qnode(i,dist[i]));
             }
         }
     }
 }
 struct edge
 {
     int from,to,cap,flow;
     edge(){}
     edge(int f,int t,int c,int fl):from(f),to(t),cap(c),flow(fl){}
 };

 struct Dinic
 {
     int n,m,s,t;
     vector<edge> edges;
     vector<int> G[MAXN];
     int cur[MAXN];
     int d[MAXN];
     bool vis[MAXN];
     void init(int n,int s,int t)
     {
         this->n=n, this->s=s, this->t=t;
         edges.clear();
         for(int i=;i<n;i++) G[i].clear();
     }
     void AddEdge(int from,int to,int cap)
     {
         edges.push_back( edge(from,to,cap,) );
         edges.push_back( edge(to,from,,) );
         m = edges.size();
         G[from].push_back(m-);
         G[to].push_back(m-);
     }
     bool BFS()
     {
         queue<int> Q;
         Q.push(s);
         memset(vis,,sizeof(vis));
         d[s]=;
         vis[s]=true;
         while(!Q.empty())
         {
             int x=Q.front(); Q.pop();
             for(int i=;i<G[x].size();++i)
             {
                 edge& e=edges[G[x][i]];
                 if(!vis[e.to] && e.cap>e.flow)
                 {
                     d[e.to]=+d[x];
                     vis[e.to]=true;
                     Q.push(e.to);
                 }
             }
         }
         return vis[t];
     }
     int DFS(int x,int a)
     {
         if(x==t || a==) return a;
         int flow=,f;
         for(int& i=cur[x];i<G[x].size();++i)
         {
             edge& e=edges[G[x][i]];
             if(d[e.to]==d[x]+ && (f=DFS(e.to,min(a,e.cap-e.flow) ) )>)
             {
                 e.flow +=f;
                 edges[G[x][i]^].flow -=f;
                 flow +=f;
                 a-=f;
                 if(a==) break;
             }
         }
         return flow;
     }
     int max_flow()
     {
         int ans=;
         while(BFS())
         {
             memset(cur,,sizeof(cur));
             ans += DFS(s,INF);
         }
         return ans;
     }
 }DC;
 int ggg[][];

 int main()
 {
     int n,m,i,j,a,b,c;
     while(~scanf("%d%d",&n,&m))
     {
         DC.init(n,,n);
         memset(ggg,,sizeof(ggg));
         for(i=;i<=n;i++)
             for(j=;j<=n;j++)
                 mp[i][j]=mp2[i][j]=INF;
         for(i=;i<m;i++)
         {
             scanf("%d%d%d",&a,&b,&c);
             if(mp[a][b]>c)
             {
                 mp[a][b]=c;
                 mp[b][a]=c;
                 ggg[a][b]=;
                 ggg[b][a]=;
             }
             else if(mp[a][b]==c)
             {
                 ggg[a][b]++;
                 ggg[b][a]++;
             }
         }
         Dijkstra(n,);
         for(i=;i<=n;i++)
         {
             for(j=;j<=n;j++)
             {
                 if(mp[i][j]+dist[i]==dist[j])
                 {
                     for(int k=;k<ggg[i][j];k++)
                         DC.AddEdge(i,j,);
                     mp2[i][j]=;
                 }
             }
         }
         Dijkstra1(n,);
         printf("%d %d\n",DC.max_flow(),m-dist[n]);
     }
     return ;
 }