第96场双周赛T1~T4 & 第329场周赛T1~T3 (7)

Author: gdut-yy

leetcode-26/src/main/java/Solution2540.java

@@ -0,0 +1,33 @@
+public class Solution2540 {
+    public int getCommon(int[] nums1, int[] nums2) {
+        int n = nums1.length;
+        int m = nums2.length;
+        int i = 0;
+        int j = 0;
+        while (i < n && j < m) {
+            if (nums1[i] == nums2[j]) {
+                return nums1[i];
+            } else if (nums1[i] > nums2[j]) {
+                j++;
+            } else {
+                i++;
+            }
+        }
+        return -1;
+    }
+}
+/*
+2540. 最小公共值
+https://leetcode.cn/problems/minimum-common-value/
+
+第 96 场双周赛 T1。
+
+给你两个整数数组 nums1 和 nums2 ，它们已经按非降序排序，请你返回两个数组的 最小公共整数 。如果两个数组 nums1 和 nums2 没有公共整数，请你返回 -1 。
+如果一个整数在两个数组中都 至少出现一次 ，那么这个整数是数组 nums1 和 nums2 公共 的。
+提示：
+1 <= nums1.length, nums2.length <= 10^5
+1 <= nums1[i], nums2[j] <= 10^9
+nums1 和 nums2 都是 非降序 的。
+
+双指针
+ */

leetcode-26/src/main/java/Solution2541.java

@@ -0,0 +1,51 @@
+import java.util.Arrays;
+
+public class Solution2541 {
+    public long minOperations(int[] nums1, int[] nums2, int k) {
+        // 特判
+        if (k == 0) {
+            return Arrays.equals(nums1, nums2) ? 0 : -1;
+        }
+
+        int n = nums1.length;
+        long add = 0;
+        long sub = 0;
+        for (int i = 0; i < n; i++) {
+            if (nums1[i] < nums2[i]) {
+                int d = nums2[i] - nums1[i];
+                if (d % k != 0) {
+                    return -1;
+                } else {
+                    add += d / k;
+                }
+            } else if (nums1[i] > nums2[i]) {
+                int d = nums1[i] - nums2[i];
+                if (d % k != 0) {
+                    return -1;
+                } else {
+                    sub += d / k;
+                }
+            }
+        }
+        return add == sub ? add : -1;
+    }
+}
+/*
+2541. 使数组中所有元素相等的最小操作数 II
+https://leetcode.cn/problems/minimum-operations-to-make-array-equal-ii/
+
+第 96 场双周赛 T2。
+
+给你两个整数数组 nums1 和 nums2 ，两个数组长度都是 n ，再给你一个整数 k 。你可以对数组 nums1 进行以下操作：
+- 选择两个下标 i 和 j ，将 nums1[i] 增加 k ，将 nums1[j] 减少 k 。换言之，nums1[i] = nums1[i] + k 且 nums1[j] = nums1[j] - k 。
+如果对于所有满足 0 <= i < n 都有 num1[i] == nums2[i] ，那么我们称 nums1 等于 nums2 。
+请你返回使 nums1 等于 nums2 的 最少 操作数。如果没办法让它们相等，请你返回 -1 。
+提示：
+n == nums1.length == nums2.length
+2 <= n <= 10^5
+0 <= nums1[i], nums2[j] <= 10^9
+0 <= k <= 10^5
+
+模拟，判断加和减的次数是否相等。
+注意 RE java.lang.ArithmeticException: / by zero
+ */

leetcode-26/src/main/java/Solution2542.java

