Create 787. K 站中转内最便宜的航班.md

Author: CompetitiveLin

Shortest Path/1030 Travel Plan.md

@@ -0,0 +1,120 @@
+#### [1030 Travel Plan](https://pintia.cn/problem-sets/994805342720868352/exam/problems/994805464397627392)
+
+A traveler's map gives the distances between cities along the highways, together with the cost of each highway. Now you are supposed to write a program to help a traveler to decide the shortest path between his/her starting city and the destination. If such a shortest path is not unique, you are supposed to output the one with the minimum cost, which is guaranteed to be unique.
+
+### Input Specification:
+
+Each input file contains one test case. Each case starts with a line containing 4 positive integers *N*, *M*, *S*, and *D*, where *N* (≤500) is the number of cities (and hence the cities are numbered from 0 to *N*−1); *M* is the number of highways; *S* and *D* are the starting and the destination cities, respectively. Then *M* lines follow, each provides the information of a highway, in the format:
+
+```
+City1 City2 Distance Cost
+```
+
+where the numbers are all integers no more than 500, and are separated by a space.
+
+### Output Specification:
+
+For each test case, print in one line the cities along the shortest path from the starting point to the destination, followed by the total distance and the total cost of the path. The numbers must be separated by a space and there must be no extra space at the end of output.
+
+### Sample Input:
+
+```in
+4 5 0 3
+0 1 1 20
+1 3 2 30
+0 3 4 10
+0 2 2 20
+2 3 1 20
+```
+
+### Sample Output:
+
+```out
+0 2 3 3 40
+```
+
+---
+
+Dijkstra算法：边有两种代价的情况，另外再使用一个数组记录最小代价的路径，`a[2] = 3` 意为最短路径是由节点 `3` 指向节点 `2` 的，采用方式是因为在求最小代价时**一个点可以有多条出边，但是只能有一条入边**。得到最小代价后深度优先搜索即可。
+
+```java
+import java.util.*;
+public class Main{
+    private static final int INF = Integer.MAX_VALUE / 2;
+    private static int[] dis;
+    private static int[][] g;
+    private static int[][] cost;
+    private static int[] sum_cost;
+    private static int[] a;
+    private static boolean[] visited;
+    private static ArrayList<Integer> arraylist = new ArrayList<>();
+    
+    public static void dfs(int d, int s){
+        if(d == s){
+            arraylist.add(s);
+            return;
+        }
+        dfs(a[d], s);
+        arraylist.add(d);
+    }
+    
+    
+    public static void main(String[] args){
+        Scanner scanner = new Scanner(System.in);
+        int N = scanner.nextInt(), M = scanner.nextInt(), S = scanner.nextInt(), D = scanner.nextInt();
+        dis = new int[N];
+        g = new int[N][N];
+        cost = new int[N][N];
+        sum_cost = new int[N];
+        visited = new boolean[N];
+        a = new int[N];
+        for(int i = 0; i < N; i++){
+            Arrays.fill(g[i], INF);
+            Arrays.fill(cost[i], INF);
+        }
+        Arrays.fill(dis, INF);
+        Arrays.fill(sum_cost, INF);
+        
+        for(int i = 0; i < M; i++){
+            int temp1 = scanner.nextInt(), temp2 = scanner.nextInt(), temp3 = scanner.nextInt(), temp4 = scanner.nextInt();
+            g[temp1][temp2] = temp3;
+            g[temp2][temp1] = temp3;
+            cost[temp1][temp2] = temp4;
+            cost[temp2][temp1] = temp4;
+        }
+        
+        dis[S] = 0;
+        sum_cost[S] = 0;
+        for(int i = 0; i < N; i++){
+            int cur = -1, min = INF;
+            for(int j = 0; j < N; j++){
+                if(!visited[j] && dis[j] < min){
+                    min = dis[j];
+                    cur = j;
+                }
+            }
+            if(cur == -1) return;
+            visited[cur] = true;
+            for(int j = 0; j < N; j++){
+                if(visited[j] == false && g[cur][j] != INF){
+                    if(g[cur][j] + dis[cur] < dis[j]){
+                        dis[j] = dis[cur] + g[cur][j];
+                        sum_cost[j] = cost[cur][j] + sum_cost[cur];
+                        a[j] = cur;
+                    }
+                    else if(g[cur][j] + dis[cur] == dis[j] && cost[cur][j] + sum_cost[cur] < sum_cost[j]){
+                        sum_cost[j] = cost[cur][j] + sum_cost[cur];
+                        a[j] = cur;
+                    }
+                }
+            }
+            
+        }
+        dfs(D, S);
+        for(int i = 0; i < arraylist.size(); i++) System.out.print(arraylist.get(i) + " ");
+        System.out.println(dis[D] + " " + sum_cost[D]);
+        
+    }
+}
+```
+

