1210-1477 (2)

gdut-yy · gdut-yy · commit df3a6978ca16 · 2023-02-05T23:18:20.000+08:00
diff --git a/leetcode-13/src/main/java/Solution1210.java b/leetcode-13/src/main/java/Solution1210.java
@@ -0,0 +1,61 @@
+import java.util.LinkedList;
+import java.util.Queue;
+
+public class Solution1210 {
+    private static final int[][] DIRS = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
+
+    public int minimumMoves(int[][] grid) {
+        int n = grid.length;
+        boolean[][][] visited = new boolean[n][n][2];
+        Queue<int[]> queue = new LinkedList<>();
+        visited[0][0][0] = true;
+        queue.add(new int[]{0, 0, 0});
+        int step = 0;
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            for (int i = 0; i < size; i++) {
+                int[] cur = queue.remove();
+                if (cur[0] == n - 1 && cur[1] == n - 2) {
+                    return step;
+                }
+                for (int[] dir : DIRS) {
+                    int x = cur[0] + dir[0];
+                    int y = cur[1] + dir[1];
+                    int s = cur[2] ^ dir[2];
+                    int x2 = x + s;
+                    int y2 = y + (s ^ 1);
+                    if (x2 < n && y2 < n && !visited[x][y][s]
+                            && grid[x][y] == 0 && grid[x2][y2] == 0
+                            && (dir[2] == 0 || grid[x + 1][y + 1] == 0)) {
+                        visited[x][y][s] = true;
+                        queue.add(new int[]{x, y, s});
+                    }
+                }
+            }
+            step++;
+        }
+        return -1;
+    }
+}
+/*
+1210. 穿过迷宫的最少移动次数
+https://leetcode.cn/problems/minimum-moves-to-reach-target-with-rotations/
+
+你还记得那条风靡全球的贪吃蛇吗？
+我们在一个 n*n 的网格上构建了新的迷宫地图，蛇的长度为 2，也就是说它会占去两个单元格。蛇会从左上角（(0, 0) 和 (0, 1)）开始移动。我们用 0 表示空单元格，用 1 表示障碍物。蛇需要移动到迷宫的右下角（(n-1, n-2) 和 (n-1, n-1)）。
+每次移动，蛇可以这样走：
+- 如果没有障碍，则向右移动一个单元格。并仍然保持身体的水平／竖直状态。
+- 如果没有障碍，则向下移动一个单元格。并仍然保持身体的水平／竖直状态。
+- 如果它处于水平状态并且其下面的两个单元都是空的，就顺时针旋转 90 度。蛇从（(r, c)、(r, c+1)）移动到 （(r, c)、(r+1, c)）。
+- 如果它处于竖直状态并且其右面的两个单元都是空的，就逆时针旋转 90 度。蛇从（(r, c)、(r+1, c)）移动到（(r, c)、(r, c+1)）。
+返回蛇抵达目的地所需的最少移动次数。
+如果无法到达目的地，请返回 -1。
+提示：
+2 <= n <= 100
+0 <= grid[i][j] <= 1
+蛇保证从空单元格开始出发。
+
+https://leetcode.cn/problems/minimum-moves-to-reach-target-with-rotations/solution/huan-zai-if-elseyi-ge-xun-huan-chu-li-li-tw8b/
+时间复杂度 O(n^2)
+空间复杂度 O(n^2)
+ */
diff --git a/leetcode-13/src/test/java/Solution1210Tests.java b/leetcode-13/src/test/java/Solution1210Tests.java
@@ -0,0 +1,34 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1210Tests {
+    private final Solution1210 solution1210 = new Solution1210();
+
+    @Test
+    public void example1() {
+        int[][] grid = UtUtils.stringToInts2("""
+                [[0,0,0,0,0,1],
+                 [1,1,0,0,1,0],
+                 [0,0,0,0,1,1],
+                 [0,0,1,0,1,0],
+                 [0,1,1,0,0,0],
+                 [0,1,1,0,0,0]]
+                """);
+        int expected = 11;
+        Assertions.assertEquals(expected, solution1210.minimumMoves(grid));
+    }
+
+    @Test
+    public void example2() {
+        int[][] grid = UtUtils.stringToInts2("""
+                [[0,0,1,1,1,1],
+                 [0,0,0,0,1,1],
+                 [1,1,0,0,0,1],
+                 [1,1,1,0,0,1],
+                 [1,1,1,0,0,1],
+                 [1,1,1,0,0,0]]
+                """);
+        int expected = 9;
+        Assertions.assertEquals(expected, solution1210.minimumMoves(grid));
+    }
+}
diff --git a/leetcode-15/src/main/java/Solution1477.java b/leetcode-15/src/main/java/Solution1477.java
@@ -0,0 +1,43 @@
+public class Solution1477 {
+    public int minSumOfLengths(int[] arr, int target) {
+        int n = arr.length;
+
+        // f[i] 表示 [0, i) 之间最短的和为 target 的子数组长度
+        int[] f = new int[n + 1];
+        f[0] = n + 1;
+
+        int left = 0, right = 0;
+        int sum = 0;
+        int min = n + 1;
+        while (right < n) {
+            sum += arr[right];
+            while (sum > target) {
+                sum -= arr[left];
+                left++;
+            }
+            if (sum == target) {
+                min = Math.min(min, (right - left + 1) + f[left]);
+                f[right + 1] = Math.min(f[right], right - left + 1);
+            } else {
+                f[right + 1] = f[right];
+            }
+            right++;
+        }
+        return (min == n + 1) ? -1 : min;
+    }
+}
+/*
+1477. 找两个和为目标值且不重叠的子数组
+https://leetcode.cn/problems/find-two-non-overlapping-sub-arrays-each-with-target-sum/
+
+给你一个整数数组 arr 和一个整数值 target 。
+请你在 arr 中找 两个互不重叠的子数组 且它们的和都等于 target 。可能会有多种方案，请你返回满足要求的两个子数组长度和的 最小值 。
+请返回满足要求的最小长度和，如果无法找到这样的两个子数组，请返回 -1 。
+提示：
+1 <= arr.length <= 10^5
+1 <= arr[i] <= 1000
+1 <= target <= 10^8
+
+双指针 + 动态规划
+时间复杂度 O(n)
+ */
diff --git a/leetcode-15/src/test/java/Solution1477Tests.java b/leetcode-15/src/test/java/Solution1477Tests.java
@@ -0,0 +1,46 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution1477Tests {
+    private final Solution1477 solution1477 = new Solution1477();
+
+    @Test
+    public void example1() {
+        int[] arr = {3, 2, 2, 4, 3};
+        int target = 3;
+        int expected = 2;
+        Assertions.assertEquals(expected, solution1477.minSumOfLengths(arr, target));
+    }
+
+    @Test
+    public void example2() {
+        int[] arr = {7, 3, 4, 7};
+        int target = 7;
+        int expected = 2;
+        Assertions.assertEquals(expected, solution1477.minSumOfLengths(arr, target));
+    }
+
+    @Test
+    public void example3() {
+        int[] arr = {4, 3, 2, 6, 2, 3, 4};
+        int target = 6;
+        int expected = -1;
+        Assertions.assertEquals(expected, solution1477.minSumOfLengths(arr, target));
+    }
+
+    @Test
+    public void example4() {
+        int[] arr = {5, 5, 4, 4, 5};
+        int target = 3;
+        int expected = -1;
+        Assertions.assertEquals(expected, solution1477.minSumOfLengths(arr, target));
+    }
+
+    @Test
+    public void example5() {
+        int[] arr = {3, 1, 1, 1, 5, 1, 2, 1};
+        int target = 3;
+        int expected = 3;
+        Assertions.assertEquals(expected, solution1477.minSumOfLengths(arr, target));
+    }
+}
diff --git a/leetcode-26/src/main/java/Solution6331.java b/leetcode-26/src/main/java/Solution6331.java
@@ -1,17 +1,18 @@
 public class Solution6331 {
     public int maximizeWin(int[] prizePositions, int k) {
-        int len = prizePositions.length;
-        int left = 0;
-        int right = 0;
-        // pre[right] = max{[l, right]}
-        int[] pre = new int[len + 1];
+        int n = prizePositions.length;
+
+        // f[i] 表示 [0, i) 线段长度 <= k 的最多奖品数
+        int[] f = new int[n + 1];
+
+        int left = 0, right = 0;
         int res = 0;
-        while (right < len) {
+        while (right < n) {
             while (prizePositions[right] - prizePositions[left] > k) {
                 left++;
             }
-            res = Math.max(res, right - left + 1 + pre[left]);
-            pre[right + 1] = Math.max(pre[right], right - left + 1);
+            res = Math.max(res, (right - left + 1) + f[left]);
+            f[right + 1] = Math.max(f[right], right - left + 1);
             right++;
         }
         return res;