@@ -0,0 +1,80 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class Solution2542 {
+    public long maxScore(int[] nums1, int[] nums2, int k) {
+        int n = nums1.length;
+        List<Node> list = new ArrayList<>();
+        for (int i = 0; i < n; i++) {
+            list.add(new Node(i, nums1[i], nums2[i]));
+        }
+        // 大到小排序，枚举 min(nums2[i]) 范围 [k-1, n-1]
+        list.sort((o1, o2) -> Integer.compare(o2.n2, o1.n2));
+
+        // 大小为 k 的最小堆
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        long sum = 0;
+        // [0, k-1]
+        for (int i = 0; i < k; i++) {
+            int n1 = list.get(i).n1;
+            minHeap.add(n1);
+            sum += n1;
+        }
+        long min = list.get(k - 1).n2;
+        long res = sum * min;
+
+        // [k, n-1]
+        for (int i = k; i < n; i++) {
+            int n1 = list.get(i).n1;
+            min = list.get(i).n2;
+
+            int top = minHeap.element();
+            if (n1 > top) {
+                minHeap.add(n1);
+                sum -= minHeap.remove();
+                sum += n1;
+            }
+            res = Math.max(res, sum * min);
+
+        }
+        return res;
+    }
+
+    private static class Node {
+        int id;
+        int n1;
+        int n2;
+
+        public Node(int id, int n1, int n2) {
+            this.id = id;
+            this.n1 = n1;
+            this.n2 = n2;
+        }
+    }
+}
+/*
+2542. 最大子序列的分数
+https://leetcode.cn/problems/maximum-subsequence-score/
+
+第 96 场双周赛 T3。
+
+给你两个下标从 0 开始的整数数组 nums1 和 nums2 ，两者长度都是 n ，再给你一个正整数 k 。你必须从 nums1 中选一个长度为 k 的 子序列 对应的下标。
+对于选择的下标 i0 ，i1 ，...， ik - 1 ，你的 分数 定义如下：
+- nums1 中下标对应元素求和，乘以 nums2 中下标对应元素的 最小值 。
+- 用公示表示： (nums1[i0] + nums1[i1] +...+ nums1[ik - 1]) * min(nums2[i0] , nums2[i1], ... ,nums2[ik - 1]) 。
+请你返回 最大 可能的分数。
+一个数组的 子序列 下标是集合 {0, 1, ..., n-1} 中删除若干元素得到的剩余集合，也可以不删除任何元素。
+提示：
+n == nums1.length == nums2.length
+1 <= n <= 10^5
+0 <= nums1[i], nums2[j] <= 10^5
+1 <= k <= n
+
+将 nums1 和 nums2 组合起来后按 nums2 由大至小排序。枚举 nums2[i] 取值范围为 [k-1, n-1]
+同时用最小堆维护 k 个 nums1 最大值。
+时间复杂度 O(nlogn)
+空间复杂度 O(n)
+相似题目: 703. 数据流中的第 K 大元素
+https://leetcode.cn/problems/kth-largest-element-in-a-stream/
+ */

leetcode-26/src/main/java/Solution2543.java

@@ -0,0 +1,36 @@
+public class Solution2543 {
+    public boolean isReachable(int targetX, int targetY) {
+        int gcd = getGCD(targetX, targetY);
+        // 是否为 2 的幂
+        return (gcd & (gcd - 1)) == 0;
+    }
+
+    private int getGCD(int num1, int num2) {
+        if (num1 == 0) {
+            return num2;
+        }
+        return getGCD(num2 % num1, num1);
+    }
+}
+/*
+2543. 判断一个点是否可以到达
+https://leetcode.cn/problems/check-if-point-is-reachable/
+
+第 96 场双周赛 T4。
+
+给你一个无穷大的网格图。一开始你在 (1, 1) ，你需要通过有限步移动到达点 (targetX, targetY) 。
+每一步 ，你可以从点 (x, y) 移动到以下点之一：
+- (x, y - x)
+- (x - y, y)
+- (2 * x, y)
+- (x, 2 * y)
+给你两个整数 targetX 和 targetY ，分别表示你最后需要到达点的 X 和 Y 坐标。如果你可以从 (1, 1) 出发到达这个点，请你返回true ，否则返回 false 。
+提示：
+1 <= targetX, targetY <= 10^9
+
+数学
+前两个操作是辗转相除法，即 GCD。
+后两个移动让 GCD 乘以 2^k.
+时间复杂度 O(logmin(targetX, targetY))
+空间复杂度 O(1)
+ */

leetcode-26/src/main/java/Solution2544.java

@@ -0,0 +1,27 @@
+public class Solution2544 {
+    public int alternateDigitSum(int n) {
+        boolean positive = true;
+        int res = 0;
+        while (n > 0) {
+            res += (positive ? 1 : -1) * (n % 10);
+            n /= 10;
+            positive = !positive;
+        }
+        return positive ? -res : res;
+    }
+}
+/*
+2544. 交替数字和
+https://leetcode.cn/problems/alternating-digit-sum/
+
+第 329 场周赛 T1。
+
+给你一个正整数 n 。n 中的每一位数字都会按下述规则分配一个符号：
+- 最高有效位 上的数字分配到 正 号。
+- 剩余每位上数字的符号都与其相邻数字相反。
+返回所有数字及其对应符号的和。
+提示：
+1 <= n <= 10^9
+
+模拟
+ */

leetcode-26/src/main/java/Solution2545.java

