一刷2684

diguage · diguage · commit 7526755bb65d · 2025-05-05T23:24:59.000+08:00
diff --git a/README.adoc b/README.adoc
@@ -18814,12 +18814,12 @@ TIP: **公众号的微信号是: `jikerizhi`**。__因为众所周知的原因
 //|Medium
 //|
 
-//|{counter:codes}
-//|{leetcode_base_url}/maximum-number-of-moves-in-a-grid/[2684. Maximum Number of Moves in a Grid^]
-//|{source_base_url}/_2684_MaximumNumberOfMovesInAGrid.java[Java]
-//|{doc_base_url}/2684-maximum-number-of-moves-in-a-grid.adoc[题解]
-//|Medium
-//|
+|{counter:codes}
+|{leetcode_base_url}/maximum-number-of-moves-in-a-grid/[2684. Maximum Number of Moves in a Grid^]
+|{source_base_url}/_2684_MaximumNumberOfMovesInAGrid.java[Java]
+|{doc_base_url}/2684-maximum-number-of-moves-in-a-grid.adoc[题解]
+|Medium
+|
 
 //|{counter:codes}
 //|{leetcode_base_url}/count-the-number-of-complete-components/[2685. Count the Number of Complete Components^]
diff --git a/docs/2684-maximum-number-of-moves-in-a-grid.adoc b/docs/2684-maximum-number-of-moves-in-a-grid.adoc
@@ -1,63 +1,61 @@
 [#2684-maximum-number-of-moves-in-a-grid]
-= 2684. Maximum Number of Moves in a Grid
+= 2684. 矩阵中移动的最大次数
 
-{leetcode}/problems/maximum-number-of-moves-in-a-grid/[LeetCode - 2684. Maximum Number of Moves in a Grid ^]
+https://leetcode.cn/problems/maximum-number-of-moves-in-a-grid/[LeetCode - 2684. 矩阵中移动的最大次数 ^]
 
-You are given a *0-indexed* `m x n` matrix `grid` consisting of *positive* integers.
+给你一个下标从 *0* 开始、大小为 `m x n` 的矩阵 `grid` ，矩阵由若干 *正* 整数组成。
 
-You can start at *any* cell in the first column of the matrix, and traverse the grid in the following way:
+你可以从矩阵第一列中的 *任一* 单元格出发，按以下方式遍历 `grid` ：
 
+* 从单元格 `(row, col)` 可以移动到 `(row - 1, col + 1)`、`(row, col + 1)` 和 `(row + 1, col + 1)` 三个单元格中任一满足值 *严格* 大于当前单元格的单元格。
 
-* From a cell `(row, col)`, you can move to any of the cells: `(row - 1, col + 1)`, `(row, col + 1)` and `(row + 1, col + 1)` such that the value of the cell you move to, should be *strictly* bigger than the value of the current cell.
+返回你在矩阵中能够 *移动* 的 *最大* 次数。
 
+*示例 1：*
 
-Return _the *maximum* number of *moves* that you can perform._
+image::images/2684-01.png[{image_attr}]
 
- 
-*Example 1:*
-<img alt="" src="https://assets.leetcode.com/uploads/2023/04/11/yetgriddrawio-10.png" style="width: 201px; height: 201px;" />
-[subs="verbatim,quotes"]
-----
-*Input:* grid = [[2,4,3,5],[5,4,9,3],[3,4,2,11],[10,9,13,15]]
-*Output:* 3
-*Explanation:* We can start at the cell (0, 0) and make the following moves:
+....
+输入：grid = [[2,4,3,5],[5,4,9,3],[3,4,2,11],[10,9,13,15]]
+输出：3
+解释：可以从单元格 (0, 0) 开始并且按下面的路径移动：
 - (0, 0) -> (0, 1).
 - (0, 1) -> (1, 2).
 - (1, 2) -> (2, 3).
-It can be shown that it is the maximum number of moves that can be made.
-----
+可以证明这是能够移动的最大次数。
+....
 
-*Example 2:*
+*示例 2：*
 
-[subs="verbatim,quotes"]
-----
-<img alt="" src="https://assets.leetcode.com/uploads/2023/04/12/yetgrid4drawio.png" />
-*Input:* grid = [[3,2,4],[2,1,9],[1,1,7]]
-*Output:* 0
-*Explanation:* Starting from any cell in the first column we cannot perform any moves.
-
-----
+image::images/2684-02.png[{image_attr}]
 
- 
-*Constraints:*
+....
+输入：grid = [[3,2,4],[2,1,9],[1,1,7]]
+输出：0
+解释：从第一列的任一单元格开始都无法移动。
+....
 
+*提示：*
 
 * `m == grid.length`
 * `n == grid[i].length`
-* `2 <= m, n <= 1000`
-* `4 <= m * n <= 10^5^`
-* `1 <= grid[i][j] <= 10^6^`
+* `+2 <= m, n <= 1000+`
+* `4 \<= m * n \<= 10^5^`
+* `1 \<= grid[i][j] \<= 10^6^`
 
 
+== 思路分析
 
+首先想到的思路是回溯，从第一列每个位置出发，向右进行探索，成功前进，失败则回溯。思路正确，通过 810 / 814 个测试用例。然后，超时。
 
-== 思路分析
+TIP: 又想了想，这不能叫回溯，因为没有回溯动作。应该是深度优先搜索。
 
+后想到动态规划。初始化一个同样大小的二维数组，每个表格记录到达该点需要行走记录。从左向右，按列遍历即可。
 
 [[src-2684]]
 [tabs]
 ====
-一刷::
+一刷（深度优先搜索）::
 +
 --
 [{java_src_attr}]
@@ -66,6 +64,15 @@ include::{sourcedir}/_2684_MaximumNumberOfMovesInAGrid.java[tag=answer]
 ----
 --
 
+一刷（动态规划）::
++
+--
+[{java_src_attr}]
+----
+include::{sourcedir}/_2684_MaximumNumberOfMovesInAGrid_1.java[tag=answer]
+----
+--
+
 // 二刷::
 // +
 // --
@@ -79,4 +86,9 @@ include::{sourcedir}/_2684_MaximumNumberOfMovesInAGrid.java[tag=answer]
 
 == 参考资料
 
+. https://leetcode.cn/problems/maximum-number-of-moves-in-a-grid/solutions/2684036/ju-zhen-zhong-yi-dong-de-zui-da-ci-shu-b-b7jx/[2684. 矩阵中移动的最大次数 - 官方题解^] -- 广度优先搜索的解法。其实，每次遍历只需要保存当前列可以到达的节点坐标即可，当没有坐标可以到达时，已经走到了尽头。这个解法更简单高效。
+. https://leetcode.cn/problems/maximum-number-of-moves-in-a-grid/solutions/2269244/cong-ji-yi-hua-sou-suo-dao-di-tui-by-end-pgq3/[2684. 矩阵中移动的最大次数 - 两种方法：DFS / BFS^] -- 深度优先遍历的解法非常有意思，把到达的处理后的节点都设置成 `0`，这样就可以有效避免重复遍历，加快处理速度。
+
+
+
 
diff --git a/docs/images/2684-01.png b/docs/images/2684-01.png
diff --git a/docs/images/2684-02.png b/docs/images/2684-02.png
diff --git a/docs/index.adoc b/docs/index.adoc
@@ -5452,7 +5452,7 @@ include::2560-house-robber-iv.adoc[leveloffset=+1]
 
 // include::2683-neighboring-bitwise-xor.adoc[leveloffset=+1]
 
-// include::2684-maximum-number-of-moves-in-a-grid.adoc[leveloffset=+1]
+include::2684-maximum-number-of-moves-in-a-grid.adoc[leveloffset=+1]
 
 // include::2685-count-the-number-of-complete-components.adoc[leveloffset=+1]
 
diff --git a/logbook/202503.adoc b/logbook/202503.adoc
@@ -608,6 +608,11 @@ endif::[]
 |{doc_base_url}/0199-binary-tree-right-side-view.adoc[题解]
 |✅ 深度优先遍历。按照 `<level, node>` 的格式，把每个节点都放到 `Map` 里，因为是先左后右，所以，每层最后只剩下了最右边的元素。
 
+|{counter:codes2503}
+|{leetcode_base_url}/maximum-number-of-moves-in-a-grid/[2684. Maximum Number of Moves in a Grid^]
+|{doc_base_url}/2684-maximum-number-of-moves-in-a-grid.adoc[题解]
+|✅ 动态规划。也可以使用深度优先搜索的解法，使用深度优先搜索时，需要把处理过的节点值设置为 `0`，防止重新判断，加快处理速度。
+
 |===
 
 截止目前，本轮练习一共完成 {codes2503} 道题。
diff --git a/src/main/java/com/diguage/algo/leetcode/_2684_MaximumNumberOfMovesInAGrid.java b/src/main/java/com/diguage/algo/leetcode/_2684_MaximumNumberOfMovesInAGrid.java
@@ -0,0 +1,62 @@
+package com.diguage.algo.leetcode;
+
+public class _2684_MaximumNumberOfMovesInAGrid {
+  // tag::answer[]
+
+  /**
+   * 通过 810 / 814 个测试用例。超时
+   *
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-05-05 22:11:52
+   */
+  public int maxMoves(int[][] grid) {
+    int result = 0;
+    for (int i = 0; i < grid.length; i++) {
+      result = Math.max(result, dfs(grid, i, 0));
+      if (result == grid[i].length) {
+        break;
+      }
+    }
+    return result;
+  }
+
+  private int dfs(int[][] grid, int row, int column) {
+    if (column == grid[row].length - 1) {
+      return 0;
+    }
+    int result = -1;
+    if (row - 1 >= 0 && column + 1 < grid[row - 1].length
+      && grid[row][column] < grid[row - 1][column + 1]) {
+      result = Math.max(result, dfs(grid, row - 1, column + 1));
+    }
+    if (column + 1 < grid[row].length
+      && grid[row][column] < grid[row][column + 1]) {
+      result = Math.max(result, dfs(grid, row, column + 1));
+    }
+    if (row + 1 < grid.length && column + 1 < grid[row + 1].length
+      && grid[row][column] < grid[row + 1][column + 1]) {
+      result = Math.max(result, dfs(grid, row + 1, column + 1));
+    }
+    // 受灵茶山艾府题解启发，加这么一行代码，答案即可通过。
+    grid[row][column] = 0;
+    return result + 1;
+  }
+
+  // end::answer[]
+  public static void main(String[] args) {
+    new _2684_MaximumNumberOfMovesInAGrid().maxMoves(new int[][]{
+      {65, 200, 263, 220, 91, 183, 2, 187, 175, 61, 225, 120, 39},
+      {111, 242, 294, 31, 241, 90, 145, 25, 262, 214, 145, 71, 294},
+      {152, 25, 240, 69, 279, 238, 222, 9, 137, 277, 8, 143, 143},
+      {189, 31, 86, 250, 20, 63, 188, 209, 75, 22, 127, 272, 110},
+      {122, 94, 298, 25, 90, 169, 68, 3, 208, 274, 202, 135, 275},
+      {205, 20, 171, 90, 70, 272, 280, 138, 142, 151, 80, 122, 130},
+      {284, 272, 271, 269, 265, 134, 185, 243, 247, 50, 283, 20, 232},
+      {266, 236, 265, 234, 249, 62, 98, 130, 122, 226, 285, 168, 204},
+      {231, 24, 256, 101, 142, 28, 268, 82, 111, 63, 115, 13, 144},
+      {277, 277, 31, 144, 49, 132, 28, 138, 133, 29, 286, 45, 93},
+      {163, 96, 25, 9, 3, 159, 148, 59, 25, 81, 233, 127, 12},
+      {127, 38, 31, 209, 300, 256, 15, 43, 74, 64, 73, 141, 200}
+    });
+  }
+}
diff --git a/src/main/java/com/diguage/algo/leetcode/_2684_MaximumNumberOfMovesInAGrid_1.java b/src/main/java/com/diguage/algo/leetcode/_2684_MaximumNumberOfMovesInAGrid_1.java
@@ -0,0 +1,60 @@
+package com.diguage.algo.leetcode;
+
+public class _2684_MaximumNumberOfMovesInAGrid_1 {
+  // tag::answer[]
+
+  /**
+   * @author D瓜哥 · https://www.diguage.com
+   * @since 2025-05-05 22:38:45
+   */
+  public int maxMoves(int[][] grid) {
+    int m = grid.length, n = grid[0].length;
+    int[][] dp = new int[m][n];
+    int result = 0;
+    // 📢：注意这里的遍历顺序，需要按列向右推进
+    for (int column = 1; column < n; column++) {
+      // 不加 stop，击败 12.96%；加 stop，击败 50.07%
+      boolean stop = true;
+      for (int row = 0; row < m; row++) {
+        if (row - 1 >= 0 && grid[row - 1][column - 1] < grid[row][column]
+          && (column == 1 || dp[row - 1][column - 1] > 0)) {
+          dp[row][column] = Math.max(dp[row][column], dp[row - 1][column - 1] + 1);
+          stop = false;
+        }
+        if (grid[row][column - 1] < grid[row][column]
+          && (column == 1 || dp[row][column - 1] > 0)) {
+          dp[row][column] = Math.max(dp[row][column], dp[row][column - 1] + 1);
+          stop = false;
+        }
+        if (row + 1 < m && grid[row + 1][column - 1] < grid[row][column]
+          && (column == 1 || dp[row + 1][column - 1] > 0)) {
+          dp[row][column] = Math.max(dp[row][column], dp[row + 1][column - 1] + 1);
+          stop = false;
+        }
+        result = Math.max(result, dp[row][column]);
+      }
+      if (stop) {
+        return result;
+      }
+    }
+    return result;
+  }
+
+  // end::answer[]
+  public static void main(String[] args) {
+    new _2684_MaximumNumberOfMovesInAGrid_1().maxMoves(new int[][]{
+      {65, 200, 263, 220, 91, 183, 2, 187, 175, 61, 225, 120, 39},
+      {111, 242, 294, 31, 241, 90, 145, 25, 262, 214, 145, 71, 294},
+      {152, 25, 240, 69, 279, 238, 222, 9, 137, 277, 8, 143, 143},
+      {189, 31, 86, 250, 20, 63, 188, 209, 75, 22, 127, 272, 110},
+      {122, 94, 298, 25, 90, 169, 68, 3, 208, 274, 202, 135, 275},
+      {205, 20, 171, 90, 70, 272, 280, 138, 142, 151, 80, 122, 130},
+      {284, 272, 271, 269, 265, 134, 185, 243, 247, 50, 283, 20, 232},
+      {266, 236, 265, 234, 249, 62, 98, 130, 122, 226, 285, 168, 204},
+      {231, 24, 256, 101, 142, 28, 268, 82, 111, 63, 115, 13, 144},
+      {277, 277, 31, 144, 49, 132, 28, 138, 133, 29, 286, 45, 93},
+      {163, 96, 25, 9, 3, 159, 148, 59, 25, 81, 233, 127, 12},
+      {127, 38, 31, 209, 300, 256, 15, 43, 74, 64, 73, 141, 200}
+    });
+  }
+}
