一刷787

Author: diguage

README.adoc

@@ -5534,14 +5534,14 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 //|{doc_base_url}/0786-k-th-smallest-prime-fraction.adoc[题解]
 //|Hard
 //|
-//
-//|{counter:codes}
-//|{leetcode_base_url}/cheapest-flights-within-k-stops/[787. Cheapest Flights Within K Stops^]
-//|{source_base_url}/_0787_CheapestFlightsWithinKStops.java[Java]
-//|{doc_base_url}/0787-cheapest-flights-within-k-stops.adoc[题解]
-//|Medium
-//|
-//
+
+|{counter:codes}
+|{leetcode_base_url}/cheapest-flights-within-k-stops/[787. Cheapest Flights Within K Stops^]
+|{source_base_url}/_0787_CheapestFlightsWithinKStops.java[Java]
+|{doc_base_url}/0787-cheapest-flights-within-k-stops.adoc[题解]
+|Medium
+|
+
 //|{counter:codes}
 //|{leetcode_base_url}/rotated-digits/[788. Rotated Digits^]
 //|{source_base_url}/_0788_RotatedDigits.java[Java]

docs/0787-cheapest-flights-within-k-stops.adoc

@@ -1,58 +1,99 @@
 [#0787-cheapest-flights-within-k-stops]
-= 787. Cheapest Flights Within K Stops
+= 787. K 站中转内最便宜的航班
 
-{leetcode}/problems/cheapest-flights-within-k-stops/[LeetCode - Cheapest Flights Within K Stops^]
+https://leetcode.cn/problems/cheapest-flights-within-k-stops/[LeetCode - 787. K 站中转内最便宜的航班 ^]
 
-There are `n` cities connected by `m` flights. Each fight starts from city `u `and arrives at `v` with a price `w`.
+有 `n` 个城市通过一些航班连接。给你一个数组 `flights`，其中 `flights[i] = [from~i~, to~i~, price~i~]`，表示该航班都从城市 `from~i~ 开始，以价格 `price~i~ 抵达 `to~i~。
 
-Now given all the cities and flights, together with starting city `src` and the destination `dst`, your task is to find the cheapest price from `src` to `dst` with up to `k` stops. If there is no such route, output `-1`.
+现在给定所有的城市和航班，以及出发城市 `src` 和目的地 `dst`，你的任务是找到出一条最多经过 `k` 站中转的路线，使得从 `src` 到 `dst` 的 *价格最便宜* ，并返回该价格。 如果不存在这样的路线，则输出 `-1`。
 
-[subs="verbatim,quotes,macros"]
-----
-*Example 1:*
-*Input:* 
-n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
-src = 0, dst = 2, k = 1
-*Output:* 200
-*Explanation:* 
-The graph looks like this:
 
-image::https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png[{image_attr}]
+*示例 1：*
 
-The cheapest price from city `0` to city `2` with at most 1 stop costs 200, as marked red in the picture.
-----
+image::images/0787-01.png[{image_attr}]
 
-[subs="verbatim,quotes,macros"]
-----
-*Example 2:*
-*Input:* 
-n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]]
-src = 0, dst = 2, k = 0
-*Output:* 500
-*Explanation:* 
-The graph looks like this:
+....
+输入:
+n = 4, flights = [[0,1,100],[1,2,100],[2,0,100],[1,3,600],[2,3,200]], src = 0, dst = 3, k = 1
+输出: 700
+解释: 城市航班图如上
+从城市 0 到城市 3 经过最多 1 站的最佳路径用红色标记，费用为 100 + 600 = 700。
+请注意，通过城市 [0, 1, 2, 3] 的路径更便宜，但无效，因为它经过了 2 站。
+....
 
-image::https://s3-lc-upload.s3.amazonaws.com/uploads/2018/02/16/995.png[{image_attr}]
+*示例 2：*
 
-The cheapest price from city `0` to city `2` with at most 0 stop costs 500, as marked blue in the picture.
-----
+image::images/0787-02.png[{image_attr}]
 
-*Note:*
+....
+输入:
+n = 3, edges = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 1
+输出: 200
+解释:
+城市航班图如上
+从城市 0 到城市 2 经过最多 1 站的最佳路径标记为红色，费用为 100 + 100 = 200。
+....
 
+*示例 3：*
 
-* The number of nodes `n` will be in range `[1, 100]`, with nodes labeled from `0` to `n`` - 1`.
-* The size of `flights` will be in range `[0, n * (n - 1) / 2]`.
-* The format of each flight will be `(src, ``dst``, price)`.
-* The price of each flight will be in the range `[1, 10000]`.
-* `k` is in the range of `[0, n - 1]`.
-* There will not be any duplicated flights or self cycles.
+image::images/0787-03.png[{image_attr}]
 
+....
+输入：n = 3, flights = [[0,1,100],[1,2,100],[0,2,500]], src = 0, dst = 2, k = 0
+输出：500
+解释：
+城市航班图如上
+从城市 0 到城市 2 不经过站点的最佳路径标记为红色，费用为 500。
+....
 
+*提示：*
+
+* `+1 <= n <= 100+`
+* `+0 <= flights.length <= (n * (n - 1) / 2)+`
+* `flights[i].length == 3`
+* `0 \<= from~i~, to~i~ < n`
+* `from~i~ != to~i~`
+* `1 \<= price~i~ \<= 10^4^`
+* 航班没有重复，且不存在自环
+* `+0 <= src, dst, k < n+`
+* `src != dst`
+
+
+== 思路分析
 
 
 [[src-0787]]
+[tabs]
+====
+一刷（回溯，超时）::
++
+--
 [{java_src_attr}]
 ----
 include::{sourcedir}/_0787_CheapestFlightsWithinKStops.java[tag=answer]
 ----
+--
+
+一刷（动态规划）::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_0787_CheapestFlightsWithinKStops_1.java[tag=answer]
+----
+--
+
+// 二刷::
+// +
+// --
+// [{java_src_attr}]
+// ----
+// include::{sourcedir}/_0787_CheapestFlightsWithinKStops_2.java[tag=answer]
+// ----
+// --
+====
+
+
+== 参考资料
+
 

docs/images/0787-01.png

@@ -1658,7 +1658,7 @@ include::0768-max-chunks-to-make-sorted-ii.adoc[leveloffset=+1]
 
 // include::0786-k-th-smallest-prime-fraction.adoc[leveloffset=+1]
 
-// include::0787-cheapest-flights-within-k-stops.adoc[leveloffset=+1]
+include::0787-cheapest-flights-within-k-stops.adoc[leveloffset=+1]
 
 // include::0788-rotated-digits.adoc[leveloffset=+1]
 

docs/images/0787-02.png

@@ -609,10 +609,16 @@ endif::[]
 |✅ 深度优先遍历。按照 `<level, node>` 的格式，把每个节点都放到 `Map` 里，因为是先左后右，所以，每层最后只剩下了最右边的元素。
 
 |{counter:codes2503}
-|{leetcode_base_url}/maximum-number-of-moves-in-a-grid/[2684. Maximum Number of Moves in a Grid^]
+|{leetcode_base_url}/maximum-number-of-moves-in-a-grid/[2684. 矩阵中移动的最大次数^]
 |{doc_base_url}/2684-maximum-number-of-moves-in-a-grid.adoc[题解]
 |✅ 动态规划。也可以使用深度优先搜索的解法，使用深度优先搜索时，需要把处理过的节点值设置为 `0`，防止重新判断，加快处理速度。
 
+|{counter:codes2503}
+|{leetcode_base_url}/cheapest-flights-within-k-stops/[787. K 站中转内最便宜的航班^]
+|{doc_base_url}/0787-cheapest-flights-within-k-stops.adoc[题解]
+|⭕️ 回溯解法通过 48 / 56 个测试用例。
+
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。

docs/images/0787-03.png

@@ -0,0 +1,53 @@
+package com.diguage.algo.leetcode;
+
+import java.util.*;
+
+public class _0787_CheapestFlightsWithinKStops {
+  // tag::answer[]
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-05-06 18:53:25
+   */
+  int result = Integer.MAX_VALUE;
+
+  public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+    Map<Integer, List<int[]>> srcMap = new HashMap<>();
+    for (int[] flight : flights) {
+      int start = flight[0];
+      srcMap.computeIfAbsent(start, x -> new ArrayList<>()).add(flight);
+    }
+    backtrack(n, srcMap, src, dst, k + 1, 0);
+    return result == Integer.MAX_VALUE ? -1 : result;
+  }
+
+  private void backtrack(int n, Map<Integer, List<int[]>> srcMap,
+                         int src, int dst, int k, int expend) {
+
+    if (k < 0) {
+      return;
+    }
+    if (src == dst) {
+      result = Math.min(result, expend);
+      return;
+    }
+    for (int[] flight : srcMap.getOrDefault(src, Collections.emptyList())) {
+      int idst = flight[1];
+      int cost = flight[2];
+      // 不加该判断，通过 28 / 56 个测试用例；加上，通过 48 / 56 个测试用例
+      if (cost + expend >= result) {
+        continue;
+      }
+      backtrack(n, srcMap, idst, dst, k - 1, cost + expend);
+    }
+  }
+  // end::answer[]
+  public static void main(String[] args) {
+    new _0787_CheapestFlightsWithinKStops().findCheapestPrice(4,
+      new int[][]{
+        {0, 1, 100},
+        {1, 2, 100},
+        {2, 0, 100},
+        {1, 3, 600},
+        {2, 3, 200}}, 0, 3, 1);
+  }
+}

docs/index.adoc

@@ -0,0 +1,23 @@
+package com.diguage.algo.leetcode;
+
+public class _0787_CheapestFlightsWithinKStops_1 {
+  // tag::answer[]
+
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-05-06 19:30:49
+   */
+  public int findCheapestPrice(int n, int[][] flights, int src, int dst, int k) {
+    return 0; // TODO
+  }
+  // end::answer[]
+  public static void main(String[] args) {
+    new _0787_CheapestFlightsWithinKStops_1().findCheapestPrice(4,
+      new int[][]{
+        {0, 1, 100},
+        {1, 2, 100},
+        {2, 0, 100},
+        {1, 3, 600},
+        {2, 3, 200}}, 0, 3, 1);
+  }
+}