第158场双周赛T1~T4 & 第453场周赛T1~T4 (8)

Author: gdut-yy

leetcode/leetcode-36/src/main/java/Solution3572.java

@@ -0,0 +1,44 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution3572 {
+ public int maxSumDistinctTriplet(int[] x, int[] y) {
+ int n = x.length;
+ Map<Integer, Integer> x_maxy = new HashMap<>();
+ for (int i = 0; i < n; i++) {
+ int x_i = x[i];
+ int y_i = y[i];
+ x_maxy.merge(x_i, y_i, Math::max);
+ }
+ List<Integer> a = new ArrayList<>(x_maxy.values());
+ int sz = a.size();
+ if (sz < 3) return -1;
+ a.sort(null);
+ int ans = 0;
+ for (int i = 0; i < 3; i++) {
+ ans += a.get(sz - 1 - i);
+ }
+ return ans;
+ }
+}
+/*
+3572. 选择不同 X 值三元组使 Y 值之和最大
+https://leetcode.cn/problems/maximize-ysum-by-picking-a-triplet-of-distinct-xvalues/description/
+
+第 158 场双周赛 T1。
+
+给你两个整数数组 x 和 y，长度均为 n。你必须选择三个 不同 的下标 i ，j 和 k，满足以下条件：
+- x[i] != x[j]
+- x[j] != x[k]
+- x[k] != x[i]
+你的目标是在满足这些条件下 最大化 y[i] + y[j] + y[k] 的值。返回通过选择这样一组三元组下标所能获得的 最大 可能和。
+如果不存在这样的三元组，返回 -1。
+提示：
+n == x.length == y.length
+3 <= n <= 10^5
+1 <= x[i], y[i] <= 10^6
+
+贪心。
+ */

leetcode/leetcode-36/src/main/java/Solution3573.java

@@ -0,0 +1,74 @@
+import java.util.Arrays;
+
+public class Solution3573 {
+ private int[] prices;
+ private long[][][] memo;
+
+ public long maximumProfit(int[] prices, int k) {
+ this.prices = prices;
+ int n = prices.length;
+ memo = new long[n][k + 1][3];
+ for (int i = 0; i < n; i++) {
+ for (int j = 0; j < k + 1; j++) {
+ Arrays.fill(memo[i][j], -1);
+ }
+ }
+ return dfs(n - 1, k, 0);
+ }
+
+ // dfs(i, 0) 表示到第 i 天结束时完成至多 j 笔交易，未持有股票的最大利润
+ // dfs(i, 1) 表示到第 i 天结束时完成至多 j 笔交易，持有股票的最大利润
+ // 第 i-1 天结束就是第 i 天的开始
+ // hold 0:未持有 1:普通 2:做空
+ private long dfs(int i, int j, int hold) {
+ if (j < 0) return (long) -1e18;
+ if (i < 0) {
+ if (hold != 0) return (long) -1e18;
+ return 0;
+ }
+ if (memo[i][j][hold] != -1) return memo[i][j][hold];
+ long res;
+ if (hold == 0) {
+ // 什么也不干，普通交易，做空交易
+ res = max(dfs(i - 1, j, 0), dfs(i - 1, j, 1) + prices[i], dfs(i - 1, j, 2) - prices[i]);
+ } else if (hold == 1) {
+ // 什么也不干，普通交易
+ res = max(dfs(i - 1, j, 1), dfs(i - 1, j - 1, 0) - prices[i]);
+ } else {
+ // 什么也不干，做空交易
+ res = max(dfs(i - 1, j, 2), dfs(i - 1, j - 1, 0) + prices[i]);
+ }
+ return memo[i][j][hold] = res;
+ }
+
+ private long max(long... values) {
+ long maxValue = Long.MIN_VALUE;
+ for (long i : values) {
+ if (i > maxValue) {
+ maxValue = i;
+ }
+ }
+ return maxValue;
+ }
+}
+/*
+3573. 买卖股票的最佳时机 V
+https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-v/description/
+
+第 158 场双周赛 T2。
+
+给你一个整数数组 prices，其中 prices[i] 是第 i 天股票的价格（美元），以及一个整数 k。
+你最多可以进行 k 笔交易，每笔交易可以是以下任一类型：
+- 普通交易：在第 i 天买入，然后在之后的第 j 天卖出，其中 i < j。你的利润是 prices[j] - prices[i]。
+- 做空交易：在第 i 天卖出，然后在之后的第 j 天买回，其中 i < j。你的利润是 prices[i] - prices[j]。
+注意：你必须在开始下一笔交易之前完成当前交易。此外，你不能在已经进行买入或卖出操作的同一天再次进行买入或卖出操作。
+通过进行 最多 k 笔交易，返回你可以获得的最大总利润。
+提示:
+2 <= prices.length <= 10^3
+1 <= prices[i] <= 10^9
+1 <= k <= prices.length / 2
+
+记忆化搜索。在 188 题基础上改改即可。
+相似题目: 188. 买卖股票的最佳时机 IV
+https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-iv/
+ */

