第432场周赛T1~T4 (4)

Author: gdut-yy

leetcode/leetcode-35/src/main/java/Solution3417.java

@@ -0,0 +1,44 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution3417 {
+ public List<Integer> zigzagTraversal(int[][] grid) {
+ int m = grid.length;
+ int n = grid[0].length;
+
+ List<Integer> ans = new ArrayList<>();
+ boolean add = true;
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ if (add) {
+ if (i % 2 == 0) ans.add(grid[i][j]);
+ else ans.add(grid[i][n - 1 - j]);
+ }
+ add = !add;
+ }
+ }
+ return ans;
+ }
+}
+/*
+3417. 跳过交替单元格的之字形遍历
+https://leetcode.cn/problems/zigzag-grid-traversal-with-skip/description/
+
+第 432 场周赛 T1。
+
+给你一个 m x n 的二维数组 grid，数组由 正整数 组成。
+你的任务是以 之字形 遍历 grid，同时跳过每个 交替 的单元格。
+之字形遍历的定义如下：
+- 从左上角的单元格 (0, 0) 开始。
+- 在当前行中向 右 移动，直到到达该行的末尾。
+- 下移到下一行，然后在该行中向 左 移动，直到到达该行的开头。
+- 继续在行间交替向右和向左移动，直到所有行都被遍历完。
+注意：在遍历过程中，必须跳过每个 交替 的单元格。
+返回一个整数数组 result，其中包含按 顺序 记录的、且跳过交替单元格后的之字形遍历中访问到的单元格值。
+提示：
+2 <= n == grid.length <= 50
+2 <= m == grid[i].length <= 50
+1 <= grid[i][j] <= 2500
+
+模拟。
+ */

leetcode/leetcode-35/src/main/java/Solution3418.java

@@ -0,0 +1,62 @@
+import java.util.Arrays;
+
+public class Solution3418 {
+ public int maximumAmount(int[][] coins) {
+ int m = coins.length;
+ int n = coins[0].length;
+
+ int[][][] f = new int[m][n][3];
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ Arrays.fill(f[i][j], (int) -1e9);
+ }
+ }
+ f[0][0][0] = coins[0][0]; // 感化0次
+ f[0][0][1] = Math.max(0, f[0][0][0]); // 感化1次
+ f[0][0][2] = Math.max(0, f[0][0][1]); // 感化2次
+ for (int i = 0; i < m; i++) {
+ for (int j = 0; j < n; j++) {
+ for (int k0 = 0; k0 <= 2; k0++) {
+ if (j - 1 >= 0) {
+ f[i][j][k0] = Math.max(f[i][j][k0], f[i][j - 1][k0] + coins[i][j]);
+ }
+ if (i - 1 >= 0) {
+ f[i][j][k0] = Math.max(f[i][j][k0], f[i - 1][j][k0] + coins[i][j]);
+ }
+ // 感化
+ if (coins[i][j] >= 0) continue;
+ int k1 = k0 + 1;
+ if (k1 > 2) continue;
+ if (j - 1 >= 0) {
+ f[i][j][k1] = Math.max(f[i][j][k1], f[i][j - 1][k0]);
+ }
+ if (i - 1 >= 0) {
+ f[i][j][k1] = Math.max(f[i][j][k1], f[i - 1][j][k0]);
+ }
+ }
+ }
+ }
+ return Arrays.stream(f[m - 1][n - 1]).max().orElseThrow();
+ }
+}
+/*
+3418. 机器人可以获得的最大金币数
+https://leetcode.cn/problems/maximum-amount-of-money-robot-can-earn/description/
+
+第 432 场周赛 T2。
+
+给你一个 m x n 的网格。一个机器人从网格的左上角 (0, 0) 出发，目标是到达网格的右下角 (m - 1, n - 1)。在任意时刻，机器人只能向右或向下移动。
+网格中的每个单元格包含一个值 coins[i][j]：
+- 如果 coins[i][j] >= 0，机器人可以获得该单元格的金币。
+- 如果 coins[i][j] < 0，机器人会遇到一个强盗，强盗会抢走该单元格数值的 绝对值 的金币。
+机器人有一项特殊能力，可以在行程中 最多感化 2个单元格的强盗，从而防止这些单元格的金币被抢走。
+注意：机器人的总金币数可以是负数。
+返回机器人在路径上可以获得的 最大金币数 。
+提示：
+m == coins.length
+n == coins[i].length
+1 <= m, n <= 500
+-1000 <= coins[i][j] <= 1000
+
+网格图 DP。
+ */

leetcode/leetcode-35/src/main/java/Solution3419.java

