第146场双周赛T1~T4 (4)

Author: gdut-yy

leetcode/leetcode-34/src/main/java/Solution3392.java

@@ -0,0 +1,27 @@
+public class Solution3392 {
+ public int countSubarrays(int[] nums) {
+ int n = nums.length;
+ int ans = 0;
+ for (int i = 1; i + 1 < n; i++) {
+ if ((nums[i - 1] + nums[i + 1]) * 2 == nums[i]) {
+ ans++;
+ }
+ }
+ return ans;
+ }
+}
+/*
+3392. 统计符合条件长度为 3 的子数组数目
+https://leetcode.cn/problems/count-subarrays-of-length-three-with-a-condition/description/
+
+第 146 场双周赛 T1。
+
+给你一个整数数组 nums ，请你返回长度为 3 的 子数组，满足第一个数和第三个数的和恰好为第二个数的一半。
+子数组 指的是一个数组中连续 非空 的元素序列。
+提示：
+3 <= nums.length <= 100
+-100 <= nums[i] <= 100
+
+模拟。
+时间复杂度 O(n)。
+ */

leetcode/leetcode-34/src/main/java/Solution3393.java

@@ -0,0 +1,51 @@
+public class Solution3393 {
+ private static final int MOD = (int) (1e9 + 7);
+
+ public int countPathsWithXorValue(int[][] grid, int k) {
+ int m = grid.length;
+ int n = grid[0].length;
+
+ // 15 xor 16 = 31
+ long[][][] f = new long[m][n][17];
+ f[0][0][grid[0][0]] = 1;
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ for (int k0 = 0; k0 < 17; k0++) {
+ int k1 = k0 ^ grid[i][j];
+ if (k1 > 16) continue;
+ if (j - 1 >= 0) {
+ f[i][j][k1] += f[i][j - 1][k0];
+ }
+ if (i - 1 >= 0) {
+ f[i][j][k1] += f[i - 1][j][k0];
+ }
+ f[i][j][k1] %= MOD;
+ }
+ }
+ }
+ return (int) f[m - 1][n - 1][k];
+ }
+}
+/*
+3393. 统计异或值为给定值的路径数目
+https://leetcode.cn/problems/count-paths-with-the-given-xor-value/description/
+
+第 146 场双周赛 T2。
+
+给你一个大小为 m x n 的二维整数数组 grid 和一个整数 k 。
+你的任务是统计满足以下 条件 且从左上格子 (0, 0) 出发到达右下格子 (m - 1, n - 1) 的路径数目：
+- 每一步你可以向右或者向下走，也就是如果格子存在的话，可以从格子 (i, j) 走到格子 (i, j + 1) 或者格子 (i + 1, j) 。
+- 路径上经过的所有数字 XOR 异或值必须 等于 k 。
+请你返回满足上述条件的路径总数。
+由于答案可能很大，请你将答案对 10^9 + 7 取余 后返回。
+提示：
+1 <= m == grid.length <= 300
+1 <= n == grid[r].length <= 300
+0 <= grid[r][c] < 16
+0 <= k < 16
+
+动态规划。
+时间复杂度 O(mnk)。
+相似题目: 2435. 矩阵中和能被 K 整除的路径
+https://leetcode.cn/problems/paths-in-matrix-whose-sum-is-divisible-by-k/
+ */

leetcode/leetcode-34/src/main/java/Solution3394.java