leetcode/leetcode-36/src/main/java/Solution3574.java

@@ -0,0 +1,51 @@
+public class Solution3574 {
+ public long maxGCDScore(int[] nums, int k) {
+ long ans = 0;
+ for (int i = 0; i < nums.length; i++) {
+ int lowbitMin = Integer.MAX_VALUE;
+ int lowbitCnt = 0;
+ int g = 0;
+ for (int j = i; j >= 0; j--) {
+ int x = nums[j];
+ int lb = x & -x;
+ if (lb < lowbitMin) {
+ lowbitMin = lb;
+ lowbitCnt = 1;
+ } else if (lb == lowbitMin) {
+ lowbitCnt++;
+ }
+
+ g = getGCD(g, x);
+ int newG = lowbitCnt <= k ? g * 2 : g;
+ ans = Math.max(ans, (long) newG * (i - j + 1));
+ }
+ }
+ return ans;
+ }
+
+ private int getGCD(int num1, int num2) {
+ return num1 == 0 ? num2 : getGCD(num2 % num1, num1);
+ }
+}
+/*
+3574. 最大子数组 GCD 分数
+https://leetcode.cn/problems/maximize-subarray-gcd-score/description/
+
+第 158 场双周赛 T3。
+
+给你一个正整数数组 nums 和一个整数 k。
+你最多可以执行 k 次操作。在每次操作中，你可以选择数组中的一个元素并将其值 翻倍 。每个元素 最多 只能翻倍一次。
+连续 子数组 的 分数 定义为其所有元素的最大公约数 (GCD) 与子数组长度的 乘积 。
+你的任务是返回修改后数组中选择一个连续子数组可以获得的最大 分数 。
+注意：
+- 子数组 是数组中连续的元素序列。
+- 数组的 最大公约数 (GCD) 是能整除数组所有元素的最大整数。
+提示：
+1 <= n == nums.length <= 1500
+1 <= nums[i] <= 10^9
+1 <= k <= n
+
+两种方法：暴力枚举 / logTrick
+https://leetcode.cn/problems/maximize-subarray-gcd-score/solutions/3695642/liang-chong-xie-fa-bao-li-mei-ju-logtric-zz7e/
+rating 2252 (clist.by)
+ */

leetcode/leetcode-36/src/main/java/Solution3575.java

@@ -0,0 +1,92 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution3575 {
+ private long ans = 0;
+
+ public int goodSubtreeSum(int[] vals, int[] par) {
+ int n = par.length;
+ List<Integer>[] g = new ArrayList[n];
+ Arrays.setAll(g, i -> new ArrayList<>());
+ for (int i = 1; i < n; i++) {
+ g[par[i]].add(i);
+ }
+
+ dfs(0, vals, g);
+ return (int) (ans % 1_000_000_007);
+ }
+
+ // 返回每种 mask 下的最大子树和
+ private Map<Integer, Integer> dfs(int x, int[] vals, List<Integer>[] g) {
+ Map<Integer, Integer> f = new HashMap<>();
+
+ // 计算 vals[x] 的数位集合 mask
+ int mask = 0;
+ for (int v = vals[x]; v > 0; v /= 10) {
+ int d = v % 10;
+ if ((mask >> d & 1) > 0) { // d 在集合 mask 中
+ mask = 0; // 不符合要求
+ break;
+ }
+ mask |= 1 << d; // 把 d 加到集合 mask 中
+ }
+
+ if (mask > 0) {
+ f.put(mask, vals[x]);
+ }
+
+ for (int y : g[x]) {
+ Map<Integer, Integer> fy = dfs(y, vals, g);
+ Map<Integer, Integer> nf = new HashMap<>(f);
+ for (Map.Entry<Integer, Integer> e : fy.entrySet()) {
+ int msk = e.getKey();
+ int s = e.getValue();
+ // 同一个 mask 至多选一个，直接取 max
+ nf.merge(msk, s, Math::max);
+ // 求两个 mask 的并集，刷表转移
+ for (Map.Entry<Integer, Integer> e2 : f.entrySet()) {
+ int msk2 = e2.getKey();
+ if ((msk & msk2) == 0) {
+ nf.merge(msk | msk2, s + e2.getValue(), Math::max);
+ }
+ }
+ }
+ f = nf;
+ }
+
+ if (!f.isEmpty()) {
+ ans += Collections.max(f.values());
+ }
+
+ return f;
+ }
+}
+/*
+3575. 最大好子树分数
+https://leetcode.cn/problems/maximum-good-subtree-score/description/
+
+第 158 场双周赛 T4。
+
+给你一个根节点为 0 的无向树，包含 n 个节点，编号从 0 到 n - 1。每个节点 i 都有一个整数值 vals[i]，其父节点为 par[i] 。
+从一个节点 子树 内选取部分节点，它们的数值组成一个 子集 ，如果所选数值的十进制表示中，从 0 到 9 每个数字在所有数的数位最多出现一次，那么我们称它是 好 子集。
+一个好子集的 分数 是其节点值的总和。
+定义一个长度为 n 的数组 maxScore，其中 maxScore[u] 表示以节点 u 为根的子树（包括 u 本身及其所有后代）中，好子集的最大可能值总和。
+返回 maxScore 中所有值的总和。
+由于答案可能很大，请将其对 10^9 + 7 取模 后返回。
+数组的 子集 是选取数组中元素得到的集合（可能为空）。
+提示:
+1 <= n == vals.length <= 500
+1 <= vals[i] <= 10^9
+par.length == n
+par[0] == -1
+对于 [1, n - 1] 中的每一个 i ，都有 0 <= par[i] < n 。
+输入生成保证父数组 par 表示一棵有效的树。
+
+树形 DP + 状态压缩 + 启发式合并
+https://leetcode.cn/problems/maximum-good-subtree-score/solutions/3695614/shu-xing-dp-mei-ju-zi-ji-by-endlesscheng-e2je/
+rating 2350 (clist.by)
+ */

