PAT天梯赛练习题——L3-007. 天梯地图（多边权SPFA）

 

L3-007. 天梯地图

时间限制

300 ms

内存限制

65536 kB

代码长度限制

8000 B

判题程序

Standard

作者

陈越

本题要求你实现一个天梯赛专属在线地图，队员输入自己学校所在地和赛场地点后，该地图应该推荐两条路线：一条是最快到达路线；一条是最短距离的路线。题目保证对任意的查询请求，地图上都至少存在一条可达路线。

输入格式：

输入在第一行给出两个正整数N（2 <= N <=500）和M，分别为地图中所有标记地点的个数和连接地点的道路条数。随后M行，每行按如下格式给出一条道路的信息：

V1 V2 one-way length time

其中V1和V2是道路的两个端点的编号（从0到N-1）；如果该道路是从V1到V2的单行线，则one-way为1，否则为0；length是道路的长度；time是通过该路所需要的时间。最后给出一对起点和终点的编号。

输出格式：

首先按下列格式输出最快到达的时间T和用节点编号表示的路线：

Time = T: 起点 => 节点₁ => ... => 终点

然后在下一行按下列格式输出最短距离D和用节点编号表示的路线：

Distance = D: 起点 => 节点₁ => ... => 终点

如果最快到达路线不唯一，则输出几条最快路线中最短的那条，题目保证这条路线是唯一的。而如果最短距离的路线不唯一，则输出途径节点数最少的那条，题目保证这条路线是唯一的。

如果这两条路线是完全一样的，则按下列格式输出：

Time = T; Distance = D: 起点 => 节点₁ => ... => 终点

输入样例1：

10 15
0 1 0 1 1
8 0 0 1 1
4 8 1 1 1
5 4 0 2 3
5 9 1 1 4
0 6 0 1 1
7 3 1 1 2
8 3 1 1 2
2 5 0 2 2
2 1 1 1 1
1 5 0 1 3
1 4 0 1 1
9 7 1 1 3
3 1 0 2 5
6 3 1 2 1
5 3

输出样例1：

Time = 6: 5 => 4 => 8 => 3
Distance = 3: 5 => 1 => 3

输入样例2:

7 9
0 4 1 1 1
1 6 1 3 1
2 6 1 1 1
2 5 1 2 2
3 0 0 1 1
3 1 1 3 1
3 2 1 2 1
4 5 0 2 2
6 5 1 2 1
3 5

输出样例2:

Time = 3; Distance = 4: 3 => 2 => 5

一开始把两条路径的选择方法看成一样的了。以为时间相同时也选节点数最少的，中间一组一直答案错误，然后改完发现最后一组仍然是段错误估计是数组越界，然后不停地加边数，最后段错误太多次直接给他25W就过了。

 

代码：

#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<sstream>
#include<cstring>
#include<cstdio>
#include<string>
#include<deque>
#include<stack>
#include<cmath>
#include<queue>
#include<set>
#include<map>
using namespace std;
#define INF 0x3f3f3f3f
#define MM(x) memset(x,0,sizeof(x))
#define MMINF(x) memset(x,INF,sizeof(x))
typedef long long LL;
const double PI=acos(-1.0);
const int N=510,M=250010;
typedef pair<int,int> pii;

struct info
{
	int to;
	int len;
	int time;
	int pre;
}E[M];
int head[M*2],cnt;

void add(int s,int t,int dx,int costt)
{
	E[cnt].to=t;
	E[cnt].len=dx;
	E[cnt].time=costt;
	E[cnt].pre=head[s];
	head[s]=cnt++;
}
struct road
{
	int dx;
	int step;
	int pre;
}dlen[N];
struct costtime
{
	int sumtime;
	int dx;
	int pre;
}dt[N];
void init(int n)
{
	memset(head,-1,sizeof(head));
	cnt=0;
	for (int i=0; i<N; i++)
	{
		dlen[i].dx=INF;
		dlen[i].step=1;
		dlen[i].pre=-1;
		dt[i].sumtime=INF;
		dt[i].dx=INF;
		dt[i].pre=-1;
	}
}
void LEN_spfa(int s)
{
	dlen[s].dx=0;
	priority_queue<pii>Q;
	Q.push(pii(-dlen[s].dx,s));
	while (!Q.empty())
	{
		int now=Q.top().second;
		Q.pop();
		for (int i=head[now]; i!=-1; i=E[i].pre)
		{
			int v=E[i].to;
			if((dlen[v].dx>dlen[now].dx+E[i].len)||
			(dlen[v].dx==dlen[now].dx+E[i].len&&dlen[v].step>dlen[now].step+1))
			{
				dlen[v].dx=dlen[now].dx+E[i].len;
				dlen[v].pre=now;
				dlen[v].step=dlen[now].step+1;
				Q.push(pii(-dlen[v].dx,v));
			}
		}
	}
}
void TIME_spfa(int s)
{
	dt[s].sumtime=0;
	dt[s].dx=0;
	priority_queue<pii>Q;
	Q.push(pii(-dt[s].sumtime,s));
	while (!Q.empty())
	{
		int now=Q.top().second;
		Q.pop();
		for (int i=head[now]; i!=-1; i=E[i].pre)
		{
			int v=E[i].to;
			if((dt[v].sumtime>dt[now].sumtime+E[i].time)||
			(dt[v].sumtime==dt[now].sumtime+E[i].time&&dt[v].dx>dt[now].dx+E[i].len))
			{
				dt[v].sumtime=dt[now].sumtime+E[i].time;
				dt[v].pre=now;
				dt[v].dx=dt[now].dx+E[i].len;
				Q.push(pii(-dt[v].sumtime,v));
			}
		}
	}
}
int main(void)
{
	int v1,v2,ops,len,time,n,m,i,j,s,t;
	while (~scanf("%d%d",&n,&m))
	{
		init(n);
		for (i=0; i<m; i++)
		{
			scanf("%d%d%d%d%d",&v1,&v2,&ops,&len,&time);
			add(v1,v2,len,time);
			if(ops==0)
				add(v2,v1,len,time);
		}
		scanf("%d%d",&s,&t);
		LEN_spfa(s);
		TIME_spfa(s);
		vector<int>LEN_road,TIME_road;
		for (i=t; i!=-1; i=dlen[i].pre)
		{
			LEN_road.push_back(i);
		}
		for (i=t; i!=-1; i=dt[i].pre)
		{
			TIME_road.push_back(i);
		}
		if(LEN_road==TIME_road)
		{
			printf("Time = %d; Distance = %d: ",dt[t].sumtime,dlen[t].dx);
			for (i=LEN_road.size()-1; i>=0; i--)
			{
				if(i==0)
					printf("%d\n",LEN_road[i]);
				else
					printf("%d => ",LEN_road[i]);
			}
		}
		else
		{
			printf("Time = %d: ",dt[t].sumtime);
			for (i=TIME_road.size()-1; i>=0; i--)
			{
				if(i==0)
					printf("%d\n",TIME_road[i]);
				else
					printf("%d => ",TIME_road[i]);
			}
			printf("Distance = %d: ",dlen[t].dx);
			for (i=LEN_road.size()-1; i>=0; i--)
			{
				if(i==0)
					printf("%d\n",LEN_road[i]);
				else
					printf("%d => ",LEN_road[i]);
			}
		}
	}
	return 0;
}

转载于:https://www.cnblogs.com/Blackops/p/5766321.html