第99场双周赛T1~T4 & 第335场周赛T1~T4 (8)

Author: gdut-yy

leetcode-01/src/main/java/Solution56.java

@@ -65,4 +65,6 @@ public int[][] merge(int[][] intervals) {
 0 <= starti <= endi <= 10^4
 
 排序后分三种情况合并区间即可。
+时间复杂度 O(nlogn)
+空间复杂度 O(logn)
  */

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

@@ -0,0 +1,31 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution6307 {
+    public int passThePillow(int n, int time) {
+        // 构造一个周期
+        List<Integer> list = new ArrayList<>();
+        for (int i = 1; i <= n; i++) list.add(i);
+        for (int i = n - 1; i > 1; i--) list.add(i);
+
+        int sz = list.size();
+        return list.get(time % sz);
+    }
+}
+/*
+6307. 递枕头
+https://leetcode.cn/problems/pass-the-pillow/
+
+第 335 场周赛 T1。
+
+n 个人站成一排，按从 1 到 n 编号。
+最初，排在队首的第一个人拿着一个枕头。每秒钟，拿着枕头的人会将枕头传递给队伍中的下一个人。一旦枕头到达队首或队尾，传递方向就会改变，队伍会继续沿相反方向传递枕头。
+- 例如，当枕头到达第 n 个人时，TA 会将枕头传递给第 n - 1 个人，然后传递给第 n - 2 个人，依此类推。
+给你两个正整数 n 和 time ，返回 time 秒后拿着枕头的人的编号。
+提示：
+2 <= n <= 1000
+1 <= time <= 1000
+
+模拟。
+时间复杂度 O(n)
+ */

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

@@ -0,0 +1,52 @@
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.LinkedList;
+import java.util.List;
+import java.util.Queue;
+
+public class Solution6308 {
+    public long kthLargestLevelSum(TreeNode root, int k) {
+        List<Long> sumList = new ArrayList<>();
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+        while (!queue.isEmpty()) {
+            int size = queue.size();
+            long sum = 0L;
+            for (int i = 0; i < size; i++) {
+                TreeNode node = queue.remove();
+                sum += node.val;
+                if (node.left != null) {
+                    queue.add(node.left);
+                }
+                if (node.right != null) {
+                    queue.add(node.right);
+                }
+            }
+            sumList.add(sum);
+        }
+
+        // 第 K 大
+        sumList.sort(Comparator.reverseOrder());
+        return k - 1 < sumList.size() ? sumList.get(k - 1) : -1;
+    }
+}
+/*
+6308. 二叉树中的第 K 大层和
+https://leetcode.cn/problems/kth-largest-sum-in-a-binary-tree/
+
+第 335 场周赛 T2。
+
+给你一棵二叉树的根节点 root 和一个正整数 k 。
+树中的 层和 是指 同一层 上节点值的总和。
+返回树中第 k 大的层和（不一定不同）。如果树少于 k 层，则返回 -1 。
+注意，如果两个节点与根节点的距离相同，则认为它们在同一层。
+提示：
+树中的节点数为 n
+2 <= n <= 10^5
+1 <= Node.val <= 10^6
+1 <= k <= n
+
+层序遍历 + 排序
+时间复杂度 O(nlogn)
+ */

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

@@ -0,0 +1,82 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Solution6309 {
+    public int findValidSplit(int[] nums) {
+        int n = nums.length;
+        Map<Integer, int[]> map = new HashMap<>();
+        for (int i = 0; i < n; i++) {
+            List<Integer> factorPrime = getFactorPrime(nums[i]);
+            for (int x : factorPrime) {
+                if (!map.containsKey(x)) {
+                    map.put(x, new int[]{i, i});
+                } else {
+                    map.get(x)[1] = i;
+                }
+            }
+        }
+
+        // f[i] 表示下标 starti 对应的最长 endi
+        int[] f = new int[n];
+        for (Map.Entry<Integer, int[]> entry : map.entrySet()) {
+            int[] val = entry.getValue();
+            f[val[0]] = val[1];
+        }
+
+        // 能到达的最远距离下标，当前下标
+        int maxR = 0, curR = 0;
+        // [1, time) 返回所需片段的最小数目
+        for (int i = 0; i < n - 1; i++) {
+            maxR = Math.max(maxR, f[i]);
+            if (i == curR) {
+                if (i == maxR) {
+                    return i;
+                }
+                curR = maxR;
+            }
+        }
+        return -1;
+    }
+
+    private static List<Integer> getFactorPrime(int num) {
+        List<Integer> resList = new ArrayList<>();
+        for (int i = 2; i * i <= num; i++) {
+            // 如果 i 能够整除 N，说明 i 为 N 的一个质因子。
+            if (num % i == 0) {
+                while (num % i == 0) {
+                    num /= i;
+                }
+                resList.add(i);
+            }
+        }
+        // 说明再经过操作之后 N 留下了一个素数
+        if (num != 1) {
+            resList.add(num);
+        }
+        return resList;
+    }
+}
+/*
+6309. 分割数组使乘积互质
+https://leetcode.cn/problems/split-the-array-to-make-coprime-products/
+
+第 335 场周赛 T3。
+
+给你一个长度为 n 的整数数组 nums ，下标从 0 开始。
+如果在下标 i 处 分割 数组，其中 0 <= i <= n - 2 ，使前 i + 1 个元素的乘积和剩余元素的乘积互质，则认为该分割 有效 。
+- 例如，如果 nums = [2, 3, 3] ，那么在下标 i = 0 处的分割有效，因为 2 和 9 互质，而在下标 i = 1 处的分割无效，因为 6 和 3 不互质。在下标 i = 2 处的分割也无效，因为 i == n - 1 。
+返回可以有效分割数组的最小下标 i ，如果不存在有效分割，则返回 -1 。
+当且仅当 gcd(val1, val2) == 1 成立时，val1 和 val2 这两个值才是互质的，其中 gcd(val1, val2) 表示 val1 和 val2 的最大公约数。
+提示：
+n == nums.length
+1 <= n <= 10^4
+1 <= nums[i] <= 10^6
+
+分解质因数 + 贪心
+考虑每个质因数的 第一次出现下标 与 最后一次出现下标。然后类似跳跃游戏，看从下标 0 最远到达多远，这部分都是不能分割的。
+时间复杂度 O(n * √n)
+相似题目: 45. 跳跃游戏 II
+https://leetcode.cn/problems/jump-game-ii/
+ */

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

@@ -0,0 +1,38 @@
+public class Solution6310 {
+    private static final int MOD = (int) (1e9 + 7);
+
+    public int waysToReachTarget(int target, int[][] types) {
+        // 多重背包 求方案数
+        long[] f = new long[target + 1];
+        f[0] = 1L;
+
+        for (int[] type : types) {
+            for (int j = target; j >= type[1]; j--) {
+                for (int k = 1; k <= type[0] && k * type[1] <= j; k++) {
+                    f[j] = (f[j] + f[j - k * type[1]]) % MOD;
+                }
+            }
+        }
+        return (int) f[target];
+    }
+}
+/*
+6310. 获得分数的方法数
+https://leetcode.cn/problems/number-of-ways-to-earn-points/
+
+第 335 场周赛 T4。
+
+考试中有 n 种类型的题目。给你一个整数 target 和一个下标从 0 开始的二维整数数组 types ，其中 types[i] = [counti, marksi] 表示第 i 种类型的题目有 counti 道，每道题目对应 marksi 分。
+返回你在考试中恰好得到 target 分的方法数。由于答案可能很大，结果需要对 109 +7 取余。
+注意，同类型题目无法区分。
+- 比如说，如果有 3 道同类型题目，那么解答第 1 和第 2 道题目与解答第 1 和第 3 道题目或者第 2 和第 3 道题目是相同的。
+提示：
+1 <= target <= 1000
+n == types.length
+1 <= n <= 50
+types[i].length == 2
+1 <= counti, marksi <= 50
+
+多重背包求方案数。
+时间复杂度 O(target * sum(count))
+ */

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

@@ -0,0 +1,24 @@
+public class Solution6311 {
+    public long coloredCells(int n) {
+        long k = n * 2L - 1;
+        return (k * k + 1) / 2;
+    }
+}
+/*
+6311. 统计染色格子数
+https://leetcode.cn/problems/count-total-number-of-colored-cells/
+
+第 99 场双周赛 T2。
+
+有一个无穷大的二维网格图，一开始所有格子都未染色。给你一个正整数 n ，表示你需要执行以下步骤 n 分钟：
+- 第一分钟，将 任一 格子染成蓝色。
+- 之后的每一分钟，将与蓝色格子相邻的 所有 未染色格子染成蓝色。
+下图分别是 1、2、3 分钟后的网格图。
+请你返回 n 分钟之后 被染色的格子 数目。
+提示：
+1 <= n <= 10^5
+
+找规律。
+时间复杂度 O(1)
+https://oeis.org/A001844
+ */

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

@@ -0,0 +1,44 @@
+import java.util.ArrayList;
+import java.util.List;
+import java.util.PriorityQueue;
+
+public class Solution6312 {
+    public int splitNum(int num) {
+        PriorityQueue<Integer> minHeap = new PriorityQueue<>();
+        while (num > 0) {
+            minHeap.add(num % 10);
+            num /= 10;
+        }
+
+        List<StringBuilder> sbs = new ArrayList<>();
+        sbs.add(new StringBuilder());
+        sbs.add(new StringBuilder());
+
+        int i = 0;
+        while (!minHeap.isEmpty()) {
+            sbs.get(i).append(minHeap.remove());
+            i = 1 - i;
+        }
+        return Integer.parseInt(sbs.get(0).toString()) + Integer.parseInt(sbs.get(1).toString());
+    }
+}
+/*
+6312. 最小和分割
+https://leetcode.cn/problems/split-with-minimum-sum/
+
+第 99 场双周赛 T1。
+
+给你一个正整数 num ，请你将它分割成两个非负整数 num1 和 num2 ，满足：
+- num1 和 num2 直接连起来，得到 num 各数位的一个排列。
+  - 换句话说，num1 和 num2 中所有数字出现的次数之和等于 num 中所有数字出现的次数。
+- num1 和 num2 可以包含前导 0 。
+请你返回 num1 和 num2 可以得到的和的 最小 值。
+注意：
+- num 保证没有前导 0 。
+- num1 和 num2 中数位顺序可以与 num 中数位顺序不同。
+提示：
+10 <= num <= 10^9
+
+贪心。
+时间复杂度 O(nlogn) 其中 n <= 9
+ */

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

@@ -0,0 +1,82 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class Solution6313 {
+    private static final int MOD = (int) (1e9 + 7);
+
+    public int countWays(int[][] ranges) {
+        // 连通块个数 k，答案为 2^k
+        int k = merge(ranges);
+        return (int) quickPow(2, k);
+    }
+
+    private int merge(int[][] intervals) {
+        // start 升序 end 降序
+        Arrays.sort(intervals, (o1, o2) -> {
+            if (o1[0] == o2[0]) {
+                return Integer.compare(o2[1], o1[1]);
+            }
+            return Integer.compare(o1[0], o2[0]);
+        });
+
+        int left = intervals[0][0];
+        int right = intervals[0][1];
+        List<int[]> resList = new ArrayList<>();
+        for (int i = 1; i < intervals.length; i++) {
+            int[] interval = intervals[i];
+            if (left <= interval[0] && right >= interval[1]) {
+                continue;
+            }
+            if (right >= interval[0] && right <= interval[1]) {
+                right = interval[1];
+                continue;
+            }
+            if (right < interval[0]) {
+                resList.add(new int[]{left, right});
+                left = interval[0];
+                right = interval[1];
+            }
+        }
+        resList.add(new int[]{left, right});
+        return resList.size();
+    }
+
+    // 模下的 a^b
+    private long quickPow(long a, long b) {
+        long res = 1L;
+        while (b > 0) {
+            if ((b & 1) == 1) {
+                res = res * a % MOD;
+            }
+            a = a * a % MOD;
+            b >>= 1;
+        }
+        return res;
+    }
+}
+/*
+6313. 统计将重叠区间合并成组的方案数
+https://leetcode.cn/problems/count-ways-to-group-overlapping-ranges/
+
+第 99 场双周赛 T3。
+
+给你一个二维整数数组 ranges ，其中 ranges[i] = [starti, endi] 表示 starti 到 endi 之间（包括二者）的所有整数都包含在第 i 个区间中。
+你需要将 ranges 分成 两个 组（可以为空），满足：
+- 每个区间只属于一个组。
+- 两个有 交集 的区间必须在 同一个 组内。
+如果两个区间有至少 一个 公共整数，那么这两个区间是 有交集 的。
+- 比方说，区间 [1, 3] 和 [2, 5] 有交集，因为 2 和 3 在两个区间中都被包含。
+请你返回将 ranges 划分成两个组的 总方案数 。由于答案可能很大，将它对 109 + 7 取余 后返回。
+提示：
+1 <= ranges.length <= 10^5
+ranges[i].length == 2
+0 <= starti <= endi <= 10^9
+
+合并区间 + 快速幂
+问题转换为有多少个连通块 k，答案为 2^k
+相似题目: 56. 合并区间
+https://leetcode.cn/problems/merge-intervals/
+2550. 猴子碰撞的方法数
+https://leetcode.cn/problems/count-collisions-of-monkeys-on-a-polygon/
+ */