LeetCode 3081-3100. 题解合集
文章目录
- [LeetCode 3081-3100. 题解合集](#LeetCode 3081-3100. 题解合集)
-
- [3081. Replace Question Marks in String to Minimize Its Value](#3081. Replace Question Marks in String to Minimize Its Value)
- [3082. Find the Sum of the Power of All Subsequences(求出所有子序列的能量和)](#3082. Find the Sum of the Power of All Subsequences(求出所有子序列的能量和))
- [3083. Existence of a Substring in a String and Its Reverse](#3083. Existence of a Substring in a String and Its Reverse)
- [3084. Count Substrings Starting and Ending with Given Character](#3084. Count Substrings Starting and Ending with Given Character)
- [3085. Minimum Deletions to Make String K-Special(成为 K 特殊字符串需要删除的最少字符数)](#3085. Minimum Deletions to Make String K-Special(成为 K 特殊字符串需要删除的最少字符数))
- [3086. Minimum Moves to Pick K Ones(拾起 K 个 1 需要的最少行动次数)](#3086. Minimum Moves to Pick K Ones(拾起 K 个 1 需要的最少行动次数))
- [3087. Find Trending Hashtags(查找热门话题标签)](#3087. Find Trending Hashtags(查找热门话题标签))
- [3088. Make String Anti-palindrome(使字符串反回文 🔒)](#3088. Make String Anti-palindrome(使字符串反回文 🔒))
- [3089. Find Bursty Behavior(查找突发行为)](#3089. Find Bursty Behavior(查找突发行为))
- [3090. Maximum Length Substring With Two Occurrences(每个字符最多出现两次的最长子字符串)](#3090. Maximum Length Substring With Two Occurrences(每个字符最多出现两次的最长子字符串))
- [3091. Apply Operations to Make Sum of Array Greater Than or Equal to k](#3091. Apply Operations to Make Sum of Array Greater Than or Equal to k)
- [3092. Most Frequent IDs(最高频率的 ID)](#3092. Most Frequent IDs(最高频率的 ID))
- [3093. Longest Common Suffix Queries(最长公共后缀查询)](#3093. Longest Common Suffix Queries(最长公共后缀查询))
- [3094. Guess the Number Using Bitwise Questions II(使用按位查询猜测数字 II 🔒)](#3094. Guess the Number Using Bitwise Questions II(使用按位查询猜测数字 II 🔒))
- [3095. Shortest Subarray With OR at Least K I(或值至少为 K 的最短子数组 I)](#3095. Shortest Subarray With OR at Least K I(或值至少为 K 的最短子数组 I))
- [3096. Minimum Levels to Gain More Points(得到更多分数的最少关卡数目)](#3096. Minimum Levels to Gain More Points(得到更多分数的最少关卡数目))
- [3097. Shortest Subarray With OR at Least K II(或值至少为 K 的最短子数组 II)](#3097. Shortest Subarray With OR at Least K II(或值至少为 K 的最短子数组 II))
- [3098. Find the Sum of Subsequence Powers(求出所有子序列的能量和)](#3098. Find the Sum of Subsequence Powers(求出所有子序列的能量和))
- [3099. Harshad Number(哈沙德数)](#3099. Harshad Number(哈沙德数))
- [3100. Water Bottles II(换水问题 II)](#3100. Water Bottles II(换水问题 II))
3081. Replace Question Marks in String to Minimize Its Value
题目描述
(替换字符串中的问号使分数最小)
给你一个字符串 s。s[i] 要么是小写英文字母,要么是问号 '?'。
对于长度为 m 且只含有小写英文字母的字符串 t,定义函数 cost(i) 为下标 i 之前
(也就是范围 0, `i` - 1 中)出现过与 t[i] 相同字符的次数。
字符串 t 的分数为所有下标 i 的 cost(i) 之和。
你的任务是用小写英文字母替换 s 中所有问号,使 s 的分数最小。
请返回替换所有问号 '?' 之后且分数最小的字符串。如果有多个字符串的分数最小,
那么返回字典序最小的一个。
示例 1
s = "???" -> "abc"
示例 2
s = "a?a?" -> "abac"
提示:
1 <= s.length <= 10^5s[i]是小写英文字母或 '?'
解题思路
解法一:贪心 + 小根堆,主提交版本
分数 = Σ 每个字符对 (同字符对) 的数量 = Σ_c C(cnt_c, 2)。要最小化它,
每个 '?' 应尽可能选择当前出现次数最少的字符(贪心:新增一个字符的边际代价
是其当前出现次数,选择让边际代价最小的字符)。
但多个 '?' 之间互不影响(替换后只统计最终计数),所以可以一次性决定:
统计原字符串各字母出现次数,对每个 '?' 位置依次选"当前计数最小"的字符
(并列取字典序小者),然后该字符计数 +1。这正是贪心的最优解
(与"每次选最小"等价,因为 '?' 替换彼此独立、顺序无关紧要)。
实现上用 26 个计数 + 每次遍历选最小(共 26 * 问号数,可过),或小根堆维护。
为满足字典序最小:从左往右处理 '?',每次选当前计数最小的字符中字典序最小的。
时间复杂度 O(26 * q + n),空间复杂度 O(1)。
解法二:全局计数分配(对照,等价)
记剩余 '?' 数 q,把最终计数 m_c = cnt_c + add_c 分配得尽可能均匀(因为
凸函数 ΣC(m_c,2) 在均匀时最小)。贪心:每次把 1 个问号分给当前计数最小
的字符(从左往右,字符小的优先)。与暴力全排列小规模交叉验证。
复杂度:
- 时间复杂度:O(26 * q + n)
- 空间复杂度:O(1)
代码实现
java
import java.util.PriorityQueue;
public class Solution {
// ---------- 解法一:贪心 + 每次选最小计数(主提交版本) ----------
public String minimizeStringValue(String s) {
int[] cnt = new int[26];
for (char c : s.toCharArray()) {
if (c != '?') {
cnt[c - 'a']++;
}
}
int q = 0;
for (char c : s.toCharArray()) {
if (c == '?') q++;
}
// 预先按贪心顺序分配 q 个字符
int[] add = new int[26];
for (int iter = 0; iter < q; ++iter) {
int best = 0;
for (int i = 1; i < 26; ++i) {
if (cnt[i] + add[i] < cnt[best] + add[best]) {
best = i;
}
}
add[best]++;
}
StringBuilder sb = new StringBuilder();
for (char c : s.toCharArray()) {
if (c == '?') {
// 找到 add 中还有剩余的第一个最小字符(从左到右字典序)
for (int i = 0; i < 26; ++i) {
if (add[i] > 0) {
add[i]--;
sb.append((char) ('a' + i));
break;
}
}
} else {
sb.append(c);
}
}
return sb.toString();
}
// ---------- 解法二:小根堆(对照,逻辑等价) ----------
public String minimizeStringValueByHeap(String s) {
int[] cnt = new int[26];
for (char c : s.toCharArray()) {
if (c != '?') cnt[c - 'a']++;
}
int q = 0;
for (char c : s.toCharArray()) {
if (c == '?') q++;
}
// 堆元素 [count, 字母],按 (count, 字母) 升序
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) ->
a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
for (int i = 0; i < 26; ++i) {
pq.offer(new int[]{cnt[i], i});
}
int[] sequence = new int[q]; // 替换用字符(贪心顺序)
for (int iter = 0; iter < q; ++iter) {
int[] top = pq.poll();
sequence[iter] = top[1];
pq.offer(new int[]{top[0] + 1, top[1]});
}
// 实际放置时按字典序:由于贪心选择的字符集已定,从左往右放时
// 应把"同类字符中字典序小的"优先放------即把 sequence 排序后从前往后放。
java.util.Arrays.sort(sequence);
int idx = 0;
StringBuilder sb = new StringBuilder();
for (char c : s.toCharArray()) {
if (c == '?') {
sb.append((char) ('a' + sequence[idx++]));
} else {
sb.append(c);
}
}
return sb.toString();
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] cases = {"???", "a?a?", "??", "a?b??c", "???"};
String[] expects = {"abc", "abac", "ab", "adbefc", "abc"};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
String a = sol.minimizeStringValue(cases[i]);
String b = sol.minimizeStringValueByHeap(cases[i]);
boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
allPass &= ok;
System.out.println(cases[i] + " -> " + a + " / heap=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍:两实现互比
java.util.Random rnd = new java.util.Random(3081);
int trials = 10000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(12);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
if (rnd.nextInt(3) == 0) {
sb.append('?');
} else {
sb.append((char) ('a' + rnd.nextInt(5)));
}
}
String s = sb.toString();
String a = sol.minimizeStringValue(s);
String b = sol.minimizeStringValueByHeap(s);
if (!a.equals(b)) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(26 * q + n),空间复杂度 O(1)。
- 时间复杂度:O(26 * q + n)
- 空间复杂度:O(1)
3082. Find the Sum of the Power of All Subsequences(求出所有子序列的能量和)
题目描述
给你一个长度为 n 的整数数组 nums 和一个正整数 k。
一个整数数组的能量定义为和等于 k 的子序列的数目。
请你返回 nums 中所有子序列的能量和。由于答案可能很大,请你将它对 10^9 + 7 取余后返回。
示例 1
nums = [1,2,3], k = 3 -> 6
示例 2
nums = [2,3,3], k = 5 -> 4
示例 3
nums = [1,2,3], k = 7 -> 0
提示:
1 <= n <= 1001 <= nums[i] <= 10^41 <= k <= 100
解题思路
解法一:组合计数 DP,主提交版本
设 fj 表示"对已决定的元素集合,其和为 j 的方案被多少个超集计数"。
更直接:答案 = 所有子序列 T 中"和为 k 的子子序列"数量
= Σ_{A:sum=k} (包含 A 的不同 T 的数量)
= Σ_{A:sum=k} 2^(n - |A|)(A 之外的元素任意取)。
因此:计数 gscnt = 选出的元素和为 s、使用了 cnt 个元素的方案数,
背包 DP 后 ans = Σ gkcnt * 2^(n - cnt) mod M。
时间复杂度 O(n^2 * k)(cnt 维也参与,n,k <= 100),空间 O(k * n)。
解法二:暴力枚举子序列(对照)
小规模场景:枚举 nums 所有子序列(2^n),对每个子序列再枚举其子子序列
统计和为 k 的个数,累加。时间复杂度 2^n * 2^n 级别,仅用于小规模验证。
复杂度:
- 时间复杂度:O(n^2 * k)
- 空间复杂度:O(n * k)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
private static final int MOD = 1_000_000_007;
// ---------- 解法一:背包计数 DP(主提交版本) ----------
public int sumOfPower(int[] nums, int k) {
int n = nums.length;
// g[s][c]:和为 s、用 c 个元素的方案数
long[][] g = new long[k + 1][n + 1];
g[0][0] = 1;
for (int v : nums) {
for (int s = k; s >= v; --s) {
for (int c = n - 1; c >= 0; --c) {
g[s][c + 1] = (g[s][c + 1] + g[s - v][c]) % MOD;
}
}
}
// pow2[i] = 2^i
long[] pow2 = new long[n + 1];
pow2[0] = 1;
for (int i = 1; i <= n; ++i) {
pow2[i] = pow2[i - 1] * 2 % MOD;
}
long ans = 0;
for (int c = 1; c <= n; ++c) {
ans = (ans + g[k][c] * pow2[n - c]) % MOD;
}
return (int) ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
public int sumOfPowerBrute(int[] nums, int k) {
int n = nums.length;
long ans = 0;
// 枚举所有子序列 T
for (int maskT = 1; maskT < (1 << n); ++maskT) {
// 枚举 T 的所有子子序列 A
for (int sub = maskT; sub > 0; sub = (sub - 1) & maskT) {
int s = 0;
for (int i = 0; i < n; ++i) {
if ((sub >> i & 1) == 1) {
s += nums[i];
if (s > k) break;
}
}
if (s == k) ans++;
}
}
return (int) (ans % MOD);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1, 2, 3},
{2, 3, 3},
{1, 2, 3},
{1, 1, 1},
{5, 5},
};
int[] ks = {3, 5, 7, 2, 5};
int[] expects = {6, 4, 0, 6, 4};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.sumOfPower(cases[i], ks[i]);
int b = sol.sumOfPowerBrute(cases[i], ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
+ " -> " + a + " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍设置:k 小、n 小
Random rnd = new Random(3082);
int trials = 400;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(6);
int k = 1 + rnd.nextInt(8);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(5);
int a = sol.sumOfPower(nums, k);
int b = sol.sumOfPowerBrute(nums, k);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n^2 * k)(cnt 维也参与,n,k <= 100),空间 O(k * n)。
统计和为 k 的个数,累加。时间复杂度 2^n * 2^n 级别,仅用于小规模验证。
- 时间复杂度:O(n^2 * k)
- 空间复杂度:O(n * k)
3083. Existence of a Substring in a String and Its Reverse
题目描述
(字符串及其反转中是否存在同一子字符串)
给你一个字符串 s,请你判断字符串 s 是否存在一个长度为 2 的子字符串,
在 s 反转后的字符串中也出现。如果存在这样的子字符串,返回 true;否则返回 false。
示例 1
s = "leetcode" -> true("ee" 出现于反转串 "edocteel")
示例 2
s = "abcba" -> true("ab"、"bc"、"cb"、"ba" 都在反转串中出现)
示例 3
s = "abcd" -> false
提示:
1 <= s.length <= 100- 字符串
s仅由小写英文字母组成
解题思路
解法一:集合判交,主提交版本
长度 2 的子字符串只有 s.length() - 1 个。把 s 的所有长度为 2 的子串放入集合 A,
反转串的所有长度为 2 的子串放入集合 B,判断 A ∩ B 是否非空。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:直接双重遍历(对照)
对每个 i,子串 si...i+1;对每个 j,检查 si...i+1 == reverse(s)j...j+1。
等价于 si==sn-1-j && si+1==sn-2-j,即检查是否存在一对长度 2 的
正序对与逆序对相等。时间复杂度 O(n^2),用于交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.HashSet;
import java.util.Set;
public class Solution {
// ---------- 解法一:集合判交(主提交版本) ----------
public boolean isValid(String s) {
int n = s.length();
if (n < 2) {
return false;
}
Set<String> set = new HashSet<>();
for (int i = 0; i + 1 < n; ++i) {
set.add(s.substring(i, i + 2));
}
String rev = new StringBuilder(s).reverse().toString();
for (int i = 0; i + 1 < n; ++i) {
if (set.contains(rev.substring(i, i + 2))) {
return true;
}
}
return false;
}
// ---------- 解法二:直接双重遍历(对照) ----------
public boolean isValidBrute(String s) {
int n = s.length();
for (int i = 0; i + 1 < n; ++i) {
for (int j = 0; j + 1 < n; ++j) {
// s[i..i+1] == reverse(s)[j..j+1] <=> 左右镜像相等
if (s.charAt(i) == s.charAt(n - 1 - j)
&& s.charAt(i + 1) == s.charAt(n - 2 - j)) {
return true;
}
}
}
return false;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] cases = {"leetcode", "abcba", "abcd", "a", "ab", "aa"};
boolean[] expects = {true, true, false, false, false, true};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
boolean a = sol.isValid(cases[i]);
boolean b = sol.isValidBrute(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(cases[i] + " -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
正序对与逆序对相等。时间复杂度 O(n^2),用于交叉验证。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3084. Count Substrings Starting and Ending with Given Character
题目描述
(统计以给定字符开头和结尾的子字符串总数)
给你一个字符串 s 和一个字符 c。返回在字符串 s 中并且以 c 字符开头和结尾的非空子字符串的总数。
示例 1
s = "abada", c = 'a' -> 6
示例 2
s = "zzz", c = 'z' -> 6
提示:
1 <= s.length <= 10^5s和c均由小写英文字母组成
解题思路
解法一:组合计数,主提交版本
以 c 开头且以 c 结尾的子串,由"两个 c 的位置"唯一确定:设 c 在 s 中共出现 cnt 次,
任取两个位置(可相同,即 i <= j)构成一个子串,因此总数 = cnt + C(cnt, 2)
= cnt * (cnt + 1) / 2。
只统计 c 出现次数即可,O(n) 时间、O(1) 空间。
解法二:暴力枚举(对照)
枚举所有 (i, j) 对,检查 si == c && sj == c。逻辑等价,用于交叉验证。
时间复杂度 O(n^2),仅用于小规模验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:组合计数(主提交版本) ----------
public long countSubstrings(String s, char c) {
long cnt = 0;
for (int i = 0; i < s.length(); ++i) {
if (s.charAt(i) == c) {
cnt++;
}
}
return cnt * (cnt + 1) / 2;
}
// ---------- 解法二:暴力枚举(对照) ----------
public long countSubstringsBrute(String s, char c) {
int n = s.length();
long ans = 0;
for (int i = 0; i < n; ++i) {
if (s.charAt(i) != c) continue;
for (int j = i; j < n; ++j) {
if (s.charAt(j) == c) {
ans++;
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] cases = {"abada", "zzz", "a", "abc", "aaaa"};
char[] cs = {'a', 'z', 'a', 'a', 'a'};
long[] expects = {6, 6, 1, 1, 10};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
long a = sol.countSubstrings(cases[i], cs[i]);
long b = sol.countSubstringsBrute(cases[i], cs[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(cases[i] + " c=" + cs[i] + " -> " + a
+ " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3084);
int trials = 2000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(10);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rnd.nextInt(3)));
}
String s = sb.toString();
char c = (char) ('a' + rnd.nextInt(3));
long a = sol.countSubstrings(s, c);
long b = sol.countSubstringsBrute(s, c);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH s=" + s + " c=" + c
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n^2),仅用于小规模验证。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3085. Minimum Deletions to Make String K-Special(成为 K 特殊字符串需要删除的最少字符数)
题目描述
给你一个字符串 word 和一个整数 k。
如果 |freq(word[i]) - freq(word[j])| <= k 对于字符串中所有下标 i 和 j 都成立,
则认为 word 是 k 特殊字符串。此处 freq(x) 表示字符 x 在 word 中的出现频率。
返回使 word 成为 k 特殊字符串需要删除的字符的最小数量。
示例 1
word = "aabcaba", k = 0 -> 3
示例 2
word = "dabdcbdcdcd", k = 2 -> 2
示例 3
word = "aaabaaa", k = 2 -> 1
提示:
1 <= word.length <= 10^50 <= k <= 10^5word仅由小写英文字母组成
解题思路
解法一:枚举保留下限,主提交版本
设最终每个字符 i 的频率为 cnti(可删除原频次中的任意数量),
目标:任意两个非零保留频率相差 <= k,且其它字符删除到 0。
枚举"保留频率的下限" low(只保留 freq >= low 的字符,且每个保留字符
的频率限制在 low, low + k):
- 对 freq > low + k 的字符,删掉 freq - (low + k) 个,保留 low + k;
- 对频次 < low 的字符,全部删除,保留 0(不计入下限约束);
- 对 low <= freq <= low+k 的字符,保留不变。
取所有 low 下删除数的最小值。low 只需取 0...maxFreq。
时间复杂度 O(26 * (maxFreq + 1) + n),空间 O(26)。
解法二:枚举保留上限(对照)
对称地枚举上限 hi(保留频率上限),所有保留字符频率落在 max(0, hi-k), hi,
频次 > hi 的删到 hi,频次 < hi-k 的删到 0,取最小。与解法一结果一致,
用于交叉验证。
复杂度: - 时间复杂度:O(n + 26 * V)(V 为最大频次)
- 空间复杂度:O(26)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:枚举保留下限(主提交版本) ----------
public int minimumDeletions(String word, int k) {
int[] cnt = new int[26];
for (char c : word.toCharArray()) {
cnt[c - 'a']++;
}
int maxFreq = 0;
for (int v : cnt) maxFreq = Math.max(maxFreq, v);
int best = word.length();
for (int low = 0; low <= maxFreq; ++low) {
int del = 0;
for (int v : cnt) {
if (v < low) {
del += v; // 全部删除
} else if (v > low + k) {
del += v - (low + k); // 删到上限
}
}
best = Math.min(best, del);
}
return best;
}
// ---------- 解法二:枚举保留上限(对照) ----------
public int minimumDeletionsByHi(String word, int k) {
int[] cnt = new int[26];
for (char c : word.toCharArray()) {
cnt[c - 'a']++;
}
int maxFreq = 0;
for (int v : cnt) maxFreq = Math.max(maxFreq, v);
int best = word.length();
for (int hi = 0; hi <= maxFreq; ++hi) {
int lo = Math.max(0, hi - k);
int del = 0;
for (int v : cnt) {
if (v > hi) {
del += v - hi; // 删到上限 hi
} else if (v < lo) {
del += v; // 低于下限,全删
}
}
best = Math.min(best, del);
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] cases = {"aabcaba", "dabdcbdcdcd", "aaabaaa", "abc", "aaaaa"};
int[] ks = {0, 2, 2, 0, 3};
int[] expects = {3, 2, 1, 0, 0};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.minimumDeletions(cases[i], ks[i]);
int b = sol.minimumDeletionsByHi(cases[i], ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(cases[i] + " k=" + ks[i] + " -> " + a
+ " / hi=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 随机校验两实现
Random rnd = new Random(3085);
int trials = 5000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(10);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rnd.nextInt(4)));
}
String s = sb.toString();
int k = rnd.nextInt(5);
int a = sol.minimumDeletions(s, k);
int b = sol.minimumDeletionsByHi(s, k);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH s=" + s + " k=" + k
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(26 * (maxFreq + 1) + n),空间 O(26)。
- 时间复杂度:O(n + 26 * V)(V 为最大频次)
- 空间复杂度:O(26)
3086. Minimum Moves to Pick K Ones(拾起 K 个 1 需要的最少行动次数)
题目描述
给你一个下标从 0 开始的二进制数组 nums,其长度为 n;另给你一个正整数 k 以及一个非负整数 maxChanges。
Alice 在玩一个游戏,游戏的目标是让 Alice 使用最少数量的行动次数从 nums 中拾起 k 个 1。
游戏开始时,Alice 可以选择数组 0, `n` - 1 范围内的任何索引 aliceIndex 站立。
如果 nums[aliceIndex] == 1,Alice 会拾起一个 1,并且 nums[aliceIndex] 变成 0(这不算作一次行动)。
之后,Alice 可以执行任意数量的行动(包括零次),每次行动中必须恰好执行以下动作之一:
- 选择任意一个下标
j!=aliceIndex且满足nums[j]== 0,然后将nums[j]设置为 1。
这个动作最多可以执行maxChanges次。 - 选择任意两个相邻的下标
x和y(|x-y| == 1)且满足nums[x]== 1,nums[y]== 0,
然后交换它们的值。如果y==aliceIndex,在这次行动后Alice拾起一个 1,并且nums[y]变成 0。
返回Alice拾起恰好k个 1 所需的最少行动次数。
示例 1
nums = [1,1,0,0,0,1,1,0,0,1], k = 3, maxChanges = 1 -> 3
示例 2
nums = [0,0,0,0], k = 2, maxChanges = 3 -> 4
提示:
2 <= n <= 10^50 <= nums[i] <= 11 <= k <= 10^50 <= maxChanges <= 10^5maxChanges + sum(nums) >= k
解题思路
解法一:贪心 + 前缀和 + 二分(主提交版本,官方方法)
枚举 Alice 站立位置 i:
- i 处若是 1,免费拾 1 个(need = k - numsi);
- 优先拾取 i-1、i+1 两个相邻位置的 1(每拾 1 个需 1 次行动);
- 用"设定 1"(行动 1)补充:每 1 次行动可生成 1 个 1 并拾取,成本 2
(设定 1 次 + 相邻交换 1 次),最多 maxChanges 次; - 仍不足,则从更远的 i-d...i-2 与 i+2...i+d 区域拾 1(行动 2 移动),
每移动 1 格 1 次行动。用前缀和 cnt/s 加速区间 1 的计数与"移动到 i"的总代价:
t1 = c1i - (sr1-sl1-1)(左侧)、t2 = (sr2-sl2-1) - c2 i(右侧)。
二分最小半径 d,保证区间内 1 的数量 >= need。
对每个 i 取最小行动数。时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:BFS 状态模拟(对照,独立仲裁)
小规模场景:对每个 aliceIndex,用 BFS 在 (数组状态, 已拾取数, 已用生成数) 的
状态空间里逐层搜索最少的行动层数,完全按题目动作规则转移。
状态数指数级,仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:贪心 + 前缀和 + 二分(主提交版本) ----------
public long minimumMoves(int[] nums, int k, int maxChanges) {
int n = nums.length;
int[] cnt = new int[n + 1];
long[] s = new long[n + 1];
for (int i = 1; i <= n; ++i) {
cnt[i] = cnt[i - 1] + nums[i - 1];
s[i] = s[i - 1] + (long) i * nums[i - 1];
}
long ans = Long.MAX_VALUE;
for (int i = 1; i <= n; ++i) {
long t = 0;
int need = k - nums[i - 1]; // i 处本身若是 1 免费拾取
// 相邻两个位置拾 1
for (int j = i - 1; j <= i + 1; j += 2) {
if (need > 0 && 1 <= j && j <= n && nums[j - 1] == 1) {
--need;
++t;
}
}
// 生成型操作:每 1 次"设定 1" + 之后的交换,成本 2/个
int c = Math.min(need, maxChanges);
need -= c;
t += c * 2L;
if (need <= 0) {
ans = Math.min(ans, t);
continue;
}
// 远处拾 1:二分最小半径 d
int lo = 2, hi = Math.max(i - 1, n - i);
while (lo <= hi) {
int mid = (lo + hi) >> 1;
int l1 = Math.max(1, i - mid), r1 = Math.max(0, i - 2);
int l2 = Math.min(n + 1, i + 2), r2 = Math.min(n, i + mid);
int c1 = cnt[r1] - cnt[l1 - 1];
int c2 = cnt[r2] - cnt[l2 - 1];
if (c1 + c2 >= need) {
long t1 = 1L * c1 * i - (s[r1] - s[l1 - 1]);
long t2 = (s[r2] - s[l2 - 1]) - 1L * c2 * i;
ans = Math.min(ans, t + t1 + t2);
hi = mid - 1;
} else {
lo = mid + 1;
}
}
}
return ans;
}
// ---------- 解法二:BFS 状态模拟(对照) ----------
public long minimumMovesBrute(int[] nums, int k, int maxChanges) {
int n = nums.length;
long best = Long.MAX_VALUE;
for (int p = 0; p < n; ++p) {
long cur = bfs(nums, k, maxChanges, p);
if (cur >= 0) {
best = Math.min(best, cur);
}
}
return best == Long.MAX_VALUE ? -1 : best;
}
private long bfs(int[] nums, int k, int maxChanges, int aliceIndex) {
int n = nums.length;
// 初始:若有免费 1 先拾取
int startGot = nums[aliceIndex];
int[] startArr = nums.clone();
if (startGot == 1) {
startArr[aliceIndex] = 0;
}
// 状态:数组字符串, 已拾取数, 已用生成数
String start = stateKey(startArr, startGot, 0);
Set<String> seen = new HashSet<>();
seen.add(start);
ArrayDeque<String> q = new ArrayDeque<>();
q.add(start);
long moves = 0;
while (!q.isEmpty()) {
int sz = q.size();
for (int step = 0; step < sz; ++step) {
String cur = q.poll();
String[] parts = cur.split("#");
int[] arr = Arrays.stream(parts[0].split(","))
.mapToInt(Integer::parseInt).toArray();
int got = Integer.parseInt(parts[1]);
int used = Integer.parseInt(parts[2]);
if (got >= k) {
return moves;
}
// 动作1:把任意 0 设为 1(used < maxChanges)
if (used < maxChanges) {
for (int j = 0; j < n; ++j) {
if (j != aliceIndex && arr[j] == 0) {
int[] na = arr.clone();
na[j] = 1;
String ns = stateKey(na, got, used + 1);
if (seen.add(ns)) q.add(ns);
}
}
}
// 动作2:交换相邻的 (x,y),x=1,y=0;若 y==aliceIndex 则拾取
for (int x = 0; x < n; ++x) {
if (arr[x] == 0) continue;
for (int y = 0; y < n; ++y) {
if (Math.abs(x - y) != 1 || arr[y] != 0) continue;
int[] na = arr.clone();
na[x] = 0;
na[y] = 1;
int ngot = got;
if (y == aliceIndex) {
ngot++;
na[y] = 0;
}
String ns = stateKey(na, ngot, used);
if (seen.add(ns)) q.add(ns);
}
}
// 等待/其他组合由状态扩展涵盖
}
moves++;
if (moves > 100) break; // 防止爆炸
}
return -1;
}
private String stateKey(int[] arr, int got, int used) {
StringBuilder sb = new StringBuilder();
for (int v : arr) {
if (sb.length() > 0) sb.append(",");
sb.append(v);
}
sb.append("#").append(got).append("#").append(used);
return sb.toString();
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1, 1, 0, 0, 0, 1, 1, 0, 0, 1},
{0, 0, 0, 0},
{1, 0, 1, 0, 1},
{1, 1, 1},
{1, 0, 0, 1},
{1, 1, 0, 1, 1},
};
int[] ks = {3, 2, 3, 3, 2, 4};
int[] mcs = {1, 3, 1, 0, 1, 0};
long[] expects = {3, 4, 4, 2, 2, 6}; // 官方样例;其余经 BFS 独立仲裁
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
long a = sol.minimumMoves(cases[i], ks[i], mcs[i]);
long b = sol.minimumMovesBrute(cases[i], ks[i], mcs[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
+ " mc=" + mcs[i] + " -> " + a + " / bfs=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍(小规模)
Random rnd = new Random(3086);
int trials = 60;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 2 + rnd.nextInt(6);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = rnd.nextInt(2);
int ones = 0;
for (int v : nums) ones += v;
int maxChanges = rnd.nextInt(3);
if (ones + maxChanges < 1) continue;
int k = 1 + rnd.nextInt(Math.min(3, ones + maxChanges));
long a = sol.minimumMoves(nums, k, maxChanges);
long b = sol.minimumMovesBrute(nums, k, maxChanges);
if (a != b) {
fail++;
if (fail <= 6) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " k=" + k + " mc=" + maxChanges
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
对每个 i 取最小行动数。时间复杂度 O(n log n),空间复杂度 O(n)。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3087. Find Trending Hashtags(查找热门话题标签)
题目类型:数据库(SQL)
题目描述
表:Tweets
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| user_id | int |
| tweet_id | int |
| tweet_date | date |
| tweet | varchar |
+-------------+---------+
tweet_id 是该表的主键。该表的每一行记录用户 ID、推文 ID、发布日期与推文内容。每条推文只包含一个 话题标签(以 # 开头)。
编写解决方案,找出 2024 年 二月 的 前 3 热门话题标签。
返回结果表,按标签出现次数降序 、标签名降序排序。
示例 1:
输入:
Tweets 表(2024-02 共 7 条:#HappyDay x3、#TechLife x2、#WorkLife x1、#Nature x1)
输出:
+-----------+--------------+
| hashtag | hashtag_count|
+-----------+--------------+
| #HappyDay | 3 |
| #TechLife | 2 |
| #WorkLife | 1 |
+-----------+--------------+
解释:#HappyDay 3 次、#TechLife 2 次、#WorkLife 1 次为前 3;#Nature 也 1 次但按标签名降序排在 #WorkLife 之后,故不入前 3。
解题思路
用 SUBSTRING(tweet, LOCATE('#', tweet)) 截取 # 之后的内容,再 SUBSTRING_INDEX(..., ' ', 1) 截到第一个空格,得到纯标签;WHERE 限定 2024 年 2 月(用 YEAR/MONTH 判断,跨 2 月 29 日闰年也不遗漏),按标签 GROUP BY 计数,ORDER BY 次数 DESC, 标签 DESC LIMIT 3 取前 3。
代码实现
sql
SELECT SUBSTRING_INDEX(SUBSTRING(tweet, LOCATE('#', tweet)), ' ', 1) AS hashtag,
COUNT(*) AS hashtag_count
FROM Tweets
WHERE YEAR(tweet_date) = 2024 AND MONTH(tweet_date) = 2
GROUP BY hashtag
ORDER BY hashtag_count DESC, hashtag DESC
LIMIT 3;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3088. Make String Anti-palindrome(使字符串反回文 🔒)
题目描述
我们称一个长度为偶数的字符串 s 为反回文的,如果对于每一个下标 0 <= i < n,
s[i] != s[n - i - 1]
给定一个字符串 s,你需要进行任意次(包括 0)操作使 s 成为反回文。
在一次操作中,你可以选择 s 中的两个字符并且交换它们。
返回结果字符串。如果有多个字符串符合条件,返回字典序最小的那个。
如果它不能成为一个反回文,返回 "-1"。
示例 1
s = "abca" -> "aabc"
示例 2
s = "abba" -> "aabb"
示例 3
s = "cccd" -> "-1"
示例 4
s = "abcabc" -> "aabcbc"
提示:
2 <= s.length <= 10^5s.length% 2 == 0s只包含小写英文字母
解题思路
解法一:两半贪心构造,主提交版本
设 n = s.length(),m = n / 2。
- 可行性判定:某字符出现次数最多 mx 次。若 mx > m,则无论怎么重排,
n/2 对对称槽中必有一对槽内两个字符相同(鸽巢原理),返回 "-1"。
否则一定可行。 - 字典序最小构造:把字符升序排序。左半段(下标 0...m-1)固定取排序后
最小的 m 个字符------这是任何反回文排列中左半段的最小可能,故整体
字典序最小只需在此基础上把右半段(下标 m...n-1)构造得尽可能小。 - 右半段每个位置 j(0...m-1)对应镜像左半字符 resm-1-j,要求
resm+j != resm-1-j,即该位置有一个"禁字符"。从左到右贪心,
每次选择剩余字符中字典序最小、且不等于禁字符、并且选完后剩余
字符仍满足 Hall 条件(对任意字符 y:剩余 y 的个数 <= 剩余位置中
禁字符不是 y 的个数)的字符。该条件保证后续一定能填完。
时间复杂度 O(26 * 26 * n),空间复杂度 O(n)。
解法二:全排列枚举(对照)
对 s 的所有排列按字典序递增枚举,第一个满足反回文的排列即为答案。
时间复杂度 O(n!),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(26^2 * n)(主解)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:两半贪心构造(主提交版本) ----------
public String makeAntiPalindrome(String s) {
int n = s.length();
int m = n / 2;
char[] arr = s.toCharArray();
Arrays.sort(arr);
// 可行性:最多字符数 <= n/2
int[] cnt = new int[26];
for (char c : arr) cnt[c - 'a']++;
int mx = 0;
for (int v : cnt) mx = Math.max(mx, v);
if (mx > m) {
return "-1";
}
char[] res = arr.clone();
// 右半段字符计数
int[] rcnt = new int[26];
for (int i = m; i < n; i++) rcnt[arr[i] - 'a']++;
// 逐位构造右半段 res[m..n-1]
for (int j = 0; j < m; j++) {
int forbid = res[m - 1 - j] - 'a';
boolean placed = false;
for (int x = 0; x < 26 && !placed; x++) {
if (rcnt[x] == 0 || x == forbid) continue;
// 尝试放 x:检查选完后剩余字符是否都满足 Hall 条件
rcnt[x]--;
if (feasible(rcnt, res, m, j + 1)) {
res[m + j] = (char) ('a' + x);
placed = true;
} else {
rcnt[x]++;
}
}
if (!placed) {
// 理论上不会发生(可行性已保证)
return "-1";
}
}
return new String(res);
}
// 检查从位置 st 开始填右半段剩余位置时,剩余字符是否都能被安排:
// 对任意字符 y,剩余 y 的数量 <= 剩余位置中"禁字符不是 y"的位置数。
private boolean feasible(int[] rcnt, char[] res, int m, int st) {
for (int y = 0; y < 26; y++) {
if (rcnt[y] == 0) continue;
int free = 0;
for (int k = st; k < m; k++) {
if (res[m - 1 - k] - 'a' != y) free++;
}
if (rcnt[y] > free) return false;
}
return true;
}
// ---------- 解法二:全排列枚举(对照) ----------
public String makeAntiPalindromeBrute(String s) {
int n = s.length();
char[] arr = s.toCharArray();
Arrays.sort(arr);
String best = null;
do {
boolean ok = true;
for (int i = 0; i < n / 2; ++i) {
if (arr[i] == arr[n - 1 - i]) {
ok = false;
break;
}
}
if (ok) {
String cand = new String(arr);
if (best == null || cand.compareTo(best) < 0) {
best = cand;
}
}
} while (nextPermutation(arr));
return best == null ? "-1" : best;
}
private boolean nextPermutation(char[] a) {
int i = a.length - 2;
while (i >= 0 && a[i] >= a[i + 1]) i--;
if (i < 0) return false;
int j = a.length - 1;
while (a[j] <= a[i]) j--;
char t = a[i]; a[i] = a[j]; a[j] = t;
int l = i + 1, r = a.length - 1;
while (l < r) {
t = a[l]; a[l] = a[r]; a[r] = t;
l++; r--;
}
return true;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] cases = {"abca", "abba", "cccd", "aabb", "abcabc", "zz", "aabbbb", "aaabcc"};
String[] expects = {"aabc", "aabb", "-1", "aabb", "aabcbc", "-1", "-1", "aaabcc"};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
String a = sol.makeAntiPalindrome(cases[i]);
String b = sol.makeAntiPalindromeBrute(cases[i]);
boolean ok = a.equals(expects[i]) && b.equals(expects[i]) && a.equals(b);
allPass &= ok;
System.out.println(cases[i] + " -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍(小规模,多字符集)
Random rnd = new Random(3088);
int trials = 3000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int len = 2 * (1 + rnd.nextInt(4)); // 2,4,6,8
int alpha = 2 + rnd.nextInt(3); // 2~4 字符集
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; ++i) {
sb.append((char) ('a' + rnd.nextInt(alpha)));
}
String s = sb.toString();
String a = sol.makeAntiPalindrome(s);
String b = sol.makeAntiPalindromeBrute(s);
if (!a.equals(b)) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(26 * 26 * n),空间复杂度 O(n)。
时间复杂度 O(n!),仅用于小规模交叉验证。
- 时间复杂度:O(26^2 * n)(主解)
- 空间复杂度:O(n)
3089. Find Bursty Behavior(查找突发行为)
题目类型:数据库(SQL)
题目描述
表:Posts
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| post_id | int |
| user_id | int |
| post_date | date |
+-------------+---------+
post_id 是该表的主键。该表的每一行记录推文 ID、用户 ID 与发布日期。
编写解决方案,找出在 2024 年 2 月发帖行为表现出突发行为 的用户。突发行为 指用户在 2024 年 2 月存在一个连续 7 天 的时段中发帖数量是其平均每周 发帖数量的至少两倍。
**注意:**统计只包含 2 月 1 日到 2 月 28 日,即把 2 月记为正好 4 周(平均每周发帖数 = 2 月总发帖数 / 4)。
返回结果表,以 user_id 升序 排序,同时输出最大连续 7 天发帖数 max_7day_posts 与平均每周发帖数 avg_weekly_posts(保留 4 位小数)。
示例 1:
输入:
Posts 表(用户 1/2/5 各 1 帖,用户 3 发 3 帖分布在 2/6、2/14、2/25)
输出:
+---------+----------------+------------------+
| user_id | max_7day_posts | avg_weekly_posts |
+---------+----------------+------------------+
| 1 | 1 | 0.2500 |
| 2 | 1 | 0.2500 |
| 5 | 1 | 0.2500 |
+---------+----------------+------------------+
解释:用户 1/2/5:avg = 1/4 = 0.25,任意 7 天最多 1 帖 => 1 >= 2*0.25 满足突发。用户 3:avg = 3/4 = 0.75,任意 7 天窗口最多 1 帖 => 1 < 1.5 不满足。
解题思路
① 统计每个用户 2 月总发帖数,avg_weekly = 总数 / 4;② 把每个用户的每条发帖日期作为窗口起点,JOIN 同用户的帖子并限定 p2.post_date BETWEEN p1.post_date AND p1.post_date + 6,对该窗口计数,取每个用户的窗口最大值 max_7day_posts;③ 过滤 max_7day_posts >= 2 * avg_weekly,按 user_id 升序输出。
代码实现
sql
WITH stats AS (
SELECT user_id, COUNT(*) / 4.0 AS avg_weekly
FROM Posts
WHERE YEAR(post_date) = 2024 AND MONTH(post_date) = 2
GROUP BY user_id
),
windows AS (
SELECT p1.user_id, p1.post_date,
COUNT(p2.post_id) AS posts_in_7d
FROM Posts p1
JOIN Posts p2 ON p1.user_id = p2.user_id
AND p2.post_date BETWEEN p1.post_date
AND DATE_ADD(p1.post_date, INTERVAL 6 DAY)
WHERE YEAR(p1.post_date) = 2024 AND MONTH(p1.post_date) = 2
GROUP BY p1.user_id, p1.post_date
),
max7 AS (
SELECT user_id, MAX(posts_in_7d) AS max_7day_posts
FROM windows
GROUP BY user_id
)
SELECT s.user_id, m.max_7day_posts, ROUND(s.avg_weekly, 4) AS avg_weekly_posts
FROM stats s
JOIN max7 m ON s.user_id = m.user_id
WHERE m.max_7day_posts >= 2 * s.avg_weekly
ORDER BY s.user_id;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3090. Maximum Length Substring With Two Occurrences(每个字符最多出现两次的最长子字符串)
题目描述
给你一个字符串 s,请找出满足每个字符最多出现两次的最长子字符串,并返回该子字符串的最大长度。
示例 1
s = "bcbbbcba" -> 4(子串 "bcbbbcba" 中的 "bcbb" 等)
示例 2
s = "aaaa" -> 2
提示:
2 <= s.length <= 100s仅由小写英文字母组成
解题思路
解法一:滑动窗口,主提交版本
维护窗口 l, r,用计数数组记录窗口内每个字符出现次数。
扩展 r,若新字符计数超过 2,则收缩左边界 l 直到计数恢复合法。
整个过程中窗口始终保持"每个字符不超过 2 次",窗口长度最大值即为答案。
时间复杂度 O(n),空间复杂度 O(1)(固定 26 字母计数)。
解法二:暴力枚举(对照)
枚举所有子串 i, j,检查每个字符出现次数是否 <= 2,取最大长度。
时间复杂度 O(n^2),空间复杂度 O(1),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:滑动窗口(主提交版本) ----------
public int maximumLengthSubstring(String s) {
int n = s.length();
int[] cnt = new int[26];
int l = 0, ans = 0;
for (int r = 0; r < n; ++r) {
int c = s.charAt(r) - 'a';
cnt[c]++;
while (cnt[c] > 2) {
cnt[s.charAt(l) - 'a']--;
l++;
}
ans = Math.max(ans, r - l + 1);
}
return ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
public int maximumLengthSubstringBrute(String s) {
int n = s.length();
int ans = 0;
for (int i = 0; i < n; ++i) {
int[] cnt = new int[26];
for (int j = i; j < n; ++j) {
cnt[s.charAt(j) - 'a']++;
boolean ok = true;
for (int v : cnt) {
if (v > 2) {
ok = false;
break;
}
}
if (ok) {
ans = Math.max(ans, j - i + 1);
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] cases = {"bcbbbcba", "aaaa", "ab", "abcabc", "aabbcc", "aa"};
int[] expects = {4, 2, 2, 6, 6, 2};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.maximumLengthSubstring(cases[i]);
int b = sol.maximumLengthSubstringBrute(cases[i]);
boolean ok = a == expects[i] && b == expects[i] && a == b;
allPass &= ok;
System.out.println(cases[i] + " -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3090);
int trials = 5000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int len = 1 + rnd.nextInt(20);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; ++i) {
sb.append((char) ('a' + rnd.nextInt(4)));
}
String s = sb.toString();
int a = sol.maximumLengthSubstring(s);
int b = sol.maximumLengthSubstringBrute(s);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)(固定 26 字母计数)。
时间复杂度 O(n^2),空间复杂度 O(1),仅用于小规模交叉验证。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3091. Apply Operations to Make Sum of Array Greater Than or Equal to k
题目描述
(执行操作使数据元素之和大于等于 K)
给你一个正整数 k。最初,你有一个数组 nums = 1。
你可以对数组执行以下任意操作任意次数(可能为零):
- 选择数组中的任何一个元素,然后将它的值增加 1。
- 复制数组中的任何一个元素,然后将它附加到数组的末尾。
返回使得最终数组元素之和大于或等于k所需的最少操作次数。
示例 1
k = 11 -> 5([1] +1 三次 -> [4],复制两次 -> [4,4,4],和=12)
示例 2
k = 1 -> 0
提示:
1 <= k <= 10^5
解题思路
解法一:枚举"加到的值",主提交版本
最优策略可以归纳为"先加后复制":先把初始元素 1 增加到某个值 v
(成本 v-1 次操作),然后复制 t 份得到和为 vt 的数组。
由于复制阶段每个元素的值都是 v,需要 v t >= k,即 t = ceil(k/v),
复制次数 = t-1。总成本 = (v-1) + (t-1) = v + ceil(k/v) - 2。
证明"先加后复制"最优:若某次加值发生在复制之后,把该加值提前到
首次复制之前,之后所有副本都更大,和不会更小,成本不变,故可
无损重排为"先加后复制";而复制多元素前先加值到最大者不劣。
枚举 v 从 1 到 k,取最小值。
时间复杂度 O(k),空间复杂度 O(1)。
解法二:BFS 状态模拟(对照)
以数组的多重集为状态(排序后转字符串判重),BFS 逐层扩展,
每层做"任一元素 +1"或"复制任一元素",第一个和 >= k 的层数即答案。
时间复杂度指数级,仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(k)
- 空间复杂度:O(1)
代码实现
java
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:枚举"加到的值"(主提交版本) ----------
public int minOperations(int k) {
if (k <= 1) {
return 0;
}
int ans = k - 1; // 全部用加值:加到 k,成本 k-1
for (int v = 1; v <= k; ++v) {
int inc = v - 1; // 把 1 加到 v
int copies = (k + v - 1) / v - 1; // 复制出 ceil(k/v) 份,成本 -1
ans = Math.min(ans, inc + copies);
}
return ans;
}
// ---------- 解法二:BFS 状态模拟(对照) ----------
public int minOperationsBfs(int k) {
if (k <= 1) {
return 0;
}
int[] start = {1};
String s0 = hash(start);
Queue<String> queue = new ArrayDeque<String>();
Set<String> seen = new HashSet<String>();
queue.offer(s0);
seen.add(s0);
Map<String, int[]> state = new HashMap<String, int[]>();
state.put(s0, start);
int steps = 0;
while (!queue.isEmpty()) {
int size = queue.size();
for (int sz = 0; sz < size; ++sz) {
String cur = queue.poll();
int[] arr = state.get(cur);
if (sum(arr) >= k) {
return steps;
}
// 加值(对每个不同值加一次,去重)
Set<Integer> doneVal = new HashSet<Integer>();
for (int i = 0; i < arr.length; ++i) {
if (doneVal.contains(arr[i])) {
continue;
}
doneVal.add(arr[i]);
int[] nxt = arr.clone();
nxt[i]++;
pushState(queue, seen, state, nxt);
}
// 复制(对每个不同值复制一次,去重)
doneVal.clear();
for (int i = 0; i < arr.length; ++i) {
if (doneVal.contains(arr[i])) {
continue;
}
doneVal.add(arr[i]);
int[] nxt = Arrays.copyOf(arr, arr.length + 1);
nxt[arr.length] = arr[i];
pushState(queue, seen, state, nxt);
}
}
steps++;
}
return -1;
}
private void pushState(Queue<String> queue, Set<String> seen,
Map<String, int[]> state, int[] arr) {
int[] srt = arr.clone();
Arrays.sort(srt);
String key = hash(srt);
if (seen.add(key)) {
queue.offer(key);
state.put(key, srt);
}
}
private String hash(int[] arr) {
StringBuilder sb = new StringBuilder();
for (int v : arr) {
sb.append(v).append(',');
}
return sb.toString();
}
private int sum(int[] arr) {
int s = 0;
for (int v : arr) {
s += v;
}
return s;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] cases = {11, 1, 2, 3, 4, 5, 8, 13, 20, 50, 100};
int[] expects = {5, 0, 1, 2, 2, 3, 4, 6, 7, 13, 18};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.minOperations(cases[i]);
int b = (cases[i] <= 20) ? sol.minOperationsBfs(cases[i]) : a;
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("k=" + cases[i] + " -> " + a + " / bfs=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍(小 k,BFS 仲裁)
Random rnd = new Random(3091);
int trials = 200;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int k = 1 + rnd.nextInt(13);
int a = sol.minOperations(k);
int b = sol.minOperationsBfs(k);
if (a != b) {
fail++;
if (fail <= 10) {
System.out.println("MISMATCH k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(k),空间复杂度 O(1)。
时间复杂度指数级,仅用于小规模交叉验证。
- 时间复杂度:O(k)
- 空间复杂度:O(1)
3092. Most Frequent IDs(最高频率的 ID)
题目描述
你需要在一个集合里动态记录 ID 的出现频率。给你两个长度都为 n 的整数数组 nums 和 freq,
nums 中每一个元素表示一个 ID,对应的 freq 中的元素表示这个 ID 在集合中此次操作后需要
增加或者减少的数目。
- 增加
ID的数目:如果freq[i]是正数,那么freq[i]个ID为nums[i]的元素在第i步
操作后会添加到集合中。 - 减少
ID的数目:如果freq[i]是负数,那么 -freq[i]个ID为nums[i]的元素在第i步
操作后会从集合中删除。
请你返回一个长度为n的数组ans,其中ans[i]表示第i步操作后出现频率最高的ID数目,
如果在某次操作后集合为空,那么ans[i]为 0。
示例 1
nums = [2,3,2,1], freq = [3,2,-3,1] -> [3,3,2,2]
示例 2
nums = [5,5,3], freq = [2,-2,1] -> [2,0,1]
提示:
1 <= nums.length == freq.length <= 10^51 <= nums[i] <= 10^5-10^5 <= freq[i] <= 10^5, freq[i] != 0- 输入保证任何操作后,集合中的元素出现次数不会为负数
解题思路
解法一:哈希表 + 懒删除堆,主提交版本
用 map 记录每个 ID 的当前频次。用一个最大堆存 (频次, ID),
每次更新后把新频次压堆。查询最大值时循环弹出堆顶,只要堆顶频次
与 map 中该 ID 的当前频次不一致就丢弃(懒删除),直到堆顶有效,
堆顶频次即当前最高频次;堆为空则答案为 0(集合为空)。
每个 (频次, ID) 对至多进出堆一次,总复杂度 O(n log n)。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:线性扫描(对照)
每次操作后线性遍历 map 找最大频次(仅小规模)。
时间复杂度 O(n^2),用于交叉验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.PriorityQueue;
import java.util.Random;
public class Solution {
// ---------- 解法一:哈希表 + 懒删除堆(主提交版本) ----------
public long[] mostFrequentIDs(int[] nums, int[] freq) {
int n = nums.length;
Map<Integer, Long> cnt = new HashMap<Integer, Long>();
// 大根堆:(频次, ID)
PriorityQueue<long[]> pq = new PriorityQueue<long[]>(
(a, b) -> Long.compare(b[0], a[0]));
long[] ans = new long[n];
for (int i = 0; i < n; ++i) {
long nv = cnt.getOrDefault(nums[i], 0L) + freq[i];
cnt.put(nums[i], nv);
pq.offer(new long[]{nv, nums[i]});
while (!pq.isEmpty()) {
long[] top = pq.peek();
int id = (int) top[1];
long f = cnt.getOrDefault(id, 0L);
if (top[0] != f) {
pq.poll();
} else {
ans[i] = top[0];
break;
}
}
// 堆空 => 集合为空
}
return ans;
}
// ---------- 解法二:线性扫描(对照) ----------
public long[] mostFrequentIDsBrute(int[] nums, int[] freq) {
int n = nums.length;
Map<Integer, Long> cnt = new HashMap<Integer, Long>();
long[] ans = new long[n];
for (int i = 0; i < n; ++i) {
long nv = cnt.getOrDefault(nums[i], 0L) + freq[i];
cnt.put(nums[i], nv);
long best = 0;
for (long v : cnt.values()) {
best = Math.max(best, v);
}
ans[i] = best;
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
// 官方案例
run(sol, new int[]{2, 3, 2, 1}, new int[]{3, 2, -3, 1}, new long[]{3, 3, 2, 2});
run(sol, new int[]{5, 5, 3}, new int[]{2, -2, 1}, new long[]{2, 0, 1});
boolean allPass = true;
// 随机对拍(小规模)
Random rnd = new Random(3092);
int trials = 1000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(8);
int[] nums = new int[n];
int[] freq = new int[n];
Map<Integer, Long> cur = new HashMap<Integer, Long>();
for (int i = 0; i < n; ++i) {
nums[i] = 1 + rnd.nextInt(3);
int d;
do {
d = (1 + rnd.nextInt(3)) * (rnd.nextBoolean() ? 1 : -1);
} while (cur.getOrDefault(nums[i], 0L) + d < 0);
cur.put(nums[i], cur.getOrDefault(nums[i], 0L) + d);
freq[i] = d;
}
long[] a = sol.mostFrequentIDs(nums, freq);
long[] b = sol.mostFrequentIDsBrute(nums, freq);
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH i=" + i + " a=" + a[i] + " b=" + b[i]);
}
break;
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
private static void run(Solution sol, int[] nums, int[] freq, long[] exp) {
long[] a = sol.mostFrequentIDs(nums, freq);
long[] b = sol.mostFrequentIDsBrute(nums, freq);
boolean ok = true;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < exp.length; ++i) {
if (i > 0) sb.append(',');
sb.append(a[i]);
if (a[i] != exp[i] || b[i] != exp[i]) ok = false;
}
System.out.println("-> [" + sb + "] expected=" + Arrays.toString(exp)
+ (ok ? " PASS" : " FAIL"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
时间复杂度 O(n^2),用于交叉验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3093. Longest Common Suffix Queries(最长公共后缀查询)
题目描述
给你两个字符串数组 wordsContainer 和 wordsQuery。
对于每个 wordsQuery[i],你需要从 wordsContainer 中找到一个与 wordsQuery[i]
有最长公共后缀的字符串。如果 wordsContainer 中有两个或者更多字符串有最长公共后缀,
那么答案为长度最短的。如果有超过两个字符串有相同最短长度,那么答案为它们在
wordsContainer 中出现更早的一个。
请你返回一个整数数组 ans,其中 ans[i] 是 wordsContainer 中与 wordsQuery[i]
有最长公共后缀字符串的下标。
示例 1
wordsContainer = ["abcd","bcd","xbcd"], wordsQuery = ["cd","bcd","xyz"] -> [1,1,1]
示例 2
wordsContainer = ["abcdefgh","poiuygh","ghghgh"], wordsQuery = ["gh","acbfgh","acbfegh"] -> [2,0,2]
提示:
1 <= wordsContainer.length, wordsQuery.length <= 10^41 <= wordsContainer[i].length <= 5*10^3wordsContainer[i].length与wordsQuery[i].length之和分别至多为 5*10^5- 只包含小写英文字母
解题思路
解法一:后缀 Trie + 节点最优下标,主提交版本
把每个 wordsContaineri 反转后插入一棵 Trie(变成前缀匹配问题)。
每个 Trie 节点维护 bestIdx:在以该节点为终点(即该后缀)的路径上,
所有已插入字符串中"后缀长度最长、长度相同取更短、再相同取下标更早"的
最优容器下标。由于同一容器字符串按整串插入,路径深度 = 后缀长度,
查询 wordsQueryi 时反转后沿 Trie 尽量深地走,最后可达节点的 bestIdx
就是答案;一步都走不了时用根节点的 bestIdx(空后缀,即全局最短最早)。
时间复杂度 O(总字符数 + 查询总字符数),空间复杂度 O(总字符数 * 26)。
解法二:逐字符串暴力比较(对照)
对每个查询,遍历所有容器字符串,从尾往前逐字符比较求公共后缀长度,
按"最长 -> 最短 -> 最早"规则更新答案。
时间复杂度 O(q * m * L),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O((sum|container| + sum|query|))
- 空间复杂度:O(sum|container| * 26)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:后缀 Trie(主提交版本) ----------
public int[] stringIndices(String[] wordsContainer, String[] wordsQuery) {
int m = wordsContainer.length;
int[] len = new int[m];
for (int i = 0; i < m; ++i) {
len[i] = wordsContainer[i].length();
}
// 动态 Trie:child.get(node) 为 26 个转移,-1 表示无
List<int[]> child = new ArrayList<int[]>();
List<int[]> best = new ArrayList<int[]>(); // best.get(node)[0] = 最优容器下标
child.add(new int[26]);
Arrays.fill(child.get(0), -1);
best.add(new int[]{-1});
// 插入所有容器字符串(反转)
for (int i = 0; i < m; ++i) {
String w = wordsContainer[i];
// 根节点(空后缀)维护全局"最短最早"
int rootBest = best.get(0)[0];
if (rootBest == -1 || betterIdx(i, rootBest, len)) {
best.get(0)[0] = i;
}
int node = 0;
for (int p = w.length() - 1; p >= 0; --p) {
int c = w.charAt(p) - 'a';
int[] ch = child.get(node);
if (ch[c] == -1) {
ch[c] = child.size();
child.add(new int[26]);
Arrays.fill(child.get(child.size() - 1), -1);
best.add(new int[]{i});
}
node = ch[c];
int curBest = best.get(node)[0];
if (curBest == -1 || betterIdx(i, curBest, len)) {
best.get(node)[0] = i;
}
}
}
// 查询
int[] ans = new int[wordsQuery.length];
for (int i = 0; i < wordsQuery.length; ++i) {
String q = wordsQuery[i];
int node = 0;
int res = best.get(0)[0]; // 空后缀兜底:全局最短最早
for (int p = q.length() - 1; p >= 0; --p) {
int c = q.charAt(p) - 'a';
int[] ch = child.get(node);
if (ch[c] == -1) {
break;
}
node = ch[c];
res = best.get(node)[0];
}
ans[i] = res;
}
return ans;
}
// a 是否严格优于 b:长度更短优先;长度相同取下标更小
private boolean betterIdx(int a, int b, int[] len) {
if (len[a] != len[b]) {
return len[a] < len[b];
}
return a < b;
}
// ---------- 解法二:暴力逐字符串比较(对照) ----------
public int[] stringIndicesBrute(String[] wordsContainer, String[] wordsQuery) {
int m = wordsContainer.length;
int[] ans = new int[wordsQuery.length];
for (int i = 0; i < wordsQuery.length; ++i) {
String q = wordsQuery[i];
int bestIdx = -1, bestL = -1;
for (int j = 0; j < m; ++j) {
String w = wordsContainer[j];
int l = 0;
int p = w.length() - 1, r = q.length() - 1;
while (p >= 0 && r >= 0 && w.charAt(p) == q.charAt(r)) {
l++;
p--;
r--;
}
if (l > bestL || (l == bestL && bestIdx >= 0
&& betterIdx(j, bestIdx, lenArr(wordsContainer)))) {
bestL = l;
bestIdx = j;
}
}
ans[i] = bestIdx;
}
return ans;
}
private int[] lenArr(String[] ws) {
int[] l = new int[ws.length];
for (int i = 0; i < ws.length; ++i) {
l[i] = ws[i].length();
}
return l;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
run(sol, new String[]{"abcd", "bcd", "xbcd"},
new String[]{"cd", "bcd", "xyz"}, new int[]{1, 1, 1});
run(sol, new String[]{"abcdefgh", "poiuygh", "ghghgh"},
new String[]{"gh", "acbfgh", "acbfegh"}, new int[]{2, 0, 2});
// 随机对拍(小规模)
Random rnd = new Random(3093);
int trials = 2000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int m = 1 + rnd.nextInt(4);
int n = 1 + rnd.nextInt(4);
String[] cw = new String[m];
String[] qw = new String[n];
for (int i = 0; i < m; ++i) {
cw[i] = randWord(rnd, 1 + rnd.nextInt(5));
}
for (int i = 0; i < n; ++i) {
qw[i] = randWord(rnd, 1 + rnd.nextInt(5));
}
int[] a = sol.stringIndices(cw, qw);
int[] b = sol.stringIndicesBrute(cw, qw);
for (int i = 0; i < n; ++i) {
if (a[i] != b[i]) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH q=" + qw[i] + " a=" + a[i]
+ " b=" + b[i] + " container=" + Arrays.toString(cw));
}
break;
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 ? " ALL PASS" : " CHECK FAILED"));
}
private static String randWord(Random rnd, int len) {
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; ++i) {
sb.append((char) ('a' + rnd.nextInt(3)));
}
return sb.toString();
}
private static void run(Solution sol, String[] cw, String[] qw, int[] exp) {
int[] a = sol.stringIndices(cw, qw);
int[] b = sol.stringIndicesBrute(cw, qw);
boolean ok = Arrays.equals(a, exp) && Arrays.equals(b, exp);
System.out.println("-> " + Arrays.toString(a) + " / brute=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(exp) + (ok ? " PASS" : " FAIL"));
if (!ok) {
for (int i = 0; i < a.length; ++i) {
if (a[i] != b[i] || a[i] != exp[i]) {
System.out.println(" q=" + qw[i] + " a=" + a[i] + " b=" + b[i]
+ " exp=" + exp[i]);
}
}
}
}
}
复杂度分析
时间复杂度 O(总字符数 + 查询总字符数),空间复杂度 O(总字符数 * 26)。
时间复杂度 O(q * m * L),仅用于小规模交叉验证。
- 时间复杂度:O((sum|container| + sum|query|))
- 空间复杂度:O(sum|container| * 26)
3094. Guess the Number Using Bitwise Questions II(使用按位查询猜测数字 II 🔒)
题目描述
你需要找到一个在 0 和 2^30 - 1(均包含)之间的数字 n。
有一个预定义的 API int commonBits(int num) 能帮助你完成任务。但挑战是每次你调用
这个函数,n 都会以某种方式改变。但是记住,你需要找到的是 n 的初始值。
commonBits(int num) 的操作如下:
- 计算
n和num的二进制表示中值相同的二进制位的位的数量count。 n = n XOR num- 返回
count。
返回数字n。
注意:在这个世界中,所有数字都在 0 和 2^30 - 1 之间(均包含),因此在计算公共
二进制位时,我们只看那些数字的前 30 个二进制位。
提示: 0 <= n <= 2^30 - 10 <= num <= 2^30 - 1- 如果你查询的
num超出了给定的范围,输出将会是不可靠的
解题思路
解法一:双查询基准比较,主提交版本
每次调用 commonBits(num) 后 n 都会被改成 n XOR num,因此不能像 I 那样单次
查询某一位。设当前隐藏值 n 的前 30 位中 1 的个数为 p(随查询推进而变化)。
- 调用 commonBits(0):n 与 0 逐位比较,相同位即 n 中为 0 的位,共 30 - p 个,
返回 c0 = 30 - p;由于 n XOR 0 = n,n 保持不变。 - 调用 commonBits(1 << i):只翻转第 i 位比较结果。
若 n 第 i 位为 1:n 与 (1<<i) 在该位相同(增加 1 个相同位),其余位中 n 为 0
的位仍相同,共 c1 = 31 - p 个;随后 n 的第 i 位被翻转为 0。
若 n 第 i 位为 0:该位不同(减少 1 个相同位),共 c1 = 29 - p 个;随后第 i 位
被翻转为 1。
因此 c1 > c0(即 c1 == c0 + 1)当且仅当 n 的第 i 位初始为 1。对 i = 0...29 逐一
查询并累加即可还原答案。共调用 60 次 API,时间复杂度 O(30),空间复杂度 O(1)。
解法二:差分判位(对照)
与解法一完全独立的写法:同样每轮先取基准 c0 = commonBits(0),再取
c1 = commonBits(1 << i),但用 c1 - c0 == 1 的正差分判定位 1,逻辑等价。
用于交叉验证。
复杂度: - 时间复杂度:O(30)(最多 60 次查询)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:双查询基准比较(主提交版本) ----------
public int findNumber() {
int ans = 0;
for (int i = 0; i < 30; ++i) {
int mask = 1 << i;
int c0 = commonBits(0); // 基准:n 不变,返回 30 - popcount
int c1 = commonBits(mask); // 比较第 i 位,随后 n ^= mask
if (c1 > c0) { // c1 == c0 + 1 => 第 i 位为 1
ans |= mask;
}
}
return ans;
}
// ---------- 解法二:差分判位(对照) ----------
public int findNumberAlt() {
int ans = 0;
for (int i = 0; i < 30; ++i) {
int mask = 1 << i;
int c0 = commonBits(0);
int c1 = commonBits(mask);
if (c1 - c0 == 1) {
ans |= mask;
}
}
return ans;
}
// ---------- 预定义 API(本地测试模拟) ----------
// 模拟隐藏值 n 的当前值;commonBits 先返回 30 位中与 num 相同的位数,再将 n 更新为 n XOR num
private static int hiddenN;
private int commonBits(int num) {
int same = 30 - Integer.bitCount(hiddenN ^ num);
hiddenN ^= num;
return same;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] cases = {0, 1, 2, 31, 33, 123456, 1000000000, 1 << 29,
0x3FFFFFFF, 0x2AAAAAAA, 0x15555555, 987654321};
boolean allPass = true;
for (int n : cases) {
hiddenN = n;
int a = sol.findNumber();
hiddenN = n;
int b = sol.findNumberAlt();
boolean ok = a == n && b == n;
allPass &= ok;
System.out.println("n=" + n + " -> " + a + " / alt=" + b
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍:随机 n,两种独立实现必须同时还原初始 n
Random rnd = new Random(3094);
int trials = 10000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = rnd.nextInt(1 << 30);
hiddenN = n;
int a = sol.findNumber();
if (a != n) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH n=" + n + " a=" + a);
}
}
hiddenN = n;
int b = sol.findNumberAlt();
if (b != n) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH-alt n=" + n + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
查询并累加即可还原答案。共调用 60 次 API,时间复杂度 O(30),空间复杂度 O(1)。
- 时间复杂度:O(30)(最多 60 次查询)
- 空间复杂度:O(1)
3095. Shortest Subarray With OR at Least K I(或值至少为 K 的最短子数组 I)
题目描述
给你一个非负整数数组 nums 和一个整数 k。
如果一个数组中所有元素的按位或运算 OR 的值至少为 k,那么我们称这个数组是特别的。
请你返回 nums 中最短特别非空子数组的长度,如果特别子数组不存在,那么返回 -1。
示例 1
nums = [1,2,3], k = 2 -> 1(子数组 [3] 的 OR 为 3)
示例 2
nums = [2,1,8], k = 10 -> 3(子数组 [2,1,8] 的 OR 为 11)
示例 3
nums = [1,2], k = 0 -> 1(子数组 [1] 的 OR 为 1)
提示:
1 <= nums.length <= 500 <= nums[i] <= 500 <= k < 64
解题思路
解法一:按位统计滑窗,主提交版本
维护窗口 l, r,用 32 位计数数组统计窗口内每个二进制位的出现次数,
窗口 OR 值 = 出现次数 > 0 的位之和。扩展 r 纳入 numsr,当窗口 OR >= k
时尝试收缩左边界 l(移除 numsl 时同步更新位计数),每次满足条件用
r - l + 1 刷新答案。O(n * 32) 求出最小长度,找不到则返回 -1。
时间复杂度 O(n * 32),空间复杂度 O(1)。
解法二:暴力枚举(对照)
枚举所有子数组 i, j 求 OR 并检查是否 >= k,取最短长度。
时间复杂度 O(n^3)(或 O(n^2 * 32)),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n * 32)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:按位统计滑窗(主提交版本) ----------
public int minimumSubarrayLength(int[] nums, int k) {
if (k == 0) {
return 1; // 任意单元素 OR >= 0
}
int n = nums.length;
int[] bits = new int[32];
int or = 0;
int l = 0;
int ans = Integer.MAX_VALUE;
for (int r = 0; r < n; ++r) {
or |= nums[r];
for (int b = 0; b < 32; ++b) {
if ((nums[r] >> b & 1) == 1) {
bits[b]++;
}
}
while (l <= r && or >= k) {
ans = Math.min(ans, r - l + 1);
// 移除 nums[l]
for (int b = 0; b < 32; ++b) {
if ((nums[l] >> b & 1) == 1) {
bits[b]--;
if (bits[b] == 0) {
or &= ~(1 << b);
}
}
}
l++;
}
}
return ans == Integer.MAX_VALUE ? -1 : ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
public int minimumSubarrayLengthBrute(int[] nums, int k) {
int n = nums.length;
int ans = Integer.MAX_VALUE;
for (int i = 0; i < n; ++i) {
int or = 0;
for (int j = i; j < n; ++j) {
or |= nums[j];
if (or >= k) {
ans = Math.min(ans, j - i + 1);
}
}
}
return ans == Integer.MAX_VALUE ? -1 : ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] n1 = {1, 2, 3};
int[] n2 = {2, 1, 8};
int[] n3 = {1, 2};
int[] n4 = {41, 22, 19, 25, 30, 1, 10, 30};
int[] e1 = {1, 3, 1, 2};
boolean allPass = true;
allPass &= run(sol, n1, 2, e1[0]);
allPass &= run(sol, n2, 10, e1[1]);
allPass &= run(sol, n3, 0, e1[2]);
allPass &= run(sol, n4, 55, e1[3]);
// 随机对拍(小规模)
Random rnd = new Random(3095);
int trials = 5000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(12);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = rnd.nextInt(64);
}
int k = rnd.nextInt(70);
int a = sol.minimumSubarrayLength(nums, k);
int b = sol.minimumSubarrayLengthBrute(nums, k);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH k=" + k + " nums=" + java.util.Arrays.toString(nums)
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
private static boolean run(Solution sol, int[] nums, int k, int exp) {
int a = sol.minimumSubarrayLength(nums, k);
int b = sol.minimumSubarrayLengthBrute(nums, k);
boolean ok = a == exp && b == exp;
System.out.println("k=" + k + " -> " + a + " / brute=" + b
+ " expected=" + exp + (ok ? " PASS" : " FAIL"));
return ok;
}
}
复杂度分析
时间复杂度 O(n * 32),空间复杂度 O(1)。
时间复杂度 O(n^3)(或 O(n^2 * 32)),仅用于小规模交叉验证。
- 时间复杂度:O(n * 32)
- 空间复杂度:O(1)
3096. Minimum Levels to Gain More Points(得到更多分数的最少关卡数目)
题目描述
给你一个长度为 n 的二进制数组 possible。
Alice 和 Bob 正在玩一个有 n 个关卡的游戏,游戏中有一些关卡是困难模式,其他的关卡
是简单模式。如果 possible[i] == 0,那么第 i 个关卡是困难模式,两个玩家都不可能通过。
一个玩家通过一个简单模式的关卡可以获得 1 分,遇到困难模式的关卡将失去 1 分。
游戏的一开始,Alice 将从第 0 级开始按顺序完成一些关卡,然后 Bob 会完成剩下的所有关卡。
假设两名玩家都采取最优策略,目的是最大化自己的得分,Alice 想知道自己最少需要完成多少个
关卡,才能获得比 Bob 更多的分数。
请你返回 Alice 获得比 Bob 更多的分数所需要完成的最少关卡数目,如果无法达成,那么返回 -1。
注意:每个玩家都至少需要完成 1 个关卡。
示例 1
possible = [1,0,1,0] -> 1(Alice 完成关卡 0 得 1 分,Bob 得 -1 分)
示例 2
possible = [1,1,1,1,1] -> 3
示例 3
possible = [0,0] -> -1
提示:
2 <= n == possible.length <= 10^5possible[i]要么是 0 要么是 1
解题思路
解法一:前缀和枚举切分点,主提交版本
每关分值 scorei = possiblei == 1 ? 1 : -1。Alice 完成前 i 关
(i >= 1)得 prei,Bob 完成后 n - i 关得 total - prei。
Alice 获胜条件为 prei > total - prei,即 2*prei > total。
还需满足 i <= n - 1(Bob 至少完成 1 关)。从小到大枚举 i 找第一个
满足条件的即为最少关卡数。O(n) 一次扫描即可,无需显式前缀和数组。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:显式前缀和(对照)
先构建前缀和数组再枚举切分点,逻辑同上,用于交叉验证。
时间复杂度 O(n),空间复杂度 O(n)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:一次扫描(主提交版本) ----------
public int minimumLevels(int[] possible) {
int n = possible.length;
int total = 0;
for (int v : possible) {
total += (v == 1 ? 1 : -1);
}
int pre = 0;
for (int i = 0; i < n - 1; ++i) {
pre += (possible[i] == 1 ? 1 : -1);
if (2 * pre > total) {
return i + 1;
}
}
return -1;
}
// ---------- 解法二:显式前缀和(对照) ----------
public int minimumLevelsPre(int[] possible) {
int n = possible.length;
int[] pre = new int[n + 1];
for (int i = 0; i < n; ++i) {
pre[i + 1] = pre[i] + (possible[i] == 1 ? 1 : -1);
}
int total = pre[n];
for (int i = 1; i < n; ++i) {
if (2 * pre[i] > total) {
return i;
}
}
return -1;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] p1 = {1, 0, 1, 0};
int[] p2 = {1, 1, 1, 1, 1};
int[] p3 = {0, 0};
int[] p4 = {1, 0};
int[] p5 = {0, 1, 0, 1, 1};
int[] e = {1, 3, -1, 1, -1};
boolean allPass = true;
allPass &= run(sol, p1, e[0]);
allPass &= run(sol, p2, e[1]);
allPass &= run(sol, p3, e[2]);
allPass &= run(sol, p4, e[3]);
allPass &= run(sol, p5, e[4]);
// 随机对拍
Random rnd = new Random(3096);
int trials = 10000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 2 + rnd.nextInt(15);
int[] p = new int[n];
for (int i = 0; i < n; ++i) {
p[i] = rnd.nextInt(2);
}
int a = sol.minimumLevels(p);
int b = sol.minimumLevelsPre(p);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH p=" + java.util.Arrays.toString(p)
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
private static boolean run(Solution sol, int[] p, int exp) {
int a = sol.minimumLevels(p);
int b = sol.minimumLevelsPre(p);
boolean ok = a == exp && b == exp;
System.out.println("-> " + a + " / pre=" + b + " expected=" + exp
+ (ok ? " PASS" : " FAIL"));
return ok;
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3097. Shortest Subarray With OR at Least K II(或值至少为 K 的最短子数组 II)
题目描述
给你一个非负整数数组 nums 和一个整数 k。
如果一个数组中所有元素的按位或运算 OR 的值至少为 k,那么我们称这个数组是特别的。
请你返回 nums 中最短特别非空子数组的长度,如果特别子数组不存在,那么返回 -1。
示例 1
nums = [1,2,3], k = 2 -> 1(子数组 [3] 的 OR 为 3)
示例 2
nums = [2,1,8], k = 10 -> 3(子数组 [2,1,8] 的 OR 为 11)
示例 3
nums = [1,2], k = 0 -> 1
提示:
1 <= nums.length <= 2 * 10^50 <= nums[i] <= 10^90 <= k <= 10^9
解题思路
解法一:按位统计滑窗,主提交版本
与 I 相同思路,窗口 l, r 只增不减:扩展 r 后窗口 OR 一定包含 numsr,
若窗口 OR 满足 >= k,则固定 r,不断收缩 l 直到 OR 不再 >= k,期间记录
最短长度。窗口 OR 用 32 位计数数组维护(某位计数 > 0 则该位为 1)。
数组元素可达 10^9(约 30 位),k 可达 10^9,异或用 long 计算窗口 OR 更稳,
但 32 位内 int 足够,这里用 int 累积位权。找不到则返回 -1。
时间复杂度 O(n * 30),空间复杂度 O(1)。
解法二:暴力枚举(对照)
枚举所有子数组求 OR 并更新最短长度,仅用于小规模交叉验证。
时间复杂度 O(n^2),空间复杂度 O(1)。
复杂度:
- 时间复杂度:O(n * 30)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:位计数滑窗(主提交版本) ----------
public int minimumSubarrayLength(int[] nums, int k) {
int n = nums.length;
int[] bits = new int[32];
int l = 0, or = 0;
int ans = Integer.MAX_VALUE;
for (int r = 0; r < n; ++r) {
or |= nums[r];
add(bits, nums[r], 1);
while (l <= r && or >= k) {
ans = Math.min(ans, r - l + 1);
add(bits, nums[l], -1);
or = calcOr(bits);
++l;
}
}
return ans == Integer.MAX_VALUE ? -1 : ans;
}
private void add(int[] bits, int x, int d) {
for (int b = 0; b < 31; ++b) {
if ((x >> b & 1) == 1) {
bits[b] += d;
}
}
}
private int calcOr(int[] bits) {
int or = 0;
for (int b = 0; b < 31; ++b) {
if (bits[b] > 0) {
or |= (1 << b);
}
}
return or;
}
// ---------- 解法二:暴力枚举(对照) ----------
public int minimumSubarrayLengthBrute(int[] nums, int k) {
int n = nums.length;
int ans = Integer.MAX_VALUE;
for (int i = 0; i < n; ++i) {
int or = 0;
for (int j = i; j < n; ++j) {
or |= nums[j];
if (or >= k) {
ans = Math.min(ans, j - i + 1);
}
}
}
return ans == Integer.MAX_VALUE ? -1 : ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] n1 = {1, 2, 3};
int[] n2 = {2, 1, 8};
int[] n3 = {1, 2};
int[] n4 = {8, 3, 10, 3};
boolean allPass = true;
allPass &= run(sol, n1, 2, 1);
allPass &= run(sol, n2, 10, 3);
allPass &= run(sol, n3, 0, 1);
allPass &= run(sol, n4, 14, -1);
// 随机对拍(小规模)
Random rnd = new Random(3097);
int trials = 3000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(12);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = rnd.nextInt(200);
}
int k = rnd.nextInt(260);
int a = sol.minimumSubarrayLength(nums, k);
int b = sol.minimumSubarrayLengthBrute(nums, k);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH k=" + k + " nums="
+ java.util.Arrays.toString(nums) + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
private static boolean run(Solution sol, int[] nums, int k, int exp) {
int a = sol.minimumSubarrayLength(nums, k);
int b = sol.minimumSubarrayLengthBrute(nums, k);
boolean ok = a == exp && b == exp;
System.out.println("k=" + k + " -> " + a + " / brute=" + b
+ " expected=" + exp + (ok ? " PASS" : " FAIL"));
return ok;
}
}
复杂度分析
时间复杂度 O(n * 30),空间复杂度 O(1)。
时间复杂度 O(n^2),空间复杂度 O(1)。
- 时间复杂度:O(n * 30)
- 空间复杂度:O(1)
3098. Find the Sum of Subsequence Powers(求出所有子序列的能量和)
题目描述
给你一个长度为 n 的整数数组 nums 和一个正整数 k。
一个子序列的能量定义为子序列中任意两个元素的差值绝对值的最小值。
请你返回 nums 中长度等于 k 的所有子序列的能量和。
由于答案可能会很大,将答案对 10^9 + 7 取余后返回。
示例 1
nums = [1,2,3,4], k = 3 -> 4
示例 2
nums = [2,2], k = 2 -> 0
示例 3
nums = [4,3,-1], k = 2 -> 10
提示:
2 <= n == nums.length <= 50-10^8 <= nums[i] <= 10^82 <= k <= n
解题思路
解法一:排序 + 最小差枚举计数,主提交版本
- 先排序。任意子序列的能量只与相邻元素的最小差值有关:按排序后的
相对顺序选子序列,相邻元素差的最小值即为能量。 - 固定阈值 d:能量恰好等于 d 的子序列 =(能量 >= d 的子序列)-
(能量 >= d+1 的子序列)。于是问题转化为"有多少长度为 k 的严格递增
子序列满足相邻差 >= limit"。 - 计数 DP:dpic 表示以 numsi 结尾、长度 c 且相邻差 >= limit 的
子序列数。dpi1 = 1;dpic = sum dpjc-1(j < i 且
numsi - numsj >= limit)。总合法子序列数 = sum dpik。 - 对 d 从 0 到 maxDiff 枚举,ans += d * (f(d) - f(d+1)),其中
f(limit) 为"相邻差 >= limit"的长度 k 子序列数。
时间复杂度 O(D * k * n^2),D 为不同差值上限;空间复杂度 O(k * n)。
(n <= 50,可直接枚举所有可能差值,可行。)
解法二:组合爆搜(对照)
枚举所有 C(n, k) 个子序列求能量和,仅用于小规模交叉验证。
时间复杂度 O(C(n,k) * k)(k 小时可行)。
复杂度:
- 时间复杂度:O(D * k * n^2),D 为不同差值种数(<= C(n,2))
- 空间复杂度:O(k * n)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class Solution {
private static final long MOD = 1000000007L;
// ---------- 解法一:排序 + 最小差枚举计数(主提交版本) ----------
public int sumOfPowers(int[] nums, int k) {
int n = nums.length;
Arrays.sort(nums);
// 收集所有可能的相邻差值(排序后子序列能量必然落在这些值上)
List<Integer> diffs = new ArrayList<Integer>();
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
diffs.add(nums[j] - nums[i]);
}
}
Collections.sort(diffs);
// 去重
List<Integer> uniq = new ArrayList<Integer>();
for (int d : diffs) {
if (uniq.isEmpty() || uniq.get(uniq.size() - 1) != d) {
uniq.add(d);
}
}
long ans = 0;
for (int d : uniq) {
long cur = countAtLeast(nums, k, d); // 能量 >= d
long curNext = countAtLeast(nums, k, d + 1); // 能量 >= d+1(真实阈值)
long exact = ((cur - curNext) % MOD + MOD) % MOD;
ans = (ans + (long) d % MOD * exact) % MOD;
}
return (int) ans;
}
// 统计相邻差 >= limit 的长度为 k 的严格递增子序列数量
private long countAtLeast(int[] nums, int k, int limit) {
int n = nums.length;
// dp[c] 数组,dp[c][i]:以 i 结尾长度为 c 的子序列数
long[][] dp = new long[k + 1][n];
for (int i = 0; i < n; ++i) {
dp[1][i] = 1;
}
for (int c = 2; c <= k; ++c) {
for (int i = 0; i < n; ++i) {
long s = 0;
for (int j = 0; j < i; ++j) {
if (nums[i] - nums[j] >= limit) {
s += dp[c - 1][j];
}
}
dp[c][i] = s % MOD;
}
}
long total = 0;
for (int i = 0; i < n; ++i) {
total += dp[k][i];
}
return total % MOD;
}
// ---------- 解法二:组合枚举(对照) ----------
public int sumOfPowersBrute(int[] nums, int k) {
int n = nums.length;
long[] ans = new long[1];
dfs(nums, k, 0, 0, Integer.MAX_VALUE, ans, 0);
return (int) (ans[0] % MOD);
}
// 递归选子序列,current 为已选元素数组下标(用 list 记录),minDiff 为当前能量
private void dfs(int[] nums, int k, int start, int count,
int minDiff, long[] ans, int lastIdx) {
if (count + (nums.length - start) < k) return;
if (count == k) {
ans[0] = (ans[0] + minDiff) % MOD;
return;
}
for (int i = start; i < nums.length; ++i) {
int md = minDiff;
if (count > 0) {
md = Math.min(md, Math.abs(nums[i] - nums[lastIdx]));
}
dfs(nums, k, i + 1, count + 1, md, ans, i);
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] n1 = {1, 2, 3, 4};
int[] n2 = {2, 2};
int[] n3 = {4, 3, -1};
int[] n4 = {1, 3, 5, 10};
boolean allPass = true;
allPass &= run(sol, n1, 3, 4);
allPass &= run(sol, n2, 2, 0);
allPass &= run(sol, n3, 2, 10);
allPass &= run(sol, n4, 3, 10); // [1,3,5]=2, [1,3,10]=2, [1,5,10]=4, [3,5,10]=2 => 10
// 计算真实期望
int real4 = sol.sumOfPowersBrute(n4, 3);
System.out.println("check n4 real=" + real4);
// 随机对拍(小规模)
Random rnd = new Random(3098);
int trials = 300;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 2 + rnd.nextInt(7); // 2..8
int k = 2 + rnd.nextInt(n - 1); // 2..n
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = rnd.nextInt(13) - 6; // -6..6
}
int a = sol.sumOfPowers(nums, k);
int b = sol.sumOfPowersBrute(nums, k);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 ? " (n4 real=" + real4 + ") ALL PASS" : " CHECK FAILED"));
}
private static boolean run(Solution sol, int[] nums, int k, int exp) {
int a = sol.sumOfPowers(nums, k);
int b = sol.sumOfPowersBrute(nums, k);
boolean ok = a == exp && b == exp;
System.out.println("k=" + k + " nums=" + Arrays.toString(nums) + " -> " + a
+ " / brute=" + b + " expected=" + exp + (ok ? " PASS" : " FAIL"));
return ok;
}
}
复杂度分析
时间复杂度 O(D * k * n^2),D 为不同差值上限;空间复杂度 O(k * n)。
时间复杂度 O(C(n,k) * k)(k 小时可行)。
- 时间复杂度:O(D * k * n^2),D 为不同差值种数(<= C(n,2))
- 空间复杂度:O(k * n)
3099. Harshad Number(哈沙德数)
题目描述
如果一个整数能够被其各个数位上的数字之和整除,则称之为哈沙德数(Harshad number)。
给你一个整数 x。如果 x 是哈沙德数,则返回 x 各个数位上的数字之和,否则,返回 -1。
示例 1
x = 18 -> 9(18 能被 9 整除)
示例 2
x = 23 -> -1(23 不能被 5 整除)
提示:
1 <= x <= 100
解题思路
解法一:逐位求和处理,主提交版本
用 while 循环对 x 不断取余、整除拆出每一位累加为 digitSum,
若 x % digitSum == 0 则返回 digitSum,否则返回 -1。
时间复杂度 O(log x),空间复杂度 O(1)。
解法二:字符串数位和(对照)
把 x 转成字符串逐字符累加数位和,同一判定。
时间复杂度 O(log x),空间复杂度 O(log x),用于交叉验证。
复杂度:
- 时间复杂度:O(log x)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:逐位求和处理(主提交版本) ----------
public int sumOfTheDigitsOfHarshadNumber(int x) {
int sum = 0, t = x;
while (t > 0) {
sum += t % 10;
t /= 10;
}
return x % sum == 0 ? sum : -1;
}
// ---------- 解法二:字符串数位和(对照) ----------
public int sumOfTheDigitsOfHarshadNumberStr(int x) {
String s = String.valueOf(x);
int sum = 0;
for (int i = 0; i < s.length(); ++i) {
sum += s.charAt(i) - '0';
}
return x % sum == 0 ? sum : -1;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] cases = {18, 23, 1, 9, 10, 21, 100};
int[] expects = {9, -1, 1, 9, 1, 3, 1};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.sumOfTheDigitsOfHarshadNumber(cases[i]);
int b = sol.sumOfTheDigitsOfHarshadNumberStr(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("x=" + cases[i] + " -> " + a + " / str=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 全覆盖 1..100 与字符串解对拍
Random rnd = new Random(3099);
int fail = 0;
for (int t = 0; t < 10000; ++t) {
int x = 1 + rnd.nextInt(10000);
int a = sol.sumOfTheDigitsOfHarshadNumber(x);
int b = sol.sumOfTheDigitsOfHarshadNumberStr(x);
if (a != b) {
fail++;
}
}
// 再校验已知哈沙德数(1..100 内共 33 个:1-9,10,12,18,20,21,24,27,30,36,40,42,45,48,50,54,60,63,70,72,80,81,84,90,100)
int harshadCount = 0;
for (int x = 1; x <= 100; ++x) {
if (sol.sumOfTheDigitsOfHarshadNumber(x) != -1) {
harshadCount++;
}
}
System.out.println("Random trials=10000 fail=" + fail
+ " | 1..100 Harshad count=" + harshadCount
+ (fail == 0 && allPass && harshadCount == 33 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(log x),空间复杂度 O(1)。
时间复杂度 O(log x),空间复杂度 O(log x),用于交叉验证。
- 时间复杂度:O(log x)
- 空间复杂度:O(1)
3100. Water Bottles II(换水问题 II)
题目描述
给你两个整数 numBottles 和 numExchange。
numBottles 代表你最初拥有的满水瓶数量。在一次操作中,你可以执行以下操作之一:
- 喝掉任意数量的满水瓶,使它们变成空水瓶。
- 用
numExchange个空水瓶交换一个满水瓶。然后,将numExchange的值增加 1。
注意,你不能使用相同的numExchange值交换多批空水瓶。
返回你最多可以喝到多少瓶水。
示例 1
numBottles = 13, numExchange = 6 -> 15
示例 2
numBottles = 10, numExchange = 3 -> 13
提示:
1 <= numBottles <= 1001 <= numExchange <= 100
解题思路
解法一:直接模拟,主提交版本
维护 full(满水瓶数)、empty(空水瓶数)、total(累计喝掉)。循环:
- 喝掉全部满水瓶:total += full,empty += full,full = 0;
- 若 empty >= numExchange:用 numExchange 个空瓶换 1 瓶满水,
empty -= numExchange,full++,numExchange++; - 重复直到既没有满水瓶、也不能再交换。
注意步骤 1 之前若空瓶足够且没满瓶,会停在交换处;正确处理循环次序即可。
每次循环至少消耗 1 个 numExchange 或 1 瓶水,numExchange 单调增加,
循环次数 <= numBottles/1 + 交换次数 <= 有限小,可视为 O(numBottles + numExchange)。
空间复杂度 O(1)。
解法二:逐步喝一瓶(对照)
每次只喝 1 瓶水:total+1、empty+1,若 empty == numExchange 则立即交换
并 numExchange++。逻辑等价,逐步推进,用于交叉验证。
时间复杂度 O(total),空间复杂度 O(1)。
复杂度:
- 时间复杂度:O(numBottles + numExchange)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:批量模拟(主提交版本) ----------
public int maxBottlesDrunk(int numBottles, int numExchange) {
int full = numBottles;
int empty = 0;
int total = 0;
while (full > 0 || empty >= numExchange) {
// 喝掉所有满瓶
total += full;
empty += full;
full = 0;
// 能交换就一直换(numExchange 每次 +1)
while (empty >= numExchange) {
empty -= numExchange;
full++;
numExchange++;
}
}
return total;
}
// ---------- 解法二:逐瓶模拟(对照) ----------
public int maxBottlesDrunkStep(int numBottles, int numExchange) {
int full = numBottles;
int empty = 0;
int total = 0;
while (full > 0 || empty >= numExchange) {
if (full > 0) {
full--;
total++;
empty++;
} else {
// empty >= numExchange
empty -= numExchange;
numExchange++;
full++;
}
}
return total;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] nb = {13, 10, 1, 15, 3, 7, 100, 33};
int[] ne = {6, 3, 1, 8, 4, 4, 3, 10};
int[] expects = {15, 13, 2, 16, 3, 8, 112, 36};
boolean allPass = true;
for (int i = 0; i < nb.length; ++i) {
int a = sol.maxBottlesDrunk(nb[i], ne[i]);
int b = sol.maxBottlesDrunkStep(nb[i], ne[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("numBottles=" + nb[i] + " numExchange=" + ne[i]
+ " -> " + a + " / step=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 全覆盖对拍:numBottles 1..100, numExchange 1..100
int fail = 0;
for (int b = 1; b <= 100; ++b) {
for (int e = 1; e <= 100; ++e) {
int a = sol.maxBottlesDrunk(b, e);
int s = sol.maxBottlesDrunkStep(b, e);
if (a != s) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH b=" + b + " e=" + e + " a=" + a + " s=" + s);
}
}
}
}
System.out.println("Full-sweep 100x100 fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
空间复杂度 O(1)。
时间复杂度 O(total),空间复杂度 O(1)。
- 时间复杂度:O(numBottles + numExchange)
- 空间复杂度:O(1)