第429场周赛T1~T4 (4)

Author: gdut-yy

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

@@ -0,0 +1,30 @@
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution3396 {
+ public int minimumOperations(int[] nums) {
+ int n = nums.length;
+ Set<Integer> set = new HashSet<>();
+ for (int i = n - 1; i >= 0; i--) {
+ if (set.contains(nums[i])) break;
+ set.add(nums[i]);
+ }
+ return ((n - set.size()) + 2) / 3;
+ }
+}
+/*
+3396. 使数组元素互不相同所需的最少操作次数
+https://leetcode.cn/problems/minimum-number-of-operations-to-make-elements-in-array-distinct/description/
+
+第 429 场周赛 T1。
+
+给你一个整数数组 nums，你需要确保数组中的元素 互不相同 。为此，你可以执行以下操作任意次：
+- 从数组的开头移除 3 个元素。如果数组中元素少于 3 个，则移除所有剩余元素。
+注意：空数组也视作为数组元素互不相同。返回使数组元素互不相同所需的 最少操作次数 。
+提示：
+1 <= nums.length <= 100
+1 <= nums[i] <= 100
+
+后往前枚举，数组元素互不相同 的长度 L。则要删去 n-L。
+答案为 ceil( (n-L) / 3 )
+ */

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

@@ -0,0 +1,43 @@
+import java.util.Arrays;
+
+public class Solution3397 {
+ public int maxDistinctElements(int[] nums, int k) {
+ int n = nums.length;
+ Arrays.sort(nums);
+ int preR = Integer.MIN_VALUE;
+ int ans = 0;
+ int i = 0;
+ while (i < n) {
+ // 分组循环
+ int st = i;
+ for (i++; i < n && nums[i] == nums[st]; i++) {
+ }
+ int span = i - st;
+ int L = nums[st] - k;
+ int R = nums[st] + k;
+ // [max(L, preR+1), R]
+ int maxL = Math.max(L, preR);
+ int add = Math.min(R - maxL + 1, span);
+ ans += add;
+ preR = maxL + add;
+ }
+ return ans;
+ }
+}
+/*
+3397. 执行操作后不同元素的最大数量
+https://leetcode.cn/problems/maximum-number-of-distinct-elements-after-operations/description/
+
+第 429 场周赛 T2。
+
+给你一个整数数组 nums 和一个整数 k。
+你可以对数组中的每个元素 最多 执行 一次 以下操作：
+- 将一个在范围 [-k, k] 内的整数加到该元素上。
+返回执行这些操作后，nums 中可能拥有的不同元素的 最大 数量。
+提示：
+1 <= nums.length <= 10^5
+1 <= nums[i] <= 10^9
+0 <= k <= 10^9
+
+贪心 + 排序 + 分组循环。
+ */

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

@@ -0,0 +1,22 @@
+public class Solution3398 {
+}
+/*
+3398. 字符相同的最短子字符串 I
+https://leetcode.cn/problems/smallest-substring-with-identical-characters-i/description/
+
+第 429 场周赛 T3。
+
+给你一个长度为 n 的二进制字符串 s 和一个整数 numOps。
+你可以对 s 执行以下操作，最多 numOps 次：
+- 选择任意下标 i（其中 0 <= i < n），并 翻转 s[i]，即如果 s[i] == '1'，则将 s[i] 改为 '0'，反之亦然。
+你需要 最小化 s 的最长 相同 子字符串 的长度，相同子字符串 是指子字符串中的所有字符都 相同。
+返回执行所有操作后可获得的 最小 长度。
+提示：
+1 <= n == s.length <= 1000
+s 仅由 '0' 和 '1' 组成。
+0 <= numOps <= n
+
+同: 3399. 字符相同的最短子字符串 II
+https://leetcode.cn/problems/smallest-substring-with-identical-characters-ii/description/
+rating 2307 (clist.by)
+ */

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

@@ -0,0 +1,62 @@
+public class Solution3399 {
+ public int minLength(String s, int numOps) {
+ int n = s.length();
+ char[] cs = s.toCharArray();
+ if (check(cs, numOps, 0) || check(cs, numOps, 1)) return 1;
+
+ int left = 2;
+ int right = n;
+ while (left < right) {
+ int mid = left + (right - left) / 2;
+ // 边界二分 F, F,..., F, [T, T,..., T]
+ // ----------------------^
+ if (checkMid(cs, numOps, mid)) {
+ right = mid;
+ } else {
+ left = mid + 1;
+ }
+ }
+ return left;
+ }
+
+ private boolean check(char[] s, int numOps, int x) {
+ int cnt = 0;
+ for (int i = 0; i < s.length; i++) if (s[i] % 2 != (i + x) % 2) cnt++;
+ return cnt <= numOps;
+ }
+
+ private boolean checkMid(char[] s, int numOps, int mid) {
+ int needOps = 0;
+ int i = 0;
+ while (i < s.length) {
+ int st = i;
+ for (i++; i < s.length && s[i] == s[st]; i++) {
+ }
+ int span = i - st;
+ needOps += span / (mid + 1);
+ }
+ return needOps <= numOps;
+ }
+}
+/*
+3399. 字符相同的最短子字符串 II
+https://leetcode.cn/problems/smallest-substring-with-identical-characters-ii/description/
+
+第 429 场周赛 T4。
+
+给你一个长度为 n 的二进制字符串 s 和一个整数 numOps。
+你可以对 s 执行以下操作，最多 numOps 次：
+- 选择任意下标 i（其中 0 <= i < n），并 翻转 s[i]，即如果 s[i] == '1'，则将 s[i] 改为 '0'，反之亦然。
+你需要 最小化 s 的最长 相同 子字符串 的长度，相同子字符串是指子字符串中的所有字符都相同。
+返回执行所有操作后可获得的 最小 长度。
+提示：
+1 <= n == s.length <= 10^5
+s 仅由 '0' 和 '1' 组成。
+0 <= numOps <= n
+
+二分 + 贪心 + 分类讨论。
+但 x=1 的情况就不能使用这个调整了。考虑 s = 0110，无论是第一个 1 还是第二个 1，都位于这一段的边界，可能会影响到相邻段的答案，
+因此不能直接应用这个贪心。好在 x=1 的情况下，最终的字符串只可能有两种：要么 0101...，要么 1010...。
+我们把最终字符串和 s 进行比较，看是不是至多有 numOps 个字符不同即可。
+rating 2382 (clist.by)
+ */

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

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

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

@@ -0,0 +1,22 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3397Tests {
+ private final Solution3397 solution3397 = new Solution3397();
+
+ @Test
+ public void example1() {
+ int[] nums = {1, 2, 2, 3, 3, 4};
+ int k = 2;
+ int expected = 6;
+ Assertions.assertEquals(expected, solution3397.maxDistinctElements(nums, k));
+ }
+
+ @Test
+ public void example2() {
+ int[] nums = {4, 4, 4, 4};
+ int k = 1;
+ int expected = 3;
+ Assertions.assertEquals(expected, solution3397.maxDistinctElements(nums, k));
+ }
+}

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

@@ -0,0 +1,3 @@
+public class Solution3398Tests {
+
+}

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

@@ -0,0 +1,30 @@
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+public class Solution3399Tests {
+ private final Solution3399 solution3399 = new Solution3399();
+
+ @Test
+ public void example1() {
+ String s = "000001";
+ int numOps = 1;
+ int expected = 2;
+ Assertions.assertEquals(expected, solution3399.minLength(s, numOps));
+ }
+
+ @Test
+ public void example2() {
+ String s = "0000";
+ int numOps = 2;
+ int expected = 1;
+ Assertions.assertEquals(expected, solution3399.minLength(s, numOps));
+ }
+
+ @Test
+ public void example3() {
+ String s = "0101";
+ int numOps = 0;
+ int expected = 1;
+ Assertions.assertEquals(expected, solution3399.minLength(s, numOps));
+ }
+}