LeetCode 3101-3120. 题解合集
文章目录
- [LeetCode 3101-3120. 题解合集](#LeetCode 3101-3120. 题解合集)
-
- [3101. Count Alternating Subarrays(交替子数组计数)](#3101. Count Alternating Subarrays(交替子数组计数))
- [3102. Minimize Manhattan Distances(最小化曼哈顿距离)](#3102. Minimize Manhattan Distances(最小化曼哈顿距离))
- [3103. Find Trending Hashtags II(查找热门话题标签 II)](#3103. Find Trending Hashtags II(查找热门话题标签 II))
- [3104. Find Longest Self-Contained Substring(查找最长的自包含子串)](#3104. Find Longest Self-Contained Substring(查找最长的自包含子串))
- [3105. Longest Strictly Increasing or Strictly Decreasing Subarray(最长的严格递增或递减子数组)](#3105. Longest Strictly Increasing or Strictly Decreasing Subarray(最长的严格递增或递减子数组))
- [3106. Lexicographically Smallest String After Operations With Constraint(满足距离约束且字典序最小的字符串)](#3106. Lexicographically Smallest String After Operations With Constraint(满足距离约束且字典序最小的字符串))
- [3107. Minimum Operations to Make Median of Array Equal to K(使数组中位数等于 K 的最少操作数)](#3107. Minimum Operations to Make Median of Array Equal to K(使数组中位数等于 K 的最少操作数))
- [3108. Minimum Cost Walk in Weighted Graph(带权图里旅途的最小代价)](#3108. Minimum Cost Walk in Weighted Graph(带权图里旅途的最小代价))
- [3109. Find the Index of Permutation(查找排列的下标)](#3109. Find the Index of Permutation(查找排列的下标))
- [3110. Score of a String(字符串的分数)](#3110. Score of a String(字符串的分数))
- [3111. Minimum Rectangles to Cover Points(覆盖所有点的最少矩形数目)](#3111. Minimum Rectangles to Cover Points(覆盖所有点的最少矩形数目))
- [3112. Minimum Time to Visit Disappearing Nodes(访问消失节点的最少时间)](#3112. Minimum Time to Visit Disappearing Nodes(访问消失节点的最少时间))
- [3113. Find the Number of Subarrays Where Boundary Elements Are Maximum](#3113. Find the Number of Subarrays Where Boundary Elements Are Maximum)
- [3114. Latest Time You Can Obtain After Replacing Characters(替换字符可以得到的最晚时间)](#3114. Latest Time You Can Obtain After Replacing Characters(替换字符可以得到的最晚时间))
- [3115. Maximum Prime Difference(质数的最大距离)](#3115. Maximum Prime Difference(质数的最大距离))
- [3116. Kth Smallest Amount With Single Denomination Combination](#3116. Kth Smallest Amount With Single Denomination Combination)
- [3117. Minimum Sum of Values by Dividing Array(划分数组得到最小的值之和)](#3117. Minimum Sum of Values by Dividing Array(划分数组得到最小的值之和))
- [3118. Friday Purchase III(发生在周五的交易 III)](#3118. Friday Purchase III(发生在周五的交易 III))
- [3119. Maximum Number of Potholes That Can Be Fixed(最大数量的可修复坑洼)](#3119. Maximum Number of Potholes That Can Be Fixed(最大数量的可修复坑洼))
- [3120. Count the Number of Special Characters I(统计特殊字母的数量 I)](#3120. Count the Number of Special Characters I(统计特殊字母的数量 I))
3101. Count Alternating Subarrays(交替子数组计数)
题目描述
给你一个二进制数组 nums 。
如果一个子数组中 不存在 两个相邻元素的值相同的情况,我们称这样的子数组为交替子数组。
返回数组 nums 中交替子数组的数量。
示例 1
nums = [0,1,1,1] -> 5([0] [1] [1] [1] [0,1])
示例 2
nums = [1,0,1,0] -> 10(每个子数组都是交替子数组)
提示:
1 <= nums.length <= 10^5nums[i]不是 0 就是 1
解题思路
解法一:动态规划/滑动统计,主提交版本
统计以每个位置结尾的交替子数组数量:维护 s 表示"以当前元素结尾的最长交替连续段长度",
若 numsi != numsi-1 则 s = s + 1(可接在前一个之后),否则 s = 1(自己单独成段)。
累加所有 s 即得总数量。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:二重循环暴力(对照)
枚举所有子数组,逐个检查是否交替。
时间复杂度 O(n^2),空间复杂度 O(1)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:一次扫描统计(主提交版本) ----------
public long countAlternatingSubarrays(int[] nums) {
long ans = 0;
long s = 0;
for (int i = 0; i < nums.length; ++i) {
if (i > 0 && nums[i] != nums[i - 1]) {
s = s + 1;
} else {
s = 1;
}
ans += s;
}
return ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
public long countAlternatingSubarraysBrute(int[] nums) {
int n = nums.length;
long ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
boolean ok = true;
for (int k = i + 1; k <= j; ++k) {
if (nums[k] == nums[k - 1]) {
ok = false;
break;
}
}
if (ok) {
ans++;
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = { {0, 1, 1, 1}, {1, 0, 1, 0}, {0}, {1}, {0, 0}, {1, 1, 1} };
long[] expects = {5, 10, 1, 1, 2, 3};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
long a = sol.countAlternatingSubarrays(cases[i]);
long b = sol.countAlternatingSubarraysBrute(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rnd.nextInt(15);
int[] arr = new int[n];
for (int i = 0; i < n; ++i) {
arr[i] = rnd.nextInt(2);
}
long a = sol.countAlternatingSubarrays(arr);
long b = sol.countAlternatingSubarraysBrute(arr);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH n=" + n + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
时间复杂度 O(n^2),空间复杂度 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3102. Minimize Manhattan Distances(最小化曼哈顿距离)
题目描述
给你一个下标从 0 开始的数组 points,它表示二维平面上一些点的整数坐标,
其中 points[i] = `xi`, `yi`。两点之间的距离定义为它们的曼哈顿距离。
请你恰好移除一个点,返回移除后任意两点之间的最大距离可能的最小值。
示例 1
points = [[3,10],[5,15],[10,2],[4,4]] -> 12
示例 2
points = [[1,1],[1,1],[1,1]] -> 0
提示:
1 <= points.length <= 10^5points[i].length == 2-10^8 <= xi, yi <= 10^8
解题思路
解法一:坐标变换 + TreeMap 多集,主提交版本
曼哈顿距离 |x1-x2| + |y1-y2| 可转化为切比雪夫距离:
max(|(x1+y1)-(x2+y2)|, |(x1-y1)-(x2-y2)|)。
因此任意两点的最大曼哈顿距离 =
max( (x+y) 的最大值-最小值, (x-y) 的最大值-最小值 )。
用两个 TreeMap 分别维护 x+y 和 x-y 的频数(可重复),
枚举移除每个点 p:先将其从两个 TreeMap 各删一次,
计算当前 max(最大值-最小值),取全局最小;最后把 p 加回。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:暴力枚举(对照,小规模)
对每个被移除的点 i,遍历所有 (j,k) 对求最大曼哈顿距离,取最小。
时间复杂度 O(n^3),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
import java.util.TreeMap;
public class Solution {
// ---------- 解法一:坐标变换 + TreeMap(主提交版本) ----------
public int minimumDistance(int[][] points) {
TreeMap<Integer, Integer> tm1 = new TreeMap<>(); // x + y
TreeMap<Integer, Integer> tm2 = new TreeMap<>(); // x - y
for (int[] p : points) {
int x = p[0], y = p[1];
tm1.merge(x + y, 1, Integer::sum);
tm2.merge(x - y, 1, Integer::sum);
}
int ans = Integer.MAX_VALUE;
for (int[] p : points) {
int x = p[0], y = p[1];
int a = x + y, b = x - y;
if (tm1.merge(a, -1, Integer::sum) == 0) {
tm1.remove(a);
}
if (tm2.merge(b, -1, Integer::sum) == 0) {
tm2.remove(b);
}
ans = Math.min(ans,
Math.max(tm1.lastKey() - tm1.firstKey(), tm2.lastKey() - tm2.firstKey()));
tm1.merge(a, 1, Integer::sum);
tm2.merge(b, 1, Integer::sum);
}
return ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
public int minimumDistanceBrute(int[][] points) {
int n = points.length;
int ans = Integer.MAX_VALUE;
for (int skip = 0; skip < n; ++skip) {
int mx = 0;
for (int i = 0; i < n; ++i) {
if (i == skip) {
continue;
}
for (int j = i + 1; j < n; ++j) {
if (j == skip) {
continue;
}
int d = Math.abs(points[i][0] - points[j][0])
+ Math.abs(points[i][1] - points[j][1]);
mx = Math.max(mx, d);
}
}
ans = Math.min(ans, mx);
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] p1 = { {3, 10}, {5, 15}, {10, 2}, {4, 4} };
int[][] p2 = { {1, 1}, {1, 1}, {1, 1} };
System.out.println("case1 -> " + sol.minimumDistance(p1)
+ " brute=" + sol.minimumDistanceBrute(p1) + " expected=12");
System.out.println("case2 -> " + sol.minimumDistance(p2)
+ " brute=" + sol.minimumDistanceBrute(p2) + " expected=0");
boolean ok1 = sol.minimumDistance(p1) == 12 && sol.minimumDistanceBrute(p1) == 12;
boolean ok2 = sol.minimumDistance(p2) == 0 && sol.minimumDistanceBrute(p2) == 0;
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 800; ++t) {
int n = 2 + rnd.nextInt(6);
int[][] pts = new int[n][2];
for (int i = 0; i < n; ++i) {
pts[i][0] = rnd.nextInt(21) - 10;
pts[i][1] = rnd.nextInt(21) - 10;
}
int a = sol.minimumDistance(pts);
int b = sol.minimumDistanceBrute(pts);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH a=" + a + " b=" + b + " pts=" + Arrays.deepToString(pts));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
时间复杂度 O(n^3),仅用于小规模交叉验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3103. Find Trending Hashtags II(查找热门话题标签 II)
题目类型:数据库(SQL)
题目描述
表:Tweets
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| user_id | int |
| tweet_id | int |
| tweet_date | date |
| tweet | varchar |
+-------------+---------+
tweet_id 是这张表的主键(值互不相同的列)。这张表的每一行都包含 user_id、tweet_id、tweet_date 和 tweet。题目保证所有 tweet_date 都是 2024 年 2 月的合法日期。
编写一个解决方案来找到 2024 年 二月 的前 3 热门话题标签。一条推文可能含有多个标签。
返回结果表,根据标签的数量 和名称降序排序。
示例 1:
输入:
Tweets 表:
+---------+----------+------------------------------------------------------------+------------+
| user_id | tweet_id | tweet | tweet_date |
+---------+----------+------------------------------------------------------------+------------+
| 135 | 13 | Enjoying a great start to the day. #HappyDay #MorningVibes | 2024-02-01 |
| 136 | 14 | Another #HappyDay with good vibes! #FeelGood | 2024-02-03 |
| 137 | 15 | Productivity peaks! #WorkLife #ProductiveDay | 2024-02-04 |
| 138 | 16 | Exploring new tech frontiers. #TechLife #Innovation | 2024-02-04 |
| 139 | 17 | Gratitude for today's moments. #HappyDay #Thankful | 2024-02-05 |
| 140 | 18 | Innovation drives us. #TechLife #FutureTech | 2024-02-07 |
| 141 | 19 | Connecting with nature's serenity. #Nature #Peaceful | 2024-02-09 |
+---------+----------+------------------------------------------------------------+------------+
输出:
+-----------+-------+
| hashtag | count |
+-----------+-------+
| #HappyDay | 3 |
| #TechLife | 2 |
| #WorkLife | 1 |
+-----------+-------+
解释:#HappyDay 在 ID 13、14、17 的推文中出现共 3 次;#TechLife 在 16、18 中出现共 2 次;#WorkLife 在 15 中出现 1 次。输出表按 count 和 hashtag 降序排序。
解题思路
一条推文可能含多个标签,需要把每条推文按 # 拆分出所有标签:用递归 CTE ------锚点查询取每条推文的第一个 标签(SUBSTRING_INDEX(SUBSTRING_INDEX(tweet,'#',2),'#',-1) 再截到空格),并把 # 之前的内容从原文中剔除得到剩余串 remain_tags;递归成员对剩余串重复同样操作,直到不含 # 为止。外层对每个标签 GROUP BY 计数,按次数降序、标签名降序排序后 LIMIT 3 取前 3。
代码实现
sql
WITH RECURSIVE t1 AS (
SELECT tweet_id,
SUBSTRING_INDEX(SUBSTRING_INDEX(
SUBSTRING_INDEX(tweet, '#', 2), '#', -1), ' ', 1) AS tag,
TRIM(LEADING SUBSTRING_INDEX(tweet, '#', 2) FROM tweet) AS remain_tags
FROM Tweets
WHERE tweet LIKE '%#%' AND YEAR(tweet_date) = 2024 AND MONTH(tweet_date) = 2
UNION ALL
SELECT tweet_id,
SUBSTRING_INDEX(SUBSTRING_INDEX(
SUBSTRING_INDEX(remain_tags, '#', 2), '#', -1), ' ', 1) AS tag,
TRIM(LEADING SUBSTRING_INDEX(remain_tags, '#', 2) FROM remain_tags)
FROM t1
WHERE remain_tags LIKE '%#%'
)
SELECT CONCAT('#', tag) AS hashtag, COUNT(tweet_id) AS count
FROM t1
GROUP BY tag
ORDER BY count DESC, tag DESC
LIMIT 3;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3104. Find Longest Self-Contained Substring(查找最长的自包含子串)
题目描述
给定字符串 s,你需要找到 s 的最长自包含子串的长度。
如果 s 的一个子串 t 满足 t != s 且 t 中的每一个字符在 s 的剩余部分都不存在,
则被称为是自包含的。如果存在 s 的最长自包含子串,返回它的长度,否则返回 -1。
示例 1
s = "abba" -> 2(子串 "bb",子串外没有其它 "b")
示例 2
s = "abab" -> -1
示例 3
s = "abacd" -> 4(子串 "bcd" 外没有 b/c/d?答案为 4,即 "bcd"?)
提示:
1 <= s.length <= 10^5s仅由小写英文字母组成
解题思路
解法一:滑动窗口 + 首末位置(主提交版本)
预处理 first26 与 last26:每个字符第一次/最后一次出现的位置。
一个子串 l, r 是自包含的,当且仅当对子串内每个字符 c:
firstc >= l 且 lastc <= r,即子串恰好覆盖了其中所有字符的出现范围。
枚举每个字符 k 作为起点 c = firstk(子串左端点取其首字符首次出现位置),
向右扩展右端点 j,维护 mx = max(last字符);
若扫到某个字符其 first < i,说明子串不可能自包含(该字符在 i 之前出现过且不在子串内),
直接终止该起点。当 mx == j 且长度 < n 时,子串自包含,更新答案。
时间复杂度 O(26 * n),空间复杂度 O(26)。
解法二:暴力(对照,小规模)
枚举所有子串 l, r(长度 < n),检查其内每个字符是否在子串外出现过(扫描 l...r 之外),
全部满足则更新答案。时间复杂度 O(n^3),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(26 * n)
- 空间复杂度:O(1)(两个长度 26 数组)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:首末位置滑动(主提交版本) ----------
public int maxSubstringLength(String s) {
int[] first = new int[26];
int[] last = new int[26];
Arrays.fill(first, -1);
int n = s.length();
for (int i = 0; i < n; ++i) {
int j = s.charAt(i) - 'a';
if (first[j] == -1) {
first[j] = i;
}
last[j] = i;
}
int ans = -1;
for (int k = 0; k < 26; ++k) {
int i = first[k];
if (i == -1) {
continue;
}
int mx = last[k];
for (int j = i; j < n; ++j) {
int c = s.charAt(j) - 'a';
int a = first[c];
int b = last[c];
if (a < i) {
break; // 字符 c 在 i 之前也出现过,子串不可能自包含
}
mx = Math.max(mx, b);
if (mx == j && j - i + 1 < n) {
ans = Math.max(ans, j - i + 1);
}
}
}
return ans;
}
// ---------- 解法二:暴力(对照) ----------
public int maxSubstringLengthBrute(String s) {
int n = s.length();
int ans = -1;
for (int l = 0; l < n; ++l) {
for (int r = l; r < n; ++r) {
if (r - l + 1 >= n) {
continue; // t != s
}
boolean ok = true;
for (int p = l; p <= r; ++p) {
char c = s.charAt(p);
for (int q = 0; q < n; ++q) {
if (q >= l && q <= r) {
continue;
}
if (s.charAt(q) == c) {
ok = false;
break;
}
}
if (!ok) {
break;
}
}
if (ok) {
ans = Math.max(ans, r - l + 1);
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] ss = { "abba", "abab", "abacd" };
int[] expects = { 2, -1, 4 };
boolean ok = true;
for (int i = 0; i < ss.length; ++i) {
int a = sol.maxSubstringLength(ss[i]);
int b = sol.maxSubstringLengthBrute(ss[i]);
boolean cur = a == expects[i] && b == expects[i];
ok &= cur;
System.out.println("s=\"" + ss[i] + "\" -> " + a + " brute=" + b
+ " expected=" + expects[i] + (cur ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
String pool = "abc";
for (int t = 0; t < 500; ++t) {
int len = 1 + rnd.nextInt(8);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; ++i) {
sb.append(pool.charAt(rnd.nextInt(pool.length())));
}
String s = sb.toString();
int a = sol.maxSubstringLength(s);
int b = sol.maxSubstringLengthBrute(s);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(26 * n),空间复杂度 O(26)。
全部满足则更新答案。时间复杂度 O(n^3),仅用于小规模交叉验证。
- 时间复杂度:O(26 * n)
- 空间复杂度:O(1)(两个长度 26 数组)
3105. Longest Strictly Increasing or Strictly Decreasing Subarray(最长的严格递增或递减子数组)
题目描述
给你一个整数数组 nums。
返回数组中最长严格递增或严格递减子数组的长度。
注意:子数组是数组中的连续非空元素序列。
示例 1
nums = [1,4,3,3,2] -> 2([1,4] 或 [3,2])
示例 2
nums = [3,3,3,3] -> 1
示例 3
nums = [3,2,1] -> 3([3,2,1] 为严格递减)
提示:
1 <= nums.length <= 501 <= nums[i] <= 50
解题思路
解法一:两次扫描,主提交版本
第一次扫描统计最长严格递增段:t 记录以当前元素结尾的连续严格递增长度,
numsi-1 < numsi 时 t++,否则 t 重置为 1,不断更新答案。
第二次扫描对称统计最长严格递减段。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:暴力枚举(对照)
枚举所有子数组,检查是否严格递增或严格递减,取最长。
时间复杂度 O(n^2),空间复杂度 O(1)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:两次扫描(主提交版本) ----------
public int longestMonotonicSubarray(int[] nums) {
int ans = 1;
for (int i = 1, t = 1; i < nums.length; ++i) {
if (nums[i - 1] < nums[i]) {
ans = Math.max(ans, ++t);
} else {
t = 1;
}
}
for (int i = 1, t = 1; i < nums.length; ++i) {
if (nums[i - 1] > nums[i]) {
ans = Math.max(ans, ++t);
} else {
t = 1;
}
}
return ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
public int longestMonotonicSubarrayBrute(int[] nums) {
int n = nums.length;
int ans = 1;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
boolean inc = true, dec = true;
for (int k = i + 1; k <= j; ++k) {
if (nums[k] <= nums[k - 1]) {
inc = false;
}
if (nums[k] >= nums[k - 1]) {
dec = false;
}
}
if (inc || dec) {
ans = Math.max(ans, j - i + 1);
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = { {1, 4, 3, 3, 2}, {3, 3, 3, 3}, {3, 2, 1}, {1}, {1, 2, 3, 4}, {5, 4, 3, 2, 1} };
int[] expects = {2, 1, 3, 1, 4, 5};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.longestMonotonicSubarray(cases[i]);
int b = sol.longestMonotonicSubarrayBrute(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rnd.nextInt(12);
int[] arr = new int[n];
for (int i = 0; i < n; ++i) {
arr[i] = 1 + rnd.nextInt(10);
}
int a = sol.longestMonotonicSubarray(arr);
int b = sol.longestMonotonicSubarrayBrute(arr);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH n=" + n + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
时间复杂度 O(n^2),空间复杂度 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3106. Lexicographically Smallest String After Operations With Constraint(满足距离约束且字典序最小的字符串)
题目描述
给你一个仅由小写英文字母组成的字符串 s 和一个整数 k。
定义两个小写字母 c1 和 c2 之间的距离为它们环形的距离,即 min(|c1-c2|, 26-|c1-c2|)。
定义字符串 s 与 t 之间的距离为每对下标 i,s[i] 与 t[i] 之间的距离之和。
请你返回与 s 距离小于等于 k 的字典序最小的字符串。
如果两个字符串第一个不同的字符在 i 位置,字符 a 在字符 b 之前,那么 a 的字典序小于 b。
返回的字符串应当与 s 等长。
示例 1
s = "zbbz", k = 3 -> "aaad"
示例 2
s = "xaxcd", k = 4 -> "aawcd"
示例 3
s = "lol", k = 0 -> "lol"
提示:
1 <= s.length <= 1000 <= k <= 1000s仅由小写英文字母组成
解题思路
解法一:贪心,主提交版本
尽量把每个字符变成 'a':对第 i 个字符 c,计算把它变到 'a' 的环形距离 d,
若 d <= 剩余 k,则直接变成 'a'(字典序最小),k -= d;
否则在剩余 k 的限制下,把它变成字典序尽可能小的字符 c2(从 'a' 往 c 靠近,
找到满足环形距离 <= k 的最小字符)。
时间复杂度 O(n * 26),空间复杂度 O(n)。
解法二:逐字符枚举回溯(对照)
依次决定每个位置:若变 'a' 可行则变,否则枚举 c2 从 'a' 到 c-1 找可行最小字符。
与解法一等价,仅实现方式不同。
复杂度:
- 时间复杂度:O(n * 26)
- 空间复杂度:O(n)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:贪心(主提交版本) ----------
public String getSmallestString(String s, int k) {
char[] cs = s.toCharArray();
for (int i = 0; i < cs.length; ++i) {
char c1 = cs[i];
int dToA = Math.min(c1 - 'a', 26 - (c1 - 'a'));
if (dToA <= k) {
cs[i] = 'a';
k -= dToA;
continue;
}
// 不能到 'a',在剩余限制内选最小的可行字符
for (char c2 = 'a'; c2 < c1; ++c2) {
int d = Math.min(c1 - c2, 26 - c1 + c2);
if (d <= k) {
cs[i] = c2;
k -= d;
break;
}
}
}
return new String(cs);
}
// ---------- 解法二:逐字符枚举(对照实现) ----------
public String getSmallestStringBrute(String s, int k) {
char[] cs = s.toCharArray();
for (int i = 0; i < cs.length && k > 0; ++i) {
char c1 = cs[i];
for (char c2 = 'a'; c2 < c1; ++c2) {
int d = Math.min(c1 - c2, 26 - c1 + c2);
if (d <= k) {
cs[i] = c2;
k -= d;
break;
}
}
}
return new String(cs);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] ss = { "zbbz", "xaxcd", "lol", "a", "zzzz", "abc" };
int[] ks = { 3, 4, 0, 5, 1, 0 };
String[] expects = { "aaaz", "aawcd", "lol", "a", "azzz", "abc" };
boolean allPass = true;
for (int i = 0; i < ss.length; ++i) {
String a = sol.getSmallestString(ss[i], ks[i]);
String b = sol.getSmallestStringBrute(ss[i], ks[i]);
boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rnd.nextInt(8);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rnd.nextInt(26)));
}
int k = rnd.nextInt(30);
String a = sol.getSmallestString(sb.toString(), k);
String b = sol.getSmallestStringBrute(sb.toString(), k);
if (!a.equals(b)) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH s=" + sb + " k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n * 26),空间复杂度 O(n)。
- 时间复杂度:O(n * 26)
- 空间复杂度:O(n)
3107. Minimum Operations to Make Median of Array Equal to K(使数组中位数等于 K 的最少操作数)
题目描述
给你一个长度为 n 的整数数组 nums 和一个整数 k。
一次操作中,你可以任意选择一个下标 i(0 <= i < n),将 nums[i] 增加或减少 1。
请你返回使 nums 的中位数等于 k 所需的最少操作次数。
数组的中位数:将数组排序后,位于中间位置的元素。若 n 为偶数,则取排序后中间两个元素中较小的一个(下标 n/2)。
示例 1
nums = [2,5,6,8,5], k = 4 -> 2(修改 5 为 4:一次)
示例 2
nums = [2,5,6,8,5], k = 7 -> 3
示例 3
nums = [1,2,3,4,5], k = 5 -> 3
提示:
1 <= n <= 10^51 <= nums[i] <= 10^91 <= k <= 10^9
解题思路
解法一:排序 + 中位数两侧调整,主提交版本
将 nums 排序。设中位数为 numsm(m = n/2)。
- 若 numsm > k:需要把中位数及其左侧所有大于 k 的元素都降为 k,
累加 (numsi - k)(左侧元素不必动,因为中位数定义左侧小于等于中位数,
但若左侧有值大于 k,会突破"中位数恰为 k"的约束,需一并降)。 - 若 numsm < k:需要把中位数及其右侧所有小于 k 的元素都升为 k,
累加 (k - numsi)。 - numsm == k 时 ans = 0。
时间复杂度 O(n log n),空间复杂度 O(log n)(排序栈空间)。
解法二:复制数组排序(对照)
同上原理,不修改原数组,用 copyOf 复制排序。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(1)(原地排序)或 O(n)(复制)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:排序(主提交版本) ----------
public long minOperationsToMakeMedianK(int[] nums, int k) {
Arrays.sort(nums);
int n = nums.length;
int m = n >> 1;
long ans = Math.abs((long) nums[m] - k);
if (nums[m] > k) {
for (int i = m - 1; i >= 0 && nums[i] > k; --i) {
ans += nums[i] - k;
}
} else {
for (int i = m + 1; i < n && nums[i] < k; ++i) {
ans += k - nums[i];
}
}
return ans;
}
// ---------- 解法二:复制排序(对照) ----------
public long minOperationsToMakeMedianKCopy(int[] nums, int k) {
int[] a = Arrays.copyOf(nums, nums.length);
Arrays.sort(a);
int n = a.length;
int m = n >> 1;
long ans = Math.abs((long) a[m] - k);
if (a[m] > k) {
for (int i = m - 1; i >= 0 && a[i] > k; --i) {
ans += a[i] - k;
}
} else {
for (int i = m + 1; i < n && a[i] < k; ++i) {
ans += k - a[i];
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] nums = { {2, 5, 6, 8, 5}, {2, 5, 6, 8, 5}, {1, 2, 3, 4, 5}, {1}, {5, 5, 5}, {1, 1, 1, 10} };
int[] ks = { 4, 7, 5, 1, 7, 1 };
long[] expects = { 2, 3, 3, 0, 4, 0 };
boolean allPass = true;
for (int i = 0; i < nums.length; ++i) {
long a = sol.minOperationsToMakeMedianK(nums[i].clone(), ks[i]);
long b = sol.minOperationsToMakeMedianKCopy(nums[i].clone(), ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> " + a + " / copy=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 1 + rnd.nextInt(8);
int[] arr = new int[n];
for (int i = 0; i < n; ++i) {
arr[i] = 1 + rnd.nextInt(12);
}
int k = 1 + rnd.nextInt(12);
long a = sol.minOperationsToMakeMedianK(arr.clone(), k);
long b = sol.minOperationsToMakeMedianKCopy(arr.clone(), k);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH n=" + n + " k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(log n)(排序栈空间)。
- 时间复杂度:O(n log n)
- 空间复杂度:O(1)(原地排序)或 O(n)(复制)
3108. Minimum Cost Walk in Weighted Graph(带权图里旅途的最小代价)
题目描述
给你一个 n 个节点的带权无向图,节点编号为 0 到 n - 1。
给你一个整数 n 和一个数组 edges,其中 edges[i] = `ui`, `vi`, `wi` 表示节点 ui 和 vi 之间
有一条权值为 wi 的无向边。
一趟旅途的代价定义为经过的边权按位与 AND 的结果(与顺序无关)。
给你一个二维数组 query,其中 query[i] = `si`, `ti`。对于每一个查询,你需要找出从节点 si
开始,在节点 ti 处结束的旅途的最小代价。如果不存在这样的旅途,答案为 -1。
返回数组 answer,其中 answer[i] 表示对于查询 i 的最小旅途代价。
示例 1
n = 5, edges = [[0,1,7],[1,3,7],[1,2,1]], query = [[0,3],[3,4]] -> [1,-1]
示例 2
n = 3, edges = [[0,2,7],[0,1,15],[1,2,6],[1,2,1]], query = [[1,2]] -> [0]
提示:
1 <= n <= 10^50 <= edges.length <= 10^50 <= ui, vi < n1 <= wi <= 10^91 <= query.length <= 10^5
解题思路
解法一:并查集 + 连通分量位与,主提交版本
按位与 AND 满足"多走边只会让代价变小或不变":对同一连通分量内的任意两点,
可以把分量内所有边全部走一遍(可重复走边/节点),代价 = 分量内所有边权的按位与。
因此:
- 先用并查集合并所有边,得到连通分量;
- 对每条边 e,令其所在分量根 root 的代价 groot &= e2(初值 -1,即全 1);
- 查询 (s, t):若 s == t 返回 0;若 s、t 不同根返回 -1;否则返回 gfind(s)。
时间复杂度 O((n + m + q) * α(n)),空间复杂度 O(n)。
解法二:BFS 暴力(对照,小规模)
对每个查询,以 s 为起点做 DFS/BFS,把所有可达边权累 AND,得出 s 所在连通分量的
全体边权 AND;再判断 t 是否与其连通。仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O((n + m + q) * α(n))
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:并查集 + 分量位与(主提交版本) ----------
public int[] minimumCost(int n, int[][] edges, int[][] query) {
int[] p = new int[n];
for (int i = 0; i < n; ++i) {
p[i] = i;
}
for (int[] e : edges) {
union(p, e[0], e[1]);
}
int[] g = new int[n];
Arrays.fill(g, -1); // -1 = 全 1 位,相当于 AND 的零元
for (int[] e : edges) {
int root = find(p, e[0]);
g[root] &= e[2];
}
int m = query.length;
int[] ans = new int[m];
for (int i = 0; i < m; ++i) {
int s = query[i][0], t = query[i][1];
ans[i] = f(p, g, s, t);
}
return ans;
}
private int find(int[] p, int x) {
if (p[x] != x) {
p[x] = find(p, p[x]);
}
return p[x];
}
private void union(int[] p, int a, int b) {
int pa = find(p, a), pb = find(p, b);
if (pa != pb) {
p[pa] = pb;
}
}
private int f(int[] p, int[] g, int u, int v) {
if (u == v) {
return 0;
}
int a = find(p, u), b = find(p, v);
return a == b ? g[a] : -1;
}
// ---------- 解法二:DFS 暴力(对照) ----------
public int[] minimumCostBrute(int n, int[][] edges, int[][] query) {
// 邻接表
@SuppressWarnings({ "unchecked", "rawtypes" })
java.util.List<int[]>[] adj = new java.util.ArrayList[n];
for (int i = 0; i < n; ++i) {
adj[i] = new java.util.ArrayList<>();
}
for (int[] e : edges) {
adj[e[0]].add(new int[] { e[1], e[2] });
adj[e[1]].add(new int[] { e[0], e[2] });
}
int m = query.length;
int[] ans = new int[m];
for (int i = 0; i < m; ++i) {
int s = query[i][0], t = query[i][1];
if (s == t) {
ans[i] = 0;
continue;
}
boolean[] vis = new boolean[n];
int[] and = { -1 }; // 分量内所有可触及边权 AND
dfs(s, adj, vis, and);
if (!vis[t]) {
ans[i] = -1;
} else {
ans[i] = and[0];
}
}
return ans;
}
private void dfs(int u, java.util.List<int[]>[] adj, boolean[] vis, int[] and) {
vis[u] = true;
for (int[] nb : adj[u]) {
int v = nb[0], w = nb[1];
and[0] &= w;
if (!vis[v]) {
dfs(v, adj, vis, and);
}
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] e1 = { {0, 1, 7}, {1, 3, 7}, {1, 2, 1} };
int[][] q1 = { {0, 3}, {3, 4} };
int[][] e2 = { {0, 2, 7}, {0, 1, 15}, {1, 2, 6}, {1, 2, 1} };
int[][] q2 = { {1, 2} };
int[] r1 = sol.minimumCost(5, e1, q1);
int[] b1 = sol.minimumCostBrute(5, e1, q1);
int[] r2 = sol.minimumCost(3, e2, q2);
int[] b2 = sol.minimumCostBrute(3, e2, q2);
boolean ok1 = Arrays.equals(r1, new int[] {1, -1}) && Arrays.equals(b1, new int[] {1, -1});
boolean ok2 = Arrays.equals(r2, new int[] {0}) && Arrays.equals(b2, new int[] {0});
System.out.println("case1 -> " + Arrays.toString(r1) + " brute=" + Arrays.toString(b1)
+ (ok1 ? " PASS" : " FAIL"));
System.out.println("case2 -> " + Arrays.toString(r2) + " brute=" + Arrays.toString(b2)
+ (ok2 ? " PASS" : " FAIL"));
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 2 + rnd.nextInt(7);
int m = rnd.nextInt(12);
int[][] edges = new int[m][3];
for (int i = 0; i < m; ++i) {
edges[i][0] = rnd.nextInt(n);
edges[i][1] = rnd.nextInt(n);
edges[i][2] = 1 + rnd.nextInt(15);
}
int qn = 1 + rnd.nextInt(5);
int[][] qs = new int[qn][2];
for (int i = 0; i < qn; ++i) {
qs[i][0] = rnd.nextInt(n);
qs[i][1] = rnd.nextInt(n);
}
int[] a = sol.minimumCost(n, edges, qs);
int[] b = sol.minimumCostBrute(n, edges, qs);
if (!Arrays.equals(a, b)) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O((n + m + q) * α(n)),空间复杂度 O(n)。
- 时间复杂度:O((n + m + q) * α(n))
- 空间复杂度:O(n)
3109. Find the Index of Permutation(查找排列的下标)
题目描述
给定一个长度为 n 的数组 perm,它是 1, 2, ..., `n` 的一个排列。将 1, 2, ..., `n`
所有的排列放在数组中,并以字典序排序。返回这个数组中 perm 的下标。
由于答案可能非常大,返回值对 10^9 + 7 取模。
示例 1
perm = [1,2] -> 0(字典序最小的排列下标为 0)
示例 2
perm = [3,1,2] -> 4
提示:
1 <= n <= 10^5perm是 1, 2, ..., `n` 的一个排列
解题思路
解法一:康托展开 + 树状数组,主提交版本
字典序中 perm 的下标 = 所有排在它前面的排列个数。
对每个位置 i(下标 0 起),排在 perm 前面的排列数贡献:
cnt_i * (n - i - 1)!,其中 cnt_i = 在位置 i 处,取一个比 permi 小且未被用过的数
作为 permi 时,其余 n-i-1 个位置可任意排列的数量。
用树状数组维护"未使用的数字",cnt_i = (permi - 1) - (已经使用且 < permi 的个数)。
最后 ans = Σ cnt_i * (n-i-1)!(模 10^9+7)。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:暴力(对照,小规模)
递归枚举 1...n 的全排列(字典序生成),逐位比较找到 perm 并计数。
仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:康托展开 + 树状数组(主提交版本) ----------
public int getPermutationIndex(int[] perm) {
final int mod = (int) 1e9 + 7;
long ans = 0;
int n = perm.length;
BinaryIndexedTree tree = new BinaryIndexedTree(n + 1); // 下标 1..n,标记已使用
long[] f = new long[n];
f[0] = 1;
for (int i = 1; i < n; ++i) {
f[i] = f[i - 1] * i % mod; // 阶乘
}
for (int i = 0; i < n; ++i) {
int usedLess = tree.query(perm[i]); // 已使用且值 < perm[i] 的个数
int cnt = (perm[i] - 1) - usedLess; // 剩余未使用的比 perm[i] 小的数
ans = (ans + cnt * f[n - i - 1] % mod) % mod;
tree.update(perm[i], 1);
}
return (int) ans;
}
// ---------- 解法二:暴力全排列(对照) ----------
public int getPermutationIndexBrute(int[] perm) {
int n = perm.length;
int[] cur = new int[n];
boolean[] used = new boolean[n + 1];
int[] cnt = { 0 };
dfs(0, n, cur, used, perm, cnt);
return cnt[0];
}
private boolean dfs(int pos, int n, int[] cur, boolean[] used, int[] perm, int[] cnt) {
if (pos == n) {
if (Arrays.equals(cur, perm)) {
return true;
}
cnt[0]++;
return false;
}
for (int v = 1; v <= n; ++v) {
if (used[v]) {
continue;
}
cur[pos] = v;
used[v] = true;
if (dfs(pos + 1, n, cur, used, perm, cnt)) {
return true;
}
used[v] = false;
}
return false;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] p1 = {1, 2};
int[] p2 = {3, 1, 2};
int r1 = sol.getPermutationIndex(p1);
int b1 = sol.getPermutationIndexBrute(p1);
int r2 = sol.getPermutationIndex(p2);
int b2 = sol.getPermutationIndexBrute(p2);
boolean ok1 = r1 == 0 && b1 == 0;
boolean ok2 = r2 == 4 && b2 == 4;
System.out.println("perm=" + Arrays.toString(p1) + " -> " + r1 + " brute=" + b1
+ " expected=0 " + (ok1 ? "PASS" : "FAIL"));
System.out.println("perm=" + Arrays.toString(p2) + " -> " + r2 + " brute=" + b2
+ " expected=4 " + (ok2 ? "PASS" : "FAIL"));
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 300; ++t) {
int n = 1 + rnd.nextInt(7);
int[] perm = new int[n];
for (int i = 0; i < n; ++i) {
perm[i] = i + 1;
}
// 随机洗牌
for (int i = n - 1; i > 0; --i) {
int j = rnd.nextInt(i + 1);
int tmp = perm[i];
perm[i] = perm[j];
perm[j] = tmp;
}
// 复制避免洗牌影响
int[] permCopy = Arrays.copyOf(perm, n);
int a = sol.getPermutationIndex(perm);
int b = sol.getPermutationIndexBrute(permCopy);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH perm=" + Arrays.toString(perm) + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
}
}
class BinaryIndexedTree {
private int n;
private int[] c;
public BinaryIndexedTree(int n) {
this.n = n;
this.c = new int[n + 1];
}
public void update(int x, int delta) {
for (; x <= n; x += x & -x) {
c[x] += delta;
}
}
public int query(int x) {
int s = 0;
for (; x > 0; x -= x & -x) {
s += c[x];
}
return s;
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3110. Score of a String(字符串的分数)
题目描述
给你一个字符串 s。字符串的分数定义为相邻字符的 ASCII 码差值绝对值之和:
score(s) = sum_{i=1}^{n-1} |s[i] - s[i-1]|
返回字符串的分数。
示例 1
s = "hello" -> 13(|104-101| + |101-108| + |108-108| + |108-111| = 3 + 7 + 0 + 3 = 13)
示例 2
s = "zaz" -> 50(|122-97| + |97-122| = 25 + 25 = 50)
提示:
2 <= s.length <= 100s仅由小写英文字母组成
解题思路
解法一:一次扫描,主提交版本
遍历 i 从 1 到 n-1,累加相邻字符 ASCII 差的绝对值。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:流式求和(对照)
用 while 循环逐位累加,逻辑相同。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:一次扫描(主提交版本) ----------
public int scoreOfString(String s) {
int ans = 0;
for (int i = 1; i < s.length(); ++i) {
ans += Math.abs(s.charAt(i - 1) - s.charAt(i));
}
return ans;
}
// ---------- 解法二:while 循环(对照) ----------
public int scoreOfStringLoop(String s) {
int ans = 0;
int i = 1;
while (i < s.length()) {
ans += Math.abs(s.charAt(i) - s.charAt(i - 1));
++i;
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] ss = { "hello", "zaz", "ab", "az", "abcdef" };
int[] expects = { 13, 50, 1, 25, 5 };
boolean allPass = true;
for (int i = 0; i < ss.length; ++i) {
int a = sol.scoreOfString(ss[i]);
int b = sol.scoreOfStringLoop(ss[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(ss[i] + " -> " + a + " / loop=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 2000; ++t) {
int n = 2 + rnd.nextInt(20);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rnd.nextInt(26)));
}
int a = sol.scoreOfString(sb.toString());
int b = sol.scoreOfStringLoop(sb.toString());
if (a != b) {
fail++;
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3111. Minimum Rectangles to Cover Points(覆盖所有点的最少矩形数目)
题目描述
给你一个二维整数数组 points,其中 points[i] = `xi`, `yi` 表示二维平面内的一个点。
同时给你一个整数 w。你需要用矩形覆盖所有点。
每个矩形的左下角在某个点 (x1, 0) 处,且右上角在某个点 (x2, y2) 处,
其中 x1 <= x2 且 y2 >= 0,同时对于每个矩形都必须满足 x2 - x1 <= w。
如果一个点在矩形内或者在边上,我们说这个点被矩形覆盖了。
请你在确保每个点都至少被一个矩形覆盖的前提下,最少需要多少个矩形。
注意:一个点可以被多个矩形覆盖。
示例 1
points = [[2,1],[1,0],[1,4],[1,8],[3,5],[4,6]], w = 1 -> 2
示例 2
points = [[0,0],[1,1],[2,2],[3,3],[4,4],[5,5],[6,6]], w = 2 -> 3
示例 3
points = [[2,3],[1,2]], w = 0 -> 2
提示:
1 <= points.length <= 10^5points[i].length == 20 <= xi <= 10^90 <= yi <= 10^90 <= w <= 10^9
解题思路
解法一:按 x 排序贪心,主提交版本
矩形的高度 y2 与宽度约束无关(y2 >= 0 即可),因此问题只看 x 坐标:
按 x 升序排序后,从左到右用宽度为 w 的区间覆盖所有点。
贪心:维护上一个区间的右端点 x1(第一个矩形从第一个点的 x 开始,右端 x + w),
每当遇到点的 x > x1(即超出当前区间),新建一个矩形,并更新 x1 = x + w。
区间数即最少矩形数。
时间复杂度 O(n log n)(排序),空间复杂度 O(1)。
解法二:暴力(对照,小规模)
枚举从左到右的覆盖方式:排序后每层贪心从最左未覆盖点开始覆盖 x, x+w,
与解法一同构,这里用循环模拟完整覆盖过程作交叉验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:按 x 排序贪心(主提交版本) ----------
public int minRectanglesToCoverPoints(int[][] points, int w) {
Arrays.sort(points, (a, b) -> a[0] - b[0]);
int ans = 0, x1 = -1; // x1 = 当前矩形右端的 x 坐标
for (int[] p : points) {
int x = p[0];
if (x > x1) { // 当前点无法被已打开的矩形覆盖
++ans;
x1 = x + w;
}
}
return ans;
}
// ---------- 解法二:模拟覆盖(对照) ----------
public int minRectanglesToCoverPointsBrute(int[][] points, int w) {
int n = points.length;
int[] xs = new int[n];
for (int i = 0; i < n; ++i) {
xs[i] = points[i][0];
}
Arrays.sort(xs);
int ans = 0;
int i = 0;
while (i < n) {
++ans;
int right = xs[i] + w;
while (i < n && xs[i] <= right) {
++i;
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] p1 = { {2, 1}, {1, 0}, {1, 4}, {1, 8}, {3, 5}, {4, 6} };
int[][] p2 = { {0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6} };
int[][] p3 = { {2, 3}, {1, 2} };
int w1 = 1, w2 = 2, w3 = 0;
boolean ok1 = sol.minRectanglesToCoverPoints(p1, w1) == 2
&& sol.minRectanglesToCoverPointsBrute(p1, w1) == 2;
boolean ok2 = sol.minRectanglesToCoverPoints(p2, w2) == 3
&& sol.minRectanglesToCoverPointsBrute(p2, w2) == 3;
boolean ok3 = sol.minRectanglesToCoverPoints(p3, w3) == 2
&& sol.minRectanglesToCoverPointsBrute(p3, w3) == 2;
System.out.println("case1 -> " + sol.minRectanglesToCoverPoints(p1, w1)
+ " brute=" + sol.minRectanglesToCoverPointsBrute(p1, w1)
+ " expected=2 " + (ok1 ? "PASS" : "FAIL"));
System.out.println("case2 -> " + sol.minRectanglesToCoverPoints(p2, w2)
+ " brute=" + sol.minRectanglesToCoverPointsBrute(p2, w2)
+ " expected=3 " + (ok2 ? "PASS" : "FAIL"));
System.out.println("case3 -> " + sol.minRectanglesToCoverPoints(p3, w3)
+ " brute=" + sol.minRectanglesToCoverPointsBrute(p3, w3)
+ " expected=2 " + (ok3 ? "PASS" : "FAIL"));
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 800; ++t) {
int n = 1 + rnd.nextInt(10);
int[][] pts = new int[n][2];
for (int i = 0; i < n; ++i) {
pts[i][0] = rnd.nextInt(31);
pts[i][1] = rnd.nextInt(31);
}
int w = rnd.nextInt(6);
int a = sol.minRectanglesToCoverPoints(pts, w);
int b = sol.minRectanglesToCoverPointsBrute(pts, w);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH a=" + a + " b=" + b + " w=" + w
+ " pts=" + Arrays.deepToString(pts));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 && ok3 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n)(排序),空间复杂度 O(1)。
- 时间复杂度:O(n log n)
- 空间复杂度:O(1)
3112. Minimum Time to Visit Disappearing Nodes(访问消失节点的最少时间)
题目描述
给你一个二维数组 edges 表示一个 n 个点的无向图,其中 edges[i] = `ui`, `vi`, `lengthi`
表示节点 ui 和节点 vi 之间有一条需要 lengthi 单位时间通过的无向边。
同时给你一个数组 disappear,其中 disappear[i] 表示节点 i 从图中消失的时间点,
在那一刻及以后,你无法再访问这个节点。
注意,图有可能一开始是不连通的,两个节点之间也可能有多条边。
返回数组 answer,answer[i] 表示从节点 0 到节点 i 需要的最少单位时间。
如果从节点 0 出发无法到达节点 i,那么 answer[i] 为 -1。
示例 1
n = 3, edges = [[0,1,2],[1,2,1],[0,2,4]], disappear = [1,1,5] -> [0,-1,4]
示例 2
n = 3, edges = [[0,1,2],[1,2,1],[0,2,4]], disappear = [1,3,5] -> [0,2,3]
示例 3
n = 2, edges = [[0,1,1]], disappear = [1,1] -> [0,-1]
提示:
2 <= n <= 10^51 <= edges.length <= 10^50 <= ui, vi <= n - 11 <= lengthi <= 10^5disappear.length == n0 <= disappear[i] <= 10^9
解题思路
解法一:Dijkstra 最短路,主提交版本
节点 i 在 disappeari 时刻及以后无法访问,因此松弛边 (u, v, w) 时,
只有当 distu + w < disappearv 才允许更新 distv。
起点 0 的 dist 为 0;最终 answeri = disti < disappeari ? disti : -1。
用优先队列实现堆优化 Dijkstra。
时间复杂度 O((n + m) log n),空间复杂度 O(n + m)。
解法二:Bellman-Ford(对照,小规模)
重复 n-1 轮,每轮对所有无向边松弛两次(带消失时间约束),直到不再更新。
与堆优化的写法完全不同(朴素逐轮松弛),用于交叉验证。
时间复杂度 O(n * m),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O((n + m) log n)
- 空间复杂度:O(n + m)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.PriorityQueue;
import java.util.Random;
public class Solution {
// ---------- 解法一:Dijkstra 堆优化(主提交版本) ----------
public int[] minimumTime(int n, int[][] edges, int[] disappear) {
List<int[]>[] g = new List[n];
for (int i = 0; i < n; ++i) {
g[i] = new ArrayList<>();
}
for (int[] e : edges) {
int u = e[0], v = e[1], w = e[2];
g[u].add(new int[] {v, w});
g[v].add(new int[] {u, w});
}
int[] dist = new int[n];
Arrays.fill(dist, Integer.MAX_VALUE / 2);
dist[0] = 0;
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
pq.offer(new int[] {0, 0});
while (!pq.isEmpty()) {
int[] cur = pq.poll();
int d = cur[0], u = cur[1];
if (d > dist[u]) {
continue;
}
for (int[] nx : g[u]) {
int v = nx[0], w = nx[1];
int nd = d + w;
if (nd < dist[v] && nd < disappear[v]) {
dist[v] = nd;
pq.offer(new int[] {nd, v});
}
}
}
int[] ans = new int[n];
for (int i = 0; i < n; ++i) {
ans[i] = dist[i] < disappear[i] ? dist[i] : -1;
}
return ans;
}
// ---------- 解法二:Bellman-Ford(对照) ----------
public int[] minimumTimeBF(int n, int[][] edges, int[] disappear) {
int[] dist = new int[n];
Arrays.fill(dist, Integer.MAX_VALUE / 2);
dist[0] = 0;
for (int r = 0; r < n - 1; ++r) {
boolean changed = false;
for (int[] e : edges) {
int u = e[0], v = e[1], w = e[2];
if (dist[u] + w < dist[v] && dist[u] + w < disappear[v]) {
dist[v] = dist[u] + w;
changed = true;
}
if (dist[v] + w < dist[u] && dist[v] + w < disappear[u]) {
dist[u] = dist[v] + w;
changed = true;
}
}
if (!changed) {
break;
}
}
int[] ans = new int[n];
for (int i = 0; i < n; ++i) {
ans[i] = dist[i] < disappear[i] ? dist[i] : -1;
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] e1 = { {0, 1, 2}, {1, 2, 1}, {0, 2, 4} };
int[] d1 = {1, 1, 5};
int[] d2 = {1, 3, 5};
int[][] e3 = { {0, 1, 1} };
int[] d3 = {1, 1};
boolean ok1 = Arrays.equals(sol.minimumTime(3, e1, d1), new int[] {0, -1, 4})
&& Arrays.equals(sol.minimumTimeBF(3, e1, d1), new int[] {0, -1, 4});
boolean ok2 = Arrays.equals(sol.minimumTime(3, e1, d2), new int[] {0, 2, 3})
&& Arrays.equals(sol.minimumTimeBF(3, e1, d2), new int[] {0, 2, 3});
boolean ok3 = Arrays.equals(sol.minimumTime(2, e3, d3), new int[] {0, -1})
&& Arrays.equals(sol.minimumTimeBF(2, e3, d3), new int[] {0, -1});
System.out.println("case1 -> " + Arrays.toString(sol.minimumTime(3, e1, d1))
+ (ok1 ? " PASS" : " FAIL"));
System.out.println("case2 -> " + Arrays.toString(sol.minimumTime(3, e1, d2))
+ (ok2 ? " PASS" : " FAIL"));
System.out.println("case3 -> " + Arrays.toString(sol.minimumTime(2, e3, d3))
+ (ok3 ? " PASS" : " FAIL"));
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 2 + rnd.nextInt(6);
int m = rnd.nextInt(10);
int[][] edges = new int[m][3];
for (int i = 0; i < m; ++i) {
edges[i][0] = rnd.nextInt(n);
edges[i][1] = rnd.nextInt(n);
edges[i][2] = 1 + rnd.nextInt(8);
}
int[] dis = new int[n];
for (int i = 0; i < n; ++i) {
dis[i] = 1 + rnd.nextInt(15);
}
int[] a = sol.minimumTime(n, edges, dis);
int[] b = sol.minimumTimeBF(n, edges, dis);
if (!Arrays.equals(a, b)) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 && ok3 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O((n + m) log n),空间复杂度 O(n + m)。
时间复杂度 O(n * m),仅用于小规模交叉验证。
- 时间复杂度:O((n + m) log n)
- 空间复杂度:O(n + m)
3113. Find the Number of Subarrays Where Boundary Elements Are Maximum
题目描述
(边界元素是最大值的子数组数目)
给你一个正整数数组 nums。
请你求出 nums 中有多少个子数组,满足子数组中第一个和最后一个元素都是这个子数组中的最大值。
示例 1
nums = [1,4,3,3,2] -> 6
示例 2
nums = [3,3,3] -> 6
提示:
1 <= nums.length <= 10^51 <= nums[i] <= 10^9
解题思路
解法一:单调栈 + 同值计数,主提交版本
依次将每个元素 x 作为子数组的"右端点"考虑,统计以当前位为末尾、
且首尾都是最大值的子数组个数。
维护一个严格"单调不增"的栈(栈内元素自底向上非增,同时统计相同值的出现次数):
- 弹出所有小于 x 的栈顶(它们不可能再与后续元素形成"首尾最大"子数组);
- 若栈空或栈顶值 > x:push (x, 1);
- 若栈顶值 == x:栈顶计数 +1。
每步把栈顶(即 x)的计数加到答案:这统计了"以 x 结尾、以 x 开头"且中间无更大值的
所有子数组(内含 k 个连续 x 的所有后缀组合)。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:暴力(对照,小规模)
枚举所有子数组 i, j,扫描区间找最大值,检查 numsi == 最大值 && numsj == 最大值。
仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.Deque;
import java.util.Random;
public class Solution {
// ---------- 解法一:单调栈(主提交版本) ----------
public long numberOfSubarrays(int[] nums) {
Deque<int[]> stk = new ArrayDeque<>(); // [值, 该值连续出现次数]
long ans = 0;
for (int x : nums) {
while (!stk.isEmpty() && stk.peek()[0] < x) {
stk.pop();
}
if (stk.isEmpty() || stk.peek()[0] > x) {
stk.push(new int[] {x, 1});
} else {
stk.peek()[1]++;
}
ans += stk.peek()[1];
}
return ans;
}
// ---------- 解法二:暴力(对照) ----------
public long numberOfSubarraysBrute(int[] nums) {
int n = nums.length;
long ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
int mx = nums[i];
for (int k = i + 1; k <= j; ++k) {
mx = Math.max(mx, nums[k]);
}
if (nums[i] == mx && nums[j] == mx) {
ans++;
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] n1 = {1, 4, 3, 3, 2};
int[] n2 = {3, 3, 3};
boolean ok1 = sol.numberOfSubarrays(n1) == 6 && sol.numberOfSubarraysBrute(n1) == 6;
boolean ok2 = sol.numberOfSubarrays(n2) == 6 && sol.numberOfSubarraysBrute(n2) == 6;
System.out.println("case1 -> " + sol.numberOfSubarrays(n1) + " brute="
+ sol.numberOfSubarraysBrute(n1) + " expected=6 " + (ok1 ? "PASS" : "FAIL"));
System.out.println("case2 -> " + sol.numberOfSubarrays(n2) + " brute="
+ sol.numberOfSubarraysBrute(n2) + " expected=6 " + (ok2 ? "PASS" : "FAIL"));
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 800; ++t) {
int n = 1 + rnd.nextInt(9);
int[] arr = new int[n];
for (int i = 0; i < n; ++i) {
arr[i] = 1 + rnd.nextInt(5);
}
long a = sol.numberOfSubarrays(arr);
long b = sol.numberOfSubarraysBrute(arr);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH a=" + a + " b=" + b + " arr=" + Arrays.toString(arr));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3114. Latest Time You Can Obtain After Replacing Characters(替换字符可以得到的最晚时间)
题目描述
给你一个字符串 s,表示一个 12 小时制的时间格式,其中一些数字(可能没有)被 "?" 替换。
12 小时制时间格式为 "HH:MM",其中 HH 的取值范围为 00 至 11,MM 的取值范围为 00 至 59。
最早的时间为 00:00,最晚的时间为 11:59。
你需要将 s 中的所有 "?" 字符替换为数字,使得结果字符串代表的时间是一个有效的 12 小时制时间,
并且是可能的最晚时间。返回结果字符串。
示例 1
s = "1?:?4" -> "11:54"
示例 2
s = "0?:5?" -> "09:59"
提示:
s.length== 5,s[2]是字符 ":"- 除
s[2]外,其他字符都是数字或 "?" - 输入保证存在至少一个介于 "00:00" 和 "11:59" 之间的时间
解题思路
解法一:倒序枚举,主提交版本
从最晚时间 11:59 开始倒序枚举所有 12 小时制时间 HH:MM,
检查当前时间是否与 s 的每个非 '?' 字符匹配,第一个匹配即答案。
枚举范围有限(12 * 60 = 720 种),时间空间均很小。
时间复杂度 O(12 * 60 * 5),空间复杂度 O(1)。
解法二:按位贪心构造(对照)
直接按位确定:第一位尽量取满足约束的最大数字,
但由于 HH 的十位和个位相互制约,需逐位检查。
实现复杂度略高,用于交叉验证。
复杂度:
- 时间复杂度:O(1)(枚举上限固定)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:倒序枚举(主提交版本) ----------
public String findLatestTime(String s) {
for (int h = 11; h >= 0; --h) {
for (int m = 59; m >= 0; --m) {
String t = String.format("%02d:%02d", h, m);
boolean ok = true;
for (int i = 0; i < s.length(); ++i) {
if (s.charAt(i) != '?' && s.charAt(i) != t.charAt(i)) {
ok = false;
break;
}
}
if (ok) {
return t;
}
}
}
return "";
}
// ---------- 解法二:按位贪心(对照) ----------
public String findLatestTimeGreedy(String s) {
char[] cs = s.toCharArray();
// 时
if (cs[0] == '?' && cs[1] == '?') {
cs[0] = '1';
cs[1] = '1';
} else if (cs[0] == '?') {
cs[0] = (cs[1] <= '1') ? '1' : '0';
} else if (cs[1] == '?') {
cs[1] = (cs[0] == '1') ? '1' : '9';
}
// 分
if (cs[3] == '?') {
cs[3] = '5';
}
if (cs[4] == '?') {
cs[4] = '9';
}
return new String(cs);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] ss = { "1?:?4", "0?:5?", "??:??", "0?:??", "?3:??", "11:59", "00:00" };
String[] expects = { "11:54", "09:59", "11:59", "09:59", "03:59", "11:59", "00:00" };
boolean allPass = true;
for (int i = 0; i < ss.length; ++i) {
String a = sol.findLatestTime(ss[i]);
String b = sol.findLatestTimeGreedy(ss[i]);
boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
allPass &= ok;
System.out.println(ss[i] + " -> " + a + " / greedy=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 全量对拍所有合法 ? 组合(随机生成)
Random rnd = new Random(42);
int fail = 0;
String chars = "0123456789?";
for (int t = 0; t < 3000; ++t) {
StringBuilder sb = new StringBuilder();
sb.append(chars.charAt(rnd.nextInt(11)));
sb.append(chars.charAt(rnd.nextInt(11)));
sb.append(':');
sb.append(chars.charAt(rnd.nextInt(11)));
sb.append(chars.charAt(rnd.nextInt(11)));
String s = sb.toString();
// 只保留存在合法解的模式(用枚举法判)
boolean has = false;
for (int h = 0; h < 12 && !has; ++h) {
for (int m = 0; m < 60 && !has; ++m) {
String tt = String.format("%02d:%02d", h, m);
boolean ok = true;
for (int i = 0; i < 5; ++i) {
if (s.charAt(i) != '?' && s.charAt(i) != tt.charAt(i)) {
ok = false;
break;
}
}
has = ok;
}
}
if (!has) {
continue;
}
String a = sol.findLatestTime(s);
String b = sol.findLatestTimeGreedy(s);
if (!a.equals(b)) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(12 * 60 * 5),空间复杂度 O(1)。
- 时间复杂度:O(1)(枚举上限固定)
- 空间复杂度:O(1)
3115. Maximum Prime Difference(质数的最大距离)
题目描述
给你一个整数数组 nums,返回两个(不一定不同的)质数在 nums 中下标的最大距离。
两个下标 i 和 j 的距离定义为 |i - j|。nums 中至少存在一个质数。
示例 1
nums = [4,2,9,5,3] -> 3(2 在下标 1,3 在下标 4,|4-1|=3)
示例 2
nums = [4,8,2,8] -> 0(只有一个质数 2,|2-2|=0)
提示:
1 <= nums.length <= 3 * 10^51 <= nums[i] <= 100nums中至少有一个质数
解题思路
解法一:两端双指针,主提交版本
从左向右找第一个质数下标 i,从右向左找最后一个质数下标 j,
答案为 j - i。
判断质数用试除法:x < 2 不是质数,枚举 v 从 2 到 sqrt(x) 检查因子。
时间复杂度 O(n * sqrt(max)),空间复杂度 O(1)。
解法二:先收集所有质数下标(对照)
从左到右扫描收集所有质数下标,答案为首尾下标之差。
复杂度:
- 时间复杂度:O(n * sqrt(V)),V 为最大元素值(100)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:两端双指针(主提交版本) ----------
public int maximumPrimeDifference(int[] nums) {
for (int i = 0; ; ++i) {
if (isPrime(nums[i])) {
for (int j = nums.length - 1; ; --j) {
if (isPrime(nums[j])) {
return j - i;
}
}
}
}
}
private boolean isPrime(int x) {
if (x < 2) {
return false;
}
for (int v = 2; v * v <= x; ++v) {
if (x % v == 0) {
return false;
}
}
return true;
}
// ---------- 解法二:收集下标(对照) ----------
public int maximumPrimeDifferenceList(int[] nums) {
int first = -1, last = -1;
for (int i = 0; i < nums.length; ++i) {
if (isPrime(nums[i])) {
if (first == -1) {
first = i;
}
last = i;
}
}
return last - first;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = { {4, 2, 9, 5, 3}, {4, 8, 2, 8}, {2}, {7}, {1, 2, 3, 4, 5, 6, 7}, {11, 4, 8} };
int[] expects = { 3, 0, 0, 0, 5, 0 };
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.maximumPrimeDifference(cases[i]);
int b = sol.maximumPrimeDifferenceList(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> " + a + " / list=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rnd.nextInt(10);
int[] arr = new int[n];
boolean hasPrime = false;
for (int i = 0; i < n; ++i) {
arr[i] = 1 + rnd.nextInt(50);
hasPrime |= sol.isPrime(arr[i]);
}
if (!hasPrime) {
arr[rnd.nextInt(n)] = 2;
}
int a = sol.maximumPrimeDifference(arr);
int b = sol.maximumPrimeDifferenceList(arr);
if (a != b) {
fail++;
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n * sqrt(max)),空间复杂度 O(1)。
- 时间复杂度:O(n * sqrt(V)),V 为最大元素值(100)
- 空间复杂度:O(1)
3116. Kth Smallest Amount With Single Denomination Combination
题目描述
(单面值组合的第 K 小金额)
给你一个整数数组 coins 表示不同面额的硬币,另给你一个整数 k。
你有无限量的每种面额的硬币。但是,你不能组合使用不同面额的硬币。
返回使用这些硬币能制造的第 k 小金额。
示例 1
coins = [3,6,9], k = 3 -> 9
示例 2
coins = [5,2], k = 7 -> 12
提示:
1 <= coins.length <= 151 <= coins[i] <= 251 <= k <= 2 * 10^9
解题思路
解法一:二分答案 + 容斥原理,主提交版本
不能组合不同面额,因此能制造的金额集合 = 各面额正倍数集合的并。
f(m) = <= m 的金额个数 = Σ_{非空子集 S} (-1)^(|S|+1) * floor(m / lcm(S))。
对 m 二分:"f(m) >= k" 的最小 m 即答案。面额两两可能不互质,
lcm 可能爆 long,遇到 lcm > m 直接剪枝(该子集贡献为 0)。
子集枚举用位运算(coins.length <= 15,共 2^15 个子集)。
时间复杂度 O(2^n * n * log(max)),空间复杂度 O(1)。
解法二:小堆/集合暴力(对照,小规模)
维护 TreeSet 存储各面额倍数,重复取最小 k 次(每个面额维护游标)。
仅用于小规模交叉验证(k 小、max 小)。
复杂度:
- 时间复杂度:O(2^n * n * log C)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
import java.util.TreeSet;
public class Solution {
// ---------- 解法一:二分 + 容斥(主提交版本) ----------
public long findKthSmallest(int[] coins, int k) {
long l = 1, r = (long) 1e11;
while (l < r) {
long mid = (l + r) >> 1;
if (check(coins, mid) >= k) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
private long check(int[] coins, long mx) {
long cnt = 0;
int n = coins.length;
for (int mask = 1; mask < 1 << n; ++mask) {
long v = 1;
for (int j = 0; j < n; ++j) {
if ((mask >> j & 1) == 1) {
v = lcm(v, coins[j]);
if (v > mx) {
break; // 超过上界,该子集贡献为 0
}
}
}
if (v > mx) {
continue;
}
int bit = Integer.bitCount(mask);
if ((bit & 1) == 1) {
cnt += mx / v;
} else {
cnt -= mx / v;
}
}
return cnt;
}
private long lcm(long a, long b) {
if (a == 0 || b == 0) {
return 1;
}
return a / gcd(a, b) * b;
}
private long gcd(long a, long b) {
return b == 0 ? a : gcd(b, a % b);
}
// ---------- 解法二:TreeSet 暴力(对照) ----------
public long findKthSmallestBrute(int[] coins, int k) {
// 每个面额维护当前倍数游标
long[] cur = new long[coins.length];
TreeSet<long[]> set = new TreeSet<>((a, b) ->
a[0] != b[0] ? Long.compare(a[0], b[0]) : Long.compare(a[1], b[1]));
for (int i = 0; i < coins.length; ++i) {
cur[i] = coins[i];
set.add(new long[] {cur[i], i});
}
long last = 0;
int taken = 0;
while (taken < k) {
long[] top = set.pollFirst();
long val = top[0];
int idx = (int) top[1];
if (val != last) { // 去重
last = val;
taken++;
}
cur[idx] += coins[idx];
set.add(new long[] {cur[idx], idx});
}
return last;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] c1 = {3, 6, 9};
int[] c2 = {5, 2};
boolean ok1 = sol.findKthSmallest(c1, 3) == 9 && sol.findKthSmallestBrute(c1, 3) == 9;
boolean ok2 = sol.findKthSmallest(c2, 7) == 12 && sol.findKthSmallestBrute(c2, 7) == 12;
System.out.println("case1 -> " + sol.findKthSmallest(c1, 3) + " brute="
+ sol.findKthSmallestBrute(c1, 3) + " expected=9 " + (ok1 ? "PASS" : "FAIL"));
System.out.println("case2 -> " + sol.findKthSmallest(c2, 7) + " brute="
+ sol.findKthSmallestBrute(c2, 7) + " expected=12 " + (ok2 ? "PASS" : "FAIL"));
// 随机对拍(k 小)
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 300; ++t) {
int n = 1 + rnd.nextInt(4);
int[] coins = new int[n];
for (int i = 0; i < n; ++i) {
coins[i] = 1 + rnd.nextInt(12);
}
int k = 1 + rnd.nextInt(25);
long a = sol.findKthSmallest(coins, k);
long b = sol.findKthSmallestBrute(coins, k);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH coins=" + Arrays.toString(coins) + " k=" + k
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(2^n * n * log(max)),空间复杂度 O(1)。
- 时间复杂度:O(2^n * n * log C)
- 空间复杂度:O(1)
3117. Minimum Sum of Values by Dividing Array(划分数组得到最小的值之和)
题目描述
给你两个数组 nums 和 andValues,长度分别为 n 和 m。
数组的值等于该数组的最后一个元素。
你需要将 nums 划分为 m 个不相交的连续子数组,对于第 ith 个子数组 `li`, `ri`,
子数组元素的按位 AND 运算结果等于 andValues[i]。
返回将 nums 划分为 m 个子数组所能得到的可能的最小子数组值之和。
如果无法完成这样的划分,则返回 -1。
示例 1
nums = [1,4,3,3,2], andValues = [0,3,3,2] -> 12
示例 2
nums = [2,3,5,7,7,7,5], andValues = [0,7,5] -> 17
提示:
1 <= n == nums.length <= 10^41 <= m == andValues.length <= min(n, 10)1 <= nums[i] < 2^170 <= andValues[j] < 2^17
解题思路
解法一:记忆化 DFS,主提交版本
dfs(i, j, a):从 numsi 开始、还要划分 andValuesj... 段、当前段已累积 AND 为 a 的
最小"段值之和"(若不可行返回 inf)。
转移:
a' = a & numsi;若 a' < andValuesj 直接返回 inf(AND 只会变小,不可能再等于目标);
继续扩展当前段:dfs(i+1, j, a');
若 a' == andValuesj,可以在此处结束段 j:numsi + dfs(i+1, j+1, -1)。
剪枝:剩余可分配元素不足(n - i < m - j)返回 inf。
记忆化 key 用 (i, j, a) 打包成 long。
时间复杂度 O(n * m * 2^17),空间复杂度 O(n * m * 2^17)(实际远小于,剪枝极强)。
解法二:DP 自底向上(对照)
dpij = 把 nums0...i-1 划分为 j 段的最小值之和(INF 表示不可行)。
枚举最后一段的起点 l,若 numsl...i-1 的 AND == andValuesj-1,
则 dpij = min(dpij, dplj-1 + numsi-1)。
两法完全独立实现,交叉验证。
复杂度:
- 时间复杂度:O(m * n * m)(实际 + 剪枝)
- 空间复杂度:O(m * n)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
private static final int INF = 1 << 29;
// ---------- 解法一:记忆化 DFS(主提交版本) ----------
private int[] nums;
private int[] andValues;
private Map<Long, Integer> memo;
public int minimumValueSum(int[] nums, int[] andValues) {
this.nums = nums;
this.andValues = andValues;
this.memo = new HashMap<>();
int ans = dfs(0, 0, -1);
return ans >= INF ? -1 : ans;
}
private int dfs(int i, int j, int a) {
if (nums.length - i < andValues.length - j) {
return INF; // 剩余元素不够分
}
if (j == andValues.length) {
return i == nums.length ? 0 : INF;
}
a &= nums[i];
if (a < andValues[j]) {
return INF; // AND 只会继续变小,不可能再等于 andValues[j]
}
long key = ((long) i << 36) | ((long) j << 32) | (a & 0xffffffffL);
if (memo.containsKey(key)) {
return memo.get(key);
}
int ans = dfs(i + 1, j, a); // 当前段继续扩张
if (a == andValues[j]) {
// 在此处结束当前段,nums[i] 是本段最后一个元素(段的值)
ans = Math.min(ans, dfs(i + 1, j + 1, -1) + nums[i]);
}
memo.put(key, ans);
return ans;
}
// ---------- 解法二:自底向上 DP(对照) ----------
public int minimumValueSumDP(int[] nums, int[] andValues) {
int n = nums.length, m = andValues.length;
int[][] dp = new int[m + 1][n + 1];
for (int[] row : dp) {
Arrays.fill(row, INF);
}
dp[0][0] = 0;
// 简化实现:三重循环,内层从右向左累积 AND
for (int j = 1; j <= m; ++j) {
for (int i = 1; i <= n; ++i) {
int and = -1;
for (int l = i - 1; l >= 0; --l) {
and &= nums[l];
if (and == andValues[j - 1]) {
if (dp[j - 1][l] != INF) {
dp[j][i] = Math.min(dp[j][i], dp[j - 1][l] + nums[i - 1]);
}
} else if (and < andValues[j - 1]) {
break; // 再往前 AND 只会更小
}
}
}
}
return dp[m][n] >= INF ? -1 : dp[m][n];
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] nums1 = {1, 4, 3, 3, 2};
int[] av1 = {0, 3, 3, 2};
int[] nums2 = {2, 3, 5, 7, 7, 7, 5};
int[] av2 = {0, 7, 5};
boolean ok1 = sol.minimumValueSum(nums1, av1) == 12
&& sol.minimumValueSumDP(nums1, av1) == 12;
boolean ok2 = sol.minimumValueSum(nums2, av2) == 17
&& sol.minimumValueSumDP(nums2, av2) == 17;
System.out.println("case1 -> " + sol.minimumValueSum(nums1, av1) + " dp="
+ sol.minimumValueSumDP(nums1, av1) + " expected=12 " + (ok1 ? "PASS" : "FAIL"));
System.out.println("case2 -> " + sol.minimumValueSum(nums2, av2) + " dp="
+ sol.minimumValueSumDP(nums2, av2) + " expected=17 " + (ok2 ? "PASS" : "FAIL"));
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 300; ++t) {
int n = 3 + rnd.nextInt(7);
int m = 1 + rnd.nextInt(Math.min(4, n));
int[] nums = new int[n];
int[] av = new int[m];
for (int i = 0; i < n; ++i) {
nums[i] = rnd.nextInt(16);
}
// 生成合法段:随机划分并计算 AND 作为目标
int l = 0;
for (int j = 0; j < m; ++j) {
int r = l + 1 + rnd.nextInt(Math.max(1, (n - l) / (m - j)));
if (r > n) {
r = n;
}
int a = -1;
for (int k = l; k < r && k < n; ++k) {
a &= nums[k];
}
av[j] = j + 1 == m ? 0 : a; // 最后一组不一定用上
l = r;
}
// 简化:直接用随机目标(可能无解,DP 与 DFS 应一致)
for (int j = 0; j < m; ++j) {
av[j] = rnd.nextInt(16);
}
int a = sol.minimumValueSum(nums, av);
int b = sol.minimumValueSumDP(nums, av);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " av=" + Arrays.toString(av) + " dfs=" + a + " dp=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n * m * 2^17),空间复杂度 O(n * m * 2^17)(实际远小于,剪枝极强)。
- 时间复杂度:O(m * n * m)(实际 + 剪枝)
- 空间复杂度:O(m * n)
3118. Friday Purchase III(发生在周五的交易 III)
题目类型:数据库(SQL)
题目描述
表:Purchases
+---------------+------+
| Column Name | Type |
+---------------+------+
| user_id | int |
| purchase_date | date |
| amount_spend | int |
+---------------+------+
(user_id, purchase_date, amount_spend) 是该表的主键(具有唯一值的列)。purchase_date 的范围从 2023 年 11 月 1 日到 2023 年 11 月 30 日,并包括这两个日期。
表:Users
+-------------+------+
| Column Name | Type |
+-------------+------+
| user_id | int |
| membership | enum |
+-------------+------+
user_id 是这张表的主键。membership 是 ('Standard', 'Premium', 'VIP') 的枚举类型。
编写一个解决方案来计算 Premium 和 VIP 会员在 2023 年 11 月每周的周五 的总花费 。如果某个周五没有 Premium 或 VIP 会员购买,把它当作 0。
按照每月的周次序 升序排列结果表,然后以 membership 升序排序。
示例 1:
输入:
Purchases 表(user_id 11/15/17/12/8/1/10/13,11 月各周五及 22/21 日消费)
Users 表:11 Premier、15 VIP、17 Standard、12 VIP、8 Premium、1 VIP、10 Standard、13 Premium
输出:
+---------------+-------------+--------------+
| week_of_month | membership | total_amount |
+---------------+-------------+--------------+
| 1 | Premium | 1126 |
| 1 | VIP | 0 |
| 2 | Premium | 0 |
| 2 | VIP | 7473 |
| 3 | Premium | 0 |
| 3 | VIP | 0 |
| 4 | Premium | 5117 |
| 4 | VIP | 14933 |
+---------------+-------------+--------------+
解释:第 1 周周五(11-03)仅 Premium 的 1126 消费;第 2 周周五(11-10)仅 VIP 的 7473;第 3 周周五(11-17)无交易输出 0;第 4 周周五(11-24)Premium 5117、VIP 9692+5241=14933。输出表以 week_of_month 和 membership 升序排序。
解题思路
要求的输出是完整的 4 周 × 2 种会员 的 8 行,即使某组合没有交易也要补 0,因此需要先生成一个全组合骨架再左连接:用递归 CTE T 生成 week_of_month 1~4,用 M 常量表生成 Premium、VIP;把 Purchases 与 Users 连接后仅保留周五(DAYOFWEEK = 6),用 CEIL(DAYOFMONTH(purchase_date) / 7) 计算所在周次;最后 T JOIN M 与聚合后的 P 做 LEFT JOIN,IFNULL(SUM(amount_spend), 0) 补零,按周次、会员升序输出。
代码实现
sql
WITH RECURSIVE T AS (
SELECT 1 AS week_of_month
UNION
SELECT week_of_month + 1 FROM T WHERE week_of_month < 4
),
M AS (
SELECT 'Premium' AS membership
UNION
SELECT 'VIP'
),
P AS (
SELECT CEIL(DAYOFMONTH(purchase_date) / 7) AS week_of_month,
membership,
amount_spend
FROM Purchases
JOIN Users USING (user_id)
WHERE DAYOFWEEK(purchase_date) = 6
)
SELECT week_of_month, membership,
IFNULL(SUM(amount_spend), 0) AS total_amount
FROM T JOIN M
LEFT JOIN P USING (week_of_month, membership)
GROUP BY 1, 2
ORDER BY 1, 2;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3119. Maximum Number of Potholes That Can Be Fixed(最大数量的可修复坑洼)
题目描述
给定一个字符串 road,只包含字符 'x' 和 '.',其中每个 'x' 代表一个坑洼,
每个 '.' 代表一个平滑的道路,以及一个整数 budget。
在一次修复操作中,您可以以 n + 1 的价格修复 n 个连续坑洼(n >= 1)。
返回可以修复的坑洼的最大数量,以便所有修复的价格总和不会超过给定的预算 budget。
示例 1
road = "..", budget = 5 -> 0
示例 2
road = "..xxxxx", budget = 4 -> 3
示例 3
road = "x.x.xxx...x", budget = 14 -> 6
提示:
1 <= road.length <= 10^51 <= budget <= 10^9
解题思路
解法一:贪心 + 连续段计数,主提交版本
修复操作只能作用于"连续坑洼段"。一次修复 k 个连续坑洼花费 k + 1。
若把一个连续段拆成多个小段修,总花费会超过一次性修:修复一段长度 k 的费用 k+1,
而拆成两段 a、b(a+b=k)费用 (a+1)+(b+1) = k+2,更贵。
因此"同一坑洼段永远整段修"最优;但要修某段得先花 1 的"启动成本"。
策略:按长度从大到小贪心消费预算------把每个坑洼段的长度 k 视为
"修复 k 个坑洼、消耗预算 k+1"的候选;优先修长段(同样占用一段启动成本,
修复个数更多)。
实现:统计每种长度 k 的段数 cntk,从大到小遍历,能整段修的行段修,
预算不足时把剩余段"拆一部分"(在 cntk 段中修若干段,剩下的坑洼并入长度 k-1 的段:
因为多付出的 1 个启动成本不划算,拆出的 k 个坑洼按 k-1 处理,等下一轮再考虑)。
正确性由官方贪心保证:余下的坑洼若再修,会重新产生启动成本,因此统一降级为
长度 k-1 的段(少修 1 个坑洼但省 1 个启动成本,与修 k-1 个坑洼等价)。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:暴力(对照,小规模)
枚举所有"段划分 + 每段是否拆修"不可行(组合爆炸),改用等价的 DP/搜索:
把所有坑洼段长度收集起来;对每段枚举"修 t 个(1 <= t <= k,费用 t+1)"或 "0 个",
求预算内最大修复数。仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:贪心(主提交版本) ----------
public int maxPotholes(String road, int budget) {
road += ".";
int n = road.length();
int[] cnt = new int[n]; // cnt[k] = 长度为 k 的坑洼段数
int k = 0;
for (char c : road.toCharArray()) {
if (c == 'x') {
++k;
} else if (k > 0) {
++cnt[k];
k = 0;
}
}
int ans = 0;
for (k = n - 1; k > 0 && budget > 0; --k) {
if (cnt[k] == 0) {
continue;
}
int t = Math.min(budget / (k + 1), cnt[k]); // 预算内最多整段修 t 段
ans += t * k;
budget -= t * (k + 1);
// 剩余的 cnt[k] - t 段不整段修:降级为长度 k-1 的段(省 1 个启动成本)
cnt[k - 1] += cnt[k] - t;
}
return ans;
}
// ---------- 解法二:DP 搜索(对照) ----------
public int maxPotholesBrute(String road, int budget) {
// 收集所有坑洼段长度
int n = road.length();
java.util.List<Integer> segs = new java.util.ArrayList<>();
int k = 0;
for (char c : road.toCharArray()) {
if (c == 'x') {
++k;
} else if (k > 0) {
segs.add(k);
k = 0;
}
}
if (k > 0) {
segs.add(k);
}
// dp[c] = 花费恰好 c(<= budget)时最多修复的坑洼数
int[] dp = new int[budget + 1];
Arrays.fill(dp, -1);
dp[0] = 0;
for (int len : segs) {
int[] ndp = dp.clone();
for (int cost = 0; cost <= budget; ++cost) {
if (dp[cost] < 0) {
continue;
}
// 修 t 个(1 <= t <= len),费用 t+1
for (int t = 1; t <= len; ++t) {
int nc = cost + t + 1;
if (nc <= budget) {
ndp[nc] = Math.max(ndp[nc], dp[cost] + t);
}
}
}
dp = ndp;
}
int ans = 0;
for (int v : dp) {
ans = Math.max(ans, v);
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
boolean ok1 = sol.maxPotholes("..", 5) == 0 && sol.maxPotholesBrute("..", 5) == 0;
boolean ok2 = sol.maxPotholes("..xxxxx", 4) == 3 && sol.maxPotholesBrute("..xxxxx", 4) == 3;
boolean ok3 = sol.maxPotholes("x.x.xxx...x", 14) == 6 && sol.maxPotholesBrute("x.x.xxx...x", 14) == 6;
System.out.println("case1 -> " + sol.maxPotholes("..", 5) + " brute="
+ sol.maxPotholesBrute("..", 5) + " expected=0 " + (ok1 ? "PASS" : "FAIL"));
System.out.println("case2 -> " + sol.maxPotholes("..xxxxx", 4) + " brute="
+ sol.maxPotholesBrute("..xxxxx", 4) + " expected=3 " + (ok2 ? "PASS" : "FAIL"));
System.out.println("case3 -> " + sol.maxPotholes("x.x.xxx...x", 14) + " brute="
+ sol.maxPotholesBrute("x.x.xxx...x", 14) + " expected=6 " + (ok3 ? "PASS" : "FAIL"));
// 随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int len = 1 + rnd.nextInt(12);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < len; ++i) {
sb.append(rnd.nextInt(3) == 0 ? 'x' : '.');
}
String road = sb.toString();
int budget = rnd.nextInt(20);
int a = sol.maxPotholes(road, budget);
int b = sol.maxPotholesBrute(road, budget);
if (a != b) {
fail++;
if (fail <= 3) {
System.out.println("MISMATCH road=" + road + " budget=" + budget
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 && ok3 ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3120. Count the Number of Special Characters I(统计特殊字母的数量 I)
题目描述
给你一个字符串 word。如果 word 中同时存在某个字母的小写形式和大写形式,则称这个字母为特殊字母。
返回 word 中特殊字母的数量。
示例 1
word = "aaAbcBC" -> 3('a'、'b'、'c')
示例 2
word = "abc" -> 0
示例 3
word = "abBCab" -> 1('b')
提示:
1 <= word.length <= 50word仅由小写和大写英文字母组成
解题思路
解法一:布尔数组标记,主提交版本
用两个布尔数组分别记录每个字母的小写/大写形式是否出现过,
最后统计大小写同时出现的字母个数。
时间复杂度 O(n + 26),空间复杂度 O(26)。
解法二:位掩码(对照)
用 26 位整数 maskLower / maskUpper 记录出现过的小写/大写字母,
答案 = Integer.bitCount(maskLower & maskUpper)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)(固定 26 大小)
代码实现
java
public class Solution {
// ---------- 解法一:布尔数组(主提交版本) ----------
public int numberOfSpecialChars(String word) {
boolean[] lower = new boolean[26];
boolean[] upper = new boolean[26];
for (int i = 0; i < word.length(); ++i) {
char c = word.charAt(i);
if (c >= 'a' && c <= 'z') {
lower[c - 'a'] = true;
} else {
upper[c - 'A'] = true;
}
}
int ans = 0;
for (int i = 0; i < 26; ++i) {
if (lower[i] && upper[i]) {
++ans;
}
}
return ans;
}
// ---------- 解法二:位掩码(对照) ----------
public int numberOfSpecialCharsMask(String word) {
int maskLower = 0, maskUpper = 0;
for (int i = 0; i < word.length(); ++i) {
char c = word.charAt(i);
if (c >= 'a' && c <= 'z') {
maskLower |= 1 << (c - 'a');
} else {
maskUpper |= 1 << (c - 'A');
}
}
return Integer.bitCount(maskLower & maskUpper);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] words = { "aaAbcBC", "abc", "abBCab", "a", "A", "aA", "aAbBcCdD" };
int[] expects = { 3, 0, 1, 0, 0, 1, 4 };
boolean allPass = true;
for (int i = 0; i < words.length; ++i) {
int a = sol.numberOfSpecialChars(words[i]);
int b = sol.numberOfSpecialCharsMask(words[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(words[i] + " -> " + a + " / mask=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n + 26),空间复杂度 O(26)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)(固定 26 大小)