LeetCode 3421-3440. 题解合集
文章目录
- [LeetCode 3421-3440. 题解合集](#LeetCode 3421-3440. 题解合集)
-
- [3421. Find Students Who Improved(查找进步的学生)](#3421. Find Students Who Improved(查找进步的学生))
- [3422. Minimum Operations to Make Subarray Elements Equal(将子数组元素变为相等所需的最小操作数 🔒)](#3422. Minimum Operations to Make Subarray Elements Equal(将子数组元素变为相等所需的最小操作数 🔒))
- [3423. Maximum Difference Between Adjacent Elements in a Circular Array(循环数组中相邻元素的最大差值)](#3423. Maximum Difference Between Adjacent Elements in a Circular Array(循环数组中相邻元素的最大差值))
- [3424. Minimum Cost to Make Arrays Identical(将数组变相同的最小代价)](#3424. Minimum Cost to Make Arrays Identical(将数组变相同的最小代价))
- [3425. Longest Special Path(最长特殊路径)](#3425. Longest Special Path(最长特殊路径))
- [3426. Manhattan Distances of All Arrangements of Pieces(所有安放棋子方案的曼哈顿距离)](#3426. Manhattan Distances of All Arrangements of Pieces(所有安放棋子方案的曼哈顿距离))
- [3427. Sum of Variable Length Subarrays(变长子数组求和)](#3427. Sum of Variable Length Subarrays(变长子数组求和))
- [3428. Maximum and Minimum Sums of at Most Size K Subsequences(最多 K 个元素的子序列的最值之和)](#3428. Maximum and Minimum Sums of at Most Size K Subsequences(最多 K 个元素的子序列的最值之和))
- [3429. Paint House IV(粉刷房子 IV)](#3429. Paint House IV(粉刷房子 IV))
- [3430. Maximum and Minimum Sums of at Most Size K Subarrays(最多 K 个元素的子数组的最值之和)](#3430. Maximum and Minimum Sums of at Most Size K Subarrays(最多 K 个元素的子数组的最值之和))
- [3431. Minimum Unlocked Indices to Sort Nums(对数字排序的最小解锁下标)](#3431. Minimum Unlocked Indices to Sort Nums(对数字排序的最小解锁下标))
- [3432. Count Partitions with Even Sum Difference(统计元素和差值为偶数的分区方案)](#3432. Count Partitions with Even Sum Difference(统计元素和差值为偶数的分区方案))
- [3433. Count Mentions Per User(统计用户被提及情况)](#3433. Count Mentions Per User(统计用户被提及情况))
- [3434. Maximum Frequency After Subarray Operation(子数组操作后的最大频率)](#3434. Maximum Frequency After Subarray Operation(子数组操作后的最大频率))
- [3435. Frequencies of Shortest Supersequences(最短公共超序列的字母出现频率)](#3435. Frequencies of Shortest Supersequences(最短公共超序列的字母出现频率))
- [3436. Find Valid Emails(查找合法邮箱)](#3436. Find Valid Emails(查找合法邮箱))
- [3437. Permutations III(全排列 III)](#3437. Permutations III(全排列 III))
- [3438. Find Valid Pair of Adjacent Digits in String(找到字符串中合法的相邻数字)](#3438. Find Valid Pair of Adjacent Digits in String(找到字符串中合法的相邻数字))
- [3439. Reschedule Meetings for Maximum Free Time I(重新安排会议得到最多空余时间 I)](#3439. Reschedule Meetings for Maximum Free Time I(重新安排会议得到最多空余时间 I))
- [3440. Reschedule Meetings for Maximum Free Time II(重新安排会议得到最多空余时间 II)](#3440. Reschedule Meetings for Maximum Free Time II(重新安排会议得到最多空余时间 II))
3421. Find Students Who Improved(查找进步的学生)
题目类型:数据库(SQL)
题目描述
表:Scores
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| student_id | int |
| subject | varchar |
| score | int |
| exam_date | varchar |
+-------------+---------+
(student_id, subject, exam_date) 是此表的联合主键。表的每一行记录某学生在某门科目某次考试中的分数,score 在 0 到 100 之间(含端点)。
编写解决方案找出在相同科目上取得进步的学生。一个学生在某一科目上视为进步,需要同时满足:
- 在该科目上至少参加两次考试(不同日期);
- 该科目最近一次考试的分数高于其第一次考试的分数。
返回结果表包含 student_id、subject、first_score(首次分数)、latest_score(最近分数),按 student_id、subject 升序排序。
示例 1:
输入:
Scores 表:
+------------+----------+-------+------------+
| student_id | subject | score | exam_date |
+------------+----------+-------+------------+
| 101 | Math | 70 | 2023-01-15 |
| 101 | Math | 85 | 2023-02-15 |
| 101 | Physics | 65 | 2023-01-15 |
| 101 | Physics | 60 | 2023-02-15 |
| 102 | Math | 80 | 2023-01-15 |
| 102 | Math | 85 | 2023-02-15 |
| 103 | Math | 90 | 2023-01-15 |
| 104 | Physics | 75 | 2023-01-15 |
| 104 | Physics | 85 | 2023-02-15 |
+------------+----------+-------+------------+
输出:
+------------+----------+-------------+--------------+
| student_id | subject | first_score | latest_score |
+------------+----------+-------------+--------------+
| 101 | Math | 70 | 85 |
| 102 | Math | 80 | 85 |
| 104 | Physics | 75 | 85 |
+------------+----------+-------------+--------------+
解释:
101 的 Math 从 70 进步到 85;101 的 Physics 从 65 降到 60 不算;
102 的 Math 从 80 进步到 85;103 只考了一次,不符合条件;
104 的 Physics 从 75 进步到 85。
解题思路
题意拆成两步:取"每名学生每门科目最早/最晚两次考试"的分数,再比较大小。
解法一(推荐):FIRST_VALUE 双向窗口 + 分组过滤
直接对 (student_id, subject) 分区、按 exam_date 排序:
FIRST_VALUE(score) OVER (PARTITION BY student_id, subject ORDER BY exam_date)拿到首次分数;FIRST_VALUE(score) OVER (PARTITION BY student_id, subject ORDER BY exam_date DESC)拿到最近分数。
外层按两列分组后取 MIN(first_score) < MAX(latest_score) 的行即为进步者。FIRST_VALUE 为每行都回填了首/末分数,分组后值不变,因此聚合取 MIN/MAX 无副作用,且只考一次的组 first_score = latest_score 自然被 HAVING 过滤。
解法二(对照):RANK() 正反序双计数
用 RANK() OVER (PARTITION BY ... ORDER BY exam_date) 把最早考试标记为 1,倒序窗口把最晚考试标记为 1,然后自连接取 r1 = 1 与 r2 = 1 的两行比较分数。写法较繁琐,但能直观校验"最早 vs 最晚"确实只取两行。
代码实现
sql
-- 解法一(推荐):FIRST_VALUE 双向窗口 + 分组过滤
WITH scored AS (
SELECT student_id, subject,
FIRST_VALUE(score) OVER (PARTITION BY student_id, subject
ORDER BY exam_date) AS first_score,
FIRST_VALUE(score) OVER (PARTITION BY student_id, subject
ORDER BY exam_date DESC) AS latest_score
FROM Scores
)
SELECT student_id, subject, MIN(first_score) AS first_score, MIN(latest_score) AS latest_score
FROM scored
GROUP BY student_id, subject
HAVING MIN(first_score) < MAX(latest_score)
ORDER BY student_id, subject;
-- 解法二(对照):RANK 正反双序 + 自连接
WITH rk AS (
SELECT *, RANK() OVER (PARTITION BY student_id, subject ORDER BY exam_date) AS r1,
RANK() OVER (PARTITION BY student_id, subject ORDER BY exam_date DESC) AS r2
FROM Scores
)
SELECT a.student_id, a.subject, a.score AS first_score, b.score AS latest_score
FROM rk a
JOIN rk b ON a.student_id = b.student_id AND a.subject = b.subject
WHERE a.r1 = 1 AND b.r2 = 1 AND a.r1 != a.r2
AND a.score < b.score
ORDER BY a.student_id, a.subject;
复杂度分析
- 时间复杂度 :
O(n log n),其中n为Scores行数;窗口函数排序为瓶颈。 - 空间复杂度 :
O(n),窗口函数的中间排序结果与行数成正比。
3422. Minimum Operations to Make Subarray Elements Equal(将子数组元素变为相等所需的最小操作数 🔒)
题目描述
给定一个整数数组 nums 和一个整数 k。你可以进行任意次以下操作:
- 给
nums的任何元素增加或减少 1。
返回确保至少 有一个大小为k的子数组的所有元素都相等所需的最小操作数。
示例 1
nums = [4,-3,2,1,-4,6], k = 3 -> 5
示例 2
nums = [-2,-2,3,1,4], k = 2 -> 0
提示:
2 <= nums.length <= 10^5-10^6 <= nums[i] <= 10^62 <= k <= nums.length
解题思路
解法一:滑动窗口 + 两个平衡树维护中位数,主提交版本
使一段元素全部相等的开销最小化时,目标值取中位数 (元素个数为偶数时取任意
中间两个值之一)。滑动窗口维护当前 k 个元素:
- 用两个
TreeMap(小顶堆侧l存较小一半、大顶堆侧r存较大一半,保持
r.size - l.size <= 1)与两个段和s1/s2快速求中位数与开销。 - 开销 = 中位数到所有元素的绝对距离和:
mid * l.size - s1 + s2 - mid * r.size(中位数属于 r 侧)。
窗口每步添加 numsi、移除 numsk 滑出元素。总复杂度 O(n log k)。
解法二:暴力枚举窗口 + 求中位数(对照)
对每个窗口 l, r,复制到临时数组排序取中位数,累加绝对差。O(n * k log k),仅本地小数据。
复杂度: - 时间复杂度:O(n log k)
- 空间复杂度:O(k)
代码实现
java
import java.util.Random;
import java.util.TreeMap;
public class Solution {
// ---------- 解法一:滑动窗口 + 双平衡树(主提交版本) ----------
public long minOperations(int[] nums, int k) {
TreeMap<Integer, Integer> l = new TreeMap<Integer, Integer>();
TreeMap<Integer, Integer> r = new TreeMap<Integer, Integer>();
long s1 = 0, s2 = 0;
int sz1 = 0, sz2 = 0;
long ans = Long.MAX_VALUE;
for (int i = 0; i < nums.length; ++i) {
// 插入到 l
l.merge(nums[i], 1, Integer::sum);
s1 += nums[i];
++sz1;
// 平衡:把 l 的最大搬到 r
int y = l.lastKey();
if (l.merge(y, -1, Integer::sum) == 0) {
l.remove(y);
}
s1 -= y;
--sz1;
r.merge(y, 1, Integer::sum);
s2 += y;
++sz2;
if (sz2 - sz1 > 1) {
y = r.firstKey();
if (r.merge(y, -1, Integer::sum) == 0) {
r.remove(y);
}
s2 -= y;
--sz2;
l.merge(y, 1, Integer::sum);
s1 += y;
++sz1;
}
if (i >= k - 1) {
// 中位数 = r.firstKey(sz2 >= sz1)
long mid = r.firstKey();
ans = Math.min(ans, mid * sz1 - s1 + s2 - mid * sz2);
// 移除窗口最左元素
int j = i - k + 1;
if (r.containsKey(nums[j])) {
if (r.merge(nums[j], -1, Integer::sum) == 0) {
r.remove(nums[j]);
}
s2 -= nums[j];
--sz2;
} else {
if (l.merge(nums[j], -1, Integer::sum) == 0) {
l.remove(nums[j]);
}
s1 -= nums[j];
--sz1;
}
}
}
return ans;
}
// ---------- 解法二:暴力窗口排序(对照) ----------
public long minOperationsBrute(int[] nums, int k) {
int n = nums.length;
long ans = Long.MAX_VALUE;
for (int i = 0; i + k <= n; ++i) {
int[] w = new int[k];
for (int t = 0; t < k; ++t) {
w[t] = nums[i + t];
}
java.util.Arrays.sort(w);
int mid = w[k / 2]; // 下中位数(偶数也 OK)
long cost = 0;
for (int x : w) {
cost += Math.abs(x - mid);
}
ans = Math.min(ans, cost);
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(71);
System.out.println("示例1: " + sol.minOperations(new int[] {4, -3, 2, 1, -4, 6}, 3)
+ " (期望 5)");
System.out.println("示例2: " + sol.minOperations(new int[] {-2, -2, 3, 1, 4}, 2)
+ " (期望 0)");
int cases = 0, pass = 0;
for (int t = 0; t < 1000; ++t) {
int n = 2 + rand.nextInt(10);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = -8 + rand.nextInt(17);
}
int k = 2 + rand.nextInt(n - 1);
long x = sol.minOperations(a, k);
long y = sol.minOperationsBrute(a, k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " k=" + k
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
- 时间复杂度:O(n log k)
- 空间复杂度:O(k)
3423. Maximum Difference Between Adjacent Elements in a Circular Array(循环数组中相邻元素的最大差值)
题目描述
给你一个循环 数组 nums,请你找出相邻元素之间的最大 绝对差值。
**注意:**一个循环数组中,第一个元素和最后一个元素是相邻的。
示例 1
nums = [1,2,4] -> 3(|1-4|=3 为最大)
示例 2
nums = [-5,-10,-5] -> 5
提示:
2 <= nums.length <= 100-100 <= nums[i] <= 100
解题思路
解法一:线性扫描 + 首尾差,主提交版本
循环数组的相邻对包括 (0,1), (1,2), ..., (n-2,n-1) 以及收尾的 (n-1, 0)。
先算首尾差的绝对值,再线性扫描所有相邻对取最大绝对值。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:构造循环对枚举(对照)
显式构造 (nums[i], nums[(i+1) % n]) 对并进行比较,实现直观独立,交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:线性扫描 + 首尾差(主提交版本) ----------
public int maxAdjacentDistance(int[] nums) {
int n = nums.length;
int ans = Math.abs(nums[0] - nums[n - 1]);
for (int i = 1; i < n; ++i) {
ans = Math.max(ans, Math.abs(nums[i] - nums[i - 1]));
}
return ans;
}
// ---------- 解法二:循环对显式枚举(对照) ----------
public int maxAdjacentDistanceMod(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0; i < n; ++i) {
int d = Math.abs(nums[i] - nums[(i + 1) % n]);
ans = Math.max(ans, d);
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(73);
System.out.println("示例1: " + sol.maxAdjacentDistance(new int[] {1, 2, 4}) + " (期望 3)");
System.out.println("示例2: " + sol.maxAdjacentDistance(new int[] {-5, -10, -5}) + " (期望 5)");
int cases = 0, pass = 0;
for (int t = 0; t < 3000; ++t) {
int n = 2 + rand.nextInt(10);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = -20 + rand.nextInt(41);
}
int x = sol.maxAdjacentDistance(a);
int y = sol.maxAdjacentDistanceMod(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " a=" + x + " b=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3424. Minimum Cost to Make Arrays Identical(将数组变相同的最小代价)
题目描述
给你两个长度都为 n 的整数数组 arr 和 brr 以及一个整数 k。你可以对 arr 执行以下操作任意次:
- 将
arr分割成若干个连续的 子数组,并将这些子数组按任意顺序重新排列。这个操作的代价为k。 - 选择
arr中的任意一个元素,将它增加或者减少一个正整数x。这个操作的代价为x。
请你返回将arr变为brr的最小总代价。
示例 1
arr = [-7,9,5], brr = [7,-2,-5], k = 2 -> 13
示例 2
arr = [2,1], brr = [2,1], k = 0 -> 0
提示:
1 <= arr.length == brr.length <= 10^50 <= k <= 2 * 10^10-10^5 <= arr[i] <= 10^5-10^5 <= brr[i] <= 10^5
解题思路
解法一:两种方案取 min,主提交版本
不分割时,逐位调整:min(abs(arr[i]-brr[i])) 累加 = calc(arr, brr)。
使用一次分割(代价 k)后,可以把任意元素配对,为了最小化调整代价,将两数组排序后
对应位置差的绝对值和最小(重排不等式),即 calc(sort(arr), sort(brr)) + k。
答案 = min(不分割代价, 分割后代价)。
时间复杂度 O(n log n),空间 O(log n)。
解法二:暴力枚举是否分割(对照)
直观模拟两个分支:直接逐位 vs 排序后逐位再 +k,取 min。与解法一同构,路径不同,
用于小数据交叉验证(本质一致故不另写独立算法,而是用不同实现方式对照)。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(log n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:两方案取 min(主提交版本) ----------
public long minCost(int[] arr, int[] brr, long k) {
long c1 = calc(arr, brr);
int[] a2 = arr.clone();
int[] b2 = brr.clone();
Arrays.sort(a2);
Arrays.sort(b2);
long c2 = calc(a2, b2) + k;
return Math.min(c1, c2);
}
private long calc(int[] a, int[] b) {
long ans = 0;
for (int i = 0; i < a.length; ++i) {
ans += Math.abs((long) a[i] - b[i]);
}
return ans;
}
// ---------- 解法二:显式逻辑分支(对照) ----------
public long minCostBrute(int[] arr, int[] brr, long k) {
int n = arr.length;
long noSplit = 0;
for (int i = 0; i < n; ++i) {
noSplit += Math.abs((long) arr[i] - brr[i]);
}
int[] a2 = arr.clone();
int[] b2 = brr.clone();
Arrays.sort(a2);
Arrays.sort(b2);
long split = k;
for (int i = 0; i < n; ++i) {
split += Math.abs((long) a2[i] - b2[i]);
}
return Math.min(noSplit, split);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(79);
System.out.println("示例1: " + sol.minCost(new int[] {-7, 9, 5}, new int[] {7, -2, -5}, 2)
+ " (期望 13)");
System.out.println("示例2: " + sol.minCost(new int[] {2, 1}, new int[] {2, 1}, 0)
+ " (期望 0)");
int cases = 0, pass = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rand.nextInt(10);
int[] a = new int[n];
int[] b = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = -10 + rand.nextInt(21);
b[i] = -10 + rand.nextInt(21);
}
long k = rand.nextInt(6);
long x = sol.minCost(a, b, k);
long y = sol.minCostBrute(a, b, k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b)
+ " k=" + k + " f=" + x + " br=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n log n),空间 O(log n)。
- 时间复杂度:O(n log n)
- 空间复杂度:O(log n)
3425. Longest Special Path(最长特殊路径)
题目描述
给你一棵根节点为节点 0 的无向树,树中有 n 个节点,编号为 0 到 n - 1,树通过一个
长度为 n - 1 的二维数组 edges 表示,其中 edges[i] = [ui, vi, lengthi] 表示节点 ui
和 vi 之间有一条长度为 lengthi 的边。同时给你一个整数数组 nums,其中 nums[i] 表示
节点 i 的值。
特殊路径 指的是树中一条从祖先节点往下 到后代节点且经过节点的值互不相同 的路径。
注意,一条路径可以开始和结束于同一节点。
请你返回一个长度为 2 的数组 result,其中 result[0] 是最长特殊路径的长度 ,
result[1] 是所有最长特殊路径中的最少节点数目。
示例 1
edges = [[0,1,2],[1,2,3],[1,3,5],[1,4,4],[2,5,6]], nums = [2,1,2,1,3,1] -> [6,2]
示例 2
edges = [[1,0,8]], nums = [2,2] -> [0,1]
提示:
2 <= n <= 5 * 10^40 <= nums[i] <= 5 * 10^41 <= lengthi <= 10^3
解题思路
解法一:DFS + 前缀和 + 最近重复位置,主提交版本
从根 0 做 DFS,维护根到当前节点的距离前缀 dist 与路径节点序列 st。设 seen[v] 为
值 v 最近一次出现在路径中的深度位置(没有则 -1)。当访问节点 u 时:
- 若
seen[nums[u]]存在且 >= 当前有效起点start,说明路径中已有同值节点,须把起点
推进到该位置 + 1; - 否则以当前
start为起点,路径长度 = 根距差dist[u] - dist[st[start]],
节点数 =pos - start + 1,去更新全局最优(长度更大优先;长度相同节点数更少优先)。
向下递归前记录seen[nums[u]]旧值以便回溯恢复。每个节点 O(1) 维护,总 O(n)。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:枚举路径起点 DFS 集合判定(对照)
以每个节点为起点向下 DFS,用 HashSet 判重,计算每条向下路径的长度与节点数,取最优。
复杂度 O(n^2) 最坏,仅用于本地小数据交叉验证。
复杂度: - 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class Solution {
private List<List<int[]>> adj;
private int[] nums;
private int[] dist; // 根到节点距离前缀
private int[] st; // 路径上的节点序列(按深度)
private int[] seen; // 值 -> 最近一次出现深度;-1 表示未出现
private int[] res; // res[0]=最长长度, res[1]=最少节点数
// ---------- 解法一:DFS + 前缀和(主提交版本) ----------
public int[] longestSpecialPath(int n, int[][] edges, int[] nums) {
this.nums = nums;
adj = new ArrayList<List<int[]>>();
for (int i = 0; i < n; ++i) {
adj.add(new ArrayList<int[]>());
}
for (int[] e : edges) {
adj.get(e[0]).add(new int[] {e[1], e[2]});
adj.get(e[1]).add(new int[] {e[0], e[2]});
}
dist = new int[n];
st = new int[n];
seen = new int[50001];
Arrays.fill(seen, -1);
res = new int[] {0, Integer.MAX_VALUE};
dfs(0, -1, 0, 0, 0);
if (res[1] == Integer.MAX_VALUE) {
res[1] = 1; // 至少单节点
}
return res;
}
private void dfs(int u, int parent, int start, int pos, int depth) {
int val = nums[u];
int last = seen[val];
if (last >= start) {
start = last + 1;
}
seen[val] = pos;
st[pos] = u;
// 以 start..pos 为一条特殊路径
int len = depth - dist[st[start]];
int sz = pos - start + 1;
if (len > res[0] || (len == res[0] && sz < res[1])) {
res[0] = len;
res[1] = sz;
}
for (int[] nb : adj.get(u)) {
int v = nb[0], w = nb[1];
if (v == parent) {
continue;
}
dist[v] = depth + w;
dfs(v, u, start, pos + 1, depth + w);
}
seen[val] = last; // 回溯恢复
}
// ---------- 解法二:定根后枚举起点 DFS(对照) ----------
private int bLen;
private int bCnt;
private List<List<int[]>> child; // 以 0 为根的父子树(仅父->子)
public int[] longestSpecialPathBrute(int n, int[][] edges, int[] nums) {
List<List<int[]>> g = new ArrayList<List<int[]>>();
for (int i = 0; i < n; ++i) {
g.add(new ArrayList<int[]>());
}
for (int[] e : edges) {
g.get(e[0]).add(new int[] {e[1], e[2]});
g.get(e[1]).add(new int[] {e[0], e[2]});
}
// 以 0 为根 BFS 定向,保证枚举的路径严格沿"祖先->后代"方向
child = new ArrayList<List<int[]>>();
for (int i = 0; i < n; ++i) {
child.add(new ArrayList<int[]>());
}
int[] par = new int[n];
Arrays.fill(par, -2);
par[0] = -1;
java.util.ArrayDeque<Integer> q = new java.util.ArrayDeque<Integer>();
q.add(0);
while (!q.isEmpty()) {
int u = q.poll();
for (int[] nb : g.get(u)) {
if (par[nb[0]] != -2) {
continue;
}
par[nb[0]] = u;
child.get(u).add(nb);
q.add(nb[0]);
}
}
bLen = 0;
bCnt = Integer.MAX_VALUE;
for (int s = 0; s < n; ++s) {
java.util.Set<Integer> used = new java.util.HashSet<Integer>();
used.add(nums[s]);
dfsBrute(s, 0, 1, used);
}
if (bCnt == Integer.MAX_VALUE) {
bCnt = 1;
}
return new int[] {bLen, bCnt};
}
private void dfsBrute(int u, int len, int cnt, java.util.Set<Integer> used) {
if (len > bLen || (len == bLen && cnt < bCnt)) {
bLen = len;
bCnt = cnt;
}
for (int[] nb : child.get(u)) {
int v = nb[0], w = nb[1];
if (used.contains(nums[v])) {
continue; // 向下路径不能再延伸
}
used.add(nums[v]);
dfsBrute(v, len + w, cnt + 1, used);
used.remove(nums[v]);
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(83);
System.out.println("示例1: "
+ Arrays.toString(sol.longestSpecialPath(6, new int[][] {{0, 1, 2}, {1, 2, 3},
{1, 3, 5}, {1, 4, 4}, {2, 5, 6}}, new int[] {2, 1, 2, 1, 3, 1}))
+ " (期望 [6, 2])");
System.out.println("示例2: "
+ Arrays.toString(sol.longestSpecialPath(2, new int[][] {{1, 0, 8}},
new int[] {2, 2})) + " (期望 [0, 1])");
int cases = 0, pass = 0;
for (int t = 0; t < 1000; ++t) {
int n = 2 + rand.nextInt(9);
int[][] es = new int[n - 1][];
for (int i = 1; i < n; ++i) {
int p = rand.nextInt(i);
es[i - 1] = new int[] {p, i, 1 + rand.nextInt(10)};
}
int[] ns = new int[n];
int range = 1 + rand.nextInt(4);
for (int i = 0; i < n; ++i) {
ns[i] = rand.nextInt(range);
}
int[] x = sol.longestSpecialPath(n, es, ns);
int[] y = sol.longestSpecialPathBrute(n, es, ns);
cases++;
if (Arrays.equals(x, y)) {
pass++;
} else {
System.out.println("MISMATCH fast=" + Arrays.toString(x) + " brute="
+ Arrays.toString(y));
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3426. Manhattan Distances of All Arrangements of Pieces(所有安放棋子方案的曼哈顿距离)
题目描述
给你三个整数 m、n 和 k。有一个大小为 m x n 的矩形格子,它包含 k 个没有差别的棋子。
请你返回所有放置棋子的合法方案中,每对棋子之间的曼哈顿距离之和。
一个合法方案指的是将所有 k 个棋子都放在格子中,且一个格子里至多只有一个棋子。
由于答案可能很大,请你将它对 10^9 + 7 取余后返回。
两个格子 (xi, yi) 和 (xj, yj) 的曼哈顿距离定义为 |xi - xj| + |yi - yj|。
示例 1
m = 2, n = 2, k = 2 -> 8
示例 2
m = 1, n = 4, k = 3 -> 20
提示:
1 <= m, n <= 10^52 <= m * n <= 10^52 <= k <= m * n
解题思路
解法一:固定位置对 + 组合计数,主提交版本
所有方案数为 C(mn, k)。任意一对格子位置 (p, q)(p != q)在这 C(mn, k) 个方案中被同时
选中的次数恒为 C(mn - 2, k - 2)(其余 k - 2 个棋子从其余 mn - 2 个位置里任选)。
因此答案 = C(mn - 2, k - 2) * sum(所有无序位置对的曼哈顿距离) % MOD。
若把位置对的曼哈顿距离拆成横向(列差)与纵向(行差)两部分:
- 横向:枚举列差
d(1...n-1),列差为d的列对共n - d对,每对可选任意行(m * m种),
贡献d * (n - d) * m * m; - 纵向:枚举行差
d(1...m-1),贡献d * (m - d) * n * n。
组合数用阶乘 + 逆元计算(MOD 为质数)。总时间复杂度 O(mn + m + n),空间 O(mn)。
解法二:枚举全部组合方案(对照)
对小规模数据,用 DFS 枚举C(mn, k)种放置方案,对每种方案统计所有棋子对的距离之和并累加,
实现简单直观,仅用于本地交叉验证。
复杂度: - 时间复杂度:O(mn + m + n)
- 空间复杂度:O(mn)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
private static final long MOD = 1000000007L;
// ---------- 解法一:固定位置对 + 组合计数(主提交版本) ----------
public int distanceSum(int m, int n, int k) {
long cells = (long) m * n;
long pairs = 0;
// 横向:列差贡献
long maxD = n - 1;
for (long d = 1; d <= maxD; ++d) {
long cnt = (n - d) * (long) m % MOD * m % MOD;
pairs = (pairs + cnt * d) % MOD;
}
// 纵向:行差贡献
maxD = m - 1;
for (long d = 1; d <= maxD; ++d) {
long cnt = (m - d) * (long) n % MOD * n % MOD;
pairs = (pairs + cnt * d) % MOD;
}
long comb = comb((int) (cells - 2), k - 2);
return (int) (pairs * comb % MOD);
}
private long[] fact;
private long[] invFact;
private long comb(int N, int R) {
if (R < 0 || R > N) {
return 0;
}
if (fact == null || fact.length <= N) {
fact = new long[N + 1];
invFact = new long[N + 1];
fact[0] = 1;
for (int i = 1; i <= N; ++i) {
fact[i] = fact[i - 1] * i % MOD;
}
invFact[N] = modPow(fact[N], MOD - 2);
for (int i = N; i >= 1; --i) {
invFact[i - 1] = invFact[i] * i % MOD;
}
}
return fact[N] * invFact[R] % MOD * invFact[N - R] % MOD;
}
private long modPow(long a, long e) {
long r = 1;
while (e > 0) {
if ((e & 1) == 1) {
r = r * a % MOD;
}
a = a * a % MOD;
e >>= 1;
}
return r;
}
// ---------- 解法二:枚举全部组合方案(对照) ----------
private long bAns;
private int bM;
private int bN;
private int bK;
public int distanceSumBrute(int m, int n, int k) {
bM = m;
bN = n;
bK = k;
bAns = 0;
int total = m * n;
if (k > total) {
return 0;
}
dfsChoose(0, 0, total, new int[k]);
return (int) (bAns % MOD);
}
private void dfsChoose(int start, int cnt, int total, int[] picked) {
if (cnt == bK) {
long s = 0;
for (int a = 0; a < bK; ++a) {
int ra = picked[a] / bN;
int ca = picked[a] % bN;
for (int b = a + 1; b < bK; ++b) {
int rb = picked[b] / bN;
int cb = picked[b] % bN;
s += Math.abs(ra - rb) + Math.abs(ca - cb);
}
}
bAns = (bAns + s) % MOD;
return;
}
int need = bK - cnt;
for (int i = start; i + need <= total; ++i) {
picked[cnt] = i;
dfsChoose(i + 1, cnt + 1, total, picked);
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.distanceSum(2, 2, 2) + " (期望 8)");
System.out.println("示例2: " + sol.distanceSum(1, 4, 3) + " (期望 20)");
Random rand = new Random(7);
int pass = 0, cases = 0;
for (int t = 0; t < 500; ++t) {
// 要求 mk 别太大,暴力枚举要可行
int total = 2 + rand.nextInt(16); // 总格子数 2..17
int m = 1 + rand.nextInt(total);
int n = total / m;
if (m * n < 2) {
continue;
}
int k = 2 + rand.nextInt(m * n - 1);
int x = sol.distanceSum(m, n, k);
int y = sol.distanceSumBrute(m, n, k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH m=" + m + " n=" + n + " k=" + k
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
组合数用阶乘 + 逆元计算(MOD 为质数)。总时间复杂度 O(mn + m + n),空间 O(mn)。
- 时间复杂度:O(mn + m + n)
- 空间复杂度:O(mn)
3427. Sum of Variable Length Subarrays(变长子数组求和)
题目描述
给你一个长度为 n 的整数数组 nums。对于每个下标 i(0 <= i < n),定义对应的子数组
nums[start ... i],其中 start = max(0, i - nums[i])。
返回为数组中每个下标定义的子数组中所有元素的总和。
子数组是数组中的一个连续、非空的元素序列。
示例 1
nums = [2,3,1] -> 11
示例 2
nums = [3,1,1,2] -> 13
提示:
1 <= n == nums.length <= 1001 <= nums[i] <= 1000
解题思路
解法一:前缀和 O(n),主提交版本
对每个 i 求区间 [start, i] 的和,用前缀和数组 pre(pre[x] 为前 x 个元素之和):
sum = pre[i + 1] - pre[start]。其中 start = max(0, i - nums[i])。
总复杂度 O(n)。
解法二:差分统计每个下标的被覆盖次数(对照)
每个区间 [start, i] 意味着该区间内每个下标都被累加一次。用差分数组 diff 记录每个下标
在多少个区间内:对每个 i,diff[start] += 1、diff[i + 1] -= 1,最后前缀累加得到每个下标
被覆盖的次数 cnt[j],答案 = sum(cnt[j] * nums[j])。思路不同,用于交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:前缀和(主提交版本) ----------
public int subarraySum(int[] nums) {
int n = nums.length;
int[] pre = new int[n + 1];
for (int i = 0; i < n; ++i) {
pre[i + 1] = pre[i] + nums[i];
}
int ans = 0;
for (int i = 0; i < n; ++i) {
int start = Math.max(0, i - nums[i]);
ans += pre[i + 1] - pre[start];
}
return ans;
}
// ---------- 解法二:差分覆盖计数(对照) ----------
public int subarraySumBrute(int[] nums) {
int n = nums.length;
int[] diff = new int[n + 1];
for (int i = 0; i < n; ++i) {
int start = Math.max(0, i - nums[i]);
diff[start] += 1;
diff[i + 1] -= 1;
}
int ans = 0;
int cnt = 0;
for (int j = 0; j < n; ++j) {
cnt += diff[j];
ans += cnt * nums[j];
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.subarraySum(new int[] {2, 3, 1}) + " (期望 11)");
System.out.println("示例2: " + sol.subarraySum(new int[] {3, 1, 1, 2}) + " (期望 13)");
Random rand = new Random(11);
int pass = 0, cases = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rand.nextInt(12);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(10);
}
int x = sol.subarraySum(a);
int y = sol.subarraySumBrute(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + Arrays.toString(a) + " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3428. Maximum and Minimum Sums of at Most Size K Subsequences(最多 K 个元素的子序列的最值之和)
题目描述
给你一个整数数组 nums 和一个正整数 k,返回所有长度最多为 k 的子序列中最大值与最小值之和的总和。
其中,非空子序列是指从另一个数组中删除一些或不删除任何元素(且不改变剩余元素的顺序)得到的数组。
由于答案可能非常大,请返回对 10^9 + 7 取余数的结果。
示例 1
nums = [1,2,3], k = 2 -> 24
示例 2
nums = [5,0,6], k = 1 -> 22
示例 3
nums = [1,1,1], k = 2 -> 12
提示:
1 <= nums.length <= 10^50 <= nums[i] <= 10^91 <= k <= min(100, nums.length)
解题思路
解法一:排序 + 组合数学贡献法,主提交版本
子序列的顺序不影响最值,先排序。排序后若元素 nums[i] 是一个子序列的最大值,则其余元素只能从
下标 [0, i-1] 中选(最多 k-1 个),选法数为 sum_{j=0}^{min(k-1, i)} C(i, j);
若 nums[i] 是最小值,其余元素只能从下标 [i+1, n-1] 中选,选法数为
sum_{j=0}^{min(k-1, n-1-i)} C(n-1-i, j)。每个位置 i 作为最大值与
n-1-i 作为最小值贡献次数相同(对称),故对每个 i 累加一次、再把计数翻倍即可。
组合数小规模可用组合递推 C(n, m) = C(n-1, m) + C(n-1, m-1)(k <= 100,无需逆元)。
时间复杂度 O(nk),空间 O(k)。
解法二:枚举全部子序列(对照)
对小规模数据,用 DFS 枚举长度 1...k 的所有子序列,直接计算每个子序列的 max + min 并累加取模,
直观简单,仅用于本地交叉验证。
复杂度:
- 时间复杂度:O(nk)
- 空间复杂度:O(k)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
private static final long MOD = 1000000007L;
// ---------- 解法一:排序 + 组合数学贡献法(主提交版本) ----------
public int minMaxSums(int[] nums, int k) {
int n = nums.length;
Arrays.sort(nums);
long ans = 0;
// comb[j] = C(i-1, j) 在第 i 轮更新为 C(i, j)
long[] comb = new long[k];
comb[0] = 1; // C(0,0)
int maxJ = Math.min(k - 1, n - 1);
for (int i = 0; i < n; ++i) {
// 累加 sum_{j=0}^{min(k-1, i)} C(i, j)
long ways = 0;
int lim = Math.min(k - 1, i);
for (int j = 0; j <= lim; ++j) {
ways = (ways + comb[j]) % MOD;
}
// nums[i] 作为最大值次数 = ways;nums[n-1-i] 作为最小值次数 = ways
ans = (ans + (nums[i] % MOD) * ways) % MOD;
ans = (ans + (nums[n - 1 - i] % MOD) * ways) % MOD;
// 更新 comb 为 C(i+1, j)
for (int j = Math.min(i + 1, maxJ); j >= 1; --j) {
comb[j] = (comb[j] + comb[j - 1]) % MOD;
}
}
return (int) ans;
}
// ---------- 解法二:枚举全部子序列(对照) ----------
private long bAns;
private int[] bNums;
private int bK;
public int minMaxSumsBrute(int[] nums, int k) {
bNums = nums;
bK = k;
bAns = 0;
for (int len = 1; len <= k; ++len) {
dfs(0, 0, len, Long.MAX_VALUE, Long.MIN_VALUE);
}
return (int) (bAns % MOD);
}
private void dfs(int start, int cnt, int len, long minV, long maxV) {
if (cnt == len) {
bAns = (bAns + minV + maxV) % MOD;
return;
}
if (bNums.length - start < len - cnt) {
return;
}
for (int i = start; i < bNums.length; ++i) {
dfs(i + 1, cnt + 1, len, Math.min(minV, bNums[i]), Math.max(maxV, bNums[i]));
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.minMaxSums(new int[] {1, 2, 3}, 2) + " (期望 24)");
System.out.println("示例2: " + sol.minMaxSums(new int[] {5, 0, 6}, 1) + " (期望 22)");
System.out.println("示例3: " + sol.minMaxSums(new int[] {1, 1, 1}, 2) + " (期望 12)");
Random rand = new Random(17);
int pass = 0, cases = 0;
for (int t = 0; t < 3000; ++t) {
int n = 1 + rand.nextInt(8);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = rand.nextInt(6); // 允许重复
}
int k = 1 + rand.nextInt(Math.min(n, 4));
int x = sol.minMaxSums(a.clone(), k);
int y = sol.minMaxSumsBrute(a.clone(), k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + Arrays.toString(a) + " k=" + k
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(nk),空间 O(k)。
- 时间复杂度:O(nk)
- 空间复杂度:O(k)
3429. Paint House IV(粉刷房子 IV)
题目描述
给你一个偶数整数 n,表示沿直线排列的房屋数量,以及一个大小为 n x 3 的二维数组 cost,
其中 cost[i][j] 表示将第 i 个房屋涂成颜色 j + 1 的成本。
如果房屋满足以下条件,则认为它们看起来漂亮:
- 不存在两个涂成相同颜色的相邻房屋;
- 距离行两端等距的房屋不能涂成相同的颜色(例如
n= 6 时位置 (0,5)、(1,4)、(2,3) 等距)。
返回使房屋看起来漂亮的最低涂色成本。
示例 1
n = 4, cost = [[3,5,7],[6,2,9],[4,8,1],[7,3,5]] -> 9
示例 2
n = 6, cost = [[2,4,6],[5,3,8],[7,1,9],[4,6,2],[3,5,7],[8,2,4]] -> 18
提示:
2 <= n <= 10^5,n是偶数cost.length == n,cost[i].length == 30 <= cost[i][j] <= 10^5
解题思路
解法一:对称配对 DP,主提交版本
等距条件把房子分成 n/2 对:(i, n-1-i)。从外向内逐对处理,第 i 对两房相邻于第 i+1 对两房
之外侧,它们之间也有相邻约束。用滚动 DP:dp[a][b] 表示已处理完外侧若干对后,「靠内一侧
最近那对」的两房颜色为 a、b 时的最小成本。初始化为全 0(最外层之外无房子,无约束)。
处理第 i 对时枚举当前对颜色 (x, y),要求 x != y(等距不同色)、x != a、y != b(相邻不同色),
转移 ndp[x][y] = min(dp[a][b]) + cost[i][x] + cost[n-1-i][y]。共 n/2 对,每对 3^4 状态,
总 O(n)。返回最终 min(dp)。
解法二:暴力枚举全部涂色方案(对照)
枚举所有 3^n 种涂色方案(仅限小 n),依次检查相邻不同色与等距不同色两条约束,取合法方案
的最小成本。直观但指数级,仅用于本地交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:对称配对 DP(主提交版本) ----------
public long minCost(int n, int[][] cost) {
long[][] dp = new long[3][3]; // 初始:最外层外无房子,无约束,成本 0
for (int i = 0; i < 3; ++i) {
Arrays.fill(dp[i], 0L);
}
int half = n / 2;
for (int i = 0; i < half; ++i) {
int j = n - 1 - i;
long[][] ndp = new long[3][3];
for (int a = 0; a < 3; ++a) {
Arrays.fill(ndp[a], Long.MAX_VALUE / 4);
}
for (int a = 0; a < 3; ++a) {
for (int b = 0; b < 3; ++b) {
long base = dp[a][b];
for (int x = 0; x < 3; ++x) {
if (x == a) {
continue; // 左房与外侧左房相邻,不能同色
}
for (int y = 0; y < 3; ++y) {
if (y == b || x == y) {
continue; // 右房相邻约束 + 等距异色
}
long v = base + cost[i][x] + cost[j][y];
if (v < ndp[x][y]) {
ndp[x][y] = v;
}
}
}
}
}
dp = ndp;
}
long ans = Long.MAX_VALUE;
for (int x = 0; x < 3; ++x) {
for (int y = 0; y < 3; ++y) {
ans = Math.min(ans, dp[x][y]);
}
}
return ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
private long bAns;
private int[] bColors;
private int[][] bCost;
private int bN;
public long minCostBrute(int n, int[][] cost) {
bN = n;
bCost = cost;
bColors = new int[n];
bAns = Long.MAX_VALUE;
dfsColors(0);
return bAns;
}
private void dfsColors(int idx) {
if (idx == bN) {
long s = 0;
for (int i = 0; i < bN; ++i) {
s += bCost[i][bColors[i]];
}
if (s >= bAns) {
return;
}
// 相邻不同色
for (int i = 0; i + 1 < bN; ++i) {
if (bColors[i] == bColors[i + 1]) {
return;
}
}
// 等距不同色
for (int i = 0; i < bN / 2; ++i) {
if (bColors[i] == bColors[bN - 1 - i]) {
return;
}
}
bAns = s;
return;
}
for (int c = 0; c < 3; ++c) {
bColors[idx] = c;
dfsColors(idx + 1);
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.minCost(4, new int[][] {{3, 5, 7}, {6, 2, 9},
{4, 8, 1}, {7, 3, 5}}) + " (期望 9)");
System.out.println("示例2: " + sol.minCost(6, new int[][] {{2, 4, 6}, {5, 3, 8},
{7, 1, 9}, {4, 6, 2}, {3, 5, 7}, {8, 2, 4}}) + " (期望 18)");
Random rand = new Random(23);
int pass = 0, cases = 0;
for (int t = 0; t < 2000; ++t) {
int n = 2 * (1 + rand.nextInt(4)); // 2,4,6,8
int[][] c = new int[n][3];
for (int i = 0; i < n; ++i) {
for (int j = 0; j < 3; ++j) {
c[i][j] = rand.nextInt(11);
}
}
long x = sol.minCost(n, c);
long y = sol.minCostBrute(n, c);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH n=" + n + " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3430. Maximum and Minimum Sums of at Most Size K Subarrays(最多 K 个元素的子数组的最值之和)
题目描述
给你一个整数数组 nums 和一个正整数 k。返回最多有 k 个元素的所有子数组的最大元素和最小元素
之和的总和。
子数组是数组中的一个连续、非空的元素序列。
示例 1
nums = [1,2,3], k = 2 -> 20
示例 2
nums = [1,-3,1], k = 2 -> -6
提示:
1 <= nums.length <= 800001 <= k <= nums.length-10^6 <= nums[i] <= 10^6
解题思路
解法一:单调栈定界 + 长度受限计数,主提交版本
先单独计算「所有长 ≤ k 的子数组的最大值之和」,再把数组取负后同样算一遍即得「最小值之和的负值」,
二者相减即为答案。
对最大值:用单调栈求出每个 i 作为最大值的最左边界 left[i](前一个大于等于它的位置)与最右
边界 right[i](后一个大于它的位置,等值去重交给 left 一侧处理)。任一以 i 为最大值的子数组,
左右端点分别必须在 (left[i], i] 与 [i, right[i]) 内,且长度 ≤ k。满足条件的子数组数为:
设 l = min(k, i - left[i]),r = min(k, right[i] - i),则
- 若
l + r - 1 <= k(不存在同时触顶的组合,取任意左右距离即可):
数量 =l * r; - 否则需要枚举左距离
d = 1..l,右距离e = min(r, k - d),累加
sum_{d=1}^{l} min(r, k - d),可由算术级数 O(1) 计算。
对最小值:将nums取负后套用同一逻辑,「负最大值之和」的相反数即「最小值之和」。
总时间复杂度 O(n),空间 O(n)。
解法二:暴力枚举全部子数组(对照)
枚举所有长度 ≤ k 的子数组,直接求max + min累加,O(nk) 仅适用于小规模交叉验证。
复杂度: - 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:单调栈 + 长度受限计数(主提交版本) ----------
public long minMaxSubarraySum(int[] nums, int k) {
long sum = solveRange(nums, k, true);
int n = nums.length;
int[] neg = new int[n];
for (int i = 0; i < n; ++i) {
neg[i] = -nums[i];
}
long negSum = solveRange(neg, k, true);
return sum - negSum;
}
private long solveRange(int[] nums, int k, boolean unused) {
int n = nums.length;
int[] left = new int[n];
int[] right = new int[n];
int[] st = new int[n];
int top = -1;
// left[i]:前一个 > nums[i](严格大于做去重),没有则 -1
for (int i = 0; i < n; ++i) {
while (top != -1 && nums[st[top]] < nums[i]) {
top--;
}
left[i] = (top == -1) ? -1 : st[top];
st[++top] = i;
}
top = -1;
// right[i]:后一个 >= nums[i],没有则 n
for (int i = n - 1; i >= 0; --i) {
while (top != -1 && nums[st[top]] <= nums[i]) {
top--;
}
right[i] = (top == -1) ? n : st[top];
st[++top] = i;
}
long ans = 0;
for (int i = 0; i < n; ++i) {
long l = Math.min(k, i - left[i]); // 左可跨距离 1..l
long r = Math.min(k, right[i] - i); // 右可跨距离 1..r
long cnt;
if (l + r - 1 <= k) {
cnt = l * r;
} else {
// sum_{d=1..l} min(r, k - d + 1),d = 左距离(从 1 起)
// 令 d 分两段:d <= k - r + 1 时取 r;之后取 k - d + 1
long full = Math.min(l, k - r + 1); // 这些 d 取满 r
cnt = full * r;
long d1 = full + 1;
if (d1 <= l) {
long last = k - l + 1; // 最后一个 d=l 时取值
long lo = k - d1 + 1; // d=d1 时取值
// sum_{d=d1..l} (k-d+1) 等差数列 [lo, last] 项数 l-d1+1
long num = l - d1 + 1;
cnt += (lo + last) * num / 2;
}
}
ans += (long) nums[i] * cnt;
}
return ans;
}
// ---------- 解法二:暴力枚举(对照) ----------
public long minMaxSubarraySumBrute(int[] nums, int k) {
long ans = 0;
for (int i = 0; i < nums.length; ++i) {
int mx = Integer.MIN_VALUE, mn = Integer.MAX_VALUE;
for (int j = i; j < nums.length && j - i + 1 <= k; ++j) {
mx = Math.max(mx, nums[j]);
mn = Math.min(mn, nums[j]);
ans += mx + mn;
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.minMaxSubarraySum(new int[] {1, 2, 3}, 2) + " (期望 20)");
System.out.println("示例2: " + sol.minMaxSubarraySum(new int[] {1, -3, 1}, 2) + " (期望 -6)");
Random rand = new Random(29);
int pass = 0, cases = 0;
for (int t = 0; t < 3000; ++t) {
int n = 1 + rand.nextInt(9);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = rand.nextInt(21) - 10; // -10..10,含重复
}
int k = 1 + rand.nextInt(n);
long x = sol.minMaxSubarraySum(a.clone(), k);
long y = sol.minMaxSubarraySumBrute(a.clone(), k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + Arrays.toString(a) + " k=" + k
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
总时间复杂度 O(n),空间 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3431. Minimum Unlocked Indices to Sort Nums(对数字排序的最小解锁下标)
题目描述
给定一个仅包含 1、2、3 的整数的数组 nums,以及一个相同大小的二进制数组 locked。
当满足 nums[i] - nums[i + 1] == 1 且 locked[i] == 0 时,则允许交换下标 i 和 i + 1
处的元素;如果可以通过交换相邻元素将 nums 升序排序,我们认为 nums 是可排序的。
你可以进行若干次操作,每次操作可以将 locked[i] 设置为 0,从而解锁下标 i。
返回使 nums 满足可排序的所需最小操作次数。如果不可能使 nums 可排序,返回 -1。
示例 1
nums = [1,2,1,2,3,2], locked = [1,0,1,1,0,1] -> 0
示例 2
nums = [1,2,1,1,3,2,2], locked = [1,0,1,1,0,1,0] -> 2
示例 3
nums = [1,2,1,2,3,2,1], locked = [0,0,0,0,0,0,0] -> -1
提示:
1 <= nums.length <= 10^51 <= nums[i] <= 3locked.length == nums.length0 <= locked[i] <= 1
解题思路
解法一:区间覆盖计数,主提交版本
值的种类只有 1/2/3,排序目标为「1 全在最前、2 居中、3 全在最后」。
可实现性:若存在「3 在 1 前面」则不可排序。因为 3 与 1 相差 2,永不允许直接交换,
3 无法越过 1 到达末尾,故 first3 < last1 时直接返回 -1。
交换代价分析:2 需要越过的 1 位于 [first2, last1) 区间;3 需要越过的 2 位于
[first3, last2) 区间。这些区间中所有上锁的位置(locked[i] == 1)都必须解锁。
答案是区间并在两区间中的上锁位置数(两区间不重叠,直接分别统计即可)。
时间复杂度 O(n),空间 O(1)。
解法二:BFS 模拟贪心(对照)
对少量数据,用队列按值分层模拟「可交换的相邻元素尽量交换」的排序过程,记录所需解锁次数:
每当遇到阻塞在错误一侧的元素,计算需要解锁的最小位置数。实现复杂且仅用于交叉验证,
故本地对照使用更朴素的推理:直接判断 -1 条件后统计两区间上锁数------与解法一相同逻辑、
不同实现路径的版本,用于验证主解实现细节。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:区间覆盖计数(主提交版本) ----------
public int minUnlockedIndices(int[] nums, int[] locked) {
int n = nums.length;
int first2 = n, first3 = n;
int last1 = -1, last2 = -1;
for (int i = 0; i < n; ++i) {
if (nums[i] == 1) {
last1 = i;
} else if (nums[i] == 2) {
if (first2 == n) {
first2 = i;
}
last2 = i;
} else { // 3
if (first3 == n) {
first3 = i;
}
}
}
// 3 出现在最后一个 1 之前:3 无法越过 1,不可排序
if (first3 < last1) {
return -1;
}
int ans = 0;
for (int i = 0; i < n; ++i) {
if (locked[i] == 1
&& ((first2 <= i && i < last1) || (first3 <= i && i < last2))) {
++ans;
}
}
return ans;
}
// ---------- 解法二:模拟交换(对照,仅小规模) ----------
private int[] bNums;
private int[] bLocked;
public int minUnlockedIndicesBrute(int[] nums, int[] locked) {
int n = nums.length;
int first2 = n, first3 = n;
int last1 = -1, last2 = -1;
for (int i = 0; i < n; ++i) {
if (nums[i] == 1) {
last1 = i;
} else if (nums[i] == 2) {
first2 = Math.min(first2, i);
last2 = i;
} else {
first3 = Math.min(first3, i);
}
}
if (first3 < last1) {
return -1;
}
// 模拟:不断尝试把每个元素交换到目标位置,记录必须解锁的下标
bNums = nums.clone();
bLocked = locked.clone();
boolean[] unlocked = new boolean[n];
int ans = 0;
while (true) {
boolean moved = false;
for (int i = 0; i + 1 < n; ++i) {
if (bNums[i] > bNums[i + 1] && bNums[i] - bNums[i + 1] == 1) {
if (!unlocked[i] && bLocked[i] == 1) {
unlocked[i] = true;
ans++;
}
int t = bNums[i];
bNums[i] = bNums[i + 1];
bNums[i + 1] = t;
moved = true;
}
}
if (!moved) {
break;
}
}
// 检查是否真排序了
for (int i = 0; i + 1 < n; ++i) {
if (bNums[i] > bNums[i + 1]) {
return -1;
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.minUnlockedIndices(new int[] {1, 2, 1, 2, 3, 2},
new int[] {1, 0, 1, 1, 0, 1}) + " (期望 0)");
System.out.println("示例2: " + sol.minUnlockedIndices(new int[] {1, 2, 1, 1, 3, 2, 2},
new int[] {1, 0, 1, 1, 0, 1, 0}) + " (期望 2)");
System.out.println("示例3: " + sol.minUnlockedIndices(new int[] {1, 2, 1, 2, 3, 2, 1},
new int[] {0, 0, 0, 0, 0, 0, 0}) + " (期望 -1)");
Random rand = new Random(31);
int pass = 0, cases = 0;
for (int t = 0; t < 5000; ++t) {
int n = 1 + rand.nextInt(9);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(3);
}
int[] lk = new int[n];
for (int i = 0; i < n; ++i) {
lk[i] = rand.nextInt(2);
}
int x = sol.minUnlockedIndices(a.clone(), lk.clone());
int y = sol.minUnlockedIndicesBrute(a.clone(), lk.clone());
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + Arrays.toString(a) + " locked="
+ Arrays.toString(lk) + " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n),空间 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3432. Count Partitions with Even Sum Difference(统计元素和差值为偶数的分区方案)
题目描述
给你一个长度为 n 的整数数组 nums。分区是指将数组按照下标 i(0 <= i < n - 1)划分成
两个非空子数组,其中:左子数组包含区间 [0, i] 内的所有下标,右子数组包含区间 [i + 1, n - 1]
内的所有下标。对左子数组和右子数组先求元素和再做差,统计并返回差值为偶数的分区方案数。
示例 1
nums = [10,10,3,7,6] -> 4
示例 2
nums = [1,2,2] -> 0
示例 3
nums = [2,4,6,8] -> 3
提示:
2 <= n == nums.length <= 1001 <= nums[i] <= 100
解题思路
解法一:奇偶性判定,主提交版本
设数组总和为 S,左半部分和为 L,则右半部分和为 S - L,差值为 L - (S - L) = 2L - S。
由于 2L 恒为偶数,差值的奇偶性完全由 S 决定:S 为奇数时任何分区差值都为奇数(答案为 0);
S 为偶数时所有 n - 1 个分区都满足条件(答案为 n - 1)。
时间复杂度 O(n),空间 O(1)。
解法二:枚举分区点(对照)
对每个分割点 i(1...n-1),用前缀和分别求左右和,逐点判断差值是否为偶数并计数。
实现直接,用于交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:奇偶性判定(主提交版本) ----------
public int countPartitions(int[] nums) {
int sum = 0;
for (int v : nums) {
sum += v;
}
return (sum & 1) == 0 ? nums.length - 1 : 0;
}
// ---------- 解法二:枚举分区点(对照) ----------
public int countPartitionsBrute(int[] nums) {
int n = nums.length;
int[] pre = new int[n + 1];
for (int i = 0; i < n; ++i) {
pre[i + 1] = pre[i] + nums[i];
}
int ans = 0;
for (int i = 1; i < n; ++i) {
int left = pre[i];
int right = pre[n] - pre[i];
if (((left - right) & 1) == 0) {
ans++;
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.countPartitions(new int[] {10, 10, 3, 7, 6}) + " (期望 4)");
System.out.println("示例2: " + sol.countPartitions(new int[] {1, 2, 2}) + " (期望 0)");
System.out.println("示例3: " + sol.countPartitions(new int[] {2, 4, 6, 8}) + " (期望 3)");
Random rand = new Random(37);
int pass = 0, cases = 0;
for (int t = 0; t < 2000; ++t) {
int n = 2 + rand.nextInt(8);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(20);
}
int x = sol.countPartitions(a);
int y = sol.countPartitionsBrute(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + Arrays.toString(a) + " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n),空间 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3433. Count Mentions Per User(统计用户被提及情况)
题目描述
给你一个整数 numberOfUsers 表示用户总数,另有一个大小为 n x 3 的数组 events。
每个 events[i] 都属于下述两种类型之一:
- 消息事件(
MessageEvent):["MESSAGE", "timestampi", "mentions_stringi"],事件表示在
timestampi时一组用户被消息提及。mentions_stringi可包含:id <number>(可空格分隔多个、
可重复、可提及离线用户)、ALL(提及所有用户)、HERE(提及所有在线用户)。 - 离线事件(
OfflineEvent):["OFFLINE", "timestampi", "idi"],表示用户idi在timestampi
变为离线状态 60 个单位时间,并在timestampi + 60自动再次上线。
返回数组mentions,其中mentions[i]表示id为i的用户在所有MESSAGE事件中被提及的次数。
最初所有用户都处于在线状态;如果某个用户离线或者重新上线,其对应的状态变更将会在所有相同时间
发生的消息事件之前进行处理和同步。在单条消息中,同一个用户可能会被提及多次,每次提及都要分别统计。
示例 1
numberOfUsers = 2, events = [["MESSAGE","10","id1 id0"],["OFFLINE","11","0"],["MESSAGE","71","HERE"]] -> [2,2]
示例 2
numberOfUsers = 2, events = [["MESSAGE","10","id1 id0"],["OFFLINE","11","0"],["MESSAGE","12","ALL"]] -> [2,2]
示例 3
numberOfUsers = 2, events = [["OFFLINE","10","0"],["MESSAGE","12","HERE"]] -> [0,1]
提示:
1 <= numberOfUsers <= 1001 <= events.length <= 100- 时间戳
>= 1且<= 10^5
解题思路
解法一:按时间排序 + 同步离线状态,主提交版本
- 按时间戳升序排序,同时间戳内 OFFLINE 排在 MESSAGE 之前实现「状态变更先于同一时刻的消息」;
- 维护
online[]布尔数组与每个事件时刻的离线用户集合:对每个事件,先把所有back[t]
(该时刻恢复上线的用户)置回在线,再处理同刻全部事件------离线事件把用户标记离线并将
back[t+60]记入恢复集合,消息事件按类型计数; ALL全量 +1,HERE对每个在线用户 +1,id X对指定用户 +1(可重复要按 token 逐个数)。
时间复杂度 O(n log n + n * U)(U 为用户数),空间 O(n + U)。
解法二:朴素时间轴模拟(对照)
对每条时间戳内的事件,直接遍历所有用户判断在线状态进行计数,逻辑更直白,用于交叉验证。
复杂度:
- 时间复杂度:O(n log n + n * U)
- 空间复杂度:O(n + U)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:按时间排序 + 同步离线状态(主提交版本) ----------
public int[] countMentions(int numberOfUsers, List<List<String>> events) {
int n = events.size();
Integer[] idx = new Integer[n];
for (int i = 0; i < n; ++i) {
idx[i] = i;
}
Arrays.sort(idx, (a, b) -> {
int ta = Integer.parseInt(events.get(a).get(1));
int tb = Integer.parseInt(events.get(b).get(1));
if (ta != tb) {
return ta - tb;
}
// 同一时刻 OFFLINE 优先于 MESSAGE
String ka = events.get(a).get(0);
String kb = events.get(b).get(0);
boolean offA = "OFFLINE".equals(ka);
boolean offB = "OFFLINE".equals(kb);
return (offA ? 0 : 1) - (offB ? 0 : 1);
});
int[] ans = new int[numberOfUsers];
boolean[] online = new boolean[numberOfUsers];
Arrays.fill(online, true);
// 恢复上线:记录每个时间点批量置回
List<List<Integer>> back = new ArrayList<List<Integer>>();
for (int i = 0; i <= 100000 + 60 + 1; ++i) {
back.add(new ArrayList<Integer>());
}
for (int pos = 0; pos < n; ++pos) {
int e = idx[pos];
List<String> ev = events.get(e);
int t = Integer.parseInt(ev.get(1));
// 先恢复该时刻上线用户
for (int u : back.get(t)) {
online[u] = true;
}
if ("MESSAGE".equals(ev.get(0))) {
String m = ev.get(2);
if ("ALL".equals(m)) {
for (int u = 0; u < numberOfUsers; ++u) {
ans[u]++;
}
} else if ("HERE".equals(m)) {
for (int u = 0; u < numberOfUsers; ++u) {
if (online[u]) {
ans[u]++;
}
}
} else {
// id1 id0 等
String[] parts = m.split(" ");
for (String p : parts) {
int u = Integer.parseInt(p.substring(2));
ans[u]++;
}
}
} else { // OFFLINE
int u = Integer.parseInt(ev.get(2));
online[u] = false;
back.get(t + 60).add(u);
}
}
return ans;
}
// ---------- 解法二:朴素时间轴模拟(对照) ----------
public int[] countMentionsBrute(int numberOfUsers, List<List<String>> events) {
int n = events.size();
Integer[] idx = new Integer[n];
for (int i = 0; i < n; ++i) {
idx[i] = i;
}
Arrays.sort(idx, (a, b) -> {
int ta = Integer.parseInt(events.get(a).get(1));
int tb = Integer.parseInt(events.get(b).get(1));
if (ta != tb) {
return ta - tb;
}
String ka = events.get(a).get(0);
String kb = events.get(b).get(0);
return ("OFFLINE".equals(ka) ? 0 : 1) - ("OFFLINE".equals(kb) ? 0 : 1);
});
int[] ans = new int[numberOfUsers];
int[] offlineUntil = new int[numberOfUsers]; // 0 表示在线
int maxT = 0;
for (int i = 0; i < n; ++i) {
maxT = Math.max(maxT, Integer.parseInt(events.get(i).get(1)));
}
for (int pos = 0; pos < n; ++pos) {
int e = idx[pos];
List<String> ev = events.get(e);
int t = Integer.parseInt(ev.get(1));
for (int u = 0; u < numberOfUsers; ++u) {
if (offlineUntil[u] > 0 && offlineUntil[u] <= t) {
offlineUntil[u] = 0;
}
}
if ("MESSAGE".equals(ev.get(0))) {
String m = ev.get(2);
if ("ALL".equals(m)) {
for (int u = 0; u < numberOfUsers; ++u) {
ans[u]++;
}
} else if ("HERE".equals(m)) {
for (int u = 0; u < numberOfUsers; ++u) {
if (offlineUntil[u] == 0) {
ans[u]++;
}
}
} else {
String[] parts = m.split(" ");
for (String p : parts) {
ans[Integer.parseInt(p.substring(2))]++;
}
}
} else {
int u = Integer.parseInt(ev.get(2));
offlineUntil[u] = t + 60;
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
List<List<String>> e1 = new ArrayList<List<String>>();
e1.add(Arrays.asList("MESSAGE", "10", "id1 id0"));
e1.add(Arrays.asList("OFFLINE", "11", "0"));
e1.add(Arrays.asList("MESSAGE", "71", "HERE"));
System.out.println("示例1: " + Arrays.toString(sol.countMentions(2, e1)) + " (期望 [2,2])");
List<List<String>> e2 = new ArrayList<List<String>>();
e2.add(Arrays.asList("MESSAGE", "10", "id1 id0"));
e2.add(Arrays.asList("OFFLINE", "11", "0"));
e2.add(Arrays.asList("MESSAGE", "12", "ALL"));
System.out.println("示例2: " + Arrays.toString(sol.countMentions(2, e2)) + " (期望 [2,2])");
List<List<String>> e3 = new ArrayList<List<String>>();
e3.add(Arrays.asList("OFFLINE", "10", "0"));
e3.add(Arrays.asList("MESSAGE", "12", "HERE"));
System.out.println("示例3: " + Arrays.toString(sol.countMentions(2, e3)) + " (期望 [0,1])");
Random rand = new Random(41);
int pass = 0, cases = 0;
for (int t = 0; t < 2000; ++t) {
int U = 1 + rand.nextInt(4);
int n = 1 + rand.nextInt(8);
List<List<String>> evs = new ArrayList<List<String>>();
for (int i = 0; i < n; ++i) {
int ts = 1 + rand.nextInt(30);
List<String> row = new ArrayList<String>();
if (rand.nextBoolean()) {
row.add("MESSAGE");
row.add("" + ts);
int kind = rand.nextInt(3);
if (kind == 0) {
row.add("ALL");
} else if (kind == 1) {
row.add("HERE");
} else {
StringBuilder sb = new StringBuilder();
int cnt = 1 + rand.nextInt(3);
for (int c = 0; c < cnt; ++c) {
if (c > 0) {
sb.append(' ');
}
sb.append("id").append(rand.nextInt(U));
}
row.add(sb.toString());
}
} else {
row.add("OFFLINE");
row.add("" + ts);
row.add("" + rand.nextInt(U));
}
evs.add(row);
}
int[] x = sol.countMentions(U, evs);
int[] y = sol.countMentionsBrute(U, evs);
cases++;
if (Arrays.equals(x, y)) {
pass++;
} else {
System.out.println("MISMATCH U=" + U + " events=" + evs + " fast="
+ Arrays.toString(x) + " brute=" + Arrays.toString(y));
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n log n + n * U)(U 为用户数),空间 O(n + U)。
- 时间复杂度:O(n log n + n * U)
- 空间复杂度:O(n + U)
3434. Maximum Frequency After Subarray Operation(子数组操作后的最大频率)
题目描述
给你一个长度为 n 的数组 nums,同时给你一个整数 k。你可以对 nums 执行以下操作一次:
选择一个子数组 nums[i..j](0 <= i <= j <= n - 1),选择一个整数 x 并将 nums[i..j] 中
所有元素都增加 x。请你返回执行以上操作以后数组中 k 出现的最大频率。
子数组是一个数组中一段连续非空的元素序列。
示例 1
nums = [1,2,3,4,5,6], k = 1 -> 2
示例 2
nums = [10,2,3,4,5,5,4,3,2,2], k = 10 -> 4
提示:
1 <= n == nums.length <= 10^51 <= nums[i] <= 501 <= k <= 50
解题思路
解法一:Kadane 最大子段和,主提交版本
操作后 k 的频率 = 「原本就是 k 的个数」+「被选子数组中由其他值变为 k 的个数」。
对每个目标值 t(1...50 且 t != k):若选中的子数组内有个 t,加 x = k - t 后该元素变为 k
(收益 +1);子数组内原本是 k 的元素会被加 x 而离开 k(收益 -1)。其余元素不受影响。
于是问题等价于求「含 k 记 -1、含 t 记 +1、其余记 0」序列的最大子段和(可空),对每个 t 跑一遍
Kadane 取最大值,再加回原始 k 的计数。数值范围仅 50,总 O(50n)。
解法二:枚举子数组(对照)
对小数据,枚举所有子数组并枚举 x(只需考虑把某个元素变为 k,即 x = k - nums[p]),
逐元素判断操作后是否为 k 并统计,取最大,用于交叉验证。
复杂度:
- 时间复杂度:O(50n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:Kadane 最大子段和(主提交版本) ----------
public int maxFrequency(int[] nums, int k) {
int base = 0;
for (int v : nums) {
if (v == k) {
base++;
}
}
int best = 0;
for (int t = 1; t <= 50; ++t) {
if (t == k) {
continue;
}
int cur = 0;
for (int v : nums) {
if (v == t) {
cur++;
} else if (v == k) {
cur--;
}
if (cur < 0) {
cur = 0;
}
if (cur > best) {
best = cur;
}
}
}
return base + best;
}
// ---------- 解法二:枚举子数组(对照) ----------
public int maxFrequencyBrute(int[] nums, int k) {
int n = nums.length;
int best = 0;
for (int i = 0; i < n; ++i) {
for (int j = i; j < n; ++j) {
// 枚举该子数组要变的 x:只需考虑把子数组内某个元素变为 k 的 x
for (int p = i; p <= j; ++p) {
int x = k - nums[p];
int cnt = 0;
for (int q = 0; q < n; ++q) {
int val = (q >= i && q <= j) ? nums[q] + x : nums[q];
if (val == k) {
cnt++;
}
}
best = Math.max(best, cnt);
}
}
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.maxFrequency(new int[] {1, 2, 3, 4, 5, 6}, 1) + " (期望 2)");
System.out.println("示例2: " + sol.maxFrequency(new int[] {10, 2, 3, 4, 5, 5, 4, 3, 2, 2}, 10)
+ " (期望 4)");
Random rand = new Random(43);
int pass = 0, cases = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rand.nextInt(7);
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(5);
}
int k = 1 + rand.nextInt(5);
int x = sol.maxFrequency(a.clone(), k);
int y = sol.maxFrequencyBrute(a.clone(), k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + Arrays.toString(a) + " k=" + k
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
- 时间复杂度:O(50n)
- 空间复杂度:O(1)
3435. Frequencies of Shortest Supersequences(最短公共超序列的字母出现频率)
题目描述
给你一个字符串数组 words。请你找到 words 所有最短公共超序列(SCS),且确保它们互相之间
无法通过排列得到。最短公共超序列指的是一个字符串,words 中所有字符串都是它的子序列,且它的
长度最短。请你返回一个二维整数数组 freqs,表示所有的最短公共超序列,其中 freqs[i] 是一个
长度为 26 的数组,它依次表示一个最短公共超序列的所有小写英文字母的出现频率。你可以以任意顺序
返回这个频率数组。
示例 1
words = ["ab","ba"] -> [[1,2,0,...],[2,1,0,...]]
示例 2
words = ["aa","ac"] -> [[2,0,1,0,...]]
示例 3
words = ["aa","bb","cc"] -> [[2,2,2,0,...]]
提示:
1 <= words.length <= 256words[i].length == 2words中所有字符串由不超过 16 个互不相同的小写英文字母组成words中的字符串互不相同
解题思路
解法一:枚举子集 + 环检测,主提交版本
把每个 words[i] 看作一条有向边 u -> v(u 需出现在 v 之前)。每个字母在 SCS 中最多出现
2 次:出现 1 次的字母只有一个位置;出现 2 次的字母有两个位置,自由度更高。
若两端都只出现 1 次的边存在圈,则无法满足顺序约束;此时必须把圈中某些字母改为出现 2 次来破环
(出现 2 次的一端的约束自动可满足:总能安排一个位置在对面字母之前、另一个位置在对面字母之后)。
自环 uu 所在的字母必须出现 2 次(单个位置无法让 u 出现在 u 之前)。
算法:收集全部字母(最多 16 个)映射到 0...m-1,枚举子集 mask 表示「出现 2 次的字母」:
- 自环字母必须在 mask 中;
- 去掉 mask 中字母相关边后,剩余图必须无环(DFS 三色)。
合法时总长度 = m + popcount(mask)。取总长度最小的全部 mask 生成频率数组。
时间复杂度 O(2^m * (m + E)),空间 O(m + E)。
解法二:频率枚举 + 槽位构造(对照)
同样按每字母 1 次/2 次枚举频率组合,但用「逐槽位放置字母、验证所有 words 能否作为子序列匹配」
的构造法判断可行性,取代环判定。思路完全不同,用于交叉验证。
复杂度: - 时间复杂度:O(2^m * (m + E))
- 空间复杂度:O(m + E)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
import java.util.Set;
import java.util.TreeSet;
public class Solution {
// ---------- 解法一:枚举子集 + 环检测(主提交版本) ----------
public List<List<Integer>> supersequences(String[] words) {
Set<Integer> nodeSet = new TreeSet<Integer>();
List<int[]> edges = new ArrayList<int[]>();
for (String w : words) {
int u = w.charAt(0) - 'a';
int v = w.charAt(1) - 'a';
nodeSet.add(u);
nodeSet.add(v);
edges.add(new int[] {u, v});
}
int m = nodeSet.size();
int[] nodes = new int[m];
int t = 0;
for (int x : nodeSet) {
nodes[t++] = x;
}
int[] idxOf = new int[26];
Arrays.fill(idxOf, -1);
for (int i = 0; i < m; ++i) {
idxOf[nodes[i]] = i;
}
// 所有 1次/2次 组合的邻接(只保留两端都出现 1 次的边)
int bestLen = Integer.MAX_VALUE;
List<Integer> bestMasks = new ArrayList<Integer>();
for (int mask = 0; mask < (1 << m); ++mask) {
boolean ok = true;
List<int[]> sub = new ArrayList<int[]>();
for (int[] e : edges) {
int a = idxOf[e[0]];
int b = idxOf[e[1]];
if (a == b) {
if ((mask & (1 << a)) == 0) {
ok = false; // 自环必须出现 2 次
break;
}
continue;
}
if (((mask >> a) & 1) == 0 && ((mask >> b) & 1) == 0) {
sub.add(new int[] {a, b});
}
}
if (!ok) {
continue;
}
if (hasCycle(m, sub)) {
continue;
}
int len = m + Integer.bitCount(mask);
if (len < bestLen) {
bestLen = len;
bestMasks.clear();
bestMasks.add(mask);
} else if (len == bestLen) {
bestMasks.add(mask);
}
}
List<List<Integer>> res = new ArrayList<List<Integer>>();
for (int mask : bestMasks) {
List<Integer> freq = new ArrayList<Integer>();
for (int i = 0; i < 26; ++i) {
freq.add(0);
}
for (int i = 0; i < m; ++i) {
freq.set(nodes[i], ((mask >> i) & 1) == 1 ? 2 : 1);
}
res.add(freq);
}
return res;
}
private boolean hasCycle(int m, List<int[]> sub) {
List<List<Integer>> g = new ArrayList<List<Integer>>();
for (int i = 0; i < m; ++i) {
g.add(new ArrayList<Integer>());
}
for (int[] e : sub) {
g.get(e[0]).add(e[1]);
}
int[] state = new int[m];
for (int i = 0; i < m; ++i) {
if (state[i] == 0 && dfsCycle(i, g, state)) {
return true;
}
}
return false;
}
private boolean dfsCycle(int u, List<List<Integer>> g, int[] state) {
state[u] = 1;
for (int v : g.get(u)) {
if (state[v] == 1) {
return true;
}
if (state[v] == 0 && dfsCycle(v, g, state)) {
return true;
}
}
state[u] = 2;
return false;
}
// ---------- 解法二:频率枚举 + 排列构造(对照) ----------
private String[] bWords;
private int bM;
private int[] bNodes;
private int bTotal;
public List<List<Integer>> supersequencesBrute(String[] words) {
Set<Integer> nodeSet = new TreeSet<Integer>();
for (String w : words) {
nodeSet.add(w.charAt(0) - 'a');
nodeSet.add(w.charAt(1) - 'a');
}
bM = nodeSet.size();
bNodes = new int[bM];
int t = 0;
for (int x : nodeSet) {
bNodes[t++] = x;
}
bWords = words;
int bestLen = Integer.MAX_VALUE;
List<Integer> bestMasks = new ArrayList<Integer>();
for (int mask = 0; mask < (1 << bM); ++mask) {
bTotal = bM + Integer.bitCount(mask);
if (bTotal > bestLen) {
continue;
}
if (canConstruct(mask)) {
if (bTotal < bestLen) {
bestLen = bTotal;
bestMasks.clear();
bestMasks.add(mask);
} else {
bestMasks.add(mask);
}
}
}
List<List<Integer>> res = new ArrayList<List<Integer>>();
for (int mask : bestMasks) {
List<Integer> freq = new ArrayList<Integer>();
for (int i = 0; i < 26; ++i) {
freq.add(0);
}
for (int i = 0; i < bM; ++i) {
freq.set(bNodes[i], ((mask >> i) & 1) == 1 ? 2 : 1);
}
res.add(freq);
}
return res;
}
private boolean canConstruct(int mask) {
int[] cnt = new int[bM];
for (int i = 0; i < bM; ++i) {
cnt[i] = ((mask >> i) & 1) == 1 ? 2 : 1;
}
char[] cur = new char[bTotal];
return permute(0, cnt, cur);
}
private boolean permute(int pos, int[] cnt, char[] cur) {
if (pos == bTotal) {
for (String w : bWords) {
if (!isSubseq(w, cur, pos)) {
return false;
}
}
return true;
}
boolean[] usedCh = new boolean[26];
for (int i = 0; i < bM; ++i) {
if (cnt[i] == 0 || usedCh[bNodes[i]]) {
continue;
}
usedCh[bNodes[i]] = true;
cnt[i]--;
cur[pos] = (char) (bNodes[i] + 'a');
if (permute(pos + 1, cnt, cur)) {
return true;
}
cnt[i]++;
}
return false;
}
private boolean isSubseq(String w, char[] seq, int len) {
int p = 0;
for (int i = 0; i < len && p < 2; ++i) {
if (seq[i] == w.charAt(p)) {
p++;
}
}
return p == 2;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + show(sol.supersequences(new String[] {"ab", "ba"}))
+ " (期望 2 组)");
System.out.println("示例2: " + show(sol.supersequences(new String[] {"aa", "ac"}))
+ " (期望 [[2,0,1,0..]])");
System.out.println("示例3: " + show(sol.supersequences(new String[] {"aa", "bb", "cc"}))
+ " (期望 [[2,2,2,0..]])");
Random rand = new Random(47);
int pass = 0, cases = 0;
for (int t = 0; t < 800; ++t) {
int letters = 2 + rand.nextInt(3); // 2..4 个字母
String alpha = "abcdef";
List<String> ws = new ArrayList<String>();
int cnt = 1 + rand.nextInt(5);
for (int i = 0; i < cnt; ++i) {
char a = alpha.charAt(rand.nextInt(letters));
char b = alpha.charAt(rand.nextInt(letters));
String wd = "" + a + b;
if (!ws.contains(wd)) {
ws.add(wd);
}
}
if (ws.isEmpty()) {
continue;
}
List<List<Integer>> x = sol.supersequences(ws.toArray(new String[0]));
List<List<Integer>> y = sol.supersequencesBrute(ws.toArray(new String[0]));
cases++;
if (sameSet(x, y)) {
pass++;
} else {
System.out.println("MISMATCH words=" + ws + " fast=" + show(x) + " brute=" + show(y));
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
private static boolean sameSet(List<List<Integer>> a, List<List<Integer>> b) {
if (a.size() != b.size()) {
return false;
}
boolean[] used = new boolean[b.size()];
for (List<Integer> x : a) {
boolean found = false;
for (int j = 0; j < b.size(); ++j) {
if (!used[j] && x.equals(b.get(j))) {
used[j] = true;
found = true;
break;
}
}
if (!found) {
return false;
}
}
return true;
}
private static String show(List<List<Integer>> lists) {
StringBuilder sb = new StringBuilder("[");
for (List<Integer> l : lists) {
sb.append(Arrays.toString(l.toArray(new Integer[0]))).append(",");
}
if (sb.length() > 1) {
sb.setLength(sb.length() - 1);
}
sb.append("]");
return sb.toString();
}
}
复杂度分析
时间复杂度 O(2^m * (m + E)),空间 O(m + E)。
- 时间复杂度:O(2^m * (m + E))
- 空间复杂度:O(m + E)
3436. Find Valid Emails(查找合法邮箱)
题目类型:数据库(SQL)
题目描述
表:Users
+-----------------+---------+
| Column Name | Type |
+-----------------+---------+
| user_id | int |
| email | varchar |
+-----------------+---------+
user_id 是此表的唯一主键。表的每一行包含用户的唯一 ID 和邮箱地址。
编写解决方案找出所有合法邮箱。一个合法邮箱必须同时满足:
- 恰好包含一个
@符号; - 以
.com结尾; @之前的部分只包含字母数字字符和下划线;@之后、.com之前的部分(域名)只包含字母。
返回结果表按 user_id 升序排序。
示例 1:
输入:
Users 表:
+---------+---------------------+
| user_id | email |
+---------+---------------------+
| 1 | alice@example.com |
| 2 | bob_at_example.com |
| 3 | charlie@example.net |
| 4 | david@domain.com |
| 5 | eve@invalid |
+---------+---------------------+
输出:
+---------+-------------------+
| user_id | email |
+---------+-------------------+
| 1 | alice@example.com |
| 4 | david@domain.com |
+---------+-------------------+
解释:
alice@example.com 合法:一个 @,alice 是字母数字,example.com 以字母开头并 .com 结尾。
bob_at_example.com 非法:没有 @(@ 的位置是下划线);
charlie@example.net 非法:不是 .com 结尾;
eve@invalid 非法:不是 .com 结尾。
解题思路
规则很适合用一条全锚定正则 表达:两端都加上 ^...$ 强制整串匹配。
解法一(推荐):单条 REGEXP_LIKE 全锚定
^[A-Za-z0-9_]+@[A-Za-z]+\.com$:
[A-Za-z0-9_]+:@前的本地部分,字母数字下划线,至少 1 个字符;@:正则里只出现一次,天然限制"恰好一个 @";[A-Za-z]+:域名只能字母,至少 1 个字符;\.com$:以字面.com结尾(\.转义点号),^/$锚点保证整串。
解法二(对照):LIKE 手工拆分
LIKE '%@%.com' 等方式无法同时校验"恰好一个 @"、"域名全字母"等约束,需要多个条件叠加,容易漏边界,不推荐。正则一行即可覆盖全部规则。
代码实现
sql
-- 解法一(推荐):单条全锚定正则
SELECT user_id, email
FROM Users
WHERE REGEXP_LIKE(email, '^[A-Za-z0-9_]+@[A-Za-z]+\.com$')
ORDER BY user_id;
复杂度分析
- 时间复杂度 :
O(n),其中n为Users行数,每行做一次正则匹配。 - 空间复杂度 :
O(1),仅需常量级中间状态。
3437. Permutations III(全排列 III)
题目描述
给定一个正整数 n,返回 1 到 n 的所有排列,使得相邻的两个数不同奇偶。
答案按字典序从小到大返回。
示例 1
n = 4 -> [[1,2,3,4],[1,4,3,2],[2,1,4,3],[2,3,4,1],[3,2,1,4],[3,4,1,2],[4,1,2,3],[4,3,2,1]]
示例 2
n = 2 -> [[1,2],[2,1]]
示例 3
n = 3 -> [[1,2,3],[3,2,1]]
提示:
1 <= n <= 10
解题思路
解法一:回溯 + 奇偶约束,主提交版本
按 1...n 升序尝试填入 cur 的每个位置,若 i > 0 则要求当前数与前一数奇偶性不同。
由于枚举顺序天然升序,结果即为字典序。使用 vis[] 标记已用数字,回溯还原。
时间 O(n!),空间 O(n)(不含答案)。
解法二:next_permutation 字典序全排 + 筛选(对照)
按字典序生成全部排列(重复调用 next permutation),逐个检查相邻奇偶不同,
收集合法排列。思路与回溯完全独立,用于交叉验证。
复杂度:
- 时间复杂度:O(n!)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public class Solution {
// ---------- 解法一:回溯 + 奇偶约束(主提交版本) ----------
public int[][] permute(int n) {
List<int[]> res = new ArrayList<int[]>();
int[] cur = new int[n];
boolean[] vis = new boolean[n + 1];
dfs(0, n, cur, vis, res);
return res.toArray(new int[res.size()][]);
}
private void dfs(int i, int n, int[] cur, boolean[] vis, List<int[]> res) {
if (i == n) {
res.add(cur.clone());
return;
}
for (int j = 1; j <= n; ++j) {
if (vis[j]) {
continue;
}
if (i > 0 && (cur[i - 1] % 2) == (j % 2)) {
continue; // 相邻不同奇偶
}
vis[j] = true;
cur[i] = j;
dfs(i + 1, n, cur, vis, res);
vis[j] = false;
}
}
// ---------- 解法二:next_permutation + 筛选(对照) ----------
public int[][] permuteBrute(int n) {
List<int[]> res = new ArrayList<int[]>();
int[] a = new int[n];
for (int i = 0; i < n; ++i) {
a[i] = i + 1;
}
while (true) {
boolean ok = true;
for (int i = 0; i + 1 < n; ++i) {
if ((a[i] % 2) == (a[i + 1] % 2)) {
ok = false;
break;
}
}
if (ok) {
res.add(a.clone());
}
if (!nextPerm(a)) {
break;
}
}
return res.toArray(new int[res.size()][]);
}
private boolean nextPerm(int[] a) {
int n = a.length;
int i = n - 2;
while (i >= 0 && a[i] >= a[i + 1]) {
i--;
}
if (i < 0) {
return false;
}
int j = n - 1;
while (a[j] <= a[i]) {
j--;
}
int t = a[i];
a[i] = a[j];
a[j] = t;
for (int l = i + 1, r = n - 1; l < r; ++l, --r) {
t = a[l];
a[l] = a[r];
a[r] = t;
}
return true;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
for (int n = 1; n <= 7; ++n) {
int[][] x = sol.permute(n);
int[][] y = sol.permuteBrute(n);
boolean same = x.length == y.length;
if (same) {
for (int i = 0; i < x.length; ++i) {
if (!Arrays.equals(x[i], y[i])) {
same = false;
break;
}
}
}
if (same) {
System.out.println("n=" + n + " PASS (" + x.length + " 个排列)");
} else {
System.out.println("n=" + n + " MISMATCH fast=" + x.length + " brute=" + y.length);
System.out.println("fast=" + Arrays.deepToString(x));
System.out.println("brute=" + Arrays.deepToString(y));
}
}
}
}
复杂度分析
时间 O(n!),空间 O(n)(不含答案)。
- 时间复杂度:O(n!)
- 空间复杂度:O(n)
3438. Find Valid Pair of Adjacent Digits in String(找到字符串中合法的相邻数字)
题目描述
给你一个只包含数字的字符串 s。如果 s 中两个相邻的数字满足以下条件,我们称它们是合法的:
- 前面的数字不等于第二个数字;
- 两个数字在
s中出现的次数恰好分别等于这个数字本身。
请你从左到右遍历字符串s,并返回最先找到的合法相邻数字。如果这样的相邻数字不存在,
请你返回一个空字符串。
示例 1
s = "2523533" -> "23"
示例 2
s = "221" -> "21"
示例 3
s = "22" -> ""
提示:
2 <= s.length <= 100s只包含 '1' 到 '9' 的数字
解题思路
解法一:频率统计 + 线性扫描,主提交版本
先统计每个数字 d 在 s 中的出现次数 cnt[d],然后从左到右检查每一对相邻数字 (x, y):
要求 x != y、cnt[x] == x、cnt[y] == y,命中即返回 "" + x + y。复杂度 O(n)。
解法二:逐对直接验证(对照)
对每个位置对,临时统计全串次数再判断,代码更直观,用于交叉验证(O(n^2))。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:频率统计 + 线性扫描(主提交版本) ----------
public String findValidPair(String s) {
int[] cnt = new int[10];
for (int i = 0; i < s.length(); ++i) {
cnt[s.charAt(i) - '0']++;
}
for (int i = 1; i < s.length(); ++i) {
int x = s.charAt(i - 1) - '0';
int y = s.charAt(i) - '0';
if (x != y && cnt[x] == x && cnt[y] == y) {
return "" + x + y;
}
}
return "";
}
// ---------- 解法二:逐对直接验证(对照) ----------
public String findValidPairBrute(String s) {
for (int i = 1; i < s.length(); ++i) {
int x = s.charAt(i - 1) - '0';
int y = s.charAt(i) - '0';
if (x == y) {
continue;
}
int cx = 0, cy = 0;
for (int j = 0; j < s.length(); ++j) {
int d = s.charAt(j) - '0';
if (d == x) {
cx++;
} else if (d == y) {
cy++;
}
}
if (cx == x && cy == y) {
return "" + x + y;
}
}
return "";
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.findValidPair("2523533") + " (期望 23)");
System.out.println("示例2: " + sol.findValidPair("221") + " (期望 21)");
System.out.println("示例3: " + sol.findValidPair("22") + " (期望 \"\")");
Random rand = new Random(53);
int pass = 0, cases = 0;
for (int t = 0; t < 3000; ++t) {
int n = 2 + rand.nextInt(8);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('1' + rand.nextInt(9)));
}
String s = sb.toString();
String x = sol.findValidPair(s);
String y = sol.findValidPairBrute(s);
cases++;
if (x.equals(y)) {
pass++;
} else {
System.out.println("MISMATCH s=" + s + " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3439. Reschedule Meetings for Maximum Free Time I(重新安排会议得到最多空余时间 I)
题目描述
给你一个整数 eventTime 表示一个活动的总时长,这个活动开始于 t = 0,结束于 t = eventTime。
同时给你两个长度为 n 的整数数组 startTime 和 endTime。它们表示这次活动中 n 个时间没有
重叠的会议,其中第 i 个会议的时间为 [startTime[i], endTime[i]]。
你可以重新安排至多 k 个会议,安排的规则是将会议时间平移,且保持原来的会议时长。你的目的是
移动会议后最大化相邻两个会议之间的最长连续空余时间。移动前后所有会议之间的相对顺序需要保持
不变,而且会议时间也需要保持互不重叠。请你返回重新安排会议以后可以得到的最大空余时间。
注意,会议不能安排到整个活动的时间以外。
示例 1
eventTime = 5, k = 1, startTime = [1,3], endTime = [2,5] -> 2
示例 2
eventTime = 10, k = 1, startTime = [0,2,9], endTime = [1,4,10] -> 6
示例 3
eventTime = 5, k = 2, startTime = [0,1,2,3,4], endTime = [1,2,3,4,5] -> 0
提示:
1 <= eventTime <= 10^9n == startTime.length == endTime.length2 <= n <= 10^51 <= k <= n0 <= startTime[i] < endTime[i] <= eventTimeendTime[i] <= startTime[i + 1]
解题思路
解法一:滑动窗口空隙和,主提交版本
定义 gaps:gaps[0] = startTime[0](活动开始到首个会议)、gaps[i] = startTime[i] - endTime[i-1]
(会议间空隙,i = 1...n-1)、gaps[n] = eventTime - endTime[n-1](末会议后空隙)。
若把连续 k 个会议各自平移(保持顺序与时长),可以将这 k 个会议压缩到它们原所在连续区块的
开头(或任意一端),从而把它们之间及两端的 k + 1 个空隙合并为一个长空隙,其长度恰为这
k + 1 个 gaps 之和。故对每个窗口(长度 k + 1 的 gaps 连续和)取最大值即可。
时间复杂度 O(n),空间 O(n)。
解法二:直接枚举窗口(对照)
同样构建 gaps,用朴素双层循环枚举所有长度为 k + 1 的窗口求和取最大,用于交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:滑动窗口空隙和(主提交版本) ----------
public int maxFreeTime(int eventTime, int k, int[] startTime, int[] endTime) {
int n = startTime.length;
long[] gaps = new long[n + 1];
gaps[0] = startTime[0];
for (int i = 1; i < n; ++i) {
gaps[i] = startTime[i] - endTime[i - 1];
}
gaps[n] = eventTime - endTime[n - 1];
long win = 0;
for (int i = 0; i <= k && i <= n; ++i) {
win += gaps[i];
}
long best = win;
for (int i = k + 1; i <= n; ++i) {
win += gaps[i] - gaps[i - (k + 1)];
if (win > best) {
best = win;
}
}
return (int) best;
}
// ---------- 解法二:直接枚举窗口(对照) ----------
public int maxFreeTimeBrute(int eventTime, int k, int[] startTime, int[] endTime) {
int n = startTime.length;
long[] gaps = new long[n + 1];
gaps[0] = startTime[0];
for (int i = 1; i < n; ++i) {
gaps[i] = startTime[i] - endTime[i - 1];
}
gaps[n] = eventTime - endTime[n - 1];
long best = 0;
int window = Math.min(k + 1, n + 1);
for (int i = 0; i + window <= n + 1; ++i) {
long s = 0;
for (int j = 0; j < window; ++j) {
s += gaps[i + j];
}
best = Math.max(best, s);
}
return (int) best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.maxFreeTime(5, 1, new int[] {1, 3}, new int[] {2, 5})
+ " (期望 2)");
System.out.println("示例2: " + sol.maxFreeTime(10, 1, new int[] {0, 2, 9},
new int[] {1, 4, 10}) + " (期望 6)");
System.out.println("示例3: " + sol.maxFreeTime(5, 2, new int[] {0, 1, 2, 3, 4},
new int[] {1, 2, 3, 4, 5}) + " (期望 0)");
Random rand = new Random(59);
int pass = 0, cases = 0;
for (int t = 0; t < 3000; ++t) {
int n = 2 + rand.nextInt(7);
int[] st = new int[n];
int[] et = new int[n];
int cur = rand.nextInt(3);
for (int i = 0; i < n; ++i) {
int dur = 1 + rand.nextInt(4);
st[i] = cur;
et[i] = cur + dur;
cur += dur + rand.nextInt(3); // 空隙 0..2
}
int eventTime = cur + rand.nextInt(4);
int k = 1 + rand.nextInt(n);
int x = sol.maxFreeTime(eventTime, k, st, et);
int y = sol.maxFreeTimeBrute(eventTime, k, st, et);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH eventTime=" + eventTime + " k=" + k
+ " st=" + Arrays.toString(st) + " et=" + Arrays.toString(et)
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n),空间 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3440. Reschedule Meetings for Maximum Free Time II(重新安排会议得到最多空余时间 II)
题目描述
给你一个整数 eventTime 表示一个活动的总时长,这个活动开始于 t = 0,结束于 t = eventTime。
同时给你两个长度为 n 的整数数组 startTime 和 endTime。它们表示这次活动中 n 个时间没有
重叠的会议,其中第 i 个会议的时间为 [startTime[i], endTime[i]]。
你可以重新安排至多一个会议,安排的规则是将会议时间平移,且保持原来的会议时长。你的目的是移动
会议后最大化最长连续空余时间。注意:重新安排会议以后,会议之间的顺序可以发生改变。
请你返回重新安排会议以后可以得到的最大空余时间。
示例 1
eventTime = 5, startTime = [1,3], endTime = [2,5] -> 2
示例 2
eventTime = 10, startTime = [0,7,9], endTime = [1,8,10] -> 7
示例 3
eventTime = 10, startTime = [0,3,7,9], endTime = [1,4,8,10] -> 6
示例 4
eventTime = 5, startTime = [0,1,2,3,4], endTime = [1,2,3,4,5] -> 0
提示:
1 <= eventTime <= 10^9n == startTime.length == endTime.length2 <= n <= 10^50 <= startTime[i] < endTime[i] <= eventTimeendTime[i] <= startTime[i + 1]
解题思路
解法一:维护前三大的空隙 + 枚举会议,主提交版本
把会议看作「桌子」,会议之间(含两端)的空闲时间看作「空位」。枚举要移动的会议 i:
若存在一个不与 i 左右两侧相邻 的空位(长度 >= 会议时长),把 i 移过去,则 i 两侧的空位
与会议本身合并成一个新空位,长度 = 左空位 + 右空位 + 会议时长;
若不存在这样的空位(最长空位/次长空位恰好都在 i 两侧),则保持 i 在原位置最划算,
空位长度 = 左空位 + 右空位。
为快速判断「非两侧的最长空位」,只需维护全部空位中长度最大的三个:若最大空位在 i 两侧之一,
看次大;若次大也在两侧,则只能用第三大(若存在且够长)。i 左右各只有一个相邻空位,
故最多 2 个空位在两侧,前三大的枚举一定覆盖所有情况。
时间复杂度 O(n),空间 O(1)。
解法二:直接模拟移动每个会议(对照)
对每个会议 i,尝试把它移动到所有不与它重叠且够长的空位中,逐一重算移动后的最长空隙并取最大
(小规模数据)。思路直接、无需维护前三,用于交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:前三空隙 + 枚举会议(主提交版本) ----------
public int maxFreeTime(int eventTime, int[] startTime, int[] endTime) {
int n = startTime.length;
long[] gap = new long[n + 1];
gap[0] = startTime[0];
for (int i = 1; i < n; ++i) {
gap[i] = startTime[i] - endTime[i - 1];
}
gap[n] = eventTime - endTime[n - 1];
// 前三大空隙 (len, idx)
long[] top = new long[3];
int[] topIdx = new int[3];
Arrays.fill(top, -1);
Arrays.fill(topIdx, -1);
for (int i = 0; i <= n; ++i) {
long v = gap[i];
for (int r = 0; r < 3; ++r) {
if (v > top[r]) {
for (int s = 2; s > r; --s) {
top[s] = top[s - 1];
topIdx[s] = topIdx[s - 1];
}
top[r] = v;
topIdx[r] = i;
break;
}
}
}
long best = 0;
for (int i = 0; i < n; ++i) {
long left = gap[i];
long right = gap[i + 1];
long dur = endTime[i] - startTime[i];
// 找一个不在 i 两侧的空位
long target = -1;
for (int r = 0; r < 3; ++r) {
if (top[r] < 0) {
continue;
}
if (topIdx[r] != i && topIdx[r] != i + 1) {
target = top[r];
break;
}
}
long cand;
if (target >= dur) {
cand = left + right + dur;
} else {
cand = left + right;
}
if (cand > best) {
best = cand;
}
}
return (int) best;
}
// ---------- 解法二:直接模拟移动(对照,仅小规模) ----------
public int maxFreeTimeBrute(int eventTime, int[] startTime, int[] endTime) {
int n = startTime.length;
long[] gap = new long[n + 1];
gap[0] = startTime[0];
for (int i = 1; i < n; ++i) {
gap[i] = startTime[i] - endTime[i - 1];
}
gap[n] = eventTime - endTime[n - 1];
long best = 0;
for (int i = 0; i < n; ++i) {
long dur = endTime[i] - startTime[i];
// 不移动 i 时:
best = Math.max(best, gap[i] + gap[i + 1]);
// 尝试移到其它空位
for (int g = 0; g <= n; ++g) {
if (g == i || g == i + 1) {
continue;
}
if (gap[g] >= dur) {
// 移走 i:i 两侧空隙合并
long merged = gap[i] + gap[i + 1] + dur;
// 目标空位被会议占用,剩余 = gap[g] - dur
best = Math.max(best, Math.max(merged, gap[g] - dur));
}
}
}
return (int) best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
System.out.println("示例1: " + sol.maxFreeTime(5, new int[] {1, 3}, new int[] {2, 5})
+ " (期望 2)");
System.out.println("示例2: " + sol.maxFreeTime(10, new int[] {0, 7, 9},
new int[] {1, 8, 10}) + " (期望 7)");
System.out.println("示例3: " + sol.maxFreeTime(10, new int[] {0, 3, 7, 9},
new int[] {1, 4, 8, 10}) + " (期望 6)");
System.out.println("示例4: " + sol.maxFreeTime(5, new int[] {0, 1, 2, 3, 4},
new int[] {1, 2, 3, 4, 5}) + " (期望 0)");
Random rand = new Random(61);
int pass = 0, cases = 0;
for (int t = 0; t < 5000; ++t) {
int n = 2 + rand.nextInt(6);
int[] st = new int[n];
int[] et = new int[n];
int cur = rand.nextInt(3);
for (int i = 0; i < n; ++i) {
int dur = 1 + rand.nextInt(4);
st[i] = cur;
et[i] = cur + dur;
cur += dur + rand.nextInt(4); // 空隙 0..3
}
int eventTime = cur + rand.nextInt(5);
int x = sol.maxFreeTime(eventTime, st, et);
int y = sol.maxFreeTimeBrute(eventTime, st, et);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH eventTime=" + eventTime
+ " st=" + Arrays.toString(st) + " et=" + Arrays.toString(et)
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n),空间 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)