题目描述
一个无环的有向图称为无环图(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
该题是以最短路的思想,按照题意求最长路。但是Dijkstra O(n^2)和Bellman O(n*m)的算法对该题来讲显然会超时,所以为了减少复杂度需要用SPFA算法,该算法复杂度最多为O(2*n)。其次与以往不同该题需要输出路径,而且路径需要按字典序选取,所以反向建图会更方便记录路径。
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
using namespace std;
struct node
{
int next;
int v;
int w;
}d[51000];
struct no
{
int in,out;
}degree[11000];
int head[11000];
int dis[11000];
int pos[11000];
int vis[11000];
queue<int>q;
int top;
void creat(int x,int y,int w)
{
d[top].next=head[x];
d[top].v=y;
d[top].w=w;
head[x]=top++;
}
void SPFA(int s)
{
int x,y;
vis[s]=1;
q.push(s);
while(!q.empty())
{
x=q.front();q.pop();
vis[x]=0;
for(int k=head[x];k!=0;k=d[k].next)
{
y=d[k].v;
if(dis[x]+d[k].w>=dis[y])
{
if(dis[x]+d[k].w>dis[y])
{
dis[y]=dis[x]+d[k].w;
pos[y]=x;
if(!vis[y])
{
vis[y]=1;
q.push(y);
}
}
else if(dis[x]+d[k].w==dis[y])
{
if(x<pos[y])
{
pos[y]=x;
if(!vis[y])
{
vis[y]=1;
q.push(y);
}
}
}
}
}
}
}
int main()
{
int n,m,e,s,i;
int x,y,w,k;
while (scanf("%d%d",&n,&m)!=EOF)
{
top=1;
memset(head,0,sizeof(head));
memset(dis,0,sizeof(dis));
memset(vis,0,sizeof(vis));
memset(degree,0,sizeof(degree));
memset(pos,-1,sizeof(pos));
for(i=0;i<m;i++)
{
scanf("%d%d%d",&x,&y,&w);
creat(y,x,w);
degree[y].out++;
degree[x].in++;
}
for(i=1;i<=n;i++)
{
if(degree[i].in==0) s=i;
if(degree[i].out==0) e=i;
}
SPFA(s);
printf("%d\n",dis[e]);
k=e;
while(pos[k]!=-1)
{
printf("%d %d\n",k,pos[k]);
k=pos[k];
}
}
return 0;
}