leetcode/leetcode-36/src/main/java/Solution3576.java

@@ -0,0 +1,43 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution3576 {
+ public boolean canMakeEqual(int[] nums, int k) {
+ int n = nums.length;
+ List<Integer> pos0 = new ArrayList<>();
+ List<Integer> pos1 = new ArrayList<>();
+ for (int i = 0; i < n; i++) {
+ if (nums[i] == -1) pos0.add(i);
+ else pos1.add(i);
+ }
+ return check(k, pos0) || check(k, pos1);
+ }
+
+ private boolean check(int k, List<Integer> pos) {
+ int sz = pos.size();
+ if (sz % 2 != 0) return false;
+ for (int i = 0; i < sz; i += 2) {
+ k -= pos.get(i + 1) - pos.get(i);
+ if (k < 0) return false;
+ }
+ return true;
+ }
+}
+/*
+3576. 数组元素相等转换
+https://leetcode.cn/problems/transform-array-to-all-equal-elements/description/
+
+第 453 场周赛 T1。
+
+给你一个大小为 n 的整数数组 nums，其中只包含 1 和 -1，以及一个整数 k。
+你可以最多进行 k 次以下操作：
+选择一个下标 i（0 <= i < n - 1），然后将 nums[i] 和 nums[i + 1] 同时 乘以 -1。
+注意：你可以在 不同 的操作中多次选择相同的下标 i。
+如果在最多 k 次操作后可以使数组的所有元素相等，则返回 true；否则，返回 false。
+提示：
+1 <= n == nums.length <= 10^5
+nums[i] 的值为 -1 或 1。
+1 <= k <= n
+
+分类讨论，两种情况：都变成 1 或者都变成 -1
+ */

leetcode/leetcode-36/src/main/java/Solution3577.java

@@ -0,0 +1,37 @@
+public class Solution3577 {
+ private static final int MOD = (int) (1e9 + 7);
+
+ public int countPermutations(int[] complexity) {
+ int n = complexity.length;
+ int minVal = complexity[0];
+ long ans = 1;
+ for (int i = 1; i < n; i++) {
+ if (minVal >= complexity[i]) {
+ return 0;
+ }
+ ans = (ans * i) % MOD;
+ }
+ return (int) ans;
+ }
+}
+/*
+3577. 统计计算机解锁顺序排列数
+https://leetcode.cn/problems/count-the-number-of-computer-unlocking-permutations/description/
+
+第 453 场周赛 T2。
+
+给你一个长度为 n 的数组 complexity。
+在房间里有 n 台 上锁的 计算机，这些计算机的编号为 0 到 n - 1，每台计算机都有一个 唯一 的密码。编号为 i 的计算机的密码复杂度为 complexity[i]。
+编号为 0 的计算机密码已经 解锁 ，并作为根节点。其他所有计算机必须通过它或其他已经解锁的计算机来解锁，具体规则如下：
+可以使用编号为 j 的计算机的密码解锁编号为 i 的计算机，其中 j 是任何小于 i 的整数，且满足 complexity[j] < complexity[i]（即 j < i 并且 complexity[j] < complexity[i]）。
+要解锁编号为 i 的计算机，你需要事先解锁一个编号为 j 的计算机，满足 j < i 并且 complexity[j] < complexity[i]。
+求共有多少种 [0, 1, 2, ..., (n - 1)] 的排列方式，能够表示从编号为 0 的计算机（唯一初始解锁的计算机）开始解锁所有计算机的有效顺序。
+由于答案可能很大，返回结果需要对 10^9 + 7 取余数。
+注意：编号为 0 的计算机的密码已解锁，而 不是 排列中第一个位置的计算机密码已解锁。
+排列 是一个数组中所有元素的重新排列。
+提示：
+2 <= complexity.length <= 10^5
+1 <= complexity[i] <= 10^9
+
+脑筋急转弯。
+ */