双周赛112（模拟、分组+计数、滑动窗口、排序+计数+组合数学）
文章目录
- 双周赛112
-
- [7021. 判断通过操作能否让字符串相等 I](https://leetcode.cn/problems/check-if-strings-can-be-made-equal-with-operations-i/)
-
- 模拟
- 分组 + 计数
- [7005. 判断通过操作能否让字符串相等 II](https://leetcode.cn/problems/check-if-strings-can-be-made-equal-with-operations-ii/)
-
- 分组 + 计数
- [2841. 几乎唯一子数组的最大和](https://leetcode.cn/problems/maximum-sum-of-almost-unique-subarray/)
-
- 滑动窗口
- [8050. 统计一个字符串的 k 子序列美丽值最大的数目](https://leetcode.cn/problems/count-k-subsequences-of-a-string-with-maximum-beauty/)
-
- 排序 + 计数 + 组合数学
双周赛112
7021. 判断通过操作能否让字符串相等 I
简单
给你两个字符串 s1 和 s2 ，两个字符串的长度都为 4 ，且只包含 小写 英文字母。
你可以对两个字符串中的 任意一个 执行以下操作 任意 次：
- 选择两个下标
i和j且满足j - i = 2，然后 交换 这个字符串中两个下标对应的字符。
如果你可以让字符串 s1 和 s2 相等，那么返回 true ，否则返回 false 。
示例 1：
输入：s1 = "abcd", s2 = "cdab"
输出：true
解释： 我们可以对 s1 执行以下操作：
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbad" 。
- 选择下标 i = 1 ，j = 3 ，得到字符串 s1 = "cdab" = s2 。
示例 2：
输入：s1 = "abcd", s2 = "dacb"
输出：false
解释：无法让两个字符串相等。
提示：
s1.length == s2.length == 4s1和s2只包含小写英文字母。
模拟
class Solution {
public boolean canBeEqual(String s1, String s2) {
int idx = 0;
Set<Integer> set = new HashSet<>();
while(idx < s1.length()){
if(set.contains(idx)){
idx += 1;
continue;
}
if(s1.charAt(idx) == s2.charAt(idx)){
idx += 1;
}else{
if(idx >= s1.length()-2 || s1.charAt(idx) != s2.charAt(idx+2) || s1.charAt(idx+2) != s2.charAt(idx))
return false;
set.add(idx+2);
idx += 1;
}
}
return true;
}
}
分组 + 计数
class Solution {
public boolean canBeEqual(String s1, String s2) {
int[][] cnt = new int[26][2];
int n = s1.length();
for(int i = 0; i < n; i++){
cnt[s1.charAt(i) - 'a'][i % 2] += 1;
}
for(int i = 0; i < n; i++){
int c = s2.charAt(i) - 'a';
cnt[c][i % 2] -= 1;
if(cnt[c][i % 2] < 0) return false;
}
return true;
}
}
7005. 判断通过操作能否让字符串相等 II
中等
给你两个字符串 s1 和 s2 ，两个字符串长度都为 n ，且只包含 小写 英文字母。
你可以对两个字符串中的 任意一个 执行以下操作 任意 次：
- 选择两个下标
i和j，满足i < j且j - i是 偶数，然后 交换 这个字符串中两个下标对应的字符。
如果你可以让字符串 s1 和 s2 相等，那么返回 true ，否则返回 false 。
示例 1：
输入：s1 = "abcdba", s2 = "cabdab"
输出：true
解释：我们可以对 s1 执行以下操作：
- 选择下标 i = 0 ，j = 2 ，得到字符串 s1 = "cbadba" 。
- 选择下标 i = 2 ，j = 4 ，得到字符串 s1 = "cbbdaa" 。
- 选择下标 i = 1 ，j = 5 ，得到字符串 s1 = "cabdab" = s2 。
示例 2：
输入：s1 = "abe", s2 = "bea"
输出：false
解释：无法让两个字符串相等。
提示：
n == s1.length == s2.length1 <= n <= 105s1和s2只包含小写英文字母。
分组 + 计数
class Solution {
public boolean checkStrings(String s1, String s2) {
int[][] cnt = new int[26][2];
int n = s1.length();
for(int i = 0; i < n; i++){
cnt[s1.charAt(i) - 'a'][i % 2] += 1;
}
for(int i = 0; i < n; i++){
int c = s2.charAt(i) - 'a';
cnt[c][i % 2] -= 1;
if(cnt[c][i % 2] < 0) return false;
}
return true;
}
}
2841. 几乎唯一子数组的最大和
中等
给你一个整数数组 nums 和两个正整数 m 和 k 。
请你返回 nums 中长度为 k 的 几乎唯一 子数组的 最大和 ，如果不存在几乎唯一子数组，请你返回 0 。
如果 nums 的一个子数组有至少 m 个互不相同的元素，我们称它是 几乎唯一 子数组。
子数组指的是一个数组中一段连续 非空 的元素序列。
示例 1：
输入：nums = [2,6,7,3,1,7], m = 3, k = 4
输出：18
解释：总共有 3 个长度为 k = 4 的几乎唯一子数组。分别为 [2, 6, 7, 3] ，[6, 7, 3, 1] 和 [7, 3, 1, 7] 。这些子数组中，和最大的是 [2, 6, 7, 3] ，和为 18 。
示例 2：
输入：nums = [5,9,9,2,4,5,4], m = 1, k = 3
输出：23
解释：总共有 5 个长度为 k = 3 的几乎唯一子数组。分别为 [5, 9, 9] ，[9, 9, 2] ，[9, 2, 4] ，[2, 4, 5] 和 [4, 5, 4] 。这些子数组中，和最大的是 [5, 9, 9] ，和为 23 。
示例 3：
输入：nums = [1,2,1,2,1,2,1], m = 3, k = 3
输出：0
解释：输入数组中不存在长度为 k = 3 的子数组含有至少 m = 3 个互不相同元素的子数组。所以不存在几乎唯一子数组，最大和为 0 。
提示：
1 <= nums.length <= 2 * 1041 <= m <= k <= nums.length1 <= nums[i] <= 109
滑动窗口
class Solution {
public long maxSum(List<Integer> nums, int m, int k) {
long ans = 0, sum = 0;
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i < k-1; i++){
map.merge(nums.get(i), 1, Integer::sum);
sum += nums.get(i);
}
for(int i = k-1; i < nums.size(); i++){
map.merge(nums.get(i), 1, Integer::sum);
sum += nums.get(i);
if(map.size() >= m){
ans = Math.max(ans, sum);
}
int left = nums.get(i-k+1);
map.merge(left, -1, Integer::sum);
sum -= left;
if(map.get(left) == 0)
map.remove(left);
}
return ans;
}
}s
8050. 统计一个字符串的 k 子序列美丽值最大的数目
困难
给你一个字符串 s 和一个整数 k 。
k 子序列指的是 s 的一个长度为 k 的 子序列 ，且所有字符都是 唯一 的，也就是说每个字符在子序列里只出现过一次。
定义 f(c) 为字符 c 在 s 中出现的次数。
k 子序列的 美丽值 定义为这个子序列中每一个字符 c 的 f(c) 之 和 。
比方说，s = "abbbdd" 和 k = 2 ，我们有：
f('a') = 1,f('b') = 3,f('d') = 2- s 的部分 k 子序列为：
"***ab***bbdd"->"ab"，美丽值为f('a') + f('b') = 4"***a***bbb***d***d"->"ad"，美丽值为f('a') + f('d') = 3"a***b***bb***d***d"->"bd"，美丽值为f('b') + f('d') = 5
请你返回一个整数，表示所有 k 子序列 里面 美丽值 是 最大值 的子序列数目。由于答案可能很大，将结果对 109 + 7 取余后返回。
一个字符串的子序列指的是从原字符串里面删除一些字符（也可能一个字符也不删除），不改变剩下字符顺序连接得到的新字符串。
注意：
f(c)指的是字符c在字符串s的出现次数，不是在 k 子序列里的出现次数。- 两个 k 子序列如果有任何一个字符在原字符串中的下标不同，则它们是两个不同的子序列。所以两个不同的 k 子序列可能产生相同的字符串。
示例 1：
输入：s = "bcca", k = 2
输出：4
解释：s 中我们有 f('a') = 1 ，f('b') = 1 和 f('c') = 2 。
s 的 k 子序列为：
bcca ，美丽值为 f('b') + f('c') = 3
bcca ，美丽值为 f('b') + f('c') = 3
bcca ，美丽值为 f('b') + f('a') = 2
bcca ，美丽值为 f('c') + f('a') = 3
bcca ，美丽值为 f('c') + f('a') = 3
总共有 4 个 k 子序列美丽值为最大值 3 。
所以答案为 4 。
示例 2：
输入：s = "abbcd", k = 4
输出：2
解释：s 中我们有 f('a') = 1 ，f('b') = 2 ，f('c') = 1 和 f('d') = 1 。
s 的 k 子序列为：
abbcd ，美丽值为 f('a') + f('b') + f('c') + f('d') = 5
abbcd ，美丽值为 f('a') + f('b') + f('c') + f('d') = 5
总共有 2 个 k 子序列美丽值为最大值 5 。
所以答案为 2 。
提示：
1 <= s.length <= 2 * 1051 <= k <= s.lengths只包含小写英文字母。
排序 + 计数 + 组合数学
https://www.bilibili.com/video/BV1um4y1M7Rv/
class Solution:
def countKSubsequencesWithMaxBeauty(self, s: str, k: int) -> int:
MOD = 10 ** 9 + 7
ans = 1
cnt = Counter(Counter(s).values()) # 组合数出现次数 的次数
for c, num in sorted(cnt.items(), reverse=True):
if num >= k:
return ans * pow(c, k, MOD) * comb(num, k) % MOD # comb组合数，从num中选择k个
# 都可以选
ans *= pow(c, num, MOD)
k -= num
return 0