Shortest Path/743. 网络延迟时间.md

@@ -66,7 +66,7 @@ class Solution {
         while(!minHeap.isEmpty()){
             int[] temp = minHeap.poll();
             int temp_dis = temp[0], temp_node = temp[1];
-            if(temp_dis > dis[temp_node]) continue;
+            if(temp_dis > dis[temp_node]) continue;	// pruning
             for(int i = 0; i < n; i++){
                 if(g[temp_node][i] != INF){
                     if(temp_dis + g[temp_node][i] < dis[i]){

Shortest Path/787. K 站中转内最便宜的航班.md

@@ -0,0 +1,99 @@
+#### 787. K 站中转内最便宜的航班
+
+难度：中等
+
+---
+
+有 `n` 个城市通过一些航班连接。给你一个数组 `flights` ，其中 `flights[i] = [fromi, toi, pricei]` ，表示该航班都从城市 `fromi` 开始，以价格 `pricei` 抵达 `toi`。
+
+现在给定所有的城市和航班，以及出发城市 `src` 和目的地 `dst`，你的任务是找到出一条最多经过 `k` 站中转的路线，使得从 `src` 到 `dst` 的  **价格最便宜**  ，并返回该价格。 如果不存在这样的路线，则输出 `-1`。
+
+ **示例 1：** 
+
+```
+输入: 
+n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
+src = 0, dst = 2, k = 1
+输出: 200
+解释: 
+城市航班图如下
+
+
+从城市 0 到城市 2 在 1 站中转以内的最便宜价格是 200，如图中红色所示。
+```
+
+![img](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png) 
+
+**示例 2：** 
+
+```
+输入: 
+n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
+src = 0, dst = 2, k = 0
+输出: 500
+解释: 
+城市航班图如下
+
+
+从城市 0 到城市 2 在 0 站中转以内的最便宜价格是 500，如图中蓝色所示。
+```
+
+![img](https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png)
+
+ **提示：** 
+
+*   `1 <= n <= 100`
+*   `0 <= flights.length <= (n * (n - 1) / 2)`
+*   `flights[i].length == 3`
+*   `0 <= fromi, toi < n`
+*   `fromi != toi`
+*   `1 <= pricei <= 10^4`
+*   航班没有重复，且不存在自环
+*   `0 <= src, dst, k < n`
+*   `src != dst`
+
+---
+
+Dijkstra算法 + 堆优化：将【节点，距离和中转次数】一起存入堆中，如果中转次数小于零则放弃当前情况。如果经过同一点的中转次数少但是距离增大，也需要存入堆中一起考虑，因此不能剪枝（`if(cur_dis > dis[cur_point]) continue;`）。直到堆为空，此时返回 `-1`。
+
+```java
+class Solution {
+    public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+        final int INF = Integer.MAX_VALUE / 2;
+        int[][] g = new int[n][n];
+        for(int i = 0; i < n; i++){
+            Arrays.fill(g[i], INF);
+        }
+        for(int[] flight: flights){
+            g[flight[0]][flight[1]] = flight[2];
+        }
+        int[] dis = new int[n];
+        int[] stops = new int[n];
+        Arrays.fill(dis, INF);
+        PriorityQueue<int[]> minHeap = new PriorityQueue<>((a,b) -> (a[0] - b[0]));
+        minHeap.add(new int[] {0, src, k});
+        while(!minHeap.isEmpty()){
+            int[] temp = minHeap.poll();
+            int cur_dis = temp[0], cur_point = temp[1], cur_stop = temp[2];
+            if(cur_point == dst) return cur_dis;
+            if(cur_stop < 0) continue;
+            // if(cur_dis > dis[cur_point]) continue; // CAN'T DO PRUNING
+            for(int i = 0; i < n; i++){
+                if(g[cur_point][i] != INF){
+                    int cost = g[cur_point][i] + cur_dis;
+                    if(cost < dis[i]){
+                        dis[i] = cost;
+                        stops[i] = cur_stop - 1;
+                        minHeap.add(new int[] {cost, i, cur_stop - 1});
+                    }
+                    else if(cur_stop - 1 > stops[i]){
+                        minHeap.add(new int[] {cost, i, cur_stop - 1});
+                    }
+                }
+            }
+        }
+        return -1;
+    }
+}
+```
+

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

@@ -73,7 +73,7 @@ class Solution {
         while(!pq.isEmpty()){
             int[] temp = pq.poll();
             int des = temp[0], dis = temp[1];
-            if(dis > distance[des]) continue;
+            if(dis > distance[des]) continue;	// pruning
             for(int i = 0; i < n; i++){
                 if(g[des][i] != INF){
                     int new_dis = dis + g[des][i];