@@ -0,0 +1,49 @@
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.List;
+
+public class Solution3394 {
+ public boolean checkValidCuts(int n, int[][] rectangles) {
+ return check(rectangles, 0) || check(rectangles, 1);
+ }
+
+ // op:0 x坐标 op:1 y坐标
+ private boolean check(int[][] rectangles, int op) {
+ List<int[]> intervals = new ArrayList<>();
+ for (int[] p : rectangles) intervals.add(new int[]{p[op], p[op + 2]});
+ intervals.sort(Comparator.comparingInt(o -> o[0]));
+ List<int[]> ans = new ArrayList<>();
+ for (int[] p : intervals) {
+ int l = p[0], r = p[1] - 1;
+ if (!ans.isEmpty() && l <= ans.getLast()[1]) {
+ ans.getLast()[1] = Math.max(ans.getLast()[1], r);
+ } else {
+ ans.add(new int[]{l, r});
+ }
+ }
+ return ans.size() >= 3;
+ }
+}
+/*
+3394. 判断网格图能否被切割成块
+https://leetcode.cn/problems/check-if-grid-can-be-cut-into-sections/description/
+
+第 146 场双周赛 T3。
+
+给你一个整数 n 表示一个 n x n 的网格图，坐标原点是这个网格图的左下角。同时给你一个二维坐标数组 rectangles ，其中 rectangles[i] 的格式为 [startx, starty, endx, endy] ，表示网格图中的一个矩形。每个矩形定义如下：
+- (startx, starty)：矩形的左下角。
+- (endx, endy)：矩形的右上角。
+注意 ，矩形相互之间不会重叠。你的任务是判断是否能找到两条 要么都垂直要么都水平 的 两条切割线 ，满足：
+- 切割得到的三个部分分别都 至少 包含一个矩形。
+- 每个矩形都 恰好仅 属于一个切割得到的部分。
+如果可以得到这样的切割，请你返回 true ，否则返回 false 。
+提示：
+3 <= n <= 10^9
+3 <= rectangles.length <= 10^5
+0 <= rectangles[i][0] < rectangles[i][2] <= n
+0 <= rectangles[i][1] < rectangles[i][3] <= n
+矩形之间两两不会有重叠。
+
+相似题目: 56. 合并区间
+https://leetcode.cn/problems/merge-intervals/
+ */

leetcode/leetcode-34/src/main/java/Solution3395.java

@@ -0,0 +1,71 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class Solution3395 {
+ static final int MOD = (int) (1e9 + 7);
+
+ public int subsequencesWithMiddleMode(int[] nums) {
+ int n = nums.length;
+ long ans = (long) n * (n - 1) * (n - 2) * (n - 3) * (n - 4) / 120; // 所有方案数
+ Map<Integer, Integer> suf = new HashMap<>();
+ for (int x : nums) {
+ suf.merge(x, 1, Integer::sum); // suf[x]++
+ }
+ Map<Integer, Integer> pre = new HashMap<>(suf.size()); // 预分配空间
+ // 枚举 x，作为子序列正中间的数
+ for (int left = 0; left < n - 2; left++) {
+ int x = nums[left];
+ suf.merge(x, -1, Integer::sum); // suf[x]--
+ if (left > 1) {
+ int right = n - 1 - left;
+ int preX = pre.getOrDefault(x, 0);
+ int sufX = suf.get(x);
+ // 不合法：只有一个 x
+ ans -= (long) comb2(left - preX) * comb2(right - sufX);
+ // 不合法：只有两个 x，且至少有两个 y（y != x）
+ for (Map.Entry<Integer, Integer> e : suf.entrySet()) {
+ int y = e.getKey();
+ if (y == x) {
+ continue;
+ }
+ int sufY = e.getValue(); // 注意 sufY 可能是 0
+ int preY = pre.getOrDefault(y, 0);
+ // 左边有两个 y，右边有一个 x，即 yy x xz（z 可以等于 y）
+ ans -= (long) comb2(preY) * sufX * (right - sufX);
+ // 右边有两个 y，左边有一个 x，即 zx x yy（z 可以等于 y）
+ ans -= (long) comb2(sufY) * preX * (left - preX);
+ // 左右各有一个 y，另一个 x 在左边，即 xy x yz（z != y）
+ ans -= (long) preY * sufY * preX * (right - sufX - sufY);
+ // 左右各有一个 y，另一个 x 在右边，即 zy x xy（z != y）
+ ans -= (long) preY * sufY * sufX * (left - preX - preY);
+ }
+ }
+ pre.merge(x, 1, Integer::sum); // pre[x]++
+ }
+ return (int) (ans % MOD);
+ }
+
+ private int comb2(int num) {
+ return num * (num - 1) / 2;
+ }
+}
+/*
+3395. 唯一中间众数子序列 I
+https://leetcode.cn/problems/subsequences-with-a-unique-middle-mode-i/description/
+
+第 146 场双周赛 T4。
+
+给你一个整数数组 nums ，请你求出 nums 中大小为 5 的 子序列 的数目，它是 唯一中间众数序列 。
+由于答案可能很大，请你将答案对 10^9 + 7 取余 后返回。
+众数 指的是一个数字序列中出现次数 最多 的元素。
+如果一个数字序列众数只有一个，我们称这个序列有 唯一众数 。
+一个大小为 5 的数字序列 seq ，如果它中间的数字（seq[2]）是唯一众数，那么称它是 唯一中间众数 序列。
+提示：
+5 <= nums.length <= 1000
+-10^9 <= nums[i] <= 10^9
+
+枚举。
+时间复杂度 O(n^2)
+https://leetcode.cn/problems/subsequences-with-a-unique-middle-mode-i/solutions/3026877/zheng-nan-ze-fan-fen-lei-tao-lun-qian-ho-f7cd/
+rating 2818 (clist.by)
+ */

