周赛378（中心扩散法、分组循环）
文章目录
- 周赛378
-
- [2980. 检查按位或是否存在尾随零](https://leetcode.cn/problems/check-if-bitwise-or-has-trailing-zeros/)
-
- 转换题意
- [2981. 找出出现至少三次的最长特殊子字符串 I](https://leetcode.cn/problems/find-longest-special-substring-that-occurs-thrice-i/)
-
- 中心扩散法
- [2982. 找出出现至少三次的最长特殊子字符串 II](https://leetcode.cn/problems/find-longest-special-substring-that-occurs-thrice-ii/)
-
- 分类讨论 + 分组循环
- [2983. 回文串重新排列查询](https://leetcode.cn/problems/palindrome-rearrangement-queries/)
周赛378
2980. 检查按位或是否存在尾随零
简单
给你一个 正整数 数组 nums 。
你需要检查是否可以从数组中选出 两个或更多 元素，满足这些元素的按位或运算（ OR）结果的二进制表示中 至少 存在一个尾随零。
例如，数字 5 的二进制表示是 "101"，不存在尾随零，而数字 4 的二进制表示是 "100"，存在两个尾随零。
如果可以选择两个或更多元素，其按位或运算结果存在尾随零，返回 true；否则，返回 false 。
示例 1：
输入：nums = [1,2,3,4,5]
输出：true
解释：如果选择元素 2 和 4，按位或运算结果是 6，二进制表示为 "110" ，存在一个尾随零。
示例 2：
输入：nums = [2,4,8,16]
输出：true
解释：如果选择元素 2 和 4，按位或运算结果是 6，二进制表示为 "110"，存在一个尾随零。
其他按位或运算结果存在尾随零的可能选择方案包括：(2, 8), (2, 16), (4, 8), (4, 16), (8, 16), (2, 4, 8), (2, 4, 16), (2, 8, 16), (4, 8, 16), 以及 (2, 4, 8, 16) 。
示例 3：
输入：nums = [1,3,5,7,9]
输出：false
解释：不存在按位或运算结果存在尾随零的选择方案。
提示：
2 <= nums.length <= 1001 <= nums[i] <= 100
转换题意
class Solution {
/**
问题转变为数组中存在两个偶数即可
*/
public boolean hasTrailingZeros(int[] nums) {
int n = nums.length;
for(int i = 0; i < n; i++){
for(int j = i+1; j < n; j++){
int x = nums[i] | nums[j];
if(x % 2 == 0)
return true;
}
}
return false;
}
}
2981. 找出出现至少三次的最长特殊子字符串 I
中等
给你一个仅由小写英文字母组成的字符串 s 。
如果一个字符串仅由单一字符组成，那么它被称为 特殊 字符串。例如，字符串 "abc" 不是特殊字符串，而字符串 "ddd"、"zz" 和 "f" 是特殊字符串。
返回在 s 中出现 至少三次 的 最长特殊子字符串 的长度，如果不存在出现至少三次的特殊子字符串，则返回 -1 。
子字符串 是字符串中的一个连续 非空 字符序列。
示例 1：
输入：s = "aaaa"
输出：2
解释：出现三次的最长特殊子字符串是 "aa" ：子字符串 "aaaa"、"aaaa" 和 "aaaa"。
可以证明最大长度是 2 。
示例 2：
输入：s = "abcdef"
输出：-1
解释：不存在出现至少三次的特殊子字符串。因此返回 -1 。
示例 3：
输入：s = "abcaba"
输出：1
解释：出现三次的最长特殊子字符串是 "a" ：子字符串 "abcaba"、"abcaba" 和 "abcaba"。
可以证明最大长度是 1 。
提示：
3 <= s.length <= 50s仅由小写英文字母组成。
中心扩散法
class Solution {
public int maximumLength(String s) {
Map<String, Integer> map = new HashMap<>();
int n = s.length();
char[] arrs = s.toCharArray();
for(int i = 0; i < 2*n-1; i++){
int left = i / 2;
int right = i / 2 + i % 2;
int x = arrs[left];
while(left >= 0 && right < n && x == arrs[left] && x == arrs[right]){
map.merge(s.substring(left, right+1), 1, Integer::sum);
left--;
right++;
}
}
int res = -1;
for(Map.Entry<String, Integer> entry : map.entrySet()){
if(entry.getValue() >= 3){
res = Math.max(res, entry.getKey().length());
}
}
return res;
}
}
2982. 找出出现至少三次的最长特殊子字符串 II
中等
给你一个仅由小写英文字母组成的字符串 s 。
如果一个字符串仅由单一字符组成，那么它被称为 特殊 字符串。例如，字符串 "abc" 不是特殊字符串，而字符串 "ddd"、"zz" 和 "f" 是特殊字符串。
返回在 s 中出现 至少三次 的 最长特殊子字符串 的长度，如果不存在出现至少三次的特殊子字符串，则返回 -1 。
子字符串 是字符串中的一个连续 非空 字符序列。
示例 1：
输入：s = "aaaa"
输出：2
解释：出现三次的最长特殊子字符串是 "aa" ：子字符串 "aaaa"、"aaaa" 和 "aaaa"。
可以证明最大长度是 2 。
示例 2：
输入：s = "abcdef"
输出：-1
解释：不存在出现至少三次的特殊子字符串。因此返回 -1 。
示例 3：
输入：s = "abcaba"
输出：1
解释：出现三次的最长特殊子字符串是 "a" ：子字符串 "abcaba"、"abcaba" 和 "abcaba"。
可以证明最大长度是 1 。
提示：
3 <= s.length <= 5 * 105s仅由小写英文字母组成。
分类讨论 + 分组循环
https://leetcode.cn/problems/find-longest-special-substring-that-occurs-thrice-ii/solutions/2585801/fen-lei-tao-lun-jian-ji-xie-fa-pythonjav-671l/
class Solution {
/**
按照相同字母分组，分类讨论：
1. 从最长特殊字串a[0]中取三个长度均为a[0]-2的特殊字串
2. 从最长和次长的特殊字串中取三个长度一样的特殊字串
2.1 如果a[0] = a[1]，那么可以取三个长度为 a[0]-1的特殊字串
2.2 如果a[0] > a[1]，那么可以取三个长度均为a[1]的特殊字串
合并成min(a[0]-1, a[1])
3. 从最长、次长、第三长中各取 长为a[2]的特殊字串
三种情况取最大值
max(a[0]-2, min(a[0]-1, a[1], a[2]))
*/
public int maximumLength(String s) {
// 分组循环，按照相同字母分组
char[] cs = s.toCharArray();
List<Integer>[] groups = new ArrayList[26];
Arrays.setAll(groups, i -> new ArrayList<>());
int i = 0;
while(i < s.length()){
int start = i;
while(i < s.length() && cs[i] == cs[start])
i++;
groups[cs[start] - 'a'].add(i - start);
}
int ans = 0;
for(List<Integer> a : groups){
if(a.isEmpty()) continue;
a.sort(Collections.reverseOrder());
a.add(0);
a.add(0); // 假设还有两个空串
ans = Math.max(ans, Math.max(a.get(0) - 2, Math.max(Math.min(a.get(0) - 1, a.get(1)), a.get(2))));
}
return ans > 0 ? ans : -1;
}
}
2983. 回文串重新排列查询
困难
给你一个长度为 偶数 n ，下标从 0 开始的字符串 s 。
同时给你一个下标从 0 开始的二维整数数组 queries ，其中 queries[i] = [ai, bi, ci, di] 。
对于每个查询 i ，你需要执行以下操作：
- 将下标在范围
0 <= ai <= bi < n / 2内的 子字符串s[ai:bi]中的字符重新排列。 - 将下标在范围
n / 2 <= ci <= di < n内的 子字符串s[ci:di]中的字符重新排列。
对于每个查询，你的任务是判断执行操作后能否让 s 变成一个 回文串 。
每个查询与其他查询都是 独立的 。
请你返回一个下标从 0 开始的数组 answer ，如果第 i 个查询执行操作后，可以将 s 变为一个回文串，那么 answer[i] = true，否则为 false 。
- 子字符串 指的是一个字符串中一段连续的字符序列。
s[x:y]表示s中从下标x到y且两个端点 都包含 的子字符串。
示例 1：
输入：s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]]
输出：[true,true]
解释：这个例子中，有 2 个查询：
第一个查询：
- a0 = 1, b0 = 1, c0 = 3, d0 = 5
- 你可以重新排列 s[1:1] => abcabc 和 s[3:5] => abcabc 。
- 为了让 s 变为回文串，s[3:5] 可以重新排列得到 => abccba 。
- 现在 s 是一个回文串。所以 answer[0] = true 。
第二个查询：
- a1 = 0, b1 = 2, c1 = 5, d1 = 5.
- 你可以重新排列 s[0:2] => abcabc 和 s[5:5] => abcabc 。
- 为了让 s 变为回文串，s[0:2] 可以重新排列得到 => cbaabc 。
- 现在 s 是一个回文串，所以 answer[1] = true 。
示例 2：
输入：s = "abbcdecbba", queries = [[0,2,7,9]]
输出：[false]
解释：这个示例中，只有一个查询。
a0 = 0, b0 = 2, c0 = 7, d0 = 9.
你可以重新排列 s[0:2] => abbcdecbba 和 s[7:9] => abbcdecbba 。
无法通过重新排列这些子字符串使 s 变为一个回文串，因为 s[3:6] 不是一个回文串。
所以 answer[0] = false 。
示例 3：
输入：s = "acbcab", queries = [[1,2,4,5]]
输出：[true]
解释：这个示例中，只有一个查询。
a0 = 1, b0 = 2, c0 = 4, d0 = 5.
你可以重新排列 s[1:2] => acbcab 和 s[4:5] => acbcab 。
为了让 s 变为回文串，s[1:2] 可以重新排列得到 => abccab 。
然后 s[4:5] 重新排列得到 abccba 。
现在 s 是一个回文串，所以 answer[0] = true 。
提示：
2 <= n == s.length <= 1051 <= queries.length <= 105queries[i].length == 4ai == queries[i][0], bi == queries[i][1]ci == queries[i][2], di == queries[i][3]0 <= ai <= bi < n / 2n / 2 <= ci <= di < nn是一个偶数。s只包含小写英文字母。