@@ -0,0 +1,29 @@
+import java.util.Arrays;
+
+public class Solution2545 {
+    public int[][] sortTheStudents(int[][] score, int k) {
+        Arrays.sort(score, (o1, o2) -> Integer.compare(o2[k], o1[k]));
+        return score;
+    }
+}
+/*
+2545. 根据第 K 场考试的分数排序
+https://leetcode.cn/problems/sort-the-students-by-their-kth-score/
+
+第 329 场周赛 T2。
+
+班里有 m 位学生，共计划组织 n 场考试。给你一个下标从 0 开始、大小为 m x n 的整数矩阵 score ，
+其中每一行对应一位学生，而 score[i][j] 表示第 i 位学生在第 j 场考试取得的分数。矩阵 score 包含的整数 互不相同 。
+另给你一个整数 k 。请你按第 k 场考试分数从高到低完成对这些学生（矩阵中的行）的排序。
+返回排序后的矩阵。
+提示：
+m == score.length
+n == score[i].length
+1 <= m, n <= 250
+1 <= score[i][j] <= 10^5
+score 由 不同 的整数组成
+0 <= k < n
+
+模拟/库函数
+时间复杂度：库函数不讨论时间复杂度。
+ */

leetcode-26/src/main/java/Solution2546.java

@@ -0,0 +1,48 @@
+public class Solution2546 {
+    public boolean makeStringsEqual(String s, String target) {
+        if (s.equals(target)) {
+            return true;
+        }
+        int n = s.length();
+        int s0 = 0;
+        for (char ch : s.toCharArray()) {
+            if (ch == '0') {
+                s0++;
+            }
+        }
+        int t0 = 0;
+        for (char ch : target.toCharArray()) {
+            if (ch == '0') {
+                t0++;
+            }
+        }
+        return s0 != n && t0 != n;
+    }
+}
+/*
+2546. 执行逐位运算使字符串相等
+https://leetcode.cn/problems/apply-bitwise-operations-to-make-strings-equal/
+
+第 329 场周赛 T3。
+
+给你两个下标从 0 开始的 二元 字符串 s 和 target ，两个字符串的长度均为 n 。你可以对 s 执行下述操作 任意 次：
+- 选择两个 不同 的下标 i 和 j ，其中 0 <= i, j < n 。
+- 同时，将 s[i] 替换为 (s[i] OR s[j]) ，s[j] 替换为 (s[i] XOR s[j]) 。
+例如，如果 s = "0110" ，你可以选择 i = 0 和 j = 2，然后同时将 s[0] 替换为 (s[0] OR s[2] = 0 OR 1 = 1)，并将 s[2] 替换为 (s[0] XOR s[2] = 0 XOR 1 = 1)，最终得到 s = "1110" 。
+如果可以使 s 等于 target ，返回 true ，否则，返回 false 。
+提示：
+n == s.length == target.length
+2 <= n <= 10^5
+s 和 target 仅由数字 0 和 1 组成
+
+找规律
+i,j -> i|j, i^j
+0,0 -> 0,0
+0,1 -> 1,1
+1,0 -> 1,1
+1,1 -> 1,0
+可以观察到 1 不能凭空出现，不能突然消失。
+如果数组本身没 1，将不可能出现 1；
+如果数组本身有 1，不可能全部变成 0；
+因此当两数组不相等时，其中任一数组不能为全 0 数组
+ */

leetcode-26/src/test/java/Solution2540Tests.java

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution2540Tests {
+    private final Solution2540 solution2540 = new Solution2540();
+
+    @Test
+    public void example1() {
+        int[] nums1 = {1, 2, 3};
+        int[] nums2 = {2, 4};
+        int expected = 2;
+        Assertions.assertEquals(expected, solution2540.getCommon(nums1, nums2));
+    }
+
+    @Test
+    public void example2() {
+        int[] nums1 = {1, 2, 3, 6};
+        int[] nums2 = {2, 3, 4, 5};
+        int expected = 2;
+        Assertions.assertEquals(expected, solution2540.getCommon(nums1, nums2));
+    }
+}

leetcode-26/src/test/java/Solution2541Tests.java

@@ -0,0 +1,36 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution2541Tests {
+    private final Solution2541 solution2541 = new Solution2541();
+
+    @Test
+    public void example1() {
+        int[] nums1 = {4, 3, 1, 4};
+        int[] nums2 = {1, 3, 7, 1};
+        int k = 3;
+        long expected = 2;
+        Assertions.assertEquals(expected, solution2541.minOperations(nums1, nums2, k));
+    }
+
+    @Test
+    public void example2() {
+        int[] nums1 = {3, 8, 5, 2};
+        int[] nums2 = {2, 4, 1, 6};
+        int k = 1;
+        long expected = -1;
+        Assertions.assertEquals(expected, solution2541.minOperations(nums1, nums2, k));
+    }
+
+    // 补充用例
+    @Test
+    public void example3() {
+        // https://leetcode.cn/submissions/detail/397340535/
+        // RE java.lang.ArithmeticException: / by zero
+        int[] nums1 = {10, 5, 15, 20};
+        int[] nums2 = {20, 10, 15, 5};
+        int k = 0;
+        long expected = -1;
+        Assertions.assertEquals(expected, solution2541.minOperations(nums1, nums2, k));
+    }
+}