leetcode/leetcode-34/src/test/java/Solution3392Tests.java

@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3392Tests {
+ private final Solution3392 solution3392 = new Solution3392();
+
+ @Test
+ public void example1() {
+ int[] nums = {1, 2, 1, 4, 1};
+ int expected = 1;
+ Assertions.assertEquals(expected, solution3392.countSubarrays(nums));
+ }
+
+ @Test
+ public void example2() {
+ int[] nums = {1, 1, 1};
+ int expected = 0;
+ Assertions.assertEquals(expected, solution3392.countSubarrays(nums));
+ }
+}

leetcode/leetcode-34/src/test/java/Solution3393Tests.java

@@ -0,0 +1,30 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3393Tests {
+ private final Solution3393 solution3393 = new Solution3393();
+
+ @Test
+ public void example1() {
+ int[][] grid = UtUtils.stringToInts2("[[2, 1, 5], [7, 10, 0], [12, 6, 4]]");
+ int k = 11;
+ int expected = 3;
+ Assertions.assertEquals(expected, solution3393.countPathsWithXorValue(grid, k));
+ }
+
+ @Test
+ public void example2() {
+ int[][] grid = UtUtils.stringToInts2("[[1, 3, 3, 3], [0, 3, 3, 2], [3, 0, 1, 1]]");
+ int k = 2;
+ int expected = 5;
+ Assertions.assertEquals(expected, solution3393.countPathsWithXorValue(grid, k));
+ }
+
+ @Test
+ public void example3() {
+ int[][] grid = UtUtils.stringToInts2("[[1, 1, 1, 2], [3, 0, 3, 2], [3, 0, 2, 2]]");
+ int k = 10;
+ int expected = 0;
+ Assertions.assertEquals(expected, solution3393.countPathsWithXorValue(grid, k));
+ }
+}

leetcode/leetcode-34/src/test/java/Solution3394Tests.java

@@ -0,0 +1,27 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3394Tests {
+ private final Solution3394 solution3394 = new Solution3394();
+
+ @Test
+ public void example1() {
+ int n = 5;
+ int[][] rectangles = UtUtils.stringToInts2("[[1,0,5,2],[0,2,2,4],[3,2,5,3],[0,4,4,5]]");
+ Assertions.assertTrue(solution3394.checkValidCuts(n, rectangles));
+ }
+
+ @Test
+ public void example2() {
+ int n = 4;
+ int[][] rectangles = UtUtils.stringToInts2("[[0,0,1,1],[2,0,3,4],[0,2,2,3],[3,0,4,3]]");
+ Assertions.assertTrue(solution3394.checkValidCuts(n, rectangles));
+ }
+
+ @Test
+ public void example3() {
+ int n = 4;
+ int[][] rectangles = UtUtils.stringToInts2("[[0,2,2,4],[1,0,3,2],[2,2,3,4],[3,0,4,2],[3,2,4,4]]");
+ Assertions.assertFalse(solution3394.checkValidCuts(n, rectangles));
+ }
+}

leetcode/leetcode-34/src/test/java/Solution3395Tests.java

@@ -0,0 +1,27 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3395Tests {
+ private final Solution3395 solution3395 = new Solution3395();
+
+ @Test
+ public void example1() {
+ int[] nums = {1, 1, 1, 1, 1, 1};
+ int expected = 6;
+ Assertions.assertEquals(expected, solution3395.subsequencesWithMiddleMode(nums));
+ }
+
+ @Test
+ public void example2() {
+ int[] nums = {1, 2, 2, 3, 3, 4};
+ int expected = 4;
+ Assertions.assertEquals(expected, solution3395.subsequencesWithMiddleMode(nums));
+ }
+
+ @Test
+ public void example3() {
+ int[] nums = {0, 1, 2, 3, 4, 5, 6, 7, 8};
+ int expected = 0;
+ Assertions.assertEquals(expected, solution3395.subsequencesWithMiddleMode(nums));
+ }
+}