@@ -0,0 +1,78 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution3419 {
+ private int n;
+ private List<int[]>[] rg;
+ private int[] vis;
+
+ public int minMaxWeight(int n, int[][] edges, int threshold) {
+ this.n = n;
+ rg = new ArrayList[n]; // 反图
+ Arrays.setAll(rg, e -> new ArrayList<>());
+ int maxWt = 0;
+ for (int[] p : edges) {
+ int u = p[0], v = p[1], wt = p[2];
+ rg[v].add(new int[]{u, wt});
+ maxWt = Math.max(maxWt, wt);
+ }
+
+ vis = new int[n];
+ int left = 0;
+ int right = maxWt + 1;
+ while (left < right) {
+ int mid = left + (right - left) / 2;
+ // 边界二分 F, F,..., F, [T, T,..., T]
+ // ----------------------^
+ if (checkMid(mid)) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return (left == maxWt + 1) ? -1 : left;
+ }
+
+ private boolean checkMid(int mid) {
+ return dfs(0, mid) == n;
+ }
+
+ private int dfs(int x, int upper) {
+ vis[x] = upper; // 避免每次重新创建 vis 数组
+ int cnt = 1;
+ for (int[] e : rg[x]) {
+ int y = e[0];
+ if (e[1] <= upper && vis[y] != upper) {
+ cnt += dfs(y, upper);
+ }
+ }
+ return cnt;
+ }
+}
+/*
+3419. 图的最大边权的最小值
+https://leetcode.cn/problems/minimize-the-maximum-edge-weight-of-graph/description/
+
+第 432 场周赛 T3。
+
+给你两个整数 n 和 threshold ，同时给你一个 n 个节点的 有向 带权图，节点编号为 0 到 n - 1 。这个图用 二维 整数数组 edges 表示，其中 edges[i] = [Ai, Bi, Wi] 表示节点 Ai 到节点 Bi 之间有一条边权为 Wi的有向边。
+你需要从这个图中删除一些边（也可能 不 删除任何边），使得这个图满足以下条件：
+- 所有其他节点都可以到达节点 0 。
+- 图中剩余边的 最大 边权值尽可能小。
+- 每个节点都 至多 有 threshold 条出去的边。
+请你返回删除必要的边后，最大 边权的 最小值 为多少。如果无法满足所有的条件，请你返回 -1 。
+提示：
+2 <= n <= 10^5
+1 <= threshold <= n - 1
+1 <= edges.length <= min(105, n * (n - 1) / 2).
+edges[i].length == 3
+0 <= Ai, Bi < n
+Ai != Bi
+1 <= Wi <= 10^6
+一对节点之间 可能 会有多条边，但它们的权值互不相同。
+
+二分答案。
+threshold 是多余的。请大胆二分。
+rating 2249 (clist.by)
+ */

leetcode/leetcode-35/src/main/java/Solution3420.java

@@ -0,0 +1,85 @@
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Deque;
+import java.util.List;
+
+public class Solution3420 {
+ public long countNonDecreasingSubarrays(int[] nums, int k) {
+ int n = nums.length;
+ List<Integer>[] g = new ArrayList[n];
+ Arrays.setAll(g, e -> new ArrayList<>());
+ int[] posR = new int[n];
+ Arrays.fill(posR, n);
+ Deque<Integer> st = new ArrayDeque<>();
+ for (int i = 0; i < n; i++) {
+ int x = nums[i];
+ while (!st.isEmpty() && x >= nums[st.peek()]) {
+ posR[st.pop()] = i;
+ }
+ // 循环结束后，栈顶就是左侧 > x 的最近元素了
+ if (!st.isEmpty()) {
+ g[st.peek()].add(i);
+ }
+ st.push(i);
+ }
+
+ long ans = 0;
+ int cnt = 0;
+ int l = 0; // 窗口左端点
+ Deque<Integer> dq = new ArrayDeque<>(); // 单调队列维护最大值
+ for (int r = 0; r < n; r++) { // 窗口右端点
+ int x = nums[r];
+ // x 进入窗口
+ while (!dq.isEmpty() && nums[dq.peekLast()] <= x) {
+ dq.pollLast(); // 维护 q 的单调性
+ }
+ dq.addLast(r);
+
+ // 由于队首到队尾单调递减，所以窗口最大值就是队首
+ cnt += nums[dq.peekFirst()] - x;
+
+ // 操作次数太多，缩小窗口
+ while (cnt > k) {
+ int out = nums[l]; // 离开窗口的元素
+ for (int i : g[l]) {
+ if (i > r) {
+ break;
+ }
+ cnt -= (out - nums[i]) * (Math.min(posR[i], r + 1) - i);
+ }
+ l++;
+
+ // 队首已经离开窗口了
+ if (!dq.isEmpty() && dq.peekFirst() < l) {
+ dq.pollFirst();
+ }
+ }
+
+ ans += r - l + 1;
+ }
+
+ return ans;
+ }
+}
+/*
+3420. 统计 K 次操作以内得到非递减子数组的数目
+https://leetcode.cn/problems/count-non-decreasing-subarrays-after-k-operations/description/
+
+第 432 场周赛 T4。
+
+给你一个长度为 n 的数组 nums 和一个整数 k 。
+对于 nums 中的每一个子数组，你可以对它进行 至多 k 次操作。每次操作中，你可以将子数组中的任意一个元素增加 1 。
+注意 ，每个子数组都是独立的，也就是说你对一个子数组的修改不会保留到另一个子数组中。
+请你返回最多 k 次操作以内，有多少个子数组可以变成 非递减 的。
+如果一个数组中的每一个元素都大于等于前一个元素（如果前一个元素存在），那么我们称这个数组是 非递减 的。
+提示：
+1 <= nums.length <= 10^5
+1 <= nums[i] <= 10^9
+1 <= k <= 10^9
+
+单调栈+单调队列。
+左端点元素离开窗口 本题的难点。
+时间复杂度 O(n)。
+rating 2868 (clist.by)
+ */

leetcode/leetcode-35/src/test/java/Solution3417Tests.java

@@ -0,0 +1,29 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+
+public class Solution3417Tests {
+ private final Solution3417 solution3417 = new Solution3417();
+
+ @Test
+ public void example1() {
+ int[][] grid = UtUtils.stringToInts2("[[1,2],[3,4]]");
+ List<Integer> expected = List.of(1, 4);
+ Assertions.assertEquals(expected, solution3417.zigzagTraversal(grid));
+ }
+
+ @Test
+ public void example2() {
+ int[][] grid = UtUtils.stringToInts2("[[2,1],[2,1],[2,1]]");
+ List<Integer> expected = List.of(2, 1, 2);
+ Assertions.assertEquals(expected, solution3417.zigzagTraversal(grid));
+ }
+
+ @Test
+ public void example3() {
+ int[][] grid = UtUtils.stringToInts2("[[1,2,3],[4,5,6],[7,8,9]]");
+ List<Integer> expected = List.of(1, 3, 5, 7, 9);
+ Assertions.assertEquals(expected, solution3417.zigzagTraversal(grid));
+ }
+}

leetcode/leetcode-35/src/test/java/Solution3418Tests.java

@@ -0,0 +1,20 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3418Tests {
+ private final Solution3418 solution3418 = new Solution3418();
+
+ @Test
+ public void example1() {
+ int[][] coins = UtUtils.stringToInts2("[[0,1,-1],[1,-2,3],[2,-3,4]]");
+ int expected = 8;
+ Assertions.assertEquals(expected, solution3418.maximumAmount(coins));
+ }
+
+ @Test
+ public void example2() {
+ int[][] coins = UtUtils.stringToInts2("[[10,10,10],[10,10,10]]");
+ int expected = 40;
+ Assertions.assertEquals(expected, solution3418.maximumAmount(coins));
+ }
+}

leetcode/leetcode-35/src/test/java/Solution3419Tests.java

@@ -0,0 +1,42 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3419Tests {
+ private final Solution3419 solution3419 = new Solution3419();
+
+ @Test
+ public void example1() {
+ int n = 5;
+ int[][] edges = UtUtils.stringToInts2("[[1,0,1],[2,0,2],[3,0,1],[4,3,1],[2,1,1]]");
+ int threshold = 2;
+ int expected = 1;
+ Assertions.assertEquals(expected, solution3419.minMaxWeight(n, edges, threshold));
+ }
+
+ @Test
+ public void example2() {
+ int n = 5;
+ int[][] edges = UtUtils.stringToInts2("[[0,1,1],[0,2,2],[0,3,1],[0,4,1],[1,2,1],[1,4,1]]");
+ int threshold = 1;
+ int expected = -1;
+ Assertions.assertEquals(expected, solution3419.minMaxWeight(n, edges, threshold));
+ }
+
+ @Test
+ public void example3() {
+ int n = 5;
+ int[][] edges = UtUtils.stringToInts2("[[1,2,1],[1,3,3],[1,4,5],[2,3,2],[3,4,2],[4,0,1]]");
+ int threshold = 1;
+ int expected = 2;
+ Assertions.assertEquals(expected, solution3419.minMaxWeight(n, edges, threshold));
+ }
+
+ @Test
+ public void example4() {
+ int n = 5;
+ int[][] edges = UtUtils.stringToInts2("[[1,2,1],[1,3,3],[1,4,5],[2,3,2],[4,0,1]]");
+ int threshold = 1;
+ int expected = -1;
+ Assertions.assertEquals(expected, solution3419.minMaxWeight(n, edges, threshold));
+ }
+}

leetcode/leetcode-35/src/test/java/Solution3420Tests.java

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3420Tests {
+ private final Solution3420 solution3420 = new Solution3420();
+
+ @Test
+ public void example1() {
+ int[] nums = {6, 3, 1, 2, 4, 4};
+ int k = 7;
+ long expected = 17;
+ Assertions.assertEquals(expected, solution3420.countNonDecreasingSubarrays(nums, k));
+ }
+
+ @Test
+ public void example2() {
+ int[] nums = {6, 3, 1, 3, 6};
+ int k = 4;
+ long expected = 12;
+ Assertions.assertEquals(expected, solution3420.countNonDecreasingSubarrays(nums, k));
+ }
+}