LeetCode——1786. 从第一个节点出发到最后一个节点的受限路径数(Number of Restricted Paths From First to...)[中等]——分析及代码（Java）

一、题目

现有一个加权无向连通图。给你一个正整数 n ，表示图中有 n 个节点，并按从 1 到 n 给节点编号；另给你一个数组 edges ，其中每个 edges[i] = [ui, vi, weighti] 表示存在一条位于节点 ui 和 vi 之间的边，这条边的权重为 weighti 。
从节点 start 出发到节点 end 的路径是一个形如 [z0, z1, z2, …, zk] 的节点序列，满足 z0 = start 、zk = end 且在所有符合 0 <= i <= k-1 的节点 zi 和 zi+1 之间存在一条边。
路径的距离定义为这条路径上所有边的权重总和。用 distanceToLastNode(x) 表示节点 n 和 x 之间路径的最短距离。受限路径 为满足 distanceToLastNode(zi) > distanceToLastNode(zi+1) 的一条路径，其中 0 <= i <= k-1 。
返回从节点 1 出发到节点 n 的 受限路径数 。由于数字可能很大，请返回对 10^9 + 7 取余 的结果。

示例 1：

输入：n = 5, edges = [[1,2,3],[1,3,3],[2,3,1],[1,4,2],[5,2,2],[3,5,1],[5,4,10]]
输出：3
解释：三条受限路径分别是：
1) 1 --> 2 --> 5
2) 1 --> 2 --> 3 --> 5
3) 1 --> 3 --> 5

示例 2：

输入：n = 7, edges = [[1,3,1],[4,1,2],[7,3,4],[2,5,3],[5,6,1],[6,7,2],[7,5,3],[2,6,4]]
输出：1
解释：唯一一条受限路径是：1 --> 3 --> 7 。

提示：

• 1 <= n <= 2 * 10^4
• n - 1 <= edges.length <= 4 * 10^4
• edges[i].length == 3
• 1 <= ui, vi <= n
• ui != vi
• 1 <= weighti <= 10^5
• 任意两个节点之间至多存在一条边
• 任意两个节点之间至少存在一条路径

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/number-of-restricted-paths-from-first-to-last-node
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

二、分析及代码

1. Dijkstra 算法 + 记忆化搜索

（1）思路

用 Dijkstra 算法求各点到节点 n 之间的最短距离，结合记忆化搜索，计算受限路径数。

（2）代码

class Solution {
    public int countRestrictedPaths(int n, int[][] edges) {
        int m = edges.length, modNum = 1000000007, ans = 0;
        List<Map<Integer, Integer>> list = new ArrayList<Map<Integer, Integer>>();
        for (int i = 0; i <= n; i++)
            list.add(new HashMap<Integer, Integer>());
        for (int i = 0; i < m; i++) {//邻接表
            int x = edges[i][0], y = edges[i][1], len = edges[i][2];
            list.get(x).put(y, len);
            list.get(y).put(x, len); 
        }

        //Dijkstra计算各点距离
        int[] dis = new int[n + 1];
        boolean[] visited = new boolean[n + 1];
        Arrays.fill(dis, Integer.MAX_VALUE);
        Arrays.fill(visited, false);
        PriorityQueue<int[]> que = new PriorityQueue<>(new Comparator<int[]>() {//优先队列存储当前各点到n的距离
            public int compare(int[] a, int[] b) {
                return a[1] - b[1];
            }
        });
        que.offer(new int[]{n, 0});
        while (!que.isEmpty()) {
            int[] point = que.poll();//取出当前距离n最近的点
            int x = point[0], len = point[1];
            if (visited[x] == false) {//如果点已计算过，直接跳过
                Iterator it = list.get(x).entrySet().iterator();
                while (it.hasNext()) {
                    Map.Entry entry = (Map.Entry)it.next();
                    int y = (int)entry.getKey(), ylen = (int)entry.getValue();
                    que.offer(new int[]{y, ylen + len});//更新所有邻接点到n的距离
                }
                dis[x] = len;
                visited[x] = true;
            }
        }

        //计算受限路径数
        long[] num = new long[n + 1];
        Arrays.fill(num, -1);
        return (int)countPath(list, num, dis, modNum, n, 1);
    }

    public long countPath(List<Map<Integer, Integer>> list, long[] num, int[] dis, int modNum, int n, int i) {//记忆化搜索
        if (num[i] != -1)//该点已搜索过
            return num[i];
        if (i == n)//下一节点为n，搜索完成返回路径数1
            return 1;
        Iterator it = list.get(i).entrySet().iterator();
        long cnt = 0;
        while (it.hasNext()) {//遍历所有可能的下一节点
            Map.Entry entry = (Map.Entry)it.next();
            int y = (int)entry.getKey();
            if (dis[y] < dis[i])
                cnt += countPath(list, num, dis, modNum, n, y);
        }
        num[i] = cnt % modNum;//记录当前节点的路径数
        return num[i];
    }
}

（3）结果

执行用时 ：145 ms，在所有 Java 提交中击败了 13.26% 的用户；
内存消耗 ：69.2 MB，在所有 Java 提交中击败了 34.47% 的用户。

三、其他

暂无。