关键路径 SDUTOJ 2498

SDUTOJ 2498 AOE网上的关键路径

Time Limit: 1000ms   Memory limit: 65536K  有疑问？点这里^_^

题目描述

一个无环的有向图称为无环图（Directed Acyclic Graph），简称DAG图。
 
  AOE(Activity On Edge)网：顾名思义，用边表示活动的网，当然它也是DAG。与AOV不同，活动都表示在了边上，如下图所示：
               
                     
   
如上所示，共有11项活动（11条边），9个事件（9个顶点）。整个工程只有一个开始点和一个完成点。即只有一个入度为零的点（源点）和只有一个出度为零的点（汇点）。
   
关键路径：是从开始点到完成点的最长路径的长度。路径的长度是边上活动耗费的时间。如上图所示，1
到2 到 5到7到9是关键路径（关键路径不止一条，请输出字典序最小的），权值的和为18。

输入

   
这里有多组数据，保证不超过10组，保证只有一个源点和汇点。输入一个顶点数n(2<=n<=10000),边数m(1<=m
<=50000),接下来m行，输入起点sv，终点ev,权值w（1<=sv,ev<=n,sv != ev,1<=w
<=20)。数据保证图连通。

输出

   
关键路径的权值和，并且从源点输出关键路径上的路径（如果有多条，请输出字典序最小的）。

示例输入

9 11
1 2 6
1 3 4
1 4 5
2 5 1
3 5 1
4 6 2
5 7 9
5 8 7
6 8 4
8 9 4
7 9 2

示例输出

18
1 2
2 5
5 7
7 9

 /*以后记住，输出路径的字典序最小，要反存边，才可以取到字典序*/
 /*这个题目的精华就在把边反向存，而不是正向存，我们可以这样解释一下：路径的字典序最小就是我们走到一个点的时候，向下一步走时，选择编号最小的，这就是字典序，但是最短路的更新过程中，(dis[edge[l].v]==dis[x]+edge[l].w&&x<pre[edge[l].v]，明显是对该点之前的点的编号取小，这样取出来，会有可能不是字典序
 */
 #include<queue>
 #define N 10010
 #include<iostream>
 #define M 50010
 using namespace std;
 #include<cstdio>
 #include<cstring>
 struct Edge{
     int v,last,w;
 }edge[M];
 int head[N],ans[N],pre[N],n,m,dis[N],indu[N],chudu[N];
 bool inque[N];
 void add_edge(int u,int v,int w,int k)
 {
     edge[k].v=v;edge[k].w=w;
     edge[k].last=head[u];
     head[u]=k;
 }
 void input()
 {
     int u,v,w;
     for(int i=;i<=m;++i)
     {
         scanf("%d%d%d",&u,&v,&w);
         add_edge(v,u,w,i);
         indu[u]++;chudu[v]++;
     }
 }
 void spfa(int u,int v)
 {
     queue<int>que;
     que.push(u);
     pre[u]=;dis[u]=;
     inque[u]=true;
     while(!que.empty())
     {
         int x=que.front();
         que.pop();
         inque[x]=false;
         for(int l=head[x];l;l=edge[l].last)
         {
             if(dis[edge[l].v]<dis[x]+edge[l].w||(dis[edge[l].v]==dis[x]+edge[l].w&&x<pre[edge[l].v]))
             {
                 dis[edge[l].v]=dis[x]+edge[l].w;
                 pre[edge[l].v]=x;
                 if(!inque[edge[l].v])
                 {
                     inque[edge[l].v]=true;
                     que.push(edge[l].v);
                 }
             }
         }
     }
 }
 void print(int u,int v)
 {
     printf("%d\n",dis[v]);
     int t=v;
     ans[++ans[]]=v;
     while(pre[t]!=)
     {
         ans[++ans[]]=pre[t];
         t=pre[t];
     }
     for(int i=;i<=ans[];++i)
       printf("%d %d\n",ans[i-],ans[i]);
 }
 int main()
 {
     while(scanf("%d%d",&n,&m)==)
     {
         memset(dis,,sizeof(dis));
         memset(edge,,sizeof(edge));
         memset(head,,sizeof(head));
         memset(indu,,sizeof(indu));
         memset(chudu,,sizeof(chudu));
         memset(pre,,sizeof(pre));
         memset(ans,,sizeof(ans));
         memset(inque,false,sizeof(inque));
         input();
         int u,v;
         for(int i=;i<=n;++i)
         {
             if(!indu[i]) u=i;
             if(!chudu[i]) v=i;
         }
         spfa(u,v);
         print(u,v);
     }
     return ;
 }