AOE网上的关键路径

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

 ！！！注意：
逆序建表  容易比较字典序大小！

#include<bits/stdc++.h>

using namespace std;

struct node                                                  //建立邻接表存图
{
    int to,w;
    struct node *next;
};

struct node *rood[10010];
int indegree[10010],outdegree[10010];
int in,out;
int vis[10010],dis[10010],path[10010];
//vis标记点是否走过，其实可以用点是否在队列会更好
//dis标记距离
//path标记路径

void SPFA()                                                  //贝尔曼的改进
{
    memset(vis,0,sizeof(vis));                               //将各个量初始化
    memset(dis,0,sizeof(dis));
    memset(path,0,sizeof(path));
    queue<int>q;
    int x;
    x=in;
    vis[x]=1;
    q.push(x);
    while(!q.empty())
    {
        x=q.front();
        vis[x]=0;
        q.pop();
        struct node *p;
        p=rood[x];
        while(p)
        {
            if(dis[p->to]<dis[x]+p->w)                       //比较距离
            {
                path[p->to]=x;
                dis[p->to]=dis[x]+p->w;
                if(!vis[p->to])
                {
                    vis[p->to]=1;
                    q.push(p->to);
                }
            }
            else if(dis[p->to]==dis[x]+p->w&&x<path[p->to])  //比较字典序 
            {
                path[p->to]=x;
                dis[p->to]=dis[x]+p->w;
                if(!vis[p->to])
                {
                    vis[p->to]=1;
                    q.push(p->to);
                }
            }
            p=p->next;
        }
    }
    printf("%d\n",dis[out]);                                  //输出路径距离
    while(path[out])                                          //利用path输出路径
    {
        printf("%d %d\n",out,path[out]);
        out=path[out];
    }
}


int main()
{
    int n,m;
    while(~scanf("%d %d",&n,&m))                          
    {
        memset(indegree,0,sizeof(indegree));                  //入度出度初始化
        memset(outdegree,0,sizeof(outdegree));
        memset(rood,0,sizeof(rood));
        for(int i=0; i<m; i++)
        {
            int sv,ev,w;
            scanf("%d %d %d",&sv,&ev,&w);                      //逆序建表
            indegree[sv]++;
            outdegree[ev]++;
            struct node *t;
            t=(struct node *)malloc(sizeof(struct node));
            t->to=sv;
            t->w=w;
            t->next=NULL;
            t->next=rood[ev];
            rood[ev]=t;
        }
        for(int i=1; i<=n; i++)                                //找入口与出口
        {
            if(indegree[i]==0) in=i;
            if(outdegree[i]==0) out=i;
        }
        SPFA();
    }
    return 0;
}