UVA11374 Airport Express(SPFA求最短路)

城市里面有n个站点,一些站点之间通过双向边相连。现在在一些站点之间可能有快速路,可以减少通行的时间,但是你只能经过一次快速路。问到终点的最少时间,并输出方案。

思路还是很好想,输出就有点蛋疼了。设d1[i]表示起点到i的最短距离,d2[i]表示终点到i的最短距离。枚举每一条可能使用的快速路(a,b),用d1[a]+w(a,b)+d2[b]或d1[b]+w(a,b)+d2[a]去更新答案,最小的那个就是最终的答案。

好了,飞快地啪啪啪敲完代码我发现我RE了,改了改数组大小和输出方式又TLE了,对照网上的代码可能还是输出写错了,又把输出方案的代码照搬过来,结果又WA了,最后对拍发现是每一组数据之间有一行空格!简直坑爹,这破题调了我将近大半个下午!

#include<cstdio>
#include<cstring>
#include<queue>
#include<vector>
#define MAXN 10100
using namespace std;
struct edge
{
	int v,w,next;
}edge[100100];
int cnt,head[MAXN];
void add_edge(int u,int v,int w)
{
	edge[cnt].v = v;
	edge[cnt].w = w;
	edge[cnt].next = head[u];
	head[u] = cnt++;
}
int s,e,d1[MAXN],d2[MAXN],pre[2][MAXN],n,m;
int st,ed;
bool inque[MAXN];
void SPFA1()
{
	memset(inque,0,sizeof inque);
	memset(d1,0x3f,sizeof d1);
	d1[s] = 0;
	queue<int> Q;
	Q.push(s),inque[s] = 1;
	pre[0][s] = s;
	while(!Q.empty())
	{
		int u = Q.front();
		Q.pop(),inque[u] = 0;
		for(int i = head[u]; i != -1; i = edge[i].next)
		{
			int v = edge[i].v;
			if(d1[u]+edge[i].w < d1[v]){
				d1[v] = d1[u]+edge[i].w; pre[0][v] = u;
				if(!inque[v]) Q.push(v),inque[v] = 1;
			}
		}
	}
}
void SPFA2()
{
	memset(inque,0,sizeof inque);
	memset(d2,0x3f,sizeof d2);
	d2[e] = 0;
	queue<int> Q;
	Q.push(e),inque[e] = 1;
	while(!Q.empty())
	{
		int u = Q.front();
		Q.pop(),inque[u] = 0;
		for(int i = head[u]; i != -1; i = edge[i].next)
		{
			int v = edge[i].v;
			if(d2[u]+edge[i].w < d2[v]){
				d2[v] = d2[u]+edge[i].w; pre[1][v] = u;
				if(!inque[v]) Q.push(v),inque[v] = 1;
			}
		}
	}
} 
vector<int> Road;
void print(int x) 
{
    if (pre[0][x] == x) 
	{
        printf("%d",x);    
        return;
    }
    print(pre[0][x]);
    printf(" %d",x);
}
void Init()
{
	memset(head,-1,sizeof head);
	memset(pre,-1,sizeof pre);
	memset(edge,0,sizeof edge);
	cnt = 0;
	Road.clear();
}
int main()
{
	int cas = 0;
	while(scanf("%d",&n) != EOF)
	{
		cas++;
		if(cas != 1) printf("\n");
		Init();
		scanf("%d%d%d",&s,&e,&m);
		int a,b,c;
		for(int i = 1; i <= m; i++)
		{
			scanf("%d%d%d",&a,&b,&c);
			add_edge(a,b,c);
			add_edge(b,a,c);
		}
		SPFA1();
		SPFA2();
		int q,ans = d1[e];
		st = ed = -1;
		scanf("%d",&q);
		for(int i = 1; i <= q; i++)
		{
			scanf("%d%d%d",&a,&b,&c);
			if(d1[a]+c+d2[b] < ans)
			{
				ans = d1[a]+c+d2[b];
				st = a,ed = b;
			}
			if(d1[b]+c+d2[a] < ans)
			{
				ans = d1[b]+c+d2[a];
				st = b,ed = a;
			}
		}
		if(st == -1)
		{
			print(e);
			printf("\n");
			printf("Ticket Not Used\n");
			printf("%d\n",ans);
		}
		else
		{
			print(st);
			for (int i = ed; i != e; i = pre[1][i]) printf(" %d", i);
			printf(" %d\n",e);
			printf("%d\n",st);
			printf("%d\n",ans);
		}
	}
}


SPFA算法(Shortest Path Faster Algorithm)是一种用于解决最短路问题的算法。它是一种单源最短路算法,可以解决带有负权边的图的最短路径问题。 SPFA算法基本思想是使用队列对图中的所有节点进行遍历,对于每一个节点,如果它的邻居节点的最短路径可以通过当前节点更新,则将邻居节点加入队列中进行下一轮遍历,直到所有节点的最短路径都被更新后停止遍历。 在Java中,可以使用邻接矩阵或邻接表来表示图,并使用队列来实现SPFA算法。下面是一个使用邻接矩阵实现SPFA算法的Java代码示例: ```java import java.util.*; public class SPFA { public static void main(String[] args) { int[][] graph = { {0, 2, 5, Integer.MAX_VALUE, Integer.MAX_VALUE}, {Integer.MAX_VALUE, 0, 7, 1, Integer.MAX_VALUE}, {Integer.MAX_VALUE, Integer.MAX_VALUE, 0, 4, Integer.MAX_VALUE}, {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 0, 3}, {Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, Integer.MAX_VALUE, 0} }; int[] dist = shortestPath(graph, 0); System.out.println(Arrays.toString(dist)); } public static int[] shortestPath(int[][] graph, int start) { int n = graph.length; int[] dist = new int[n]; Arrays.fill(dist, Integer.MAX_VALUE); dist[start] = 0; Queue<Integer> queue = new LinkedList<>(); queue.offer(start); boolean[] inQueue = new boolean[n]; inQueue[start] = true; while (!queue.isEmpty()) { int u = queue.poll(); inQueue[u] = false; for (int v = 0; v < n; v++) { if (graph[u][v] != Integer.MAX_VALUE && dist[v] > dist[u] + graph[u][v]) { dist[v] = dist[u] + graph[u][v]; if (!inQueue[v]) { queue.offer(v); inQueue[v] = true; } } } } return dist; } } ``` 在上面的代码中,我们使用一个二维数组`graph`来表示图,其中`graph[i][j]`表示从节点`i`到节点`j`的边的权重,如果没有边则为`Integer.MAX_VALUE`。函数`shortestPath`接受一个图和一个起点`start`,返回一个数组`dist`,其中`dist[i]`表示从起点`start`到节点`i`的最短路径。 在函数中,我们首先初始化`dist`数组为`Integer.MAX_VALUE`,表示所有节点到起点的距离都是无限大。然后将起点`start`加入队列中,并标记为已加入队列。进入循环后,每次取出队列中的一个节点`u`,将`u`标记为未加入队列,然后遍历`u`的所有邻居节点`v`,如果从起点到`v`的距离可以通过从起点到`u`再加上`u`到`v`的距离来更新,则更新`dist[v]`的值,并将`v`加入队列中,并标记为已加入队列。当队列为空时,所有节点的最短路径都已被更新,函数返回`dist`数组。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值