L2-001 紧急救援 (25分) 详细 dijskra算法 +最短路径打印

作为一个城市的应急救援队伍的负责人，你有一张特殊的全国地图。在地图上显示有多个分散的城市和一些连接城市的快速道路。每个城市的救援队数量和每一条连接两个城市的快速道路长度都标在地图上。当其他城市有紧急求助电话给你的时候，你的任务是带领你的救援队尽快赶往事发地，同时，一路上召集尽可能多的救援队。

输入格式:
输入第一行给出4个正整数N、M、S、D，其中N（2≤N≤500）是城市的个数，顺便假设城市的编号为0 ~ (N−1)；M是快速道路的条数；S是出发地的城市编号；D是目的地的城市编号。

第二行给出N个正整数，其中第i个数是第i个城市的救援队的数目，数字间以空格分隔。随后的M行中，每行给出一条快速道路的信息，分别是：城市1、城市2、快速道路的长度，中间用空格分开，数字均为整数且不超过500。输入保证救援可行且最优解唯一。

输出格式:
第一行输出最短路径的条数和能够召集的最多的救援队数量。第二行输出从S到D的路径中经过的城市编号。数字间以空格分隔，输出结尾不能有多余空格。

输入样例:
4 5 0 3
20 30 40 10
0 1 1
1 3 2
0 3 3
0 2 2
2 3 2
输出样例:
2 60
0 1 3

//核心还是利用堆优化的dijskra算法 （图是稀疏图的可能性比较大，这样可以降低时间复杂度和空间复杂度）
#include<iostream>
#include<algorithm>
#include<queue>
#include<cstring>

using namespace std;
const int N = 1e6 + 10;

struct E{
	int to,w,next;
}Edge[N];

//pre数组用来存储路径之间的顺序（倒序存储的），有点像前项星里面的next指针 （pre存储下标对应的节点的前驱节点下标）
//sum数组来存储某点最大的救援队伍数量
//ways用来存储可以到达某个点的路径的数量

int tot,Head[N],n,m,s,d,dist[N],team[N],pre[N],sum[N],st[N],ways[N];

void add(int a,int b,int w) // dj板子里面的前项星的加边操作
{
	Edge[tot].to = b;
	Edge[tot].w = w;
	Edge[tot].next = Head[a];
	
	Head[a] = tot ++ ;
}

void dijskra()
{
	//创建一个小根堆
	priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> q;
	//初始化 在小根堆里面入队起点
	q.push({0,s});
	
	//类-BFS过程
	while(!q.empty())
	{
		//取出当前离根节点最近的那个点
		auto temp = q.top();
		q.pop();
		
		//如果该点已经被确定了最优秀的路径，那么就跳过这个点，寻找下一个没有确定路径的点
		if(st[temp.second] == true) continue;
		
		st[temp.second] = true;
		
		//去依次遍历这个点的各个临边
		for(int i = Head[temp.second] ; i != -1 ; i = Edge[i].next)
		{
			//如果这个临点现在到根节点的距离和这个临点通过现在遍历的这个点到根节点的距离相等，则最短距离不用更新，只更新到这个临点的路径条数，最大的救援队伍数量，前驱节点。
			if(dist[Edge[i].to] == dist[temp.second] + Edge[i].w)
			{
				ways[Edge[i].to] += ways[temp.second]; // 更新路径的数目，因为距离相等，所以直接相加
			
				if(sum[Edge[i].to] < sum[temp.second] + team[Edge[i].to]) // 如果通过现在这个点的救援队的数量比较大，那么更新这个临节点的前驱节点为当前遍历节点
				{
					pre[Edge[i].to] = temp.second;	
				}
				
				//更新最大的救援队伍的数量
				sum[Edge[i].to] = max(sum[Edge[i].to],sum[temp.second] + team[Edge[i].to]);
			}
			
			//如果现在这个临点到根节点的距离大于通过当前遍历点所到的距离的话，还需要再次更新这个临点到根节点的距离
			if(dist[Edge[i].to] > dist[temp.second] + Edge[i].w)
			{
				//当前遍历的点到该临点只有一条路径，所以可以直接赋值（从题目意思来看，应该是没有重边的）
				ways[Edge[i].to] = ways[temp.second];
				// 更新距离 （因为想要的是路径较短的解，所以要直接修改距离）
				dist[Edge[i].to] = dist[temp.second] + Edge[i].w;
				// 加上当前临点的救援队伍的数量
				sum[Edge[i].to] = sum[temp.second] + team[Edge[i].to];
				// 添加前驱节点的顺序关系
				pre[Edge[i].to] = temp.second;
				//只有更新的点才会入队去进行下一层的遍历
				q.push({dist[Edge[i].to],Edge[i].to});	
			}	
		}
	}
}

void output(int x)
{
	//x 是终点节点的下标
	vector<int> path;
	
	for(;x != -1;x = pre[x])
	{
		//因为pre放的是其下标对应的节点的前驱节点的下标
		// 0 1 3
		//pre[3] = 1
		//pre[1] = 0
		
		path.push_back(x); // 按照逆序依次放入路径的编号 （3，1，0）
	}
	
	reverse(path.begin(),path.end()); // 对数组求一下逆反即可得出正确的路径顺序
	
	int i = 0;
	
	for(auto it : path) // 输出路径顺序 注意末尾不能有空格
	{
		if(i == 0) cout << it;
		else cout << " " << it;
		
		i ++;
	}
}

int main(void)
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    
	memset(dist,0x3f,sizeof dist);
	memset(Head,-1,sizeof Head);
	memset(pre,-1,sizeof pre);
	
	dist[s] = 0;
	
	cin >> n >> m >> s >> d;
	
	for(int i = 0 ; i < n ; i++)
	{
		cin >> team[i];
	}
	
	for(int i = 0;i < m;i++)
	{
		int a,b,w;
		cin >> a >> b >> w;
		
		add(a,b,w);
		add(b,a,w);
	}
	
	ways[s] = 1;
	sum[s] = team[s];
	
	dijskra();
	
	cout << ways[d] << " " << sum[d] << endl;
	
	output(d);
	
	return 0;
}