LeetCode 3001-3020. 题解合集
文章目录
- [LeetCode 3001-3020. 题解合集](#LeetCode 3001-3020. 题解合集)
-
- [3001. Minimum Moves to Capture The Queen(捕获黑皇后需要的最少移动次数)](#3001. Minimum Moves to Capture The Queen(捕获黑皇后需要的最少移动次数))
- [3002. Maximum Size of a Set After Removals(移除后集合的最多元素数)](#3002. Maximum Size of a Set After Removals(移除后集合的最多元素数))
- [3003. Maximize the Number of Partitions After Operations(执行操作后的最大分割数量)](#3003. Maximize the Number of Partitions After Operations(执行操作后的最大分割数量))
- [3004. Maximum Subtree of the Same Color(相同颜色的最大子树)](#3004. Maximum Subtree of the Same Color(相同颜色的最大子树))
- [3005. Count Elements With Maximum Frequency(最大频率元素计数)](#3005. Count Elements With Maximum Frequency(最大频率元素计数))
- [3006. Find Beautiful Indices in the Given Array I(找出数组中的美丽下标 I)](#3006. Find Beautiful Indices in the Given Array I(找出数组中的美丽下标 I))
- [3007. Maximum Number That Sum of the Prices Is Less Than or Equal to K(价值和小于等于 K 的最大数字)](#3007. Maximum Number That Sum of the Prices Is Less Than or Equal to K(价值和小于等于 K 的最大数字))
- [3008. Find Beautiful Indices in the Given Array II(找出数组中的美丽下标 II)](#3008. Find Beautiful Indices in the Given Array II(找出数组中的美丽下标 II))
- [3009. Maximum Number of Intersections on the Chart(折线图上的最大交点数量)](#3009. Maximum Number of Intersections on the Chart(折线图上的最大交点数量))
- [3010. Divide an Array Into Subarrays With Minimum Cost I(将数组分成最小总代价的子数组 I)](#3010. Divide an Array Into Subarrays With Minimum Cost I(将数组分成最小总代价的子数组 I))
- [3011. Find if Array Can Be Sorted(判断一个数组是否可以变为有序)](#3011. Find if Array Can Be Sorted(判断一个数组是否可以变为有序))
- [3012. Minimize Length of Array Using Operations(通过操作使数组长度最小)](#3012. Minimize Length of Array Using Operations(通过操作使数组长度最小))
- [3013. Divide an Array Into Subarrays With Minimum Cost II(将数组分成最小总代价的子数组 II)](#3013. Divide an Array Into Subarrays With Minimum Cost II(将数组分成最小总代价的子数组 II))
- [3014. Minimum Number of Pushes to Type Word I(输入单词需要的最少按键次数 I)](#3014. Minimum Number of Pushes to Type Word I(输入单词需要的最少按键次数 I))
- [3015. Count the Number of Houses at a Certain Distance I(按距离统计房屋对数目 I)](#3015. Count the Number of Houses at a Certain Distance I(按距离统计房屋对数目 I))
- [3016. Minimum Number of Pushes to Type Word II(输入单词需要的最少按键次数 II)](#3016. Minimum Number of Pushes to Type Word II(输入单词需要的最少按键次数 II))
- [3017. Count the Number of Houses at a Certain Distance II(按距离统计房屋对数目 II)](#3017. Count the Number of Houses at a Certain Distance II(按距离统计房屋对数目 II))
- [3018. Maximum Number of Removal Queries That Can Be Processed I(可处理的最大删除操作数 I 🔒)](#3018. Maximum Number of Removal Queries That Can Be Processed I(可处理的最大删除操作数 I 🔒))
- [3019. Number of Changing Keys(按键变更的次数)](#3019. Number of Changing Keys(按键变更的次数))
- [3020. Find the Maximum Number of Elements in Subset(子集中元素的最大数量)](#3020. Find the Maximum Number of Elements in Subset(子集中元素的最大数量))
3001. Minimum Moves to Capture The Queen(捕获黑皇后需要的最少移动次数)
题目描述
现有一个下标从 1 开始的 8 x 8 棋盘,上面有 3 枚棋子。
给你 6 个整数 a、b、c、d、e、f,其中 (a, b) 表示白色车的位置,(c, d) 表示白色象的位置,(e, f) 表示黑皇后的位置。
假定你只能移动白色棋子,返回捕获黑皇后所需的最少移动次数。
车可以向垂直或水平方向移动任意数量的格子,但不能跳过其他棋子;
象可以沿对角线方向移动任意数量的格子,但不能跳过其他棋子;
如果车或象能移向皇后所在的格子,则认为它们可以捕获皇后;皇后不能移动。
示例 1
a=1,b=1,c=8,d=8,e=2,f=3 -> 2(车先移动到 (1,3) 再移动到 (2,3))
示例 2
a=5,b=3,c=3,d=4,e=5,f=2 -> 1(车或象移动 1 次即可)
提示:
1 <= a, b, c, d, e, f <= 8- 两枚棋子不会同时出现在同一个格子上。
解题思路
解法一:几何判断,主提交版本
最少移动次数只可能是 1 或 2:任何情况下 2 步内必能捕获(先把车挪到与皇后同行/同列的位置)。
只需判断 1 步是否能捕获:
- 车与皇后同行(a == e):中间没有其他棋子阻挡(象不在 (a, b) 与 (e, f) 之间),1 步捕获;
- 车与皇后同列(b == f):类似判断;
- 象与皇后在同一对角线上(|c-e| == |d-f|):中间没有其他棋子阻挡(车不在两者之间),1 步捕获。
否则返回 2。
时间复杂度 O(1),空间复杂度 O(1)。
解法二:BFS 暴力,对照
以皇后位置为观察点,直接枚举车/象在 1 步内可达的位置,若任一可达皇后所在格(中途无阻挡)则 1 步;
否则必为 2 步。由于 2 步一定可行(车先平移不与象冲突的位置),BFS 最多只会走到 2 层。
复杂度:
- 时间复杂度:O(1)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:几何判断(主提交版本) ----------
public int minMovesToCaptureTheQueen(int a, int b, int c, int d, int e, int f) {
// 车与皇后同行:象不能在中间(c == a && d 在 b 与 f 之间)
if (a == e) {
if (!(c == a && between(d, b, f))) {
return 1;
}
}
// 车与皇后同列
if (b == f) {
if (!(d == b && between(c, a, e))) {
return 1;
}
}
// 象与皇后同一条对角线:车不能在中间(沿对角线方向判断)
if (Math.abs(c - e) == Math.abs(d - f)) {
if (!(Math.abs(a - e) == Math.abs(b - f) && betweenOnDiag(c, d, a, b, e, f))) {
return 1;
}
}
return 2;
}
private boolean between(int x, int lo, int hi) {
return x > Math.min(lo, hi) && x < Math.max(lo, hi);
}
// 车 (a,b) 是否在象 (c,d) 与皇后 (e,f) 之间的对角线上
private boolean betweenOnDiag(int c, int d, int a, int b, int e, int f) {
if (!(Math.abs(a - e) == Math.abs(b - f))) {
return false;
}
int dx = a - c, dy = b - d;
return dx * (e - c) > 0 && Math.abs(dx) < Math.abs(e - c) && dx * dy > 0;
}
// ---------- 解法二:BFS 可达性枚举(对照) ----------
public int minMovesToCaptureTheQueenBrute(int a, int b, int c, int d, int e, int f) {
// 车两步转移路径:先沿某方向走一格(避开象的位置),再看是否 1 步可达即返回
// 等价判断:枚举车与象各自 1 步可达位置,命中皇后即可
if (rookOneStep(a, b, c, d, e, f) || bishopOneStep(a, b, c, d, e, f)) {
return 1;
}
return 2;
}
// 车 1 步内能否吃到皇后(保持 a==e 或 b==f 且中间无象)
private boolean rookOneStep(int a, int b, int c, int d, int e, int f) {
if (a == e && b != f) {
// 中间格必须无象
return !(c == a && d > Math.min(b, f) && d < Math.max(b, f));
}
if (b == f && a != e) {
return !(d == b && c > Math.min(a, e) && c < Math.max(a, e));
}
return false;
}
// 象 1 步内能否吃到皇后(同一对角线且中间无车)
private boolean bishopOneStep(int a, int b, int c, int d, int e, int f) {
if (Math.abs(c - e) != Math.abs(d - f)) {
return false;
}
// 车是否在象到皇后的对角线上
if (Math.abs(a - e) == Math.abs(b - f)) {
int dx = a - c, dy = b - d;
if (dx == 0 && dy == 0) {
return false; // 象的位置就是车
}
// 车在两者之间则阻挡
if (Math.abs(a - e) < Math.abs(c - e) && (a - c) * (e - c) > 0) {
return false;
}
}
return true;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minMovesToCaptureTheQueen(1, 1, 8, 8, 2, 3) == 2, "3001 例1");
check(s.minMovesToCaptureTheQueen(5, 3, 3, 4, 5, 2) == 1, "3001 例2");
check(s.minMovesToCaptureTheQueen(1, 1, 8, 8, 1, 8) == 1, "3001 车同列");
check(s.minMovesToCaptureTheQueen(1, 1, 1, 3, 1, 8) == 2, "3001 象阻挡");
check(s.minMovesToCaptureTheQueen(4, 4, 2, 2, 3, 3) == 1, "3001 象路径被车挡需2步? 验证");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 200; t++) {
int[] p = new int[6];
for (int i = 0; i < 6; i++) {
p[i] = 1 + rnd.nextInt(8);
}
// 去掉重合的棋子(简化:不构造三子重合)
if (allDistinct(p)) {
int m1 = s.minMovesToCaptureTheQueen(p[0], p[1], p[2], p[3], p[4], p[5]);
int m2 = s.minMovesToCaptureTheQueenBrute(p[0], p[1], p[2], p[3], p[4], p[5]);
if (m1 != m2 || m1 < 1 || m1 > 2) {
allOk = false;
System.out.println("对拍失败 (" + p[0] + "," + p[1] + "," + p[2] + "," + p[3] + "," + p[4] + "," + p[5] + ") 主=" + m1 + " 对照=" + m2);
break;
}
}
}
check(allOk, "3001 随机对拍");
System.out.println("3001 all tests done");
}
private static boolean allDistinct(int[] p) {
for (int i = 0; i < 6; i += 2) {
for (int j = i + 2; j < 6; j += 2) {
if (p[i] == p[j] && p[i + 1] == p[j + 1]) {
return false;
}
}
}
return true;
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(1),空间复杂度 O(1)。
- 时间复杂度:O(1)
- 空间复杂度:O(1)
3002. Maximum Size of a Set After Removals(移除后集合的最多元素数)
题目描述
给你两个下标从 0 开始的整数数组 nums1 和 nums2,它们的长度都是偶数 n。
你必须从 nums1 中移除 n/2 个元素,同时从 nums2 中也移除 n/2 个元素。
移除之后,你将 nums1 和 nums2 中剩下的元素插入到集合 s 中。
返回集合 s 可能的最多包含多少元素。
示例 1
nums1 = [1,2,1,2], nums2 = [1,1,1,1] -> 2
示例 2
nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3] -> 5
示例 3
nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6] -> 6
提示:
n == nums1.length == nums2.length- 1 <=
n<= 2 * 10^4,n是偶数 1 <= nums1[i], nums2[i] <= 10^9
解题思路
解法一:按重叠分组计数,主提交版本
设每个数组保留 n/2 个。理想情况是两个数组各贡献自己独有的那部分元素。
记 only1 = nums1 独有元素数(不在 nums2 中),only2 = nums2 独有元素数,common = 两数组共有元素数。
答案 = min(only1, n/2) + min(only2, n/2) + common 中还能补上的部分。
更稳健的模型:把元素分成「仅 1」「仅 2」「共有」三类:
- 仅 1 的元素最多能贡献 min(only1, n/2) 个;
- 仅 2 的元素最多能贡献 min(only2, n/2) 个;
- 共有的元素每个最多贡献 1 个,把前两类没填满的槽位(n/2 - 已用)填上。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:枚举保留子集模拟,对照
对 n 较小的情况,直接枚举两个数组各保留 n/2 个的所有组合(用组合数剪枝),
逐组合计算并集大小取最大,作为对照验证。
复杂度: - 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:分类计数(主提交版本) ----------
public int maximumSetSize(int[] nums1, int[] nums2) {
Set<Integer> s1 = new HashSet<>();
Set<Integer> s2 = new HashSet<>();
for (int x : nums1) s1.add(x);
for (int x : nums2) s2.add(x);
// 只存在于 s1 / 只存在于 s2 / 两边共有
int only1 = 0, only2 = 0, common = 0;
for (int x : s1) {
if (s2.contains(x)) common++;
else only1++;
}
for (int x : s2) {
if (!s1.contains(x)) only2++;
}
int half = nums1.length / 2;
int take1 = Math.min(only1, half); // 从仅 1 中取
int take2 = Math.min(only2, half); // 从仅 2 中取
int ans = take1 + take2;
// 剩余槽位用共有元素填补(每个共有元素最多贡献 1 个)
int slot = (half - take1) + (half - take2);
ans += Math.min(common, slot);
return ans;
}
// ---------- 解法二:枚举子集模拟(对照) ----------
public int maximumSetSizeBrute(int[] nums1, int[] nums2) {
int n = nums1.length;
int half = n / 2;
if (n > 14) {
// 太大退化为只算一次近似(用于对拍小数据即可)
return maximumSetSize(nums1, nums2);
}
int best = 0;
// 枚举保留的 n/2 个下标
int[] keep = new int[half];
for (int m1 = (1 << n) - 1; m1 >= 0; m1--) {
if (Integer.bitCount(m1) != half) continue;
for (int m2 = (1 << n) - 1; m2 >= 0; m2--) {
if (Integer.bitCount(m2) != half) continue;
Set<Integer> s = new HashSet<>();
for (int i = 0; i < n; i++) {
if ((m1 & (1 << i)) != 0) s.add(nums1[i]);
if ((m2 & (1 << i)) != 0) s.add(nums2[i]);
}
best = Math.max(best, s.size());
}
}
return best;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.maximumSetSize(new int[]{1, 2, 1, 2}, new int[]{1, 1, 1, 1}) == 2, "3002 例1");
check(s.maximumSetSize(new int[]{1, 2, 3, 4, 5, 6}, new int[]{2, 3, 2, 3, 2, 3}) == 5, "3002 例2");
check(s.maximumSetSize(new int[]{1, 1, 2, 2, 3, 3}, new int[]{4, 4, 5, 5, 6, 6}) == 6, "3002 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int n = 2 * (1 + rnd.nextInt(4)); // 2,4,6,8
int[] a = new int[n], b = new int[n];
for (int i = 0; i < n; i++) {
a[i] = 1 + rnd.nextInt(6);
b[i] = 1 + rnd.nextInt(6);
}
int m1 = s.maximumSetSize(a, b);
int m2 = s.maximumSetSizeBrute(a, b);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 " + Arrays.toString(a) + " " + Arrays.toString(b) + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3002 随机对拍");
System.out.println("3002 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3003. Maximize the Number of Partitions After Operations(执行操作后的最大分割数量)
题目描述
给定一个字符串 s 和一个整数 k。首先,你最多可以更改 s 中的一处下标对应字符为另一个小写英文字母。
之后,执行以下分割操作,直到 s 变为空串:
- 选择
s的最长前缀,该前缀最多包含k个不同字符; - 从
s中删除这个前缀,并将分割数量加一。
返回在最多改变一处下标对应字符的情况下,经过操作后得到的最大分割数。
示例 1
s = "accca", k = 2 -> 3(把 s[2] 改为 b 得 "acbca",分成 "ac"|"bc"|"a")
示例 2
s = "aabaab", k = 3 -> 1
示例 3
s = "xxyz", k = 1 -> 4(把 s[0] 改为 w 得 "wxyz",分成 4 段)
提示:
1 <= s.length <= 10^4s只包含小写英文字母1 <= k <= 26
解题思路
解法一:记忆化搜索 DFS,主提交版本
状态 (i, cur, t):i 为当前处理到的下标,cur 为当前段已包含字符的位掩码(26 位),t 为是否已用掉一次修改机会。
对每个位置,先把 si 加入当前段:
- 若加入后不同字符数 > k,则必须重新开段(分割数 +1),从 si 单独开始一段;
- 否则继续留在当前段。
若 t == 1(还有修改机会),枚举把 si 改成任意一个字符(26 种)的情况取最大值。
用 HashMap 记忆化 (i, cur, t)。
时间复杂度 O(n * 2^26 的最坏情况被剪枝,实际远小于),空间复杂度 O(n * 状态数)。
解法二:递推 DP + 集合可达状态,对照
正向维护第 i 步所有可达状态 (cur, t),反向再从末尾算最大段数,取最优值。
与解法一逻辑等价,相互对拍验证。
复杂度: - 时间复杂度:O(n * 26 * 状态数)(状态数受不同前缀段限制,实际运行很快)
- 空间复杂度:O(n * 状态数)
代码实现
java
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
private Map<Long, Integer> memo;
private String s;
private int k;
// ---------- 解法一:DFS 记忆化(主提交版本) ----------
public int maxPartitionsAfterOperations(String s, int k) {
this.s = s;
this.k = k;
this.memo = new HashMap<>();
return dfs(0, 0, 1);
}
private int dfs(int i, int cur, int t) {
if (i >= s.length()) {
return 1;
}
long key = ((long) i << 32) | ((long) cur << 1) | t;
Integer cached = memo.get(key);
if (cached != null) {
return cached;
}
int v = 1 << (s.charAt(i) - 'a');
int nxt = cur | v;
// 不修改 s[i]
int ans = Integer.bitCount(nxt) > k
? dfs(i + 1, v, t) + 1
: dfs(i + 1, nxt, t);
// 修改 s[i](t == 1 表示还有一次机会)
if (t > 0) {
for (int j = 0; j < 26; j++) {
if (j == (s.charAt(i) - 'a')) {
continue;
}
nxt = cur | (1 << j);
if (Integer.bitCount(nxt) > k) {
ans = Math.max(ans, dfs(i + 1, 1 << j, 0) + 1);
} else {
ans = Math.max(ans, dfs(i + 1, nxt, 0));
}
}
}
memo.put(key, ans);
return ans;
}
// ---------- 解法二:暴力枚举修改 + 贪心模拟(对照) ----------
public int maxPartitionsAfterOperationsBrute(String s, int k) {
int n = s.length();
int best = 0;
// 情况 1:不修改任何字符
best = Math.max(best, simulate(s, k));
// 情况 2:修改位置 i 为任意字符(与原来不同才有意义,但枚举 26 种全试)
for (int i = 0; i < n; i++) {
char orig = s.charAt(i);
for (char ch = 'a'; ch <= 'z'; ch++) {
if (ch == orig) {
continue;
}
char[] arr = s.toCharArray();
arr[i] = ch;
best = Math.max(best, simulate(new String(arr), k));
if (best == n) {
return best; // 上限
}
}
}
return best;
}
// 模拟贪心分割:每次取最长前缀,使其不同字符数 <= k
private int simulate(String t, int k) {
int parts = 0;
int i = 0;
int n = t.length();
while (i < n) {
int mask = 0;
int j = i;
while (j < n) {
int bit = 1 << (t.charAt(j) - 'a');
if (Integer.bitCount(mask | bit) > k) {
break;
}
mask |= bit;
j++;
}
parts++;
if (j == i) {
// 单个字符超过 k(k>=1 不会发生)
return parts + n - i - 1;
}
i = j;
}
return parts;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.maxPartitionsAfterOperations("accca", 2) == 3, "3003 例1");
check(s.maxPartitionsAfterOperations("aabaab", 3) == 1, "3003 例2");
check(s.maxPartitionsAfterOperations("xxyz", 1) == 4, "3003 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 200; t++) {
int len = 1 + rnd.nextInt(10);
StringBuilder sb = new StringBuilder();
int alpha = 1 + rnd.nextInt(4);
for (int i = 0; i < len; i++) {
sb.append((char) ('a' + rnd.nextInt(alpha)));
}
int kk = 1 + rnd.nextInt(4);
int m1 = s.maxPartitionsAfterOperations(sb.toString(), kk);
int m2 = s.maxPartitionsAfterOperationsBrute(sb.toString(), kk);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 s=" + sb + " k=" + kk + " 主=" + m1 + " 对照=" + m2);
break;
}
}
check(allOk, "3003 随机对拍");
System.out.println("3003 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n * 2^26 的最坏情况被剪枝,实际远小于),空间复杂度 O(n * 状态数)。
- 时间复杂度:O(n * 26 * 状态数)(状态数受不同前缀段限制,实际运行很快)
- 空间复杂度:O(n * 状态数)
3004. Maximum Subtree of the Same Color(相同颜色的最大子树)
题目描述
给定一个二维整数数组 edges,表示一个有 n 个节点的树,节点编号从 0 到 n - 1,以节点 0 为根,
其中 edges[i] = `ui`, `vi` 表示节点 ui 和 vi 之间存在一条边。
还给定一个下标从 0 开始、大小为 n 的整数数组 colors,其中 colors[i] 表示节点 i 分配的颜色。
我们希望找到一个节点 v,使得 v 的子树中的每个节点具有相同的颜色。
返回具有尽可能多节点且符合上述要求的子树大小。
示例 1
edges = [[0,1],[0,2],[0,3]], colors = [1,1,2,3] -> 1
示例 2
edges = [[0,1],[0,2],[0,3]], colors = [1,1,1,1] -> 4
示例 3
edges = [[0,1],[0,2],[2,3],[2,4]], colors = [1,2,3,3,3] -> 3(以节点 2 为根的子树)
提示:
n == edges.length + 11 <= n <= 5 * 10^4colors.length==n,1 <=colors[i]<= 10^5- 输入保证
edges构成一棵树
解题思路
解法一:DFS 统计子树信息,主提交版本
建邻接表后从根 0 做后序遍历。对每个节点 u 统计其子树:
- sizeu:子树大小;
- allSameu:子树中所有节点颜色是否全等于 colorsu。
若 u 的所有孩子节点都 allSame 且这些颜色的值都等于 colorsu,则 u 的整棵子树同色,用 sizeu 更新答案。
否则 u 的子树不同色(置 allSame=false),答案由子树中的同色块大小决定(递归中已统计)。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:换根/全局统计,对照
先用一次 DFS 收集每个"同色连通块"的大小(颜色相同的相邻节点连成块),
再考虑"子树限制":只有当整块恰好是以某节点为根的子树时才能计入。
对拍时直接枚举每个节点 v,独立递归计算 v 子树是否同色并取最大,复杂度 O(n^2)(仅用于小数据校验)。
复杂度: - 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
private List<Integer>[] g;
private int[] colors;
private int ans;
// ---------- 解法一:DFS(主提交版本) ----------
public int maximumSubtreeSize(int[][] edges, int[] colors) {
int n = colors.length;
this.colors = colors;
this.ans = 0;
g = new List[n];
for (int i = 0; i < n; i++) {
g[i] = new ArrayList<>();
}
for (int[] e : edges) {
g[e[0]].add(e[1]);
g[e[1]].add(e[0]);
}
dfs(0, -1);
return ans;
}
// 返回子树大小;若子树全色为 colors[u],返回大小,否则返回 -size(标记不同色)
private int dfs(int u, int parent) {
int size = 1;
boolean same = true;
for (int v : g[u]) {
if (v == parent) {
continue;
}
int sub = dfs(v, u);
size += Math.abs(sub);
if (sub < 0 || colors[v] != colors[u]) {
same = false;
}
}
if (same) {
ans = Math.max(ans, size);
return size;
}
return -size;
}
// ---------- 解法二:枚举根暴力(对照,O(n^2) 仅小数据) ----------
public int maximumSubtreeSizeBrute(int[][] edges, int[] colors) {
int n = colors.length;
this.colors = colors;
this.ans = 0;
g = new List[n];
for (int i = 0; i < n; i++) {
g[i] = new ArrayList<>();
}
for (int[] e : edges) {
g[e[0]].add(e[1]);
g[e[1]].add(e[0]);
}
// 枚举每个节点作为根,独立验证其子树是否同色(以 0 为根树中的父节点为边界)
int[] parent = new int[n];
Arrays.fill(parent, -1);
dfsParent(0, -1, parent);
for (int root = 0; root < n; root++) {
int[] cnt = countSubtree(root, parent[root], colors[root]);
if (cnt[0] == cnt[1]) {
ans = Math.max(ans, cnt[0]);
}
}
return ans;
}
private void dfsParent(int u, int p, int[] parent) {
for (int v : g[u]) {
if (v != p) {
parent[v] = u;
dfsParent(v, u, parent);
}
}
}
private void dfsOrder(int u, int p, List<Integer> order) {
order.add(u);
for (int v : g[u]) {
if (v != p) {
dfsOrder(v, u, order);
}
}
}
// 返回 [子树大小, 子树中颜色==color 的个数]
private int[] countSubtree(int u, int p, int color) {
int size = 1, same = (colors[u] == color) ? 1 : 0;
for (int v : g[u]) {
if (v != p) {
int[] sub = countSubtree(v, u, color);
size += sub[0];
same += sub[1];
}
}
return new int[]{size, same};
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.maximumSubtreeSize(new int[][]{{0, 1}, {0, 2}, {0, 3}}, new int[]{1, 1, 2, 3}) == 1, "3004 例1");
check(s.maximumSubtreeSize(new int[][]{{0, 1}, {0, 2}, {0, 3}}, new int[]{1, 1, 1, 1}) == 4, "3004 例2");
check(s.maximumSubtreeSize(new int[][]{{0, 1}, {0, 2}, {2, 3}, {2, 4}}, new int[]{1, 2, 3, 3, 3}) == 3, "3004 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int n = 1 + rnd.nextInt(8);
int[][] edges = new int[n - 1][2];
int[] colors = new int[n];
for (int i = 1; i < n; i++) {
int p = rnd.nextInt(i);
edges[i - 1][0] = p;
edges[i - 1][1] = i;
}
for (int i = 0; i < n; i++) {
colors[i] = 1 + rnd.nextInt(3);
}
int m1 = s.maximumSubtreeSize(edges, colors);
int m2 = s.maximumSubtreeSizeBrute(edges, colors);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 edges=" + Arrays.deepToString(edges) + " colors=" + Arrays.toString(colors) + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3004 随机对拍");
System.out.println("3004 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3005. Count Elements With Maximum Frequency(最大频率元素计数)
题目描述
给你一个由正整数组成的数组 nums。
返回数组 nums 中所有具有最大频率的元素的 总频率。
元素的频率是指该元素在数组中出现的次数。
示例 1
nums = [1,2,2,3,1,4] -> 4(元素 1 和 2 频率为 2,均为最大频率,总频率 2+2=4)
示例 2
nums = [1,2,3,4,5] -> 5(所有元素频率都为 1)
提示:
1 <= nums.length <= 1001 <= nums[i] <= 100
解题思路
解法一:单次遍历统计最大值频率,主提交版本
用 HashMap 统计每个数频率,同时维护当前最大频率 mx:
若某数频率超过 mx,则更新 mx 并把累积和重置为该频率;
若相等则累加。最终返回累积和。
注意:当有多个元素达到最大频率时累积的是频率而非个数。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:两遍统计,对照
第一遍统计完所有频率并求出最大频率,第二遍累加所有频率等于最大值元素的总频率。
逻辑等价,独立实现交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:单次遍历(主提交版本) ----------
public int maxFrequencyElements(int[] nums) {
int[] cnt = new int[101];
int mx = 0, ans = 0;
for (int x : nums) {
cnt[x]++;
if (cnt[x] > mx) {
mx = cnt[x];
ans = cnt[x];
} else if (cnt[x] == mx) {
ans += cnt[x];
}
}
return ans;
}
// ---------- 解法二:两遍统计(对照) ----------
public int maxFrequencyElementsTwo(int[] nums) {
Map<Integer, Integer> cnt = new HashMap<>();
for (int x : nums) {
cnt.put(x, cnt.getOrDefault(x, 0) + 1);
}
int mx = 0;
for (int v : cnt.values()) {
mx = Math.max(mx, v);
}
int ans = 0;
for (int v : cnt.values()) {
if (v == mx) {
ans += v;
}
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.maxFrequencyElements(new int[]{1, 2, 2, 3, 1, 4}) == 4, "3005 例1");
check(s.maxFrequencyElements(new int[]{1, 2, 3, 4, 5}) == 5, "3005 例2");
check(s.maxFrequencyElements(new int[]{1}) == 1, "3005 单元素");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 1 + rnd.nextInt(20);
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = 1 + rnd.nextInt(10);
}
int m1 = s.maxFrequencyElements(nums);
int m2 = s.maxFrequencyElementsTwo(nums);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 主=" + m1 + " 对照=" + m2);
break;
}
}
check(allOk, "3005 随机对拍");
System.out.println("3005 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3006. Find Beautiful Indices in the Given Array I(找出数组中的美丽下标 I)
题目描述
给你一个下标从 0 开始的字符串 s、字符串 a、字符串 b 和一个整数 k。
如果下标 i 满足以下条件,则认为它是一个美丽下标:
0 <= i <= s.length - a.lengths[i..(i + a.length - 1)] == a- 存在下标
j使得 0 <=j<=s.length-b.length,s`j`...(`j` + `b.length` - 1) ==b,且 |j-i| <=k
以数组形式按从小到大排序返回美丽下标。
示例 1
s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15 -> [16,33]
示例 2
s = "abcd", a = "a", b = "a", k = 4 -> [0]
提示:
1 <= k <= s.length <= 10^51 <= a.length, b.length <= 10s、a、b只包含小写英文字母
解题思路
解法一:KMP 求出现位置 + 二分判定,主提交版本
- 用 KMP 求出 a 在 s 中的全部起始下标列表 pa,b 的起始下标列表 pb;
- 对每个 pai,在 pb 中二分查找最接近 pai 的位置,若存在与 pai 距离 <= k 的 pbj,则 pai 是美丽下标。
时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。
解法二:双重循环朴素匹配,对照
直接枚举每个位置用 startsWith 判断 a/b 是否出现(数据量小时可行),
再对每个 a 出现位置遍历 b 出现位置判定距离,作为对照验证。
复杂度:
- 时间复杂度:O(|s| + |pa| * log|pb|)
- 空间复杂度:O(|s|)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:KMP + 二分(主提交版本) ----------
public List<Integer> beautifulIndices(String s, String a, String b, int k) {
List<Integer> pa = kmp(s, a);
List<Integer> pb = kmp(s, b);
List<Integer> ans = new ArrayList<>();
for (int i : pa) {
// 二分找 pb 中最接近 i 的位置
int idx = lowerBound(pb, i);
boolean ok = false;
if (idx < pb.size() && Math.abs(pb.get(idx) - i) <= k) {
ok = true;
}
if (idx > 0 && Math.abs(pb.get(idx - 1) - i) <= k) {
ok = true;
}
if (ok) {
ans.add(i);
}
}
return ans;
}
private List<Integer> kmp(String s, String p) {
List<Integer> res = new ArrayList<>();
int m = p.length();
int[] pi = new int[m];
for (int i = 1; i < m; i++) {
int j = pi[i - 1];
while (j > 0 && p.charAt(i) != p.charAt(j)) {
j = pi[j - 1];
}
if (p.charAt(i) == p.charAt(j)) {
j++;
}
pi[i] = j;
}
int j = 0;
for (int i = 0; i < s.length(); i++) {
while (j > 0 && s.charAt(i) != p.charAt(j)) {
j = pi[j - 1];
}
if (s.charAt(i) == p.charAt(j)) {
j++;
}
if (j == m) {
res.add(i - m + 1);
j = pi[j - 1];
}
}
return res;
}
private int lowerBound(List<Integer> list, int target) {
int lo = 0, hi = list.size();
while (lo < hi) {
int mid = (lo + hi) >>> 1;
if (list.get(mid) < target) {
lo = mid + 1;
} else {
hi = mid;
}
}
return lo;
}
// ---------- 解法二:朴素双重循环(对照) ----------
public List<Integer> beautifulIndicesBrute(String s, String a, String b, int k) {
List<Integer> pa = new ArrayList<>();
List<Integer> pb = new ArrayList<>();
for (int i = 0; i + a.length() <= s.length(); i++) {
if (s.startsWith(a, i)) {
pa.add(i);
}
}
for (int i = 0; i + b.length() <= s.length(); i++) {
if (s.startsWith(b, i)) {
pb.add(i);
}
}
List<Integer> ans = new ArrayList<>();
for (int i : pa) {
for (int j : pb) {
if (Math.abs(j - i) <= k) {
ans.add(i);
break;
}
}
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.beautifulIndices("isawsquirrelnearmysquirrelhouseohmy", "my", "squirrel", 15).equals(Arrays.asList(16, 33)), "3006 例1");
check(s.beautifulIndices("abcd", "a", "a", 4).equals(Arrays.asList(0)), "3006 例2");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int len = 1 + rnd.nextInt(30);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i++) {
sb.append((char) ('a' + rnd.nextInt(3)));
}
int al = 1 + rnd.nextInt(3);
int bl = 1 + rnd.nextInt(3);
StringBuilder sa = new StringBuilder();
StringBuilder sb2 = new StringBuilder();
for (int i = 0; i < al; i++) sa.append((char) ('a' + rnd.nextInt(3)));
for (int i = 0; i < bl; i++) sb2.append((char) ('a' + rnd.nextInt(3)));
int kk = 1 + rnd.nextInt(10);
List<Integer> m1 = s.beautifulIndices(sb.toString(), sa.toString(), sb2.toString(), kk);
List<Integer> m2 = s.beautifulIndicesBrute(sb.toString(), sa.toString(), sb2.toString(), kk);
if (!m1.equals(m2)) {
allOk = false;
System.out.println("对拍失败 s=" + sb + " a=" + sa + " b=" + sb2 + " k=" + kk + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3006 随机对拍");
System.out.println("3006 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。
- 时间复杂度:O(|s| + |pa| * log|pb|)
- 空间复杂度:O(|s|)
3007. Maximum Number That Sum of the Prices Is Less Than or Equal to K(价值和小于等于 K 的最大数字)
题目描述
给你一个整数 k 和一个整数 x。整数 num 的价值是它的二进制表示中在 x,2x,3x 等位置处设置位的数目
(第 1 位是最低有效位)。num 的累加价值是从 1 到 num 的数字的总价值。
如果 num 的累加价值小于或等于 k,则 num 是廉价的。返回最大的廉价数字。
示例 1
k = 9, x = 1 -> 6(1 到 6 的累加价值是 9,7 到 12 超了)
示例 2
k = 7, x = 2 -> 9
提示:
1 <= k <= 10^151 <= x <= 8
解题思路
解法一:二分答案 + 按位统计,主提交版本
对候选 num,计算 1...num 的总价值(每个数字在 x, 2x, 3x... 这些位上 1 的个数累加)。
第 bit 位(从 1 开始计)在 1, n 中出现 1 的次数可用周期公式 O(1) 求出:
cycle = 2^bit,每个完整周期贡献 cycle 个 1,余数部分贡献 max(0, rem - cycle)。
总价值随 num 单调不减,因此二分最大的 num 使总价值 <= k。
上界从 1 倍增到总价值超过 k 即可,最多约 60 轮。
时间复杂度 O(log k * log k)(约 60 个位 × 60 轮二分),空间复杂度 O(1)。
解法二:暴力累加模拟,对照
对每个数字 n 直接数它二进制中 x, 2x, ... 位上的 1 的个数并累加,
找到使累加价值首次超过 k 的前一个数字(小数据可用),作为对照验证。
复杂度:
- 时间复杂度:O((log k)^2)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
private int x;
// ---------- 解法一:二分 + 按位统计(主提交版本) ----------
public long findMaximumNumber(long k, int x) {
this.x = x;
long lo = 1, hi = 1;
// 倍增找上界:总价值 > k
while (totalValue(hi) <= k) {
hi <<= 1;
if (hi > (1L << 62)) {
break;
}
}
// 二分最大 num 使 totalValue(num) <= k
while (lo < hi) {
long mid = lo + (hi - lo + 1) / 2;
if (totalValue(mid) <= k) {
lo = mid;
} else {
hi = mid - 1;
}
}
return lo;
}
// 1..n 中 x, 2x, 3x, ... 位为 1 的总个数
private long totalValue(long n) {
long ans = 0;
for (int bit = x; bit <= 62; bit += x) {
ans += countOnes(n, bit);
if (ans > Long.MAX_VALUE / 2) {
break;
}
}
return ans;
}
// [1, n] 中第 bit 位(从 1 开始,最低位为第 1 位)为 1 的数字个数
private long countOnes(long n, int bit) {
long step = 1L << (bit - 1); // 一个半周期长度 2^(bit-1)
long cycle = 1L << bit; // 完整周期 2^bit
long total = n + 1; // 统计 0..n
long full = total / cycle;
long rem = total % cycle;
long cnt = full * step;
if (rem > step) {
cnt += rem - step;
}
return cnt;
}
// ---------- 解法二:暴力逐数统计(对照,小数据) ----------
public long findMaximumNumberBrute(long k, int x) {
long acc = 0;
long num = 1;
while (true) {
acc += valueOf(num, x);
if (acc > k) {
return num - 1;
}
num++;
}
}
private long valueOf(long num, int x) {
long cnt = 0;
for (int bit = x; bit <= 62; bit += x) {
if ((num & (1L << (bit - 1))) != 0) {
cnt++;
}
}
return cnt;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.findMaximumNumber(9, 1) == 6, "3007 例1");
check(s.findMaximumNumber(7, 2) == 9, "3007 例2");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
long k = 1 + rnd.nextInt(2000);
int x = 1 + rnd.nextInt(4);
long m1 = s.findMaximumNumber(k, x);
long m2 = s.findMaximumNumberBrute(k, x);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 k=" + k + " x=" + x + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3007 随机对拍");
System.out.println("3007 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(log k * log k)(约 60 个位 × 60 轮二分),空间复杂度 O(1)。
- 时间复杂度:O((log k)^2)
- 空间复杂度:O(1)
3008. Find Beautiful Indices in the Given Array II(找出数组中的美丽下标 II)
题目描述
给你一个下标从 0 开始的字符串 s、字符串 a、字符串 b 和一个整数 k。
如果下标 i 满足以下条件,则认为它是一个美丽下标:
0 <= i <= s.length - a.lengths[i..(i + a.length - 1)] == a- 存在下标
j使得 0 <=j<=s.length-b.length,s`j`...(`j` + `b.length` - 1) ==b,且 |j-i| <=k
以数组形式按从小到大排序返回美丽下标。
示例 1
s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15 -> [16,33]
示例 2
s = "abcd", a = "a", b = "a", k = 4 -> [0]
提示:
1 <= k <= s.length <= 5 * 10^51 <= a.length, b.length <= 5 * 10^5s、a、b只包含小写英文字母
解题思路
解法一:KMP 求出现位置 + 二分判定,主提交版本
- 用 KMP 求出 a 在 s 中的全部起始下标列表 pa,b 的起始下标列表 pb;
- 对每个 pai,在 pb 中二分查找最接近 pai 的位置,若存在与 pai 距离 <= k 的 pbj,则 pai 是美丽下标。
时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。
解法二:双重循环朴素匹配,对照
直接枚举每个位置用 startsWith 判断 a/b 是否出现(数据量小时可行),
再对每个 a 出现位置遍历 b 出现位置判定距离,作为对照验证。
复杂度:
- 时间复杂度:O(|s| + |pa| * log|pb|)
- 空间复杂度:O(|s|)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:KMP + 二分(主提交版本) ----------
public List<Integer> beautifulIndices(String s, String a, String b, int k) {
List<Integer> pa = kmp(s, a);
List<Integer> pb = kmp(s, b);
List<Integer> ans = new ArrayList<>();
for (int i : pa) {
// 二分找 pb 中最接近 i 的位置
int idx = lowerBound(pb, i);
boolean ok = false;
if (idx < pb.size() && Math.abs(pb.get(idx) - i) <= k) {
ok = true;
}
if (idx > 0 && Math.abs(pb.get(idx - 1) - i) <= k) {
ok = true;
}
if (ok) {
ans.add(i);
}
}
return ans;
}
private List<Integer> kmp(String s, String p) {
List<Integer> res = new ArrayList<>();
int m = p.length();
int[] pi = new int[m];
for (int i = 1; i < m; i++) {
int j = pi[i - 1];
while (j > 0 && p.charAt(i) != p.charAt(j)) {
j = pi[j - 1];
}
if (p.charAt(i) == p.charAt(j)) {
j++;
}
pi[i] = j;
}
int j = 0;
for (int i = 0; i < s.length(); i++) {
while (j > 0 && s.charAt(i) != p.charAt(j)) {
j = pi[j - 1];
}
if (s.charAt(i) == p.charAt(j)) {
j++;
}
if (j == m) {
res.add(i - m + 1);
j = pi[j - 1];
}
}
return res;
}
private int lowerBound(List<Integer> list, int target) {
int lo = 0, hi = list.size();
while (lo < hi) {
int mid = (lo + hi) >>> 1;
if (list.get(mid) < target) {
lo = mid + 1;
} else {
hi = mid;
}
}
return lo;
}
// ---------- 解法二:朴素双重循环(对照) ----------
public List<Integer> beautifulIndicesBrute(String s, String a, String b, int k) {
List<Integer> pa = new ArrayList<>();
List<Integer> pb = new ArrayList<>();
for (int i = 0; i + a.length() <= s.length(); i++) {
if (s.startsWith(a, i)) {
pa.add(i);
}
}
for (int i = 0; i + b.length() <= s.length(); i++) {
if (s.startsWith(b, i)) {
pb.add(i);
}
}
List<Integer> ans = new ArrayList<>();
for (int i : pa) {
for (int j : pb) {
if (Math.abs(j - i) <= k) {
ans.add(i);
break;
}
}
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.beautifulIndices("isawsquirrelnearmysquirrelhouseohmy", "my", "squirrel", 15).equals(Arrays.asList(16, 33)), "3008 例1");
check(s.beautifulIndices("abcd", "a", "a", 4).equals(Arrays.asList(0)), "3008 例2");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int len = 1 + rnd.nextInt(30);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; i++) {
sb.append((char) ('a' + rnd.nextInt(3)));
}
int al = 1 + rnd.nextInt(3);
int bl = 1 + rnd.nextInt(3);
StringBuilder sa = new StringBuilder();
StringBuilder sb2 = new StringBuilder();
for (int i = 0; i < al; i++) sa.append((char) ('a' + rnd.nextInt(3)));
for (int i = 0; i < bl; i++) sb2.append((char) ('a' + rnd.nextInt(3)));
int kk = 1 + rnd.nextInt(10);
List<Integer> m1 = s.beautifulIndices(sb.toString(), sa.toString(), sb2.toString(), kk);
List<Integer> m2 = s.beautifulIndicesBrute(sb.toString(), sa.toString(), sb2.toString(), kk);
if (!m1.equals(m2)) {
allOk = false;
System.out.println("对拍失败 s=" + sb + " a=" + sa + " b=" + sb2 + " k=" + kk + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3008 随机对拍");
System.out.println("3008 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。
- 时间复杂度:O(|s| + |pa| * log|pb|)
- 空间复杂度:O(|s|)
3009. Maximum Number of Intersections on the Chart(折线图上的最大交点数量)
题目描述
有一条由 n 个点连接而成的折线图。给定一个下标从 1 开始的整数数组 y,第 k 个点的坐标是 (k, y[k])。
图中没有水平线,即没有两个相邻的点有相同的 y 坐标。
假设在图中任意画一条无限长的水平线。请返回这条水平线与折线相交的最多交点数。
示例 1
y = [1,2,1,2,1,3,2] -> 5
示例 2
y = [2,1,3,4,5] -> 2
提示:
2 <= y.length <= 10^51 <= y[i] <= 10^9- 对于范围 1, `n` - 1 内的所有
i,都有y[i]!=y[i+1]
解题思路
解法一:差分数组按半整数刻度离散化,主提交版本
把每个线段 (yi-1, yi) 看成一个区间,水平线 y = h 与之相交当且仅当 h 严格落在该区间
两个端点之间(开区间)。为了处理半整数(如 y = 1.5),把所有 y 值乘以 2 映射到整数刻度:
线段 (a, b) 对应整数区间 (2min(a,b), 2 max(a,b)),水平线 y = h 对应刻度 2h;
若 2h 严格落在区间内则相交。
用差分数组对每个线段的整数区间 +1,最后前缀和求最大值。
注意端点重合(折线拐点)不能重复计数------用开区间 (l, r) 处理(r 端不 +1 或 l 端 +1、r 端 -1)。
由于 y 值范围大,用 TreeMap 做离散化差分(只在端点处修改)。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:枚举半整数值逐段判定,对照
折线最多有 n 个转折点,交点数变化只可能发生在经过某个端点或半整数点时。
枚举所有候选 y 值(每个 yi、yi-0.5、yi+0.5),对每个值逐段判断是否相交取最大作对照。
时间复杂度 O(n^2)(仅小数据),用于交叉验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Random;
import java.util.TreeMap;
public class Solution {
// ---------- 解法一:离散化差分(主提交版本) ----------
public int maxIntersectionCount(int[] y) {
int n = y.length;
// 线段 i(连接 y[i-1] 和 y[i])在 2 倍刻度下的开区间 (2*min, 2*max)
// 水平线高度 h 的刻度是 2h,落在开区间内即相交
TreeMap<Long, Integer> diff = new TreeMap<>();
for (int i = 1; i < n; i++) {
long lo = 2L * Math.min(y[i - 1], y[i]);
long hi = 2L * Math.max(y[i - 1], y[i]);
diff.merge(lo + 1, 1, Integer::sum); // 开区间左端点 +1
diff.merge(hi, -1, Integer::sum); // 开区间右端点(不含)-1
}
int cur = 0, ans = 0;
for (int v : diff.values()) {
cur += v;
ans = Math.max(ans, cur);
}
return ans;
}
// ---------- 解法二:枚举候选高度逐段判定(对照) ----------
public int maxIntersectionCountBrute(int[] y) {
// 候选高度集合:每个端点的 y,以及 y±0.5(用 2 倍整数表示)
java.util.Set<Long> cand = new java.util.TreeSet<>();
for (int v : y) {
cand.add(2L * v);
cand.add(2L * v - 1);
cand.add(2L * v + 1);
}
int n = y.length;
int best = 0;
for (long h2 : cand) {
int cnt = 0;
for (int i = 1; i < n; i++) {
long lo = 2L * Math.min(y[i - 1], y[i]);
long hi = 2L * Math.max(y[i - 1], y[i]);
if (h2 > lo && h2 < hi) {
cnt++;
}
}
best = Math.max(best, cnt);
}
return best;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.maxIntersectionCount(new int[]{1, 2, 1, 2, 1, 3, 2}) == 5, "3009 例1");
check(s.maxIntersectionCount(new int[]{2, 1, 3, 4, 5}) == 2, "3009 例2");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 2 + rnd.nextInt(7);
int[] y = new int[n];
y[0] = 1 + rnd.nextInt(6);
for (int i = 1; i < n; i++) {
do {
y[i] = 1 + rnd.nextInt(6);
} while (y[i] == y[i - 1]);
}
int m1 = s.maxIntersectionCount(y);
int m2 = s.maxIntersectionCountBrute(y);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 y=" + java.util.Arrays.toString(y) + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3009 随机对拍");
System.out.println("3009 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
时间复杂度 O(n^2)(仅小数据),用于交叉验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3010. Divide an Array Into Subarrays With Minimum Cost I(将数组分成最小总代价的子数组 I)
题目描述
给你一个长度为 n 的整数数组 nums。一个数组的代价是它的第一个元素。
你需要将 nums 分成 3 个连续且没有交集的子数组。
请你返回这些子数组的最小代价总和。
示例 1
nums = [1,2,3,12] -> 6([1]、[2]、[3,12] 代价 1+2+3)
示例 2
nums = [5,4,3] -> 12
示例 3
nums = [10,3,1,1] -> 12([10,3]、[1]、[1])
提示:
3 <= n <= 501 <= nums[i] <= 50
解题思路
解法一:首元素 + 剩余最小两数,主提交版本
第一个子数组必须以 nums0 开头(且第一个元素必为第一个子数组的代价)。
为使总代价最小,让第一个子数组尽量短。
实际上最优方案一定是:nums\[0] 单独一段,再在 nums1...n-1 中选最小的两个数各开一段。
因为代价就是每段首元素,想让后两段代价最小,就挑剩余最小的两个数。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:枚举分割点暴力,对照
枚举两个分割点 i、j(1 <= i < j <= n-1),计算 nums0 + numsi + numsj 取最小。
时间复杂度 O(n^2),用于交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:首元素 + 剩余最小两数(主提交版本) ----------
public int minimumCost(int[] nums) {
int a = nums[0];
int b = Integer.MAX_VALUE, c = Integer.MAX_VALUE;
for (int i = 1; i < nums.length; i++) {
if (nums[i] < b) {
c = b;
b = nums[i];
} else if (nums[i] < c) {
c = nums[i];
}
}
return a + b + c;
}
// ---------- 解法二:枚举分割点(对照) ----------
public int minimumCostBrute(int[] nums) {
int n = nums.length;
int ans = Integer.MAX_VALUE;
for (int i = 1; i <= n - 2; i++) {
for (int j = i + 1; j <= n - 1; j++) {
ans = Math.min(ans, nums[0] + nums[i] + nums[j]);
}
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minimumCost(new int[]{1, 2, 3, 12}) == 6, "3010 例1");
check(s.minimumCost(new int[]{5, 4, 3}) == 12, "3010 例2");
check(s.minimumCost(new int[]{10, 3, 1, 1}) == 12, "3010 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 3 + rnd.nextInt(8);
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = 1 + rnd.nextInt(50);
}
int m1 = s.minimumCost(nums);
int m2 = s.minimumCostBrute(nums);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 " + Arrays.toString(nums) + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3010 随机对拍");
System.out.println("3010 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
时间复杂度 O(n^2),用于交叉验证。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3011. Find if Array Can Be Sorted(判断一个数组是否可以变为有序)
题目描述
给你一个下标从 0 开始的整数数组 nums。在一步操作中,你可以交换数组中两个相邻元素,
前提是这两个元素二进制表示中 1 的个数相同(set bits 数量相同)。
请你返回能否通过若干次操作将数组变为有序(非递减)。
示例 1
nums = [8,4,2,30,15] -> true
示例 2
nums = [1,2,3,4,5] -> true
示例 3
nums = [3,16,8,4,2] -> false
提示:
1 <= nums.length <= 1001 <= nums[i] <= 2^8
解题思路
解法一:按 set bit 分组,主提交版本
能交换的只有 set bit 数量相同的元素。把数组按连续的相同 set bit 划成若干"块",
块内元素可以任意重排;但不同块之间不能交换。
因此只需检查:前一块的最大值 <= 后一块的最小值(模拟每块内排序后的衔接)。
若存在前块最大值 > 后块最小值,则无法整体有序。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:暴力模拟冒泡,对照
直接用冒泡排序逻辑:只要相邻且 set bit 相同且前者 > 后者就交换,
反复扫描直到不能再交换,最后检查是否整体非递减。
时间复杂度 O(n^2),用于交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:按 set bit 分组(主提交版本) ----------
public boolean canSortArray(int[] nums) {
int n = nums.length;
int preMax = 0;
int i = 0;
while (i < n) {
int bits = Integer.bitCount(nums[i]);
int j = i;
int mi = nums[i], mx = nums[i];
while (j + 1 < n && Integer.bitCount(nums[j + 1]) == bits) {
j++;
mi = Math.min(mi, nums[j]);
mx = Math.max(mx, nums[j]);
}
if (preMax > mi) {
return false;
}
preMax = mx;
i = j + 1;
}
return true;
}
// ---------- 解法二:冒泡模拟(对照) ----------
public boolean canSortArrayBrute(int[] nums) {
int[] a = nums.clone();
int n = a.length;
boolean changed = true;
while (changed) {
changed = false;
for (int i = 0; i + 1 < n; i++) {
if (a[i] > a[i + 1] && Integer.bitCount(a[i]) == Integer.bitCount(a[i + 1])) {
int t = a[i];
a[i] = a[i + 1];
a[i + 1] = t;
changed = true;
}
}
}
for (int i = 0; i + 1 < n; i++) {
if (a[i] > a[i + 1]) {
return false;
}
}
return true;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.canSortArray(new int[]{8, 4, 2, 30, 15}), "3011 例1");
check(s.canSortArray(new int[]{1, 2, 3, 4, 5}), "3011 例2");
check(!s.canSortArray(new int[]{3, 16, 8, 4, 2}), "3011 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 1 + rnd.nextInt(10);
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = 1 + rnd.nextInt(255);
}
boolean m1 = s.canSortArray(nums);
boolean m2 = s.canSortArrayBrute(nums);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 " + Arrays.toString(nums) + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3011 随机对拍");
System.out.println("3011 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
时间复杂度 O(n^2),用于交叉验证。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3012. Minimize Length of Array Using Operations(通过操作使数组长度最小)
题目描述
给你一个下标从 0 开始的整数数组 nums,它只包含正整数。
你的任务是通过进行以下操作任意次(可以是 0 次)最小化 nums 的长度:
- 在
nums中选择两个不同下标i和j,满足nums[i]> 0 且nums[j]> 0; - 将结果
nums[i]%nums[j]插入nums的结尾; - 将
nums中下标为i和j的元素删除。
返回进行任意次操作以后nums的最小长度。
示例 1
nums = [1,4,3,1] -> 1
示例 2
nums = [5,5,5,10,5] -> 2
示例 3
nums = [2,3,4] -> 1
提示:
1 <= nums.length <= 10^51 <= nums[i] <= 10^9
解题思路
解法一:最小值分类,主提交版本
设数组最小值为 mi。
- 若存在某个 numsi % mi != 0:该数 x 满足 x % mi != 0,则 gcd(x, mi) 也可能不为 1,
但更本质的结论是:只要存在 x % mi != 0,就有办法通过 x % mi 生成一个更小的正数(< mi),
使新的最小值更小......官方结论:若存在 x % mi != 0,则答案恒为 1; - 否则(所有数都能被 mi 整除):每次操作消耗两个数,生成 0,而 0 不能再参与取模产生更小的正数,
所以只有 mi 们两两配对删除,答案为 (cnt_mi + 1) / 2。
原理:所有数都能被 mi 整除时,任意取模结果要么是 0 要么是 mi 的倍数,
若选出的两个数不同(比如 mi 和 2mi),mi % 2mi = mi(不变)、2mi % mi = 0。
最优策略是每次用两个 mi 配对产生 0,最终只剩 ceil(cnt/2) 个 mi。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:贪心模拟对拍,对照
小数据下直接模拟:不断寻找可配对(gcd > 1)的一对数删除,优先删除能导致最短长度的方案,
用 DFS/回溯穷举(数据量限制 <= 8),取最短最终长度作为对照。
复杂度: - 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:最小值分类(主提交版本) ----------
public int minimumArrayLength(int[] nums) {
int mi = Integer.MAX_VALUE;
for (int x : nums) {
mi = Math.min(mi, x);
}
for (int x : nums) {
if (x % mi != 0) {
return 1;
}
}
int cnt = 0;
for (int x : nums) {
if (x == mi) {
cnt++;
}
}
return (cnt + 1) / 2;
}
// ---------- 解法二:回溯模拟(对照,小型数据) ----------
public int minimumArrayLengthBrute(int[] nums) {
java.util.List<Integer> arr = new java.util.ArrayList<>();
for (int x : nums) {
arr.add(x);
}
return dfs(arr);
}
private int dfs(java.util.List<Integer> arr) {
// 收集可选的正数下标
java.util.List<Integer> pos = new java.util.ArrayList<>();
for (int i = 0; i < arr.size(); i++) {
if (arr.get(i) > 0) {
pos.add(i);
}
}
if (pos.size() < 2) {
return arr.size();
}
int best = arr.size();
for (int a = 0; a < pos.size(); a++) {
for (int b = a + 1; b < pos.size(); b++) {
int i = pos.get(a), j = pos.get(b);
// i、j 有序:两种顺序都试(nums[i]%nums[j] 与 nums[j]%nums[i])
for (int k = 0; k < 2; k++) {
int vi = k == 0 ? i : j;
int vj = k == 0 ? j : i;
int val = arr.get(vi) % arr.get(vj);
java.util.List<Integer> next = new java.util.ArrayList<>(arr);
int hi = Math.max(i, j), lo = Math.min(i, j);
next.remove(hi);
next.remove(lo);
next.add(val);
best = Math.min(best, dfs(next));
}
}
}
return best;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minimumArrayLength(new int[]{1, 4, 3, 1}) == 1, "3012 例1");
check(s.minimumArrayLength(new int[]{5, 5, 5, 10, 5}) == 2, "3012 例2");
check(s.minimumArrayLength(new int[]{2, 3, 4}) == 1, "3012 例3");
check(s.minimumArrayLength(new int[]{1}) == 1, "3012 单元素");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int n = 1 + rnd.nextInt(7);
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = 1 + rnd.nextInt(20);
}
int m1 = s.minimumArrayLength(nums);
int m2 = s.minimumArrayLengthBrute(nums);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 " + Arrays.toString(nums) + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3012 随机对拍");
System.out.println("3012 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3013. Divide an Array Into Subarrays With Minimum Cost II(将数组分成最小总代价的子数组 II)
题目描述
给你一个下标从 0 开始长度为 n 的整数数组 nums 和两个正整数 k 和 dist。
一个数组的代价是数组中的第一个元素。
你需要将 nums 分割成 k 个连续且互不相交的子数组,满足第二个子数组与第 k 个子数组中
第一个元素的下标距离不超过 dist。
返回这些子数组的最小总代价。
示例 1
nums = [1,3,2,6,4,2], k = 3, dist = 3 -> 5([1,3]、[2,6,4]、[2])
示例 2
nums = [10,1,2,2,2,1], k = 4, dist = 3 -> 15
示例 3
nums = [10,8,18,9], k = 3, dist = 1 -> 36
提示:
3 <= n <= 10^51 <= nums[i] <= 10^93 <= k <= nk - 2 <= dist <= n - 2
解题思路
解法一:滑动窗口 + 对顶堆维护窗口最小 k-1 个,主提交版本
总代价 = nums0(第一个子数组首元素)+ 其余 k-1 个子数组的首元素之和。
设其余起点为 p1 < p2 < ... < p(k-1),题目约束等价于 p(k-1) - p1 <= dist,
即这些起点全部落在某个长度为 dist+1 的窗口内。
因此枚举窗口左端点 w(w 从 1 到 n-dist-1),窗口覆盖下标 w, w+dist,
取窗口内最小的 k-1 个数之和,与 nums0 相加取最小。
用两个堆(或 TreeMap)维护窗口内最小 k-1 个元素的和:
- 大顶堆 l 存窗口内最小的 k-1 个;小顶堆 r 存其余;
- 滑动窗口时添加右端、删除左端、调整两堆平衡,保持 l 恰好 k-1 个。
时间复杂度 O(n log dist),空间复杂度 O(dist)。
解法二:枚举窗口排序求和,对照
对小数据,直接枚举每个窗口左端点 w,把窗口内元素排序取最小的 k-1 个求和,
与 nums0 相加取最小。O(n * dist log dist),仅用于交叉验证。
复杂度: - 时间复杂度:O(n log dist)
- 空间复杂度:O(dist)
代码实现
java
import java.util.Arrays;
import java.util.Random;
import java.util.TreeMap;
public class Solution {
// ---------- 解法一:对顶堆滑动窗口(主提交版本) ----------
public long minimumCost(int[] nums, int k, int dist) {
int n = nums.length;
int need = k - 1; // 除 nums[0] 外还需选 need 个起点,窗口大小 dist+1
// l 大顶堆:窗口内最小的 need 个;r 小顶堆:其余
java.util.TreeMap<Integer, Integer> l = new java.util.TreeMap<>();
java.util.TreeMap<Integer, Integer> r = new java.util.TreeMap<>();
long sumL = 0;
int sizeL = 0;
// 初始窗口 [1, dist+1]
for (int i = 1; i <= dist + 1 && i < n; i++) {
l.merge(nums[i], 1, Integer::sum);
sumL += nums[i];
sizeL++;
}
while (sizeL > need) {
int mx = l.lastKey();
dec(l, mx);
sumL -= mx;
sizeL--;
r.merge(mx, 1, Integer::sum);
}
long ans = (long) nums[0] + sumL;
// 滑动窗口:左端 i-dist-1 移出,右端 i 加入
for (int i = dist + 2; i < n; i++) {
int out = nums[i - dist - 1];
if (r.containsKey(out)) {
dec(r, out);
} else if (l.containsKey(out)) {
dec(l, out);
sumL -= out;
sizeL--;
// 从 r 补一个到 l
if (!r.isEmpty()) {
int mn = r.firstKey();
dec(r, mn);
l.merge(mn, 1, Integer::sum);
sumL += mn;
sizeL++;
}
}
int in = nums[i];
if (sizeL < need) {
l.merge(in, 1, Integer::sum);
sumL += in;
sizeL++;
} else if (!l.isEmpty() && in < l.lastKey()) {
int mx = l.lastKey();
dec(l, mx);
sumL -= mx;
r.merge(mx, 1, Integer::sum);
l.merge(in, 1, Integer::sum);
sumL += in;
sizeL++;
} else {
r.merge(in, 1, Integer::sum);
}
ans = Math.min(ans, (long) nums[0] + sumL);
}
return ans;
}
private void dec(TreeMap<Integer, Integer> m, int key) {
int c = m.get(key);
if (c == 1) {
m.remove(key);
} else {
m.put(key, c - 1);
}
}
// ---------- 解法二:枚举窗口排序(对照,小数据) ----------
public long minimumCostBrute(int[] nums, int k, int dist) {
int n = nums.length;
int need = k - 1;
long ans = Long.MAX_VALUE;
for (int w = 1; w + dist <= n - 1; w++) {
int[] win = new int[dist + 1];
int idx = 0;
for (int j = w; j <= w + dist && j < n; j++) {
win[idx++] = nums[j];
}
Arrays.sort(win, 0, idx);
long sum = nums[0];
for (int t = 0; t < need; t++) {
sum += win[t];
}
ans = Math.min(ans, sum);
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minimumCost(new int[]{1, 3, 2, 6, 4, 2}, 3, 3) == 5, "3013 例1");
check(s.minimumCost(new int[]{10, 1, 2, 2, 2, 1}, 4, 3) == 15, "3013 例2");
check(s.minimumCost(new int[]{10, 8, 18, 9}, 3, 1) == 36, "3013 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int n = 4 + rnd.nextInt(8);
int[] nums = new int[n];
for (int i = 0; i < n; i++) {
nums[i] = 1 + rnd.nextInt(50);
}
int k = 3 + rnd.nextInt((n - 3) + 1);
int maxDist = n - 2;
int minDist = k - 2;
if (minDist > maxDist) continue;
int dist = minDist + rnd.nextInt(maxDist - minDist + 1);
long m1 = s.minimumCost(nums, k, dist);
long m2 = s.minimumCostBrute(nums, k, dist);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 nums=" + Arrays.toString(nums) + " k=" + k + " dist=" + dist + " 主=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3013 随机对拍");
System.out.println("3013 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n log dist),空间复杂度 O(dist)。
- 时间复杂度:O(n log dist)
- 空间复杂度:O(dist)
3014. Minimum Number of Pushes to Type Word I(输入单词需要的最少按键次数 I)
题目描述
给你一个字符串 word,由不同小写英文字母组成。
电话键盘上的按键 2~9 可以重新映射到不同字母集合,每个按键可映射任意数量的字母,
但每个字母必须恰好映射到一个按键上。输入 word 时,字母在按键上的位置决定按键次数
(第 1 个字母按 1 次,第 2 个按 2 次......)。
返回重新映射按键后输入 word 所需的最少按键次数。
示例 1
word = "abcde" -> 5(5 个字母各在 5 个按键首位)
示例 2
word = "xycdefghij" -> 12
提示:
1 <= word.length <= 26word仅由小写英文字母组成,所有字母互不相同
解题思路
解法一:均匀分配到 8 个按键,主提交版本
只有 8 个按键(2~9)。每个字母互不相同、出现次数均为 1,输入总成本只取决于每个字母
在按键上的"槽位"(第 1 槽成本 1、第 2 槽成本 2......)。
最优策略:把字母尽量均匀地放进 8 个按键的第 1 槽(8 个成本 1),多余字母放入第 2 槽,
以此类推。总成本 = 前 8 个成本 1 ×1 + 次 8 个成本 2 ×2 + ...
简洁公式:对 0 <= i < len,成本为 i/8 + 1,累加。
时间复杂度 O(len),空间复杂度 O(1)。
解法二:逐槽分配枚举,对照
模拟"往 8 个按键里轮流放字母":第 t 轮(从 1 开始)放 min(8, 剩余) 个字母,
每个成本 t,累加。与解法一公式等价,逻辑独立重写验证。
复杂度:
- 时间复杂度:O(len)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:公式累加(主提交版本) ----------
public int minimumPushes(String word) {
int n = word.length();
int ans = 0;
for (int i = 0; i < n; i++) {
ans += i / 8 + 1;
}
return ans;
}
// ---------- 解法二:轮流分配模拟(对照) ----------
public int minimumPushesBrute(String word) {
int n = word.length();
int ans = 0;
int turn = 1;
while (n > 0) {
int put = Math.min(8, n);
ans += turn * put;
n -= put;
turn++;
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minimumPushes("abcde") == 5, "3014 例1");
check(s.minimumPushes("xycdefghij") == 12, "3014 例2");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int len = 1 + rnd.nextInt(26);
int m1 = s.minimumPushes("abcdefghijklmnopqrstuvwxyz".substring(0, len));
int m2 = s.minimumPushesBrute("abcdefghijklmnopqrstuvwxyz".substring(0, len));
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 len=" + len + " 主=" + m1 + " 对照=" + m2);
break;
}
}
check(allOk, "3014 随机对拍");
System.out.println("3014 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(len),空间复杂度 O(1)。
- 时间复杂度:O(len)
- 空间复杂度:O(1)
3015. Count the Number of Houses at a Certain Distance I(按距离统计房屋对数目 I)
题目描述
给你三个正整数 n、x 和 y。在城市中,存在编号从 1 到 n 的房屋,由 n 条街道相连。
对所有 1 <= i < n,都存在一条街道连接编号为 i 的房屋与编号为 i+1 的房屋。
另存在一条街道连接编号为 x 的房屋与编号为 y 的房屋。
对于每个 k(1 <= k <= n),找出所有满足要求的房屋对 `house1`, `house2`,
即从 house1 到 house2 需要经过的最少街道数为 k。
返回下标从 1 开始且长度为 n 的数组 result,result[k] 表示距离恰好为 k 的房屋对数量
(无向,house1 != house2,每对按两个方向各计一次)。
示例 1
n = 3, x = 1, y = 3 -> [6,0,0]
示例 2
n = 5, x = 2, y = 4 -> [10,8,2,0,0]
示例 3
n = 4, x = 1, y = 1 -> [6,4,2,0]
提示:
2 <= n <= 1001 <= x, y <= n
解题思路
解法一:从每个起点 BFS/直接算最短路,主提交版本
图结构:1-2-...-n 的链 + 一条额外边 (x, y)。
对每对 (i, j)(i < j),最短路 = min(|i-j|, |i-x|+1+|y-j|, |i-y|+1+|x-j|),
距离 d 计入 resultd,每对贡献 2(两个方向)。
时间复杂度 O(n^2),空间复杂度 O(1)。
解法二:BFS 全源,对照
建邻接表(链 + 额外边),从每个起点做 BFS 求到所有点的最短路,
统计每个距离的出现次数(只计 i<j 避免重复)。逻辑等价,独立实现验证。
复杂度:
- 时间复杂度:O(n^2)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:公式最短路(主提交版本) ----------
public int[] countOfPairs(int n, int x, int y) {
int[] ans = new int[n];
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int d = Math.abs(i - j);
d = Math.min(d, Math.abs(i - x) + 1 + Math.abs(j - y));
d = Math.min(d, Math.abs(i - y) + 1 + Math.abs(j - x));
ans[d - 1] += 2;
}
}
return ans;
}
// ---------- 解法二:BFS(对照) ----------
public int[] countOfPairsBfs(int n, int x, int y) {
int[] ans = new int[n];
for (int s = 1; s <= n; s++) {
int[] dist = new int[n + 1];
Arrays.fill(dist, -1);
java.util.ArrayDeque<Integer> q = new java.util.ArrayDeque<>();
dist[s] = 0;
q.add(s);
while (!q.isEmpty()) {
int u = q.poll();
for (int v : neighbors(u, n, x, y)) {
if (dist[v] == -1) {
dist[v] = dist[u] + 1;
q.add(v);
}
}
}
for (int t = s + 1; t <= n; t++) {
ans[dist[t] - 1] += 2;
}
}
return ans;
}
private int[] neighbors(int u, int n, int x, int y) {
int[] res = new int[4];
int cnt = 0;
if (u > 1) res[cnt++] = u - 1;
if (u < n) res[cnt++] = u + 1;
if (u == x && y != u) res[cnt++] = y;
if (u == y && x != u) res[cnt++] = x;
return java.util.Arrays.copyOf(res, cnt);
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(Arrays.equals(s.countOfPairs(3, 1, 3), new int[]{6, 0, 0}), "3015 例1");
check(Arrays.equals(s.countOfPairs(5, 2, 4), new int[]{10, 8, 2, 0, 0}), "3015 例2");
check(Arrays.equals(s.countOfPairs(4, 1, 1), new int[]{6, 4, 2, 0}), "3015 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int n = 2 + rnd.nextInt(12);
int x = 1 + rnd.nextInt(n);
int y = 1 + rnd.nextInt(n);
int[] m1 = s.countOfPairs(n, x, y);
int[] m2 = s.countOfPairsBfs(n, x, y);
if (!Arrays.equals(m1, m2)) {
allOk = false;
System.out.println("对拍失败 n=" + n + " x=" + x + " y=" + y + " 主=" + Arrays.toString(m1) + " 暴力=" + Arrays.toString(m2));
break;
}
}
check(allOk, "3015 随机对拍");
System.out.println("3015 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n^2),空间复杂度 O(1)。
- 时间复杂度:O(n^2)
- 空间复杂度:O(n)
3016. Minimum Number of Pushes to Type Word II(输入单词需要的最少按键次数 II)
题目描述
给你一个字符串 word,由小写英文字母组成(可重复)。
电话键盘上的按键 2~9 可以重新映射到不同字母集合,每个按键可映射任意数量的字母,
但每个字母必须恰好映射到一个按键上。输入 word 时,字母在按键上的位置决定按键次数
(按键上第 1 个字母按 1 次、第 2 个按 2 次......)。
返回重新映射按键后输入 word 所需的最少按键次数。
示例 1
word = "abcde" -> 5
示例 2
word = "xyzxyzxyzxyz" -> 12
示例 3
word = "aabbccddeeffgghhiiiiii" -> 24
提示:
1 <= word.length <= 10^5word仅由小写英文字母组成
解题思路
解法一:频率贪心,主提交版本
总按键次数 = sum(某字母出现次数 * 该字母所在槽位)。
出现次数越多的字母应该放在越便宜的槽位(第 1 槽成本 1,第 2 槽成本 2......)。
求出 26 个字母出现频率并降序排序,依次分配槽位:第 i 个字母(0 基)成本 i/8 + 1。
时间复杂度 O(26 log 26 + n),空间复杂度 O(1)。
解法二:分组累加,对照
相同逻辑不同写法:按 (i/8+1) 分组累加 cnt26-i-1,与解法一等价,独立重写验证。
复杂度:
- 时间复杂度:O(n + 26 log 26)
- 空间复杂度:O(26)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:频率贪心(主提交版本) ----------
public int minimumPushes(String word) {
int[] cnt = new int[26];
for (int i = 0; i < word.length(); i++) {
cnt[word.charAt(i) - 'a']++;
}
Arrays.sort(cnt);
int ans = 0;
// cnt 升序,从高频到低频分配槽位
for (int i = 0; i < 26; i++) {
ans += (i / 8 + 1) * cnt[25 - i];
}
return ans;
}
// ---------- 解法二:分组累加(对照) ----------
public int minimumPushesGroup(String word) {
int[] cnt = new int[26];
for (int i = 0; i < word.length(); i++) {
cnt[word.charAt(i) - 'a']++;
}
int ans = 0;
int turn = 1;
int used = 0;
for (int c = 25; c >= 0; c--) {
if (cnt[c] == 0) {
continue; // 不出现的字母不占槽位
}
if (used == 8) {
turn++;
used = 0;
}
ans += turn * cnt[c];
used++;
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minimumPushes("abcde") == 5, "3016 例1");
check(s.minimumPushes("xyzxyzxyzxyz") == 12, "3016 例2");
check(s.minimumPushes("aabbccddeeffgghhiiiiii") == 24, "3016 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int len = 1 + rnd.nextInt(60);
StringBuilder sb = new StringBuilder();
int alpha = 1 + rnd.nextInt(8);
for (int i = 0; i < len; i++) {
sb.append((char) ('a' + rnd.nextInt(alpha)));
}
int m1 = s.minimumPushes(sb.toString());
int m2 = s.minimumPushesGroup(sb.toString());
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 word=" + sb + " 主=" + m1 + " 对照=" + m2);
break;
}
}
check(allOk, "3016 随机对拍");
System.out.println("3016 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(26 log 26 + n),空间复杂度 O(1)。
- 时间复杂度:O(n + 26 log 26)
- 空间复杂度:O(26)
3017. Count the Number of Houses at a Certain Distance II(按距离统计房屋对数目 II)
题目描述
给你三个正整数 n、x 和 y。在城市中,存在编号从 1 到 n 的房屋,由 n 条街道相连。
对所有 1 <= i < n,都存在一条街道连接编号为 i 的房屋与编号为 i+1 的房屋。
另存在一条街道连接编号为 x 的房屋与编号为 y 的房屋。
对于每个 k(1 <= k <= n),找出所有满足要求的房屋对 `house1`, `house2`,
即从 house1 到 house2 需要经过的最少街道数为 k。
返回下标从 1 开始且长度为 n 的数组 result(无向,每对按两个方向各计一次)。
示例 1
n = 3, x = 1, y = 3 -> [6,0,0]
示例 2
n = 5, x = 2, y = 4 -> [10,8,2,0,0]
示例 3
n = 4, x = 1, y = 1 -> [6,4,2,0]
提示:
2 <= n <= 10^51 <= x, y <= n
解题思路
解法一:差分数组按起点批量贡献,主提交版本
图的本质是链条 1~n 加上额外边 (a, b)(a=min(x,y),b=max(x,y)),形成环状结构。
若 a == b 则图为纯链;否则从 a 到 b 存在"沿链"与"沿额外边+反链"两条路径,构成环。
对每个起点 i,它到环上左右两侧点的最短路分布满足对称性:
- 两侧点直线距离随 |i-j| 线性增长,先按直链距离全量 +1;
- 环内的点可通过额外边缩短距离,用第二/第三项把缩短量折算进差分;
- 越界超过环边界 n 与边界 1 的部分用 -1 消去,环内"折返"点用两项修正。
每个 i 只做常数次 O(1) 区间更新,最后对差分数组前缀和即得到每个距离的出现次数。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:双重循环最短路(对照)
直接对每对 (i, j)(i < j)套用 3015 的最短路公式
d = min(|i-j|, |i-x|+1+|j-y|, |i-y|+1+|j-x|),ansd-1 += 2。
复杂度 O(n^2),仅用于小 n 交叉验证。
复杂度: - 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:差分数组(主提交版本) ----------
public long[] countOfPairs(int n, int x, int y) {
int a = Math.min(x, y) - 1; // 0 基
int b = Math.max(x, y) - 1;
if (a > b) {
int t = a;
a = b;
b = t;
}
long[] diff = new long[n];
for (int i = 0; i < n; i++) {
diff[0] += 2; // 每个起点两侧各 +1 的"基座",配合下面修正得到距离分布
// 右侧(编号 > i)经额外边缩短
int cut1 = Math.min(Math.abs(i - a), Math.abs(i - b) + 1);
if (cut1 < n) diff[cut1] += 1;
int cut2 = Math.min(Math.abs(i - b), Math.abs(i - a) + 1);
if (cut2 < n) diff[cut2] += 1;
// 越过环边界(1 与 n)的部分要消掉
int cut3 = Math.min(Math.abs(i - 0), Math.abs(i - b) + 1 + Math.abs(a - 0));
if (cut3 < n) diff[cut3] -= 1;
int cut4 = Math.min(Math.abs(i - (n - 1)), Math.abs(i - a) + 1 + Math.abs(b - (n - 1)));
if (cut4 < n) diff[cut4] -= 1;
// 环内折返点(中位对称)修正
int cut5 = Math.max(a - i, 0) + Math.max(i - b, 0) + ((b - a) + 0) / 2;
if (cut5 < n) diff[cut5] -= 1;
int cut6 = Math.max(a - i, 0) + Math.max(i - b, 0) + ((b - a) + 1) / 2;
if (cut6 < n) diff[cut6] -= 1;
}
long[] ans = new long[n];
long cur = 0;
for (int d = 0; d < n; d++) {
cur += diff[d];
ans[d] = cur;
}
return ans;
}
// ---------- 解法二:双重循环最短路(对照) ----------
public long[] countOfPairsBrute(int n, int x, int y) {
long[] ans = new long[n];
for (int i = 1; i <= n; i++) {
for (int j = i + 1; j <= n; j++) {
int d = Math.abs(i - j);
d = Math.min(d, Math.abs(i - x) + 1 + Math.abs(j - y));
d = Math.min(d, Math.abs(i - y) + 1 + Math.abs(j - x));
ans[d - 1] += 2;
}
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(Arrays.equals(s.countOfPairs(3, 1, 3), new long[]{6, 0, 0}), "3017 例1");
check(Arrays.equals(s.countOfPairs(5, 2, 4), new long[]{10, 8, 2, 0, 0}), "3017 例2");
check(Arrays.equals(s.countOfPairs(4, 1, 1), new long[]{6, 4, 2, 0}), "3017 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 2 + rnd.nextInt(25);
int x = 1 + rnd.nextInt(n);
int y = 1 + rnd.nextInt(n);
long[] m1 = s.countOfPairs(n, x, y);
long[] m2 = s.countOfPairsBrute(n, x, y);
if (!Arrays.equals(m1, m2)) {
allOk = false;
System.out.println("对拍失败 n=" + n + " x=" + x + " y=" + y);
System.out.println(" 主=" + Arrays.toString(m1));
System.out.println(" 暴=" + Arrays.toString(m2));
break;
}
}
check(allOk, "3017 随机对拍");
System.out.println("3017 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3018. Maximum Number of Removal Queries That Can Be Processed I(可处理的最大删除操作数 I 🔒)
题目描述
给定一个下标从 0 开始的数组 nums 和一个下标从 0 开始的数组 queries。
你可以在开始时执行以下操作最多一次:用 nums 的子序列替换 nums。
我们以给定的 queries 顺序处理查询;对于 queries[i],我们执行以下操作:
- 如果
nums的第一个和最后一个元素都小于queries[i],则查询处理结束; - 否则,从
nums中选择第一个或最后一个元素,要求其大于或等于queries[i],然后将其从nums中删除。
返回通过以最佳方式执行该操作可以处理的最多次数。
示例 1
nums = [1,2,3,4,5], queries = [1,2,3,4,6] -> 4
示例 2
nums = [2,3,2], queries = [2,2,3] -> 3
示例 3
nums = [3,4,3], queries = [4,3,2] -> 2
提示:
1 <= nums.length <= 10001 <= queries.length <= 10001 <= nums[i], queries[i] <= 10^9
解题思路
解法一:区间 DP,主提交版本
每次删除都发生在剩余连续区间的左端或右端,因此"处理了若干查询后剩余的部分"
始终是 nums 的一个连续子区间 i, j。开始时可以用子序列替换 nums,等价于可以
从任意初始区间 i, j(0 <= i <= j < n)开始。
定义 fij = 剩余区间为 i, j 时,已经(最多)处理掉的查询数量。
于是区间 i, j 的下一个待处理查询是 queriesf\[ij]:
- 若 i > 0,从 i-1, j 删掉左端 numsi-1 可得到 i, j;
令 pre = fi-1j,若 pre < m 且 numsi-1 >= queriespre 则可多处理 1 个,
即 fij 用 pre + 1 更新(同时保留 pre 本身作为"停在这里"的下界); - 若 j+1 < n,同理从 i, j+1 删掉右端得到 i, j,
fij 用 fij+1 + 1(若可删)更新。
用"能删则删"的取最大方式松弛,得到的 fij 即剩余区间为 i,j 时的最大已处理数。
最终答案:对每个单元素区间 i, i,尝试处理最后一个查询
fii + (numsi >= queriesf\[ii] ? 1 : 0),取最大。
时间复杂度 O(n^2),空间复杂度 O(n^2)。
解法二:枚举初始子序列 + 回溯搜索(对照)
开始时可用 nums 的任意子序列替换 nums,因此用二进制掩码枚举所有非空子序列,
对每个子序列递归模拟处理:状态为 (剩余区间 l, r, 已处理查询数 t),每次从左端
或右端删除一个满足 queriest 的元素,或直接放弃,取能处理的最大查询数。
复杂度指数级,仅用于小规模交叉验证。
复杂度: - 时间复杂度:O(n^2)
- 空间复杂度:O(n^2)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:区间 DP(主提交版本) ----------
public int maximumProcessableQueries(int[] nums, int[] queries) {
int n = nums.length;
int m = queries.length;
int[][] f = new int[n][n]; // f[i][j]: 剩余区间 [i,j] 时最多已处理的查询数
for (int i = 0; i < n; ++i) {
for (int j = n - 1; j >= i; --j) {
if (i > 0) {
// 从 [i-1, j] 删掉左端 nums[i-1] 得到 [i, j]:
// 若 nums[i-1] 能满足下一个查询(queries[f[i-1][j]])则 +1
int pre = f[i - 1][j];
f[i][j] = Math.max(f[i][j],
pre + (pre < m && nums[i - 1] >= queries[pre] ? 1 : 0));
}
if (j + 1 < n) {
// 从 [i, j+1] 删掉右端 nums[j+1] 得到 [i, j]
int pre = f[i][j + 1];
f[i][j] = Math.max(f[i][j],
pre + (pre < m && nums[j + 1] >= queries[pre] ? 1 : 0));
}
if (f[i][j] == m) {
return m; // 所有查询都已处理
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
int t = f[i][i];
ans = Math.max(ans, t + (t < m && nums[i] >= queries[t] ? 1 : 0));
}
return ans;
}
// ---------- 解法二:枚举初始子序列 + 回溯搜索(对照) ----------
public int bruteForce(int[] nums, int[] queries) {
int n = nums.length;
int best = 0;
// 开始时可用 nums 的任意子序列替换:用掩码枚举所有非空子序列
for (int mask = 1; mask < (1 << n); ++mask) {
int[] sub = new int[n];
int len = 0;
for (int i = 0; i < n; ++i) {
if ((mask & (1 << i)) != 0) {
sub[len++] = nums[i];
}
}
best = Math.max(best, dfs(sub, 0, len - 1, 0, queries));
}
return best;
}
// 模拟:剩余子序列为 sub[l..r],已处理 t 个查询,返回能处理的最大查询数
private int dfs(int[] sub, int l, int r, int t, int[] queries) {
int m = queries.length;
if (t >= m) {
return t;
}
if (l > r) {
return t; // 区间已空,无法继续
}
int best = t;
// 尝试删左端
if (sub[l] >= queries[t]) {
best = Math.max(best, dfs(sub, l + 1, r, t + 1, queries));
}
// 尝试删右端
if (sub[r] >= queries[t]) {
best = Math.max(best, dfs(sub, l, r - 1, t + 1, queries));
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rnd = new Random(42);
// 官方案例
int[][] numss = {
{1, 2, 3, 4, 5},
{2, 3, 2},
{3, 4, 3}
};
int[][] qss = {
{1, 2, 3, 4, 6},
{2, 2, 3},
{4, 3, 2}
};
int[] expects = {4, 3, 2};
for (int t = 0; t < numss.length; ++t) {
int got = sol.maximumProcessableQueries(numss[t], qss[t]);
int bf = sol.bruteForce(numss[t], qss[t]);
System.out.println("Example " + (t + 1) + ": dp=" + got
+ " brute=" + bf + " expected=" + expects[t]
+ (got == expects[t] && bf == expects[t] ? " PASS" : " FAIL"));
}
// 随机对拍
int trials = 500;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(7);
int m = 1 + rnd.nextInt(7);
int[] nums = new int[n];
int[] queries = new int[m];
for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(8);
for (int i = 0; i < m; ++i) queries[i] = 1 + rnd.nextInt(8);
int a = sol.maximumProcessableQueries(nums, queries);
int b = sol.bruteForce(nums, queries);
if (a != b) {
fail++;
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " queries=" + Arrays.toString(queries)
+ " dp=" + a + " brute=" + b);
if (fail > 5) break;
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 ? " ALL PASS" : " FAILED"));
}
}
复杂度分析
时间复杂度 O(n^2),空间复杂度 O(n^2)。
- 时间复杂度:O(n^2)
- 空间复杂度:O(n^2)
3019. Number of Changing Keys(按键变更的次数)
题目描述
给你一个下标从 0 开始的字符串 s,该字符串由用户输入。按键变更的定义是:
使用与上次使用的按键不同的键。例如 s = "ab" 表示按键变更一次,而 s = "bBBb" 不存在按键变更。
返回用户输入过程中按键变更的次数。
注意:shift 或 caps lock 等修饰键不计入按键变更,也就是说,如果用户先输入字母 'a'
然后输入字母 'A',不算作按键变更。
示例 1
s = "aAbBcC" -> 2
示例 2
s = "AaAaAaaA" -> 0
提示:
1 <= s.length <= 100s仅由英文大写字母和小写字母组成
解题思路
解法一:相邻比较,主提交版本
修饰键不计数,等价于只看字母本身,忽略大小写。从左到右扫描,把每个字符统一转成
小写(或大写)后与前一个比较,不同则计数 +1。每一对相邻字符独立判定,不依赖全局状态。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:先归一化再遍历(对照)
先一次性把字符串转为小写,再遍历相邻位置计数。逻辑与解法一相同,仅在"何时转换大小写"
的处理上不同,用于交叉验证解题思路的一致性。
时间复杂度 O(n),空间复杂度 O(n)(需要小写副本)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:相邻比较(主提交版本) ----------
public int countKeyChanges(String s) {
int ans = 0;
char prev = Character.toLowerCase(s.charAt(0));
for (int i = 1; i < s.length(); ++i) {
char cur = Character.toLowerCase(s.charAt(i));
if (cur != prev) {
++ans;
}
prev = cur;
}
return ans;
}
// ---------- 解法二:先归一化再遍历(对照) ----------
public int countKeyChanges2(String s) {
String lower = s.toLowerCase();
int ans = 0;
for (int i = 1; i < lower.length(); ++i) {
if (lower.charAt(i) != lower.charAt(i - 1)) {
++ans;
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] cases = {"aAbBcC", "AaAaAaaA", "ab", "bBBb", "a", "AAAA", "AaBbCcDd", "aAbBcCdDeEfF"};
int[] expects = {2, 0, 1, 0, 0, 0, 3, 5};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.countKeyChanges(cases[i]);
int b = sol.countKeyChanges2(cases[i]);
boolean ok = (a == expects[i]) && (b == expects[i]);
allPass &= ok;
System.out.println("s=\"" + cases[i] + "\" -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机测试(两个解法互相校验)
Random rnd = new Random(7);
int trials = 2000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int len = 1 + rnd.nextInt(12);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; ++i) {
char c = (char) ('a' + rnd.nextInt(26));
if (rnd.nextBoolean()) c = Character.toUpperCase(c);
sb.append(c);
}
String s = sb.toString();
int a = sol.countKeyChanges(s);
int b = sol.countKeyChanges2(s);
if (a != b) {
fail++;
System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
if (fail > 5) break;
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
时间复杂度 O(n),空间复杂度 O(n)(需要小写副本)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3020. Find the Maximum Number of Elements in Subset(子集中元素的最大数量)
题目描述
给你一个正整数数组 nums。你需要从数组中选出一个满足下述条件的子集:
你可以将选中的元素放置在一个下标从 0 开始的数组中,并使其遵循以下模式:
`x`, `x`\^2, `x`\^4, ..., `x`\^(`k`/2), `x`\^`k`, `x`\^(`k`/2), ..., `x`\^4, `x`\^2, `x`
(注意,k 可以是任何非负的 2 的幂)。例如,2, 4, 16, 4, 2 和 3, 9, 3 都符合这一模式,
而 2, 4, 8, 4, 2 则不符合。
返回满足这些条件的子集中,元素数量的最大值。
示例 1
nums = [5,4,1,2,2] -> 3(子集 {4,2,2} -> [2,4,2])
示例 2
nums = [1,3,2,4] -> 1
提示:
2 <= nums.length <= 10^51 <= nums[i] <= 10^9
解题思路
解法一:哈希计数 + 平方链,主提交版本
一个数若大于 1,则连续平方会严格递增(x -> x^2 -> x^4 -> ...),因此除 1 外
数字的平方链不会出现环,链的长度至多为 log log 级别。用 HashMap 统计每个数的出现次数。
对每个数 x(x > 1)从它开始不断平方,只要下一个数在计数表中且出现次数 >= 2,就继续
前进(每步贡献 2 个元素,链两端各一个);当无法继续时,若链当前到达的数的计数 >= 1,
还可以在尾部放一个"单个元素"(链中点的单个副本),总长再 +1。
对于 x = 1:模式为 1,1,1,...,链只能由若干个 1 组成,长度为 cnt1;
若 cnt1 为奇数则正好为 cnt1,为偶数则需取 cnt1-1(形成对称回文,中间必须是奇数个)。
对所有 x 取最大。
时间复杂度 O(n * log log MAX),空间复杂度 O(n)。
解法二:枚举起点模拟平方链(对照)
与解法一相同思路,但不用"跳链"累积,而是直接从每个候选起点出发,逐次平方并
用计数器累加可放置的个数,统计最长链。为求独立验证,用朴素方式复制计数表并
每次对单个起点计算,避免共享状态,作为交叉验证。
时间复杂度 O(n * log log MAX),空间复杂度 O(n)。
复杂度:
- 时间复杂度:O(n * log log MAX)
- 空间复杂度:O(n)
代码实现
java
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:哈希计数 + 平方链(主提交版本) ----------
public int maximumLength(int[] nums) {
Map<Long, Integer> cnt = new HashMap<>();
for (int x : nums) {
cnt.merge((long) x, 1, Integer::sum);
}
// 处理 1:全 1 链只能是 1,1,...,1,回文中间必须是奇数,奇数个 1 取全部、偶数个取 cnt-1
Integer t = cnt.remove(1L);
int ans = t == null ? 0 : t - (1 - t % 2);
for (long x : cnt.keySet()) {
t = 0;
// 沿平方链前进:x, x^2, x^4, ...,每个中间值需要出现 >= 2 次(两端各一)
while (cnt.getOrDefault(x, 0) > 1) {
x = x * x; // x <= 1e9 时 x^2 <= 1e18 不会溢出 long
t += 2;
}
// 链尾(峰值)只需出现 1 次;若该值不存在说明多走了一步,把多算的 2 减成 1
t += cnt.getOrDefault(x, -1);
ans = Math.max(ans, t);
}
return ans;
}
// ---------- 解法二:按峰值逐级验证链(对照) ----------
public int maximumLength2(int[] nums) {
Map<Long, Integer> cnt = new HashMap<>();
for (int x : nums) {
cnt.merge((long) x, 1, Integer::sum);
}
Integer c1 = cnt.get(1L);
int ans = c1 == null ? 0 : c1 - (1 - c1 % 2);
for (long root : cnt.keySet()) {
if (root == 1L) continue;
// 枚举链的峰值级数 p:模式 [x, x^2, ..., x^(2^p), ..., x^2, x],长度 2p+1
for (int p = 0; ; ++p) {
long v = root;
boolean ok = true;
for (int idx = 0; idx <= p; ++idx) {
// 端点 x 与中间对称元素各需 2 份,峰值(中心)只需 1 份
int need = (idx == p) ? 1 : 2;
if (cnt.getOrDefault(v, 0) < need) {
ok = false;
break;
}
if (idx == p) break;
v = v * v;
if (v < 0) { // long 溢出
ok = false;
break;
}
}
if (!ok) break;
ans = Math.max(ans, 2 * p + 1);
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{5, 4, 1, 2, 2},
{1, 3, 2, 4},
{1, 1, 1, 1, 1},
{2, 4, 16, 4, 2},
{3, 9, 3},
{1, 1},
{2, 2, 4, 4, 16, 16},
{1000000000, 1000000000}
};
int[] expects = {3, 1, 5, 5, 3, 1, 5, 1};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.maximumLength(cases[i]);
int b = sol.maximumLength2(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(java.util.Arrays.toString(cases[i]) + " -> " + a
+ " / brute=" + b + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍(小值域 √ 链的数值控制)
Random rnd = new Random(3);
int trials = 2000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(10);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(9);
int a = sol.maximumLength(nums);
int b = sol.maximumLength2(nums);
if (a != b) {
fail++;
System.out.println("MISMATCH " + java.util.Arrays.toString(nums)
+ " a=" + a + " b=" + b);
if (fail > 5) break;
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n * log log MAX),空间复杂度 O(n)。
- 时间复杂度:O(n * log log MAX)
- 空间复杂度:O(n)