SDUT 2498 AOE网上的关键路径(SPFA 最长路径)

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

关键路径就是求最长的路径，因为输出时要输出字典序最小的，所以在SPFA中在路径相等时，将相对小的顶点压入队列，然后，在AOE网中，入度为0的为源点，出度为0的点为汇点....感谢成神的数据

6 6

1 4 1

4 3 1

3 6 1

1 5 1

5 2 1

2 6 1

结果应为

3

1 4

4 3

3 6

#include <iostream>
#include <stdlib.h>
#include <queue>
#include <cstring>
using namespace std;
const int N = 50010;
const int MAX = 9999999;
struct node
{
    int u,v;
    int next;
} q[N*2];
int head[N];
int x[N],y[N];
int n,m,cnt;
void add(int t,int u,int v)
{
    q[cnt].u=u;
    q[cnt].v=v;
    q[cnt].next=head[t];
    head[t]=cnt++;
}
void SPFA(int r,int t)
{
    int b[N],v[N],a[N];
    memset(b,0,sizeof(0));
    memset(v,0,sizeof(v));
    memset(a,-1,sizeof(a));
    queue<int >qq;
    qq.push(r);
    b[r]=1;
    v[r]=0;
    while(!qq.empty())
    {
        int s=qq.front();
        qq.pop();
        b[s]=0;
        for(int i=head[s]; i!=-1; i=q[i].next)
        {
            if(v[q[i].u] < v[s] + q[i].v)
            {
                v[q[i].u]=v[s] + q[i].v;
                a[q[i].u]=s;
                if(!b[q[i].u])
                {
                    b[q[i].u]=1;
                    qq.push(q[i].u);
                }
            }
            else if((v[q[i].u] == v[s] + q[i].v)&&(q[i].u>s))
            {
                v[q[i].u]=v[s] + q[i].v;
                a[q[i].u]=s;
                if(!b[q[i].u])
                {
                    b[q[i].u]=1;
                    qq.push(q[i].u);
                }
            }
        }
    }
    int c[N],e=0;
    c[0]=t;
    for(int i=a[t]; i!=-1; i=a[i])
        c[++e]=i;
    cout<<v[t]<<endl;
    for(int i=e; i>=1; i--)
        cout<<c[i]<<" "<<c[i-1]<<endl;

}
int main()
{
    while(cin>>n>>m)
    {
        cnt=0;
        memset(head,-1,sizeof(head));
        memset(x,0,sizeof(x));
        memset(y,0,sizeof(y));
        for(int i=0; i<m; i++)
        {
            int u,v,w;
            cin>>u>>v>>w;
            x[u]++;
            y[v]++;
            add(u,v,w);
        }
        int xx,yy;
        for(int i=1; i<=n; i++)
        {
            if(!x[i])
                xx=i;
            if(!y[i])
                yy=i;
        }
        SPFA(yy,xx);
      }
    return 0;
}

Bellman 

#include <iostream>
#include <stdlib.h>
#include <queue>
#include <cstring>
using namespace std;
const int N = 100010;
const int MAX = 9999999;
struct node
{
    int u,v;
    int w;
} q[N*2];
int x[N],y[N];
int n,m,cnt;
void add(int u,int v,int w)
{
    q[cnt].u=u;
    q[cnt].v=v;
    q[cnt++].w=w;
}
void Bellman(int r,int t)
{
    int v[N];
    memset(v,0,sizeof(v));
    v[r]=0;
    int a[N];
    memset(a,-1,sizeof(a));
    for(int i=0;i<n;i++)
     {
         int flag=1;
         for(int j=0;j<cnt;j++)
         {
             if(v[q[j].v] < v[q[j].u] + q[j].w)
               {
                   v[q[j].v] = v[q[j].u] + q[j].w;
                   a[q[j].v] = q[j].u;
                   flag=0;
               }
               else if((v[q[j].v] == v[q[j].u] + q[j].w) && (a[q[j].v] > q[j].u))
               {
                   //v[q[j].v]= v[q[j].u] + q[j].w;
                   a[q[j].v] =q[j].u;
                    flag=0;
               }
         }
         if(flag)
         break;
     }

    cout<<v[t]<<endl;
   for(int i=t; i!=r; i=a[i])
        cout<<i<<" "<<a[i]<<endl;
}

int main()
{
    while(cin>>n>>m)
    {
        cnt=0;
        //memset(head,-1,sizeof(head));
        memset(x,0,sizeof(x));
        memset(y,0,sizeof(y));
        for(int i=0; i<m; i++)
        {
            int u,v,w;
            cin>>u>>v>>w;
            x[u]++;
            y[v]++;
            add(v,u,w);
        }
        int xx,yy;
        for(int i=1; i<=n; i++)
        {
            if(!x[i])
                xx=i;
            if(!y[i])
                yy=i;
        }
        Bellman(xx,yy);
      }
    return 0;
}