Create 882. 细分图中的可到达节点.md

Author: CompetitiveLin

Shortest Path/882. 细分图中的可到达节点.md

@@ -0,0 +1,101 @@
+#### 882. 细分图中的可到达节点
+
+难度：困难
+
+---
+
+给你一个无向图（ **原始图** ），图中有 `n` 个节点，编号从 `0` 到 `n - 1` 。你决定将图中的每条边  **细分**  为一条节点链，每条边之间的新节点数各不相同。
+
+图用由边组成的二维数组 `edges` 表示，其中 `edges[i] = [ui, vi, cnti]` 表示原始图中节点 `ui` 和 `vi` 之间存在一条边，`cnti` 是将边  **细分**  后的新节点总数。注意，`cnti == 0` 表示边不可细分。
+
+要  **细分**  边 `[ui, vi]` ，需要将其替换为 `(cnti + 1)` 条新边，和 `cnti` 个新节点。新节点为 `x1`, `x2`, ..., `xcnti` ，新边为 `[ui, x1]`, `[x1, x2]`, `[x2, x3]`, ..., `[xcnti+1, xcnti]`, `[xcnti, vi]` 。
+
+现在得到一个  **新的细分图**  ，请你计算从节点 `0` 出发，可以到达多少个节点？如果节点间距离是 `maxMoves` 或更少，则视为  **可以到达**  。
+
+给你原始图和 `maxMoves` ，返回 _新的细分图中从节点 `0` 出发_  **_可到达的节点数_**  。
+
+ **示例 1：** 
+
+![](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/08/01/origfinal.png)
+```
+输入：edges = [[0,1,10],[0,2,1],[1,2,2]], maxMoves = 6, n = 3
+输出：13
+解释：边的细分情况如上图所示。
+可以到达的节点已经用黄色标注出来。
+```
+
+ **示例 2：** 
+
+```
+输入：edges = [[0,1,4],[1,2,6],[0,2,8],[1,3,1]], maxMoves = 10, n = 4
+输出：23
+```
+
+ **示例 3：** 
+
+```
+输入：edges = [[1,2,4],[1,4,5],[1,3,1],[2,3,4],[3,4,5]], maxMoves = 17, n = 5
+输出：1
+解释：节点 0 与图的其余部分没有连通，所以只有节点 0 可以到达。
+```
+
+ **提示：** 
+
+*   `0 <= edges.length <= min(n * (n - 1) / 2, 10^4)`
+*   `edges[i].length == 3`
+*   `0 <= ui < vi < n`
+*   图中  **不存在平行边** 
+*   `0 <= cnti <= 10^4`
+*   `0 <= maxMoves <= 10^9`
+*   `1 <= n <= 3000`
+
+---
+
+Dijkstra算法 + 堆优化：计算出最小距离后，遍历每个边的两个点，`maxMoves` 如果大于该点的最小距离，取其差值，否则为 `0` 。每个边的两点都计算一遍，如果两点的结果相加大于两点间的距离，那说明重复计算，即边上的所有节点都可以到达，加上该边的所有节点值即可，否则加上两点的结果。
+
+```java
+class Solution {
+    public int reachableNodes(int[][] edges, int maxMoves, int n) {
+        int INF = Integer.MAX_VALUE, ans = 0;
+        int[][] g = new int[n][n];
+        for(int i = 0; i < n; i++){
+            Arrays.fill(g[i], INF);
+        }
+        for(int i = 0; i < edges.length; i++){
+            g[edges[i][0]][edges[i][1]] = edges[i][2] + 1;
+            g[edges[i][1]][edges[i][0]] = edges[i][2] + 1;
+        }
+        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[1] - b[1]); // [destination, distance]
+        int[] distance = new int[n];
+        Arrays.fill(distance, INF);
+        distance[0] = 0;
+        pq.offer(new int[]{0, 0});
+        while(!pq.isEmpty()){
+            int[] temp = pq.poll();
+            int des = temp[0], dis = temp[1];
+            if(dis > distance[des]) continue;
+            for(int i = 0; i < n; i++){
+                if(g[des][i] != INF){
+                    int new_dis = dis + g[des][i];
+                    if(new_dis < distance[i]){
+                        distance[i] = new_dis;
+                        pq.offer(new int[]{i, new_dis});
+                    }
+                }
+            }
+        }
+
+        for(int i = 0; i < n; i++){
+            if(distance[i] <= maxMoves) ans++;
+        }
+        for(int[] edge: edges){
+            int u = edge[0], v = edge[1], cnt = edge[2];
+            int a = Math.max(maxMoves - distance[u], 0);
+            int b = Math.max(maxMoves - distance[v], 0);
+            ans += Math.min(a + b, cnt);
+        }
+        return ans;
+    }
+}
+```
+