2565 & 第98场双周赛T1~T4 & 第333场周赛T1~T4 (9)

Author: gdut-yy

atcoder-beginner/src/main/java/c287/Abc287_d.java

@@ -46,5 +46,7 @@ private static String solve(String s, String t) {
 D - Match or Not
 https://atcoder.jp/contests/abc287/tasks/abc287_d
 
-预处理 前后缀
+前后缀分解
+相似题目: 2565. 最少得分子序列
+https://leetcode.cn/problems/subsequence-with-the-minimum-score/
  */

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

@@ -0,0 +1,90 @@
+public class Solution2565 {
+    public int minimumScore(String s, String t) {
+        int n = s.length();
+        int m = t.length();
+
+        // pre[i] = x 表示 t 前缀长度为 i 时，s 需要至少前缀长度 x 匹配
+        int[] pre = new int[m + 1];
+        pre[0] = 0;
+        int j = 1;
+        // s[j] t[i]
+        for (int i = 1; i <= m; i++) {
+            while (j <= n && s.charAt(j - 1) != t.charAt(i - 1)) {
+                j++;
+            }
+            if (j <= n) {
+                pre[i] = j++;
+            } else {
+                pre[i] = n + 1;
+            }
+        }
+
+        // suf[i] = x 表示 t 后缀长度为 i 时，s 需要至少后缀长度 x 匹配
+        int[] suf = new int[m + 1];
+//        suf[0] = 0;
+        suf[m] = 0;
+        j = 1;
+        for (int i = 1; i <= m; i++) {
+            while (j <= n && s.charAt(n - j) != t.charAt(m - i)) {
+                j++;
+            }
+            if (j <= n) {
+//                suf[i] = j++;
+                suf[m - i] = j++;
+            } else {
+//                suf[i] = n + 1;
+                suf[m - i] = n + 1;
+            }
+        }
+
+        // 二分删除长度
+        int left = 0;
+        int right = m;
+        while (left < right) {
+            int mid = left + (right - left) / 2;
+            // 边界二分 F, F,..., F, [T, T,..., T]
+            // ----------------------^
+            if (checkMid(n, m, pre, suf, mid)) {
+                right = mid;
+            } else {
+                left = mid + 1;
+            }
+        }
+        return left;
+    }
+
+    private boolean checkMid(int n, int m, int[] pre, int[] suf, int mid) {
+        for (int i = 0; i + mid <= m; i++) {
+            if (pre[i] + suf[i + mid] <= n) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
+/*
+2565. 最少得分子序列
+https://leetcode.cn/problems/subsequence-with-the-minimum-score/
+
+第 332 场周赛 T4。
+
+给你两个字符串 s 和 t 。
+你可以从字符串 t 中删除任意数目的字符。
+如果没有从字符串 t 中删除字符，那么得分为 0 ，否则：
+- 令 left 为删除字符中的最小下标。
+- 令 right 为删除字符中的最大下标。
+字符串的得分为 right - left + 1 。
+请你返回使 t 成为 s 子序列的最小得分。
+一个字符串的 子序列 是从原字符串中删除一些字符后（也可以一个也不删除），剩余字符不改变顺序得到的字符串。（比方说 "ace" 是 "abcde" 的子序列，但是 "aec" 不是）。
+提示：
+1 <= s.length, t.length <= 10^5
+s 和 t 都只包含小写英文字母。
+
+前后缀分解 + 二分（感觉比双指针好理解）
+相似题目: 2484. 统计回文子序列数目
+https://leetcode.cn/problems/count-palindromic-subsequences/
+2552. 统计上升四元组
+https://leetcode.cn/problems/count-increasing-quadruplets/
+D - Match or Not
+https://atcoder.jp/contests/abc287/tasks/abc287_d
+ */

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

@@ -0,0 +1,135 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution6358 {
+    public long[] handleQuery(int[] nums1, int[] nums2, int[][] queries) {
+        long sum2 = 0L;
+        for (int x : nums2) {
+            sum2 += x;
+        }
+
+        SegmentTree segmentTree = new SegmentTree(nums1);
+        List<Long> resList = new ArrayList<>();
+        for (int[] query : queries) {
+            if (query[0] == 1) {
+                segmentTree.op1(query[1] + 1, query[2] + 1);
+            } else if (query[0] == 2) {
+                sum2 += segmentTree.getSum() * query[1];
+            } else {
+                resList.add(sum2);
+            }
+        }
+        return resList.stream().mapToLong(Long::longValue).toArray();
+    }
+
+    private static class SegmentTree {
+        private final int N;
+        private final int[] nums;
+
+        private final long[] sum;
+        private final int[] lazy;
+
+        public SegmentTree(int[] nums) {
+            N = nums.length;
+            this.nums = nums;
+
+            sum = new long[N * 4];
+            lazy = new int[N * 4];
+            build(1, N, 1);
+        }
+
+        // 建树
+        private void build(int s, int t, int p) {
+            if (s == t) {
+                sum[p] = nums[s - 1];
+                return;
+            }
+            int mid = s + (t - s) / 2;
+            build(s, mid, p * 2);
+            build(mid + 1, t, p * 2 + 1);
+            pushUp(p);
+        }
+
+        // 将 nums1 从下标 l 到下标 r 的所有 0 反转成 1 或将 1 反转成 0 。
+        public void op1(int l, int r) {
+            this.op1(l, r, 1, N, 1);
+        }
+
+        // 区间 [l,r] 求和
+        public long getSum() {
+            return this.getSum(1, N, 1, N, 1);
+        }
+
+        private void op1(int l, int r, int s, int t, int p) {
+            if (l <= s && t <= r) {
+                sum[p] = (t - s + 1L) - sum[p];
+                lazy[p] ^= 1;
+                return;
+            }
+            int mid = s + (t - s) / 2;
+            pushDown(mid, s, t, p);
+            if (l <= mid) {
+                op1(l, r, s, mid, p * 2);
+            }
+            if (r > mid) {
+                op1(l, r, mid + 1, t, p * 2 + 1);
+            }
+            pushUp(p);
+        }
+
+        private long getSum(int l, int r, int s, int t, int p) {
+            if (l <= s && t <= r) {
+                return sum[p];
+            }
+            int mid = s + (t - s) / 2;
+            pushDown(mid, s, t, p);
+            long sum = 0;
+            if (l <= mid) {
+                sum = getSum(l, r, s, mid, p * 2);
+            }
+            if (r > mid) {
+                sum += getSum(l, r, mid + 1, t, p * 2 + 1);
+            }
+            return sum;
+        }
+
+        private void pushDown(int mid, int s, int t, int p) {
+            if (lazy[p] > 0) {
+                sum[p * 2] = (mid - s + 1L) - sum[p * 2];
+                sum[p * 2 + 1] = (t - mid) - sum[p * 2 + 1];
+                lazy[p * 2] ^= lazy[p];
+                lazy[p * 2 + 1] ^= lazy[p];
+                lazy[p] = 0;
+            }
+        }
+
+        private void pushUp(int p) {
+            sum[p] = sum[p * 2] + sum[p * 2 + 1];
+        }
+    }
+}
+/*
+6358. 更新数组后处理求和查询
+https://leetcode.cn/problems/handling-sum-queries-after-update/
+
+第 98 场双周赛 T4。
+
+给你两个下标从 0 开始的数组 nums1 和 nums2 ，和一个二维数组 queries 表示一些操作。总共有 3 种类型的操作：
+1. 操作类型 1 为 queries[i] = [1, l, r] 。你需要将 nums1 从下标 l 到下标 r 的所有 0 反转成 1 或将 1 反转成 0 。l 和 r 下标都从 0 开始。
+2. 操作类型 2 为 queries[i] = [2, p, 0] 。对于 0 <= i < n 中的所有下标，令 nums2[i] = nums2[i] + nums1[i] * p 。
+3. 操作类型 3 为 queries[i] = [3, 0, 0] 。求 nums2 中所有元素的和。
+请你返回一个数组，包含所有第三种操作类型的答案。
+提示：
+1 <= nums1.length,nums2.length <= 10^5
+nums1.length = nums2.length
+1 <= queries.length <= 10^5
+queries[i].length = 3
+0 <= l <= r <= nums1.length - 1
+0 <= p <= 10^6
+0 <= nums1[i] <= 1
+0 <= nums2[i] <= 10^9
+
+线段树。基于 nums1 建树，懒标记下推 pushDown
+时间复杂度 O(n + qlogn)
+空间复杂度 O(4n)
+ */

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

@@ -0,0 +1,35 @@
+public class Solution6359 {
+    public int minMaxDifference(int num) {
+        int min = Integer.MAX_VALUE;
+        int max = 0;
+        String str = String.valueOf(num);
+        for (char i = '0'; i <= '9'; i++) {
+            for (char j = '0'; j <= '9'; j++) {
+                if (i == j) continue;
+                int n = Integer.parseInt(str.replace(i, j));
+                min = Math.min(min, n);
+                max = Math.max(max, n);
+            }
+        }
+        return max - min;
+    }
+}
+/*
+6359. 替换一个数字后的最大差值
+https://leetcode.cn/problems/maximum-difference-by-remapping-a-digit/
+
+第 98 场双周赛 T1。
+
+给你一个整数 num 。你知道 Danny Mittal 会偷偷将 0 到 9 中的一个数字 替换 成另一个数字。
+请你返回将 num 中 恰好一个 数字进行替换后，得到的最大值和最小值的差位多少。
+注意：
+- 当 Danny 将一个数字 d1 替换成另一个数字 d2 时，Danny 需要将 nums 中所有 d1 都替换成 d2 。
+- Danny 可以将一个数字替换成它自己，也就是说 num 可以不变。
+- Danny 可以将数字分别替换成两个不同的数字分别得到最大值和最小值。
+- 替换后得到的数字可以包含前导 0 。
+- Danny Mittal 获得周赛 326 前 10 名，让我们恭喜他。
+提示：
+1 <= num <= 10^8
+
+暴力
+ */

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

@@ -0,0 +1,35 @@
+import java.util.HashSet;
+import java.util.Set;
+
+public class Solution6360 {
+    public int minImpossibleOR(int[] nums) {
+        Set<Integer> set = new HashSet<>();
+        for (int x : nums) {
+            set.add(x);
+        }
+
+        int x = 1;
+        while (true) {
+            if (!set.contains(x)) {
+                return x;
+            }
+            x <<= 1;
+        }
+    }
+}
+/*
+6360. 最小无法得到的或值
+https://leetcode.cn/problems/minimum-impossible-or/
+
+给你一个下标从 0 开始的整数数组 nums 。
+如果存在一些整数满足 0 <= index1 < index2 < ... < indexk < nums.length ，得到 nums[index1] | nums[index2] | ... | nums[indexk] = x ，那么我们说 x 是 可表达的 。换言之，如果一个整数能由 nums 的某个子序列的或运算得到，那么它就是可表达的。
+请你返回 nums 不可表达的 最小非零整数 。
+提示：
+1 <= nums.length <= 10^5
+1 <= nums[i] <= 10^9
+
+脑筋急转弯。位运算。
+只需考虑 二次幂 的数即可，非二次幂都可以由比它小的 二次幂 组合得到。
+时间复杂度 O(n + logmax(nums[i]))
+空间复杂度 O(n)
+ */

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

@@ -0,0 +1,32 @@
+import java.util.Arrays;
+
+public class Solution6361 {
+    public int minimizeSum(int[] nums) {
+        int n = nums.length;
+        Arrays.sort(nums);
+
+        int res1 = nums[n - 3] - nums[0];
+        int res2 = nums[n - 2] - nums[1];
+        int res3 = nums[n - 1] - nums[2];
+        return Math.min(res1, Math.min(res2, res3));
+    }
+}
+/*
+6361. 修改两个元素的最小分数
+https://leetcode.cn/problems/minimum-score-by-changing-two-elements/
+
+第 98 场双周赛 T2。
+
+给你一个下标从 0 开始的整数数组 nums 。
+- nums 的 最小 得分是满足 0 <= i < j < nums.length 的 |nums[i] - nums[j]| 的最小值。
+- nums的 最大 得分是满足 0 <= i < j < nums.length 的 |nums[i] - nums[j]| 的最大值。
+- nums 的分数是 最大 得分与 最小 得分的和。
+我们的目标是最小化 nums 的分数。你 最多 可以修改 nums 中 2 个元素的值。
+请你返回修改 nums 中 至多两个 元素的值后，可以得到的 最小分数 。
+|x| 表示 x 的绝对值。
+提示：
+3 <= nums.length <= 10^5
+1 <= nums[i] <= 10^9
+
+脑筋急转弯，只需考虑三种情况。
+ */

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

@@ -0,0 +1,44 @@
+import java.util.Map;
+import java.util.TreeMap;
+
+public class Solution6362 {
+    public int[][] mergeArrays(int[][] nums1, int[][] nums2) {
+        TreeMap<Integer, Integer> treeMap = new TreeMap<>();
+        for (int[] x : nums1) {
+            treeMap.put(x[0], x[1]);
+        }
+        for (int[] x : nums2) {
+            treeMap.put(x[0], treeMap.getOrDefault(x[0], 0) + x[1]);
+        }
+
+        int[][] res = new int[treeMap.size()][2];
+        int i = 0;
+        for (Map.Entry<Integer, Integer> entry : treeMap.entrySet()) {
+            res[i++] = new int[]{entry.getKey(), entry.getValue()};
+        }
+        return res;
+    }
+}
+/*
+6362. 合并两个二维数组 - 求和法
+https://leetcode.cn/problems/merge-two-2d-arrays-by-summing-values/
+
+第 333 场周赛 T1。
+
+给你两个 二维 整数数组 nums1 和 nums2.
+- nums1[i] = [idi, vali] 表示编号为 idi 的数字对应的值等于 vali 。
+- nums2[i] = [idi, vali] 表示编号为 idi 的数字对应的值等于 vali 。
+每个数组都包含 互不相同 的 id ，并按 id 以 递增 顺序排列。
+请你将两个数组合并为一个按 id 以递增顺序排列的数组，并符合下述条件：
+- 只有在两个数组中至少出现过一次的 id 才能包含在结果数组内。
+- 每个 id 在结果数组中 只能出现一次 ，并且其对应的值等于两个数组中该 id 所对应的值求和。如果某个数组中不存在该 id ，则认为其对应的值等于 0 。
+返回结果数组。返回的数组需要按 id 以递增顺序排列。
+提示：
+1 <= nums1.length, nums2.length <= 200
+nums1[i].length == nums2[j].length == 2
+1 <= idi, vali <= 1000
+数组中的 id 互不相同
+数据均按 id 以严格递增顺序排列
+
+TreeMap 模拟
+ */