4196 最短路径（堆优化版的dijkstra算法、spfa算法模板）

1. 问题描述：

给定一个 n 个点 m 条边的的无向图。点的编号从 1 到 n。图中可能包含重边和自环。请你找到并输出一条从点 1 到点 n 的最短路径。

输入格式

第一行包含两个整数 n，m。接下来 m 行，每行包含三个整数 a，b，w，表示点 a 和点 b 之间存在一条无向边，边长为 w。

输出格式

如果最短路径不存在，则输出 −1。否则，在一行内输出从点 1 到点 n 的最短路径中依次包含的点的编号，各点编号之间用空格隔开。如果答案不唯一，输出任意合理方案均可。

数据范围

前六个测试点满足 2 ≤ n ≤ 10，1 ≤ m ≤ 10。
所有测试点满足 2 ≤ n ≤ 10 ^ 5，1 ≤ m ≤ 10 ^ 5，1 ≤ a，b ≤ n，1 ≤ w ≤ 10 ^ 6。
本题不卡spfa算法。

输入样例：

5 6
1 2 2
2 5 5
2 3 4
1 4 1
4 3 3
3 5 1

输出样例：

1 4 3 5
来源：https://www.acwing.com/problem/content/description/4199/

2. 思路分析：

分析题目可以知道这道题目是单源最短路径的裸题，对于单源最短路径的题目，首先需要看数据范围和边权，以便确定使用哪一种算法来解决，边权为非负的情况下可以考虑使用dijkstra算法，边权有负数的情况下则需要使用spfa算法；由于这道题目的边权为正所以原则上可以使用任意一种单源最短路径算法，因为n最大是10 ^ 5，所以不能够使用朴素版的dijkstra算法来解决（时间复杂度为O(n ^ 2)），可以使用堆优化版的dijkstra算法或者spfa算法解决，因为这道题目最终需要输出一条从1到n的最短路径，所以我们需要记录下1到n的最短路径上的节点，这里可以使用二种方法来记录，第一种是声明一个前驱数组pre，在求解1到n的最短距离的过程中更新到达某个点的前驱节点，最终如果有解的情况下我们可以通过pre数组从终点n开始递推一直到起点为止；第二种方法：由于建立的是无向边，所以我们可以终点出发，借助于dis数组最终递推到起点也可以。

3. 代码如下：

使用一个pre列表来记录最短路径中节点的前驱节点：

from typing import List
import heapq


class Solution:
    def dijkstra(self, n: int, s: int, t: int, g: List[List[int]]):
        # 因为n最多是10 ^ 5, 而且边权最大为10 ^ 6 所以要声明大一点
        INF = 10 ** 12
        dis = [INF] * (n + 10)
        dis[s] = 0
        vis = [0] * (n + 10)
        q = list()
        # pre记录最短路径的节点的前驱节点
        pre = [-1] * (n + 10)
        # 元组的第一个元素为从起点到当前点的最短距离, 第二个元素为当前节点的编号
        heapq.heappush(q, (0, s))
        while q:
            p = heapq.heappop(q)
            # 如果已经被访问过了那么跳过即可
            if vis[p[1]] == 1: continue
            # 标记已经被访问
            vis[p[1]] = 1
            for next in g[p[1]]:
                if dis[next[0]] > dis[p[1]] + next[1]:
                    # 更新最短距离
                    dis[next[0]] = dis[p[1]] + next[1]
                    # 更新前缀节点
                    pre[next[0]] = p[1]
                    heapq.heappush(q, (dis[next[0]], next[0]))
        # 判断是否无解
        if pre[t] == -1: 
            print(-1)
            return 
        # 从终点开始递推一直到起点
        k = t
        path = list()
        while k != -1:
            path.append(k)
            k = pre[k]
        for i in range(len(path) - 1, -1, -1):
            print(path[i], end=" ")

    def process(self):
        n, m = map(int, input().split())
        # 无向图所以需要建立两个方向的边
        g = [list() for i in range(n + 10)]
        for i in range(m):
            a, b, c = map(int, input().split())
            g[a].append((b, c))
            g[b].append((a, c))
        self.dijkstra(n, 1, n, g)


if __name__ == '__main__':
    Solution().process()

因为是双向边所以可以从终点开始递推一直到起点即可：

from typing import List
import heapq


class Solution:
    def dijkstra(self, n: int, s: int, t: int, g: List[List[int]]):
        INF = 10 ** 12
        dis = [INF] * (n + 10)
        dis[s] = 0
        vis = [0] * (n + 10)
        q = list()
        # 引入heapq模块对列表进行操作相当于模拟对堆进行操作
        heapq.heappush(q, (0, s))
        while q:
            p = heapq.heappop(q)
            # 如果已经被访问过了那么跳过即可
            if vis[p[1]] == 1: continue
            # 标记已经被访问
            vis[p[1]] = 1
            for next in g[p[1]]:
                if dis[next[0]] > dis[p[1]] + next[1]:
                    dis[next[0]] = dis[p[1]] + next[1]
                    heapq.heappush(q, (dis[next[0]], next[0]))
        if dis[t] == INF: 
            print(-1)
            return 
        res = [t]
        # 因为是双向边所以可以终点出发递推到达起点
        k = t
        while k != s:
            for next in g[k]:
                if dis[next[0]] + next[1] == dis[k]:
                    k = next[0]
                    res.append(k)
        # 输出最短路径
        for i in range(len(res) - 1, -1, -1):
            print(res[i], end=" ")

    def process(self):
        n, m = map(int, input().split())
        # 无向图
        g = [list() for i in range(n + 10)]
        for i in range(m):
            a, b, c = map(int, input().split())
            g[a].append((b, c))
            g[b].append((a, c))
        return self.dijkstra(n, 1, n, g)


if __name__ == '__main__':
    Solution().process()

spfa：提交上去超时了：

import collections
from typing import List


class Solution:
    def spfa(self, n: int, s: int, t: int, g: List[List[int]]):
        INF = 10 ** 12
        dis = [INF] * (n + 10)
        vis = [False] * (n + 10)
        dis[s] = 0
        # 标记起点已经被访问
        vis[s] = 1
        q = collections.deque([s])
        while q:
            p = q.popleft()
            # 出队之后需要将其标记为未访问
            vis[p] = False
            for next in g[p]:
                if dis[next[0]] > dis[p] + next[1]:
                    dis[next[0]] = dis[p] + next[1]
                    if vis[next[0]] == 0:
                        q.append(next[0])
                        vis[next[0]] = True
        if dis[t] == INF:
            print(-1)
            return
        k = t
        res = [t]
        while k != s:
            for next in g[k]:
                if dis[next[0]] + next[1] == dis[k]:
                    k = next[0]
                    res.append(k)
        for i in range(len(res) - 1, -1, -1):
            print(res[i], end=" ")

    def process(self):
        n, m = map(int, input().split())
        # 无向图
        g = [list() for i in range(n + 10)]
        for i in range(m):
            a, b, c = map(int, input().split())
            g[a].append((b, c))
            g[b].append((a, c))
        self.spfa(n, 1, n, g)


if __name__ == '__main__':
    Solution().process()