LeetCode 3401-3420. 题解合集
文章目录
- [LeetCode 3401-3420. 题解合集](#LeetCode 3401-3420. 题解合集)
-
- [3401. Find Circular Gift Exchange Chains(寻找环形礼物交换链)](#3401. Find Circular Gift Exchange Chains(寻找环形礼物交换链))
- [3402. Minimum Operations to Make Columns Strictly Increasing(使每一列严格递增的最少操作次数)](#3402. Minimum Operations to Make Columns Strictly Increasing(使每一列严格递增的最少操作次数))
- [3403. Find the Lexicographically Largest String From the Box I(从盒子中找出字典序最大的字符串 I)](#3403. Find the Lexicographically Largest String From the Box I(从盒子中找出字典序最大的字符串 I))
- [3404. Count Special Subsequences(统计特殊子序列的数目)](#3404. Count Special Subsequences(统计特殊子序列的数目))
- [3405. Count the Number of Arrays with K Matching Adjacent Elements(统计恰好有 K 个相等相邻元素的数组数目)](#3405. Count the Number of Arrays with K Matching Adjacent Elements(统计恰好有 K 个相等相邻元素的数组数目))
- [3406. Find the Lexicographically Largest String From the Box II(从盒子中找出字典序最大的字符串 II 🔒)](#3406. Find the Lexicographically Largest String From the Box II(从盒子中找出字典序最大的字符串 II 🔒))
- [3407. Substring Matching Pattern(子字符串匹配模式)](#3407. Substring Matching Pattern(子字符串匹配模式))
- [3408. Design Task Manager(设计任务管理器)](#3408. Design Task Manager(设计任务管理器))
- [3409. Longest Subsequence With Decreasing Adjacent Difference(最长相邻绝对差递减子序列)](#3409. Longest Subsequence With Decreasing Adjacent Difference(最长相邻绝对差递减子序列))
- [3410. Maximize Subarray Sum After Removing All Occurrences of One Element(删除所有值为某个元素后的最大子数组和)](#3410. Maximize Subarray Sum After Removing All Occurrences of One Element(删除所有值为某个元素后的最大子数组和))
- [3411. Maximum Subarray With Equal Products(最长乘积等价子数组)](#3411. Maximum Subarray With Equal Products(最长乘积等价子数组))
- [3412. Find Mirror Score of a String(计算字符串的镜像分数)](#3412. Find Mirror Score of a String(计算字符串的镜像分数))
- [3413. Maximum Coins From K Consecutive Bags(收集连续 K 个袋子可以获得的最多硬币数量)](#3413. Maximum Coins From K Consecutive Bags(收集连续 K 个袋子可以获得的最多硬币数量))
- [3414. Maximum Score of Non-overlapping Intervals(不重叠区间的最大得分)](#3414. Maximum Score of Non-overlapping Intervals(不重叠区间的最大得分))
- [3415. Find Products with Three Consecutive Digits(查找名称中包含三位连续数字的产品)](#3415. Find Products with Three Consecutive Digits(查找名称中包含三位连续数字的产品))
- [3416. Subsequences with a Unique Middle Mode II(唯一中间众数子序列 II 🔒)](#3416. Subsequences with a Unique Middle Mode II(唯一中间众数子序列 II 🔒))
- [3417. Zigzag Grid Traversal With Skip(跳过交替单元格的之字形遍历)](#3417. Zigzag Grid Traversal With Skip(跳过交替单元格的之字形遍历))
- [3418. Maximum Amount of Money Robot Can Earn(机器人可以获得的最大金币数)](#3418. Maximum Amount of Money Robot Can Earn(机器人可以获得的最大金币数))
- [3419. Minimize the Maximum Edge Weight of Graph(图的最大边权的最小值)](#3419. Minimize the Maximum Edge Weight of Graph(图的最大边权的最小值))
- [3420. Count Non-Decreasing Subarrays After K Operations(统计 K 次操作以内得到非递减子数组的数目)](#3420. Count Non-Decreasing Subarrays After K Operations(统计 K 次操作以内得到非递减子数组的数目))
3401. Find Circular Gift Exchange Chains(寻找环形礼物交换链)
题目类型:数据库(SQL)
题目描述
表:SecretSanta
+-------------+------+
| Column Name | Type |
+-------------+------+
| giver_id | int |
| receiver_id | int |
| gift_value | int |
+-------------+------+
(giver_id, receiver_id) 是此表的主键。每一行表示两个员工之间的一次礼物交换记录,giver_id 表示送出礼物的员工,receiver_id 表示收到礼物的员工,gift_value 表示所送礼物的价值。
编写解决方案找出所有环形礼物交换链,并报告每条环的总礼物价值 与环的长度。环形链被定义为一系列交换,其中:
- 每位员工都正好向另一位员工赠送一份礼物;
- 每位员工都恰好从另一位员工那里收到一份礼物;
- 交换形成一个连续的循环(即员工 A 给
B一份礼物,B给C,C再给 A)。
返回结果以链的长度和总礼物价值降序 排序,并按此顺序为每条环从小到大编号 chain_id(从 1 开始)。
示例 1:
输入:
SecretSanta 表:
+----------+-------------+------------+
| giver_id | receiver_id | gift_value |
+----------+-------------+------------+
| 1 | 2 | 20 |
| 2 | 3 | 30 |
| 3 | 1 | 40 |
| 4 | 5 | 25 |
| 5 | 4 | 35 |
+----------+-------------+------------+
输出:
+----------+--------------+------------------+
| chain_id | chain_length | total_gift_value |
+----------+--------------+------------------+
| 1 | 3 | 90 |
| 2 | 2 | 60 |
+----------+--------------+------------------+
解释:
链 1 包含员工 1、2 和 3:1 给 2、2 给 3、3 给 1,总价值 = 20+30+40 = 90。
链 2 包含员工 4 和 5:4 给 5、5 给 4,总价值 = 25+35 = 60。
解题思路
本题的交换关系构成若干个互不相交的有向环。关键难点在于:同一个环从不同起点出发会被重复找出多次,必须保证每条环只输出一次。
解法一(推荐):递归 CTE 沿环前进 + 环上最小节点去重
- 用递归 CTE 从每个
giver_id出发,沿receiver_id -> giver_id的边不断前进,记录起点start_id、已累计的链长与总价值; - 每一步同时维护
path_least_node = LEAST(当前节点, 历史最小节点)------由于全表只有环结构,每个环的path_least_node都收敛为该环上的最小员工编号,用它对结果去重(GROUP BY path_least_node后取最长链/最大价值),就能保证环只算一次; - 递归终止条件的关键是
g.receiver_id != g.start_id:当路径回到起点时停止继续前进,并把"回到起点的完整环"输出; - 最后用
ROW_NUMBER() OVER (ORDER BY chain_length DESC, total_gift_value DESC)按题意生成chain_id。
解法二(对照):环起点分组去重
先递归展开所有"从某起点起步的完整环",再将同一环(以最小节点代表)聚合一次,思路与解法一同模型,只是去重放在最后一级做。本题环中每个节点出度入度都为 1,两种写法正确性一致。
代码实现
sql
-- 解法一(推荐):递归 CTE,环上最小节点去重 + ROW_NUMBER 编号
WITH RECURSIVE GiftChain AS (
-- 基础:每条边作为起点
SELECT giver_id, receiver_id, gift_value,
CONCAT(giver_id, ' -> ', receiver_id) AS path,
1 AS chain_length,
gift_value AS total_gift_value,
LEAST(giver_id, 100000) AS path_least_node,
giver_id AS start_id
FROM SecretSanta
UNION ALL
-- 递归:沿 receiver -> giver 前进
SELECT g.giver_id, s.receiver_id, s.gift_value,
CONCAT(g.path, ' -> ', s.receiver_id),
g.chain_length + 1,
g.total_gift_value + s.gift_value,
LEAST(s.giver_id, g.path_least_node),
g.start_id
FROM GiftChain g
JOIN SecretSanta s ON g.receiver_id = s.giver_id
WHERE g.receiver_id != g.start_id -- 防止提前成环,回到起点即停
),
result AS (
-- 只保留回到起点的完整环
SELECT gc.path, gc.chain_length, gc.total_gift_value, gc.path_least_node
FROM GiftChain gc
WHERE gc.receiver_id = gc.start_id
),
dedup AS (
-- 同一环取一遍(以环上最小节点为代表)
SELECT MAX(chain_length) AS chain_length,
MAX(total_gift_value) AS total_gift_value
FROM result
GROUP BY path_least_node
)
SELECT ROW_NUMBER() OVER (ORDER BY chain_length DESC, total_gift_value DESC) AS chain_id,
chain_length, total_gift_value
FROM dedup
ORDER BY chain_length DESC, total_gift_value DESC;
复杂度分析
- 时间复杂度 :
O(n^2),其中n为SecretSanta行数;最坏情况每条边起始一次、沿环展开最长可达n步。 - 空间复杂度 :
O(n),递归 CTE 的中间结果集与环上节点数成正比。
3402. Minimum Operations to Make Columns Strictly Increasing(使每一列严格递增的最少操作次数)
题目描述
给你一个由非负整数组成的 m x n 矩阵 grid。在一次操作中,你可以将任意元素 grid[i][j] 的值增加 1。
返回使 grid 的所有列严格递增所需的最少操作次数。
示例 1
grid = [[3,2],[1,3],[3,4],[0,1]] -> 15
示例 2
grid = [[3,2,1],[2,1,0],[1,2,3]] -> 12
提示:
m == grid.lengthn == grid[i].length1 <= m, n <= 500 <= grid[i][j] < 2500
解题思路
解法一:逐列贪心,主提交版本
每一列独立处理。从上到下遍历该列,维护 pre 表示上一行处理后该列的取值;
若当前元素 cur > pre 则保持原值(列已严格递增的延续);否则该元素必须提升到
pre + 1,需要 pre + 1 - cur 次操作。由于每次只加 1,且提升后其他行不受影响,
逐列贪心即是全局最优。时间复杂度 O(m*n),空间复杂度 O(1)。
解法二:直接模拟操作(对照)
同样逐列处理,但显式记录差分:对每一列,从第二行起若 grid[i][j] <= grid[i-1][j],
则令目标值 grid[i-1][j] + 1,累加操作数并以目标值更新当前行(模拟重复加 1)。
与解法一数学等价,用不同书写路径交叉验证。
复杂度:
- 时间复杂度:O(m*n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:逐列贪心(主提交版本) ----------
public int minimumOperations(int[][] grid) {
int m = grid.length, n = grid[0].length;
int ans = 0;
for (int j = 0; j < n; ++j) {
int pre = -1;
for (int i = 0; i < m; ++i) {
int cur = grid[i][j];
if (cur > pre) {
pre = cur;
} else {
++pre; // 当前值必须大于上一行,提升到 pre+1
ans += pre - cur;
}
}
}
return ans;
}
// ---------- 解法二:目标值模拟(对照) ----------
public int minimumOperationsSim(int[][] grid) {
int m = grid.length, n = grid[0].length;
int ans = 0;
for (int j = 0; j < n; ++j) {
int target = -1;
for (int i = 0; i < m; ++i) {
int cur = grid[i][j];
if (cur > target) {
target = cur;
} else {
ans += target + 1 - cur;
target = target + 1;
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(42);
System.out.println("示例1: " + sol.minimumOperations(new int[][] {{3, 2}, {1, 3}, {3, 4}, {0, 1}})
+ " (期望 15)");
System.out.println("示例2: " + sol.minimumOperations(new int[][] {{3, 2, 1}, {2, 1, 0}, {1, 2, 3}})
+ " (期望 12)");
int cases = 0, pass = 0;
for (int t = 0; t < 500; ++t) {
int m = 1 + rand.nextInt(8);
int n = 1 + rand.nextInt(8);
int[][] g = new int[m][n];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
g[i][j] = rand.nextInt(12);
}
}
int x = sol.minimumOperations(g);
int y = sol.minimumOperationsSim(g);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH x=" + x + " y=" + y);
printGrid(g);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
private static void printGrid(int[][] g) {
for (int[] row : g) {
System.out.println(java.util.Arrays.toString(row));
}
}
}
复杂度分析
逐列贪心即是全局最优。时间复杂度 O(m*n),空间复杂度 O(1)。
- 时间复杂度:O(m*n)
- 空间复杂度:O(1)
3403. Find the Lexicographically Largest String From the Box I(从盒子中找出字典序最大的字符串 I)
题目描述
给你一个字符串 word 和一个整数 numFriends。
Alice 正在为她的 numFriends 位朋友组织一个游戏。游戏分为多个回合,在每一回合中:
word被分割成numFriends个非空字符串,且该分割方式与之前的任意回合所采用的都不完全相同。- 所有分割出的字符串都会被放入一个盒子中。
在所有回合结束后,找出盒子中字典序最大的字符串。
示例 1
word = "dbca", numFriends = 2 -> "dbc"
示例 2
word = "gggg", numFriends = 4 -> "g"
提示:
1 <= word.length <= 5 * 10^3word仅由小写英文字母组成。1 <= numFriends <= word.length
解题思路
解法一:按起点枚举最长合法片段,主提交版本
盒子中的任意字符串都是从某个起点 st 开始的片段。对固定的 st,该片段越长字典序越大,
而它最长能到 ed = min(n - 1, st + (n - numFriends))------因为之后还要留出 numFriends - 1
个非空片段,即片段后面至少剩 numFriends - 1 个字符。因此对每个起点取最长合法片段,
取字典序最大值即可。时间复杂度 O(n^2)(子串比较),空间复杂度 O(n)(答案)。
解法二:全片段存在性枚举(对照)
枚举每个候选片段 [st, ed],判定是否存在一种完整分割:左侧 0..st-1 切 l 段、
右侧 ed+1..n-1 切 r 段,满足 l + 1 + r == numFriends 且各段非空。存在则片段合法,
参与字典序比较。实现独立、可读性强,用于交叉验证(O(n^3) 仅本地)。
复杂度:
- 时间复杂度:O(n^2)(解法二 O(n^3) 仅本地对拍)
- 空间复杂度:O(n)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:按起点取最长合法片段(主提交版本) ----------
public String answerString(String word, int numFriends) {
if (numFriends == 1) {
return word;
}
int n = word.length();
String ans = "";
for (int st = 0; st < n; ++st) {
// 片段最长到 min(n-1, st + (n-numFriends)),保证后面能切出 numFriends-1 个非空段
int ed = Math.min(n - 1, st + (n - numFriends));
String cand = word.substring(st, ed + 1);
if (ans.compareTo(cand) < 0) {
ans = cand;
}
}
return ans;
}
// ---------- 解法二:全片段存在性枚举(对照) ----------
public String answerStringBrute(String word, int numFriends) {
int n = word.length();
String best = "";
for (int st = 0; st < n; ++st) {
for (int ed = st; ed < n; ++ed) {
if (ok(st, ed, n, numFriends)) {
String cand = word.substring(st, ed + 1);
if (best.compareTo(cand) < 0) {
best = cand;
}
}
}
}
return best;
}
// 片段 [st,ed] 能否作为某个 numFriends 分割的一个片段
private boolean ok(int st, int ed, int n, int numFriends) {
int leftLen = st; // 左侧字符数
int rightLen = n - 1 - ed; // 右侧字符数
int rest = numFriends - 1; // 除本片段外还需切出的段数
int lmin = leftLen > 0 ? 1 : 0;
int lmax = leftLen;
int rmin = rightLen > 0 ? 1 : 0;
int rmax = rightLen;
return lmin + rmin <= rest && rest <= lmax + rmax;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(7);
System.out.println("示例1: " + sol.answerString("dbca", 2) + " (期望 dbc)");
System.out.println("示例2: " + sol.answerString("gggg", 4) + " (期望 g)");
int cases = 0, pass = 0;
for (int t = 0; t < 5000; ++t) {
int n = 1 + rand.nextInt(9);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rand.nextInt(4)));
}
String w = sb.toString();
int f = 1 + rand.nextInt(n);
String x = sol.answerString(w, f);
String y = sol.answerStringBrute(w, f);
cases++;
if (x.equals(y)) {
pass++;
} else {
System.out.println("MISMATCH w=" + w + " f=" + f + " a=" + x + " b=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
取字典序最大值即可。时间复杂度 O(n^2)(子串比较),空间复杂度 O(n)(答案)。
- 时间复杂度:O(n^2)(解法二 O(n^3) 仅本地对拍)
- 空间复杂度:O(n)
3404. Count Special Subsequences(统计特殊子序列的数目)
题目描述
给你一个只包含正整数的数组 nums。
特殊子序列 是一个长度为 4 的子序列,用下标 (p, q, r, s) 表示,它们满足 p < q < r < s,
且必须满足以下条件:
nums[p] * nums[r] == nums[q] * nums[s]- 相邻坐标之间至少间隔一个数字:
q - p > 1,r - q > 1且s - r > 1。
请你返回nums中不同特殊子序列的数目。
示例 1
nums = [1,2,3,4,3,6,1] -> 1((0,2,4,6):1*3==3*1)
示例 2
nums = [3,4,3,4,3,4,3,4] -> 3
提示:
7 <= nums.length <= 10001 <= nums[i] <= 1000
解题思路
解法一:分数归约 + 双指针扫描哈希,主提交版本
等式 nums[p] * nums[r] == nums[q] * nums[s] 可改写为 nums[p] / nums[q] == nums[s] / nums[r]
(两边同除 nums[q] * nums[r])。对每对元素做约分得到最简分数 (分子, 分母) 作为哈希键。
采用「固定中间缝」的思路:第一遍先统计所有满足 r >= 4 的右侧对 (r, s)(s >= r+2)的
约分分数 nums[s]/nums[r] 出现次数;第二遍枚举 q(q >= 2,其左侧对 (p,q) 满足 p <= q-2),
把左侧对约分分数 nums[p]/nums[q] 与哈希中右侧分数匹配累加;每处理完一个 q,
就把 r = q+2 开头的右侧对从哈希中移除(它们对后续更大的 q 不再满足 r - q > 1)。
分数用 (分子 << 12) | 分母 编码(值域 1000,12 位足够)。
时间复杂度 O(n^2),空间复杂度 O(n)。
解法二:四重循环暴力(对照)
直接枚举满足间隔约束的四元组 (p, q, r, s),检查乘积等式是否成立。
时间复杂度 O(n^4),仅用于本地对小数据交叉验证。
复杂度:
- 时间复杂度:O(n^2)(解法二 O(n^4) 仅本地对拍)
- 空间复杂度:O(n)
代码实现
java
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:分数归约 + 哈希双指针(主提交版本) ----------
public long numberOfSubsequences(int[] nums) {
int n = nums.length;
Map<Integer, Integer> cnt = new HashMap<Integer, Integer>();
// 第一遍:统计所有 r >= 4 的右侧对 (r, s),键为 nums[s]/nums[r] 最简分数
for (int r = 4; r < n - 2; ++r) {
int c = nums[r];
for (int s = r + 2; s < n; ++s) {
int d = nums[s];
int g = gcd(c, d);
cnt.put(((d / g) << 12) | (c / g),
cnt.getOrDefault(((d / g) << 12) | (c / g), 0) + 1);
}
}
long ans = 0;
for (int q = 2; q < n - 4; ++q) {
int b = nums[q];
// 左侧对 (p, q),p 最大到 q-2
for (int p = 0; p < q - 1; ++p) {
int a = nums[p];
int g = gcd(a, b);
ans += cnt.getOrDefault(((a / g) << 12) | (b / g), 0);
}
// 移除以 r = q+2 开头的右侧对:对下一个 q 不再满足 r - q > 1
int c = nums[q + 2];
for (int s = q + 4; s < n; ++s) {
int d = nums[s];
int g = gcd(c, d);
int key = ((d / g) << 12) | (c / g);
int v = cnt.get(key) - 1;
if (v == 0) {
cnt.remove(key);
} else {
cnt.put(key, v);
}
}
}
return ans;
}
private int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
// ---------- 解法二:四重循环暴力(对照) ----------
public long numberOfSubsequencesBrute(int[] nums) {
int n = nums.length;
long ans = 0;
for (int p = 0; p < n - 4; ++p) {
for (int q = p + 2; q < n - 3; ++q) {
for (int r = q + 2; r < n - 2; ++r) {
for (int s = r + 2; s < n; ++s) {
if ((long) nums[p] * nums[r] == (long) nums[q] * nums[s]) {
++ans;
}
}
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(11);
System.out.println("示例1: " + sol.numberOfSubsequences(new int[] {1, 2, 3, 4, 3, 6, 1})
+ " (期望 1)");
System.out.println("示例2: " + sol.numberOfSubsequences(new int[] {3, 4, 3, 4, 3, 4, 3, 4})
+ " (期望 3)");
int cases = 0, pass = 0;
for (int t = 0; t < 300; ++t) {
int n = 7 + rand.nextInt(8);
int[] a = new int[n];
int range = 1 + rand.nextInt(6);
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(range);
}
long x = sol.numberOfSubsequences(a);
long y = sol.numberOfSubsequencesBrute(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
+ " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n^2),空间复杂度 O(n)。
时间复杂度 O(n^4),仅用于本地对小数据交叉验证。
- 时间复杂度:O(n^2)(解法二 O(n^4) 仅本地对拍)
- 空间复杂度:O(n)
3405. Count the Number of Arrays with K Matching Adjacent Elements(统计恰好有 K 个相等相邻元素的数组数目)
题目描述
给你三个整数 n,m,k。长度为 n 的好数组 arr 定义如下:
arr中每个元素都在闭区间[1, m]中。- 恰好 有
k个下标i(其中1 <= i < n)满足arr[i - 1] == arr[i]。
请你返回可以构造出的好数组数目,对10^9 + 7取模。
示例 1
n = 3, m = 2, k = 1 -> 4
示例 2
n = 4, m = 2, k = 2 -> 6
示例 3
n = 5, m = 2, k = 0 -> 2
提示:
1 <= n <= 10^51 <= m <= 10^50 <= k <= n - 1
解题思路
解法一:组合计数,主提交版本
把数组按「相等相邻」拆成若干「段」,每段内元素全相同、相邻两段元素不同。
若有 k 个相等相邻对,则段数为 n - k。先选出这 n - k 段的长度如何分布:
从 n - 1 个缝隙中选 n - k - 1 个作为「段间分界」,即 C(n-1, n-k-1) = C(n-1, k)。
第一段有 m 种取值,之后每段必须与前一段不同,有 m - 1 种取值。
因此答案 = C(n-1, k) * m * (m-1)^(n-k-1)(模意义下)。
预处理阶乘与逆元即可 O(1) 求组合数;快速幂求幂次。
时间复杂度 O(n)(预处理),空间复杂度 O(n)。
解法二:递推动态规划(对照)
dp[i][j][last] 表示前 i 个元素、恰好 j 个相等相邻对、最后一个元素为 last 的方案数;
转移时最后一个元素取与上一个相同(j+1)或不同(j 不变)。m 较大时用「相同/不同」
聚合状态:same 与 diff 两类。化简后可 O(nk) 求得,与解法一在小数据上交叉验证。
复杂度:
- 时间复杂度:O(n)(解法二 O(nk) 仅本地对拍)
- 空间复杂度:O(n)
代码实现
java
import java.util.Random;
public class Solution {
private static final int MOD = (int) 1e9 + 7;
private static final int N = (int) 1e5 + 10;
private static final long[] f = new long[N];
private static final long[] g = new long[N];
static {
f[0] = 1;
g[0] = 1;
for (int i = 1; i < N; ++i) {
f[i] = f[i - 1] * i % MOD;
g[i] = qpow(f[i], MOD - 2);
}
}
private static long qpow(long a, int k) {
long res = 1;
while (k != 0) {
if ((k & 1) == 1) {
res = res * a % MOD;
}
k >>= 1;
a = a * a % MOD;
}
return res;
}
// C(m, n)
private static long comb(int m, int n) {
return f[m] * g[n] % MOD * g[m - n] % MOD;
}
// ---------- 解法一:组合计数(主提交版本) ----------
public int countGoodArrays(int n, int m, int k) {
// C(n-1, k) * m * (m-1)^(n-k-1)
return (int) (comb(n - 1, k) * m % MOD * qpow(m - 1, n - k - 1) % MOD);
}
// ---------- 解法二:DP 递推(对照,仅小数据) ----------
public int countGoodArraysDp(int n, int m, int k) {
// dp[i][j][0] = 前 i 个中恰 j 个相等对,且最后一个元素与再前一个不同(或用 i==1 特判)
// 简化:dp[j] 表示长度为 i 时恰有 j 个相等对的方案数。
long[] dp = new long[k + 1];
dp[0] = m; // 长度 1:m 种
for (int i = 2; i <= n; ++i) {
long[] ndp = new long[k + 1];
// 末尾取与前一个相同 -> 相等对 +1
for (int j = 0; j + 1 <= k; ++j) {
ndp[j + 1] = (ndp[j + 1] + dp[j]) % MOD;
}
// 末尾取与前一个不同 -> m-1 种,相等对不变
for (int j = 0; j <= k; ++j) {
ndp[j] = (ndp[j] + dp[j] * (m - 1)) % MOD;
}
dp = ndp;
}
return (int) dp[k];
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(3);
System.out.println("示例1: " + sol.countGoodArrays(3, 2, 1) + " (期望 4)");
System.out.println("示例2: " + sol.countGoodArrays(4, 2, 2) + " (期望 6)");
System.out.println("示例3: " + sol.countGoodArrays(5, 2, 0) + " (期望 2)");
int cases = 0, pass = 0;
for (int t = 0; t < 200; ++t) {
int n = 1 + rand.nextInt(10);
int m = 1 + rand.nextInt(6);
int k = rand.nextInt(n);
int x = sol.countGoodArrays(n, m, k);
int y = sol.countGoodArraysDp(n, m, k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH n=" + n + " m=" + m + " k=" + k + " comb=" + x
+ " dp=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n)(预处理),空间复杂度 O(n)。
- 时间复杂度:O(n)(解法二 O(nk) 仅本地对拍)
- 空间复杂度:O(n)
3406. Find the Lexicographically Largest String From the Box II(从盒子中找出字典序最大的字符串 II 🔒)
题目描述
给你一个字符串 word 和一个整数 numFriends。
Alice 正在为她的 numFriends 位朋友组织一个游戏。游戏分为多个回合,在每一回合中:
word被分割成numFriends个非空字符串,且该分割方式与之前的任意回合所采用的都不完全相同。- 所有分割出的字符串都会被放入一个盒子中。
在所有回合结束后,找出盒子中字典序最大的字符串。
(与 3403 相同规则,但本题word长度可达2 * 10^5。)
示例 1
word = "dbca", numFriends = 2 -> "dbc"
示例 2
word = "gggg", numFriends = 4 -> "g"
提示:
1 <= word.length <= 2 * 10^5word仅由小写英文字母组成。1 <= numFriends <= word.length
解题思路
解法一:最大字典序子串(Lyndon 后缀)+ 截断,主提交版本
盒子中的候选片段最长 n - numFriends + 1。要字典序最大,必然从某个起点 st 取最长合法片段
word.substring(st, st + L),其中 L = n - numFriends + 1 是最大可能长度------因为对固定起点,
越长字典序越大,而答案就是「长度上限为 L 的所有子串中字典序最大者」。
这是经典「最大字典序子串」问题:在线性时间内找出字典序最大的后缀的起点 i(使用两指针
Lyndon 分解思想,word.substring(i) 是所有后缀中字典序最大的),而后取
word.substring(i, i + L)(若不足 L 则取到结尾)。由于最大字典序子串必是某个最大后缀的前缀,
该做法正确。时间复杂度 O(n),空间复杂度 O(n)。
解法二:两两比较的贪心扫描(对照)
枚举每个起点 st,候选为 word.substring(st, min(st+L, n)),用滚动指针比较维护字典序最大。
朴素实现 O(n^2) 不适合大数据,仅用于本地小数据对拍。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:最大字典序后缀 + 截断(主提交版本) ----------
public String answerString(String word, int numFriends) {
if (numFriends == 1) {
return word;
}
// 最大合法片段长度:其余 numFriends-1 段非空
int L = word.length() - numFriends + 1;
// 找字典序最大的后缀起点
int i = maxSuffixStart(word);
int ed = Math.min(word.length(), i + L);
return word.substring(i, ed);
}
// 线性求字典序最大的后缀起点(两指针 Lyndon 思想)
private int maxSuffixStart(String s) {
int n = s.length();
int i = 0, j = 1, k = 0;
while (j + k < n) {
char ci = s.charAt(i + k);
char cj = s.charAt(j + k);
if (ci == cj) {
++k;
} else if (ci < cj) {
// s[i..i+k] 小于 s[j..j+k],i 前进,跳过 i..i+k
i += k + 1;
k = 0;
if (i >= j) {
j = i + 1;
}
} else {
j += k + 1;
k = 0;
}
}
return i;
}
// ---------- 解法二:贪心比较(对照,仅小数据) ----------
public String answerStringBrute(String word, int numFriends) {
if (numFriends == 1) {
return word;
}
int n = word.length();
int L = n - numFriends + 1;
String best = "";
for (int st = 0; st < n; ++st) {
int ed = Math.min(n, st + L);
String cand = word.substring(st, ed);
if (best.compareTo(cand) < 0) {
best = cand;
}
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(19);
System.out.println("示例1: " + sol.answerString("dbca", 2) + " (期望 dbc)");
System.out.println("示例2: " + sol.answerString("gggg", 4) + " (期望 g)");
int cases = 0, pass = 0;
for (int t = 0; t < 5000; ++t) {
int n = 1 + rand.nextInt(12);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rand.nextInt(4)));
}
String w = sb.toString();
int f = 1 + rand.nextInt(n);
String x = sol.answerString(w, f);
String y = sol.answerStringBrute(w, f);
cases++;
if (x.equals(y)) {
pass++;
} else {
System.out.println("MISMATCH w=" + w + " f=" + f + " a=" + x + " b=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
该做法正确。时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3407. Substring Matching Pattern(子字符串匹配模式)
题目描述
给你一个字符串 s 和一个模式字符串 p,其中 p 恰好 包含 一个 '*' 符号。
p 中的 '*' 符号可以被替换为零个或多个字符组成的任意字符序列。
如果 p 可以变成 s 的子字符串,那么返回 true,否则返回 false。
示例 1
s = "leetcode", p = "ee*e" -> true("*" 替换为 "tcod")
示例 2
s = "car", p = "c*v" -> false
示例 3
s = "luck", p = "u*" -> true
提示:
1 <= s.length <= 501 <= p.length <= 50s只包含小写英文字母。p只包含小写英文字母和一个'*'符号。
解题思路
解法一:按星号分割顺序查找,主提交版本
将 p 按 '*' 切成前后两段 pre 与 suf。'*' 可匹配任意(可能为空)字符序列,
因此只需在 s 中按顺序找到 pre 与 suf 且 pre 的结束位置不晚于 suf 的开始位置。
用 String.indexOf 从起始位置向后找即可(前后两段都为空则任意子串都匹配)。
更一般地,若 p 有多个 *,可顺序 indexOf 各段;本题恰一个 *,只需两段。
时间复杂度 O(|s|*|p|)(indexOf 最坏),空间复杂度 O(1)。
解法二:显式贪心双指针(对照)
不切开模式串,而是用 (i, j) 双指针同步匹配 s 与 p:遇到 '*' 记录位置并假定
匹配 0 个字符,若后续失配则回退让 '*' 多吞一个字符(经典通配符贪心)。
路径与解法一不同,用于交叉验证。
复杂度:
- 时间复杂度:O(|s|*|p|)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:按星号分割顺序查找(主提交版本) ----------
public boolean hasMatch(String s, String p) {
int star = p.indexOf('*');
String pre = p.substring(0, star);
String suf = p.substring(star + 1);
int i = 0;
if (!pre.isEmpty()) {
i = s.indexOf(pre, i);
if (i == -1) {
return false;
}
i += pre.length();
}
// 后缀从 pre 之后开始找;若 pre 为空则从 0 开始
int j = suf.isEmpty() ? 0 : s.indexOf(suf, i);
// 注意:若 pre 为空,i 保持 0,后缀需从 0 开始(此时 "*x" 要求 s 以 x 结尾的不含前导不匹配)
// 实际上 i 未被推进时就是 0,行为正确。
if (j == -1) {
return false;
}
return true;
}
// ---------- 解法二:子串枚举暴力(对照) ----------
public boolean hasMatchBrute(String s, String p) {
int star = p.indexOf('*');
String pre = p.substring(0, star);
String suf = p.substring(star + 1);
int ns = s.length();
// 枚举 s 的每个子串,看能否作为"星号替换某字符序列"后的模式串
for (int l = 0; l < ns; ++l) {
for (int r = l; r < ns; ++r) {
int len = r - l + 1;
// 至少容纳 pre 与 suf 本身
if (len < pre.length() + suf.length()) {
continue;
}
String ss = s.substring(l, r + 1);
if (ss.startsWith(pre) && ss.endsWith(suf)) {
return true;
}
}
}
return false;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(5);
System.out.println("示例1: " + sol.hasMatch("leetcode", "ee*e") + " (期望 true)");
System.out.println("示例2: " + sol.hasMatch("car", "c*v") + " (期望 false)");
System.out.println("示例3: " + sol.hasMatch("luck", "u*") + " (期望 true)");
int cases = 0, pass = 0;
for (int t = 0; t < 5000; ++t) {
int n = 1 + rand.nextInt(10);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rand.nextInt(3)));
}
String s = sb.toString();
// 构造 p:含恰好一个 '*'
StringBuilder pb = new StringBuilder();
int starPos = rand.nextInt(4);
for (int i = 0; i < 4; ++i) {
if (i == starPos) {
pb.append('*');
} else {
pb.append((char) ('a' + rand.nextInt(3)));
}
}
String p = pb.toString();
boolean x = sol.hasMatch(s, p);
boolean y = sol.hasMatchBrute(s, p);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH s=" + s + " p=" + p + " a=" + x + " b=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(|s|*|p|)(indexOf 最坏),空间复杂度 O(1)。
- 时间复杂度:O(|s|*|p|)
- 空间复杂度:O(1)
3408. Design Task Manager(设计任务管理器)
题目描述
一个任务管理器系统可以让用户管理他们的任务,每个任务有一个优先级。
请你设计一个 TaskManager 类:
TaskManager(List<List<Integer>> tasks)初始化任务管理器,初始化的数组格式为
[userId, taskId, priority],表示给userId添加一个优先级为priority的任务taskId。void add(int userId, int taskId, int priority)给用户userId添加一个优先级为
priority的任务taskId,输入保证taskId不在系统中。void edit(int taskId, int newPriority)更新已经存在的任务taskId的优先级为
newPriority。输入保证taskId存在于系统中。void rmv(int taskId)从系统中删除任务taskId。输入保证taskId存在于系统中。int execTop()执行所有用户的任务中优先级最高 的任务,如果有多个任务优先级相同
且都为最高,执行taskId最大的一个任务。执行完任务后,taskId从系统中删除,返回
这个任务所属的用户userId。如果不存在任何任务,返回 -1。
示例
["TaskManager", "add", "edit", "execTop", "rmv", "add", "execTop"]
[[[[1,101,10],[2,102,20],[3,103,15]]],[4,104,5],[102,8],[],[101],[5,105,15],[]]
-> [null, null, null, 3, null, null, 5]
提示:
1 <= tasks.length <= 10^50 <= userId <= 10^5,0 <= taskId <= 10^5,0 <= priority <= 10^9add,edit,rmv和execTop的总操作次数加起来不超过2 * 10^5次。
解题思路
解法一:哈希表 + 有序集合,主提交版本
需要支持按 priority 降序、taskId 降序取最大元素的动态集合,同时按 taskId 快速
定位任务所属用户与当前优先级。用 TreeSet<int[]> 存储 {priority, taskId}:
比较器为 priority 大的在前,相同则 taskId 大的在前(符合 execTop 语义)。
用 HashMap<Integer, int[]> 映射 taskId -> {userId, priority}。
- add:写入两个结构;
- edit:先从集合移除旧
{priority, taskId},再插入新值并更新哈希; - rmv:从集合移除并删除哈希键;
- execTop:从集合取最小(即优先级最高、taskId 最大)元素,删除哈希并返回 userId。
时间复杂度 O(log n) 每次操作,空间复杂度 O(n)(n 为任务总数)。
解法二:线性扫描暴力(对照)
仅用哈希表存taskId -> {userId, priority};execTop 时遍历全部任务找出最优者。
时间复杂度 O(n) 每次 execTop,仅用于本地小数据交叉验证。
复杂度: - 时间复杂度:O(log n) 每次操作(解法二 execTop O(n) 仅本地对拍)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
public class Solution {
// ---------- 解法一:哈希表 + 有序集合(主提交版本) ----------
static class TaskManager {
private final Map<Integer, int[]> d = new HashMap<Integer, int[]>();
private final java.util.TreeSet<int[]> st =
new java.util.TreeSet<int[]>(new java.util.Comparator<int[]>() {
public int compare(int[] a, int[] b) {
if (a[0] != b[0]) {
return b[0] - a[0]; // priority 大的在前
}
return b[1] - a[1]; // taskId 大的在前
}
});
public TaskManager(List<List<Integer>> tasks) {
for (List<Integer> task : tasks) {
add(task.get(0), task.get(1), task.get(2));
}
}
public void add(int userId, int taskId, int priority) {
d.put(taskId, new int[] {userId, priority});
st.add(new int[] {priority, taskId});
}
public void edit(int taskId, int newPriority) {
int[] e = d.get(taskId);
int userId = e[0], priority = e[1];
st.remove(new int[] {priority, taskId});
st.add(new int[] {newPriority, taskId});
d.put(taskId, new int[] {userId, newPriority});
}
public void rmv(int taskId) {
int[] e = d.remove(taskId);
st.remove(new int[] {e[1], taskId});
}
public int execTop() {
if (st.isEmpty()) {
return -1;
}
int[] e = st.pollFirst();
int[] t = d.remove(e[1]);
return t[0];
}
}
// ---------- 解法二:线性扫描暴力(对照) ----------
static class TaskManagerBrute {
private final Map<Integer, int[]> d = new HashMap<Integer, int[]>();
public int lastRemovedId = -1; // 最近一次 execTop 删除的 taskId(对拍用)
public TaskManagerBrute(List<List<Integer>> tasks) {
for (List<Integer> task : tasks) {
d.put(task.get(1), new int[] {task.get(0), task.get(2)});
}
}
public void add(int userId, int taskId, int priority) {
d.put(taskId, new int[] {userId, priority});
}
public void edit(int taskId, int newPriority) {
int[] e = d.get(taskId);
d.put(taskId, new int[] {e[0], newPriority});
}
public void rmv(int taskId) {
d.remove(taskId);
}
public int execTop() {
int bestId = -1, bestPrio = -1;
for (Map.Entry<Integer, int[]> en : d.entrySet()) {
int tid = en.getKey();
int[] v = en.getValue();
if (v[1] > bestPrio || (v[1] == bestPrio && tid > bestId)) {
bestPrio = v[1];
bestId = tid;
}
}
if (bestId == -1) {
lastRemovedId = -1;
return -1;
}
lastRemovedId = bestId;
return d.remove(bestId)[0];
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
List<List<Integer>> init = new ArrayList<List<Integer>>();
init.add(java.util.Arrays.asList(1, 101, 10));
init.add(java.util.Arrays.asList(2, 102, 20));
init.add(java.util.Arrays.asList(3, 103, 15));
TaskManager tm = new TaskManager(init);
tm.add(4, 104, 5);
tm.edit(102, 8);
int r1 = tm.execTop();
tm.rmv(101);
tm.add(5, 105, 15);
int r2 = tm.execTop();
System.out.println("示例: " + r1 + ", " + r2 + " (期望 3, 5)");
// 随机对拍
java.util.Random rand = new java.util.Random(13);
int cases = 0, pass = 0;
for (int t = 0; t < 200; ++t) {
int n = 1 + rand.nextInt(8);
List<List<Integer>> ts = new ArrayList<List<Integer>>();
Map<Integer, int[]> seed = new HashMap<Integer, int[]>();
int uid = 0;
for (int i = 0; i < n; ++i) {
int u = rand.nextInt(5), pid = i + 1, pr = rand.nextInt(20);
ts.add(java.util.Arrays.asList(u, pid, pr));
seed.put(pid, new int[] {u, pr});
uid = i + 1;
}
TaskManager a = new TaskManager(ts);
TaskManagerBrute b = new TaskManagerBrute(ts);
boolean ok = true;
int ops = 0;
while (ops < 60 && ok) {
int op = rand.nextInt(4);
if (op == 0 && seed.size() > 0) {
// edit
List<Integer> keys = new ArrayList<Integer>(seed.keySet());
int tid = keys.get(rand.nextInt(keys.size()));
int np = rand.nextInt(25);
a.edit(tid, np);
b.edit(tid, np);
seed.put(tid, new int[] {seed.get(tid)[0], np});
} else if (op == 1 && seed.size() > 0) {
// rmv
List<Integer> keys = new ArrayList<Integer>(seed.keySet());
int tid = keys.get(rand.nextInt(keys.size()));
a.rmv(tid);
b.rmv(tid);
seed.remove(tid);
} else if (op == 2) {
// add
int tid = ++uid;
int u = rand.nextInt(5), pr = rand.nextInt(25);
a.add(u, tid, pr);
b.add(u, tid, pr);
seed.put(tid, new int[] {u, pr});
} else {
// execTop
int ra = a.execTop();
int rb = b.execTop();
if (ra != rb) {
System.out.println("MISMATCH execTop a=" + ra + " b=" + rb);
ok = false;
} else if (ra != -1) {
// 两者删除的是同一个任务(brute 记录 lastRemovedId),同步 seed
seed.remove(b.lastRemovedId);
}
}
ops++;
}
cases++;
if (ok) {
pass++;
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(log n) 每次操作,空间复杂度 O(n)(n 为任务总数)。
时间复杂度 O(n) 每次 execTop,仅用于本地小数据交叉验证。
- 时间复杂度:O(log n) 每次操作(解法二 execTop O(n) 仅本地对拍)
- 空间复杂度:O(n)
3409. Longest Subsequence With Decreasing Adjacent Difference(最长相邻绝对差递减子序列)
题目描述
给你一个整数数组 nums。你的任务是找到 nums 中的最长子序列 seq,这个子序列中
相邻元素的绝对差 构成一个非递增 整数序列。换句话说,nums 中的序列
seq0, seq1, seq2, ..., seqm 满足 |seq1 - seq0| >= |seq2 - seq1| >= ... >= |seqm - seqm-1|。
请你返回这个子序列的长度。
示例 1
nums = [16,6,3] -> 3(相邻绝对差 [10, 3])
示例 2
nums = [6,5,3,4,2,1] -> 4([6,4,2,1],绝对差 [2,2,1])
示例 3
nums = [10,20,10,19,10,20] -> 5([10,20,10,19,10],绝对差 [10,10,9,9])
提示:
2 <= nums.length <= 10^41 <= nums[i] <= 300
解题思路
解法一:值域 DP + 后缀最值,主提交版本
值域只有 300,适合在值域上做 DP。设 dp[num][diff] 表示「以数值 num 结尾、且最后一段
绝对差恰为 diff」的最长子序列长度。扫描每个元素 x 时:
- 以
x作为子序列第一个元素:dp[x][*]至少为 1; - 对每个可能的前驱值
pre,有转移dp[x][cur] = max(dp[x][cur], dp[pre][preDiff] + 1),
其中cur = |x - pre|,preDiff >= cur(前一段差不能小于当前差)。
对每个pre,max_{preDiff >= cur} dp[pre][preDiff]正是dp[pre]行的后缀最大值,
预处理每行后缀最大后转移 O(300)。总复杂度 O(n * V),V = 300,空间 O(V^2)。
前缀后缀的推进顺序与「按 x 不可逆」的约束处理:每处理一个 x 才把它的 dp 行投入使用,
避免同一元素作为多个前驱重复使用。
注意实际实现为:dp 行上做两次滚动------先求后缀最优,再用旧值(上一次扫描前快照)参与转移,
保证每个元素只用一次。
解法二:朴素 LIS 式 DP(对照)
dp[i]表示以 i 结尾的最长子序列长度,last[i]记录该子序列最后一段绝对差。
转移时枚举 j < i,若|nums[i]-nums[j]| <= last[j]则dp[i] = max(dp[j] + 1)。
时间复杂度 O(n^2),仅用于本地小数据交叉验证。
复杂度: - 时间复杂度:O(n * V)(V = 300)
- 空间复杂度:O(V^2)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:值域 DP + 后缀最值(主提交版本) ----------
public int longestSubsequence(int[] nums) {
final int MX = 300;
// dp[num][diff]:以数值 num 结尾、最后绝对差为 diff 的最大长度
final int[][] dp = new int[MX + 1][MX + 1];
boolean[] appeared = new boolean[MX + 1];
int ans = 0;
for (int x : nums) {
// 构建每个 num 行的后缀最值 suf[num][d] = max(base, max_{e>=d} dp[num][e]),
// base = appeared[num] ? 1 : 0,表示"以 num 为单元素"的子序列可作为任意差的前驱。
int[][] suf = new int[MX + 1][MX + 2];
for (int num = 1; num <= MX; ++num) {
int[] row = dp[num];
int base = appeared[num] ? 1 : 0;
suf[num][MX + 1] = base;
for (int d = MX; d >= 0; --d) {
int v = row[d];
suf[num][d] = Math.max(v, suf[num][d + 1]);
if (suf[num][d] < base) {
suf[num][d] = base;
}
}
}
// 单元素起点
if (dp[x][0] < 1) {
dp[x][0] = 1;
}
// 转移:cur = |x - prev|,前驱为"以 prev 结尾且最后差 >= cur"(base=1 覆盖单元素)
for (int prev = 1; prev <= MX; ++prev) {
int cur = Math.abs(x - prev);
int cand = suf[prev][cur] + 1;
if (cand > dp[x][cur]) {
dp[x][cur] = cand;
}
}
appeared[x] = true;
if (dp[x][0] > ans) {
ans = dp[x][0];
}
// 该行其他差也可能刷新答案
for (int d = 0; d <= MX; ++d) {
if (dp[x][d] > ans) {
ans = dp[x][d];
}
}
}
return ans;
}
// ---------- 解法二:索引二维 DP(对照) ----------
public int longestSubsequenceBrute(int[] nums) {
int n = nums.length;
// dp[i][d]:以索引 i 结尾、最后一段绝对差恰为 d 的最长子序列长度
int[][] dp = new int[n][301];
int ans = 0;
for (int i = 0; i < n; ++i) {
dp[i][0] = 1; // 单元素
for (int j = 0; j < i; ++j) {
int d = Math.abs(nums[i] - nums[j]);
if (dp[i][d] < 2) {
dp[i][d] = 2; // j 作为单元素起点
}
// 链式转移:前一段差 pd >= d 才能接
for (int pd = d; pd <= 300; ++pd) {
if (dp[j][pd] > 0 && dp[j][pd] + 1 > dp[i][d]) {
dp[i][d] = dp[j][pd] + 1;
}
}
}
for (int d = 0; d <= 300; ++d) {
if (dp[i][d] > ans) {
ans = dp[i][d];
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(29);
System.out.println("示例1: " + sol.longestSubsequence(new int[] {16, 6, 3}) + " (期望 3)");
System.out.println("示例2: " + sol.longestSubsequence(new int[] {6, 5, 3, 4, 2, 1})
+ " (期望 4)");
System.out.println("示例3: " + sol.longestSubsequence(new int[] {10, 20, 10, 19, 10, 20})
+ " (期望 5)");
int cases = 0, pass = 0;
for (int t = 0; t < 2000; ++t) {
int n = 2 + rand.nextInt(9);
int[] a = new int[n];
int range = 1 + rand.nextInt(10);
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(range);
}
int x = sol.longestSubsequence(a);
int y = sol.longestSubsequenceBrute(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
+ " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
预处理每行后缀最大后转移 O(300)。总复杂度 O(n * V),V = 300,空间 O(V^2)。
时间复杂度 O(n^2),仅用于本地小数据交叉验证。
- 时间复杂度:O(n * V)(V = 300)
- 空间复杂度:O(V^2)
3410. Maximize Subarray Sum After Removing All Occurrences of One Element(删除所有值为某个元素后的最大子数组和)
题目描述
给你一个整数数组 nums。你可以对数组执行以下操作至多一次:
- 选择
nums中存在的任意整数X,确保删除所有值为X的元素后剩下数组非空。 - 将数组中所有值为
X的元素都删除。
删除后剩余元素保持原顺序拼接成新数组。请你返回所有可能得到的数组中最大子数组和为多少。
示例 1
nums = [-3,2,-2,-1,3,-2,3] -> 7(删除 X=-2 后数组为 [-3,2,-1,3,3],子数组 [2,-1,3,3] 的和为 7)
示例 2
nums = [1,2,3,4] -> 10(不删除任何元素)
提示:
1 <= nums.length <= 10^5-10^6 <= nums[i] <= 10^6
解题思路
解法一:线段树维护最大子段和 + 删数置 0,主提交版本
删除所有值为 X 的元素后数组拼接,等价于在原数组上「把值为 X 的位置贡献视为 0」,
且该 0 值位置可以 被任意跨越(拼接处不再充当屏障)------这正是经典最大子段和的线性语义:
对每个候选值 X,把其出现位置改为 0 后求整个数组的最大子段和即可。
用线段树维护每个区间的 sum、mx(最大子段和)、pre(最大前缀和)、suf(最大后缀和)。
对每个不同值 X:先将 X 的所有位置改为 0,取根节点 mx,再恢复原值。
优化点:值为正时删除只会让子段和变小(0 不如保留正值),因此只需枚举负值 X;
且当数组全为非正数时,答案就是最大单个元素(删除只会更差),直接特判返回。
每个位置至多置 0、恢复各一次,总更新 O(n) 次,每次 O(log n)。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:按值分组跳过式 Kadane(对照)
对每个不同值 v,做一遍「跳过 v」的 Kadane:遇到非 v 元素按
cur = max(x, cur + x) 更新,遇到 v 元素则跳过且不重置 cur (表示拼接后子段可横跨),
维护 best。与不删除的 Kadane 结果取最大。实现独立,用于交叉验证。
复杂度:
- 时间复杂度:O(n log n)(解法二 O(u*n),u 为不同值个数,仅本地对拍)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:线段树 + 删数置 0(主提交版本) ----------
public long maxSubarraySum(int[] nums) {
int n = nums.length;
int maxElem = Integer.MIN_VALUE;
boolean hasPositive = false;
for (int x : nums) {
maxElem = Math.max(maxElem, x);
if (x > 0) {
hasPositive = true;
}
}
// 全数组无非正数:最优就是最大单个元素(删除任何值只会更差)
if (!hasPositive) {
return maxElem;
}
SegmentTree seg = new SegmentTree(nums);
long ans = seg.queryMax(); // 不删除的情况
// 收集每个负值出现的所有位置
Map<Integer, List<Integer>> posMap = new HashMap<Integer, List<Integer>>();
for (int i = 0; i < n; ++i) {
if (nums[i] < 0) {
if (!posMap.containsKey(nums[i])) {
posMap.put(nums[i], new ArrayList<Integer>());
}
posMap.get(nums[i]).add(i);
}
}
for (Map.Entry<Integer, List<Integer>> en : posMap.entrySet()) {
List<Integer> list = en.getValue();
for (int idx : list) {
seg.update(idx, 0); // 删除:置 0(可被自由跨越)
}
ans = Math.max(ans, seg.queryMax());
for (int idx : list) {
seg.update(idx, nums[idx]); // 恢复
}
}
return ans;
}
// 线段树:单点修改、全局最大子段和
static class SegmentTree {
static class Node {
long sum, mx, pre, suf;
Node(long sum, long mx, long pre, long suf) {
this.sum = sum;
this.mx = mx;
this.pre = pre;
this.suf = suf;
}
}
private final int n;
private final Node[] t;
SegmentTree(int[] a) {
n = a.length;
t = new Node[4 * n];
build(1, 0, n - 1, a);
}
private Node merge(Node l, Node r) {
long sum = l.sum + r.sum;
long mx = Math.max(Math.max(l.mx, r.mx), l.suf + r.pre);
long pre = Math.max(l.pre, l.sum + r.pre);
long suf = Math.max(r.suf, r.sum + l.suf);
return new Node(sum, mx, pre, suf);
}
private void build(int p, int l, int r, int[] a) {
if (l == r) {
t[p] = new Node(a[l], a[l], a[l], a[l]);
return;
}
int mid = (l + r) >> 1;
build(p << 1, l, mid, a);
build(p << 1 | 1, mid + 1, r, a);
t[p] = merge(t[p << 1], t[p << 1 | 1]);
}
void update(int idx, long v) {
update(1, 0, n - 1, idx, v);
}
private void update(int p, int l, int r, int idx, long v) {
if (l == r) {
t[p] = new Node(v, v, v, v);
return;
}
int mid = (l + r) >> 1;
if (idx <= mid) {
update(p << 1, l, mid, idx, v);
} else {
update(p << 1 | 1, mid + 1, r, idx, v);
}
t[p] = merge(t[p << 1], t[p << 1 | 1]);
}
long queryMax() {
return t[1].mx;
}
}
// ---------- 解法二:跳过式 Kadane(对照) ----------
public long maxSubarraySumBrute(int[] nums) {
Set<Integer> vals = new HashSet<Integer>();
for (int x : nums) {
vals.add(x);
}
long ans = Long.MIN_VALUE;
// 不删除
ans = Math.max(ans, kadaneSkip(nums, null));
for (int v : vals) {
ans = Math.max(ans, kadaneSkip(nums, v));
}
return ans;
}
// 跳过值为 skip 的元素(不重置 cur,实现拼接),求最大子段和
private long kadaneSkip(int[] nums, Integer skip) {
long best = Long.MIN_VALUE, cur = 0;
for (int x : nums) {
if (skip != null && x == skip) {
continue; // 跳过:cur 保持,子段可横跨
}
cur = Math.max(cur + x, (long) x);
best = Math.max(best, cur);
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(17);
System.out.println("示例1: " + sol.maxSubarraySum(new int[] {-3, 2, -2, -1, 3, -2, 3})
+ " (期望 7)");
System.out.println("示例2: " + sol.maxSubarraySum(new int[] {1, 2, 3, 4}) + " (期望 10)");
int cases = 0, pass = 0;
for (int t = 0; t < 500; ++t) {
int n = 1 + rand.nextInt(12);
int[] a = new int[n];
int range = 1 + rand.nextInt(8);
for (int i = 0; i < n; ++i) {
a[i] = -range / 2 + rand.nextInt(range);
}
long x = sol.maxSubarraySum(a);
long y = sol.maxSubarraySumBrute(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
+ " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
- 时间复杂度:O(n log n)(解法二 O(u*n),u 为不同值个数,仅本地对拍)
- 空间复杂度:O(n)
3411. Maximum Subarray With Equal Products(最长乘积等价子数组)
题目描述
给你一个由正整数 组成的数组 nums。
如果一个数组 arr 满足 prod(arr) == lcm(arr) * gcd(arr),则称其为乘积等价数组 ,
其中:
prod(arr)表示arr中所有元素的乘积。gcd(arr)表示arr中所有元素的最大公因数 (GCD)。lcm(arr)表示arr中所有元素的最小公倍数 (LCM)。
返回数组nums的最长乘积等价子数组的长度。
示例 1
nums = [1,2,1,2,1,1,1] -> 5([1,2,1,1,1])
示例 2
nums = [2,3,4,5,6] -> 3([3,4,5])
示例 3
nums = [1,2,3,1,4,5,1] -> 5
提示:
2 <= nums.length <= 1001 <= nums[i] <= 10
解题思路
解法一:暴力扩展 + 剪枝,主提交版本
对每个起点 i 向右扩展右端点 j,增量维护 p(乘积)、g(gcd)、l(lcm)。
值域只有 10,乘积增长极快:一旦 p 超过可能的 g * l 上限就 break(l 单调不降、
g 单调不增,因此 g * l 有界)。满足 p == g * l 时更新答案。
全局上限为 max(nums) * lcm(nums)(参考实现),据此安全剪枝。
时间复杂度 O(n^2)(最坏),空间复杂度 O(1)。
解法二:朴素 O(n^2) 无剪枝(对照)
与解法一同构但不用乘积剪枝,直接对每个 (i, j) 完整重算或增量维护并判断等式;
逻辑路径独立简单,用于交叉验证(n <= 100 无性能压力)。
复杂度:
- 时间复杂度:O(n^2)
- 空间复杂度:O(1)
代码实现
java
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:前缀扩展 + 剪枝(主提交版本) ----------
public int maxLength(int[] nums) {
int mx = 0, ml = 1;
for (int x : nums) {
mx = Math.max(mx, x);
ml = lcm(ml, x);
}
long maxP = (long) ml * mx; // 可行的乘积上限
int n = nums.length;
int ans = 0;
for (int i = 0; i < n; ++i) {
long p = 1;
int g = 0, l = 1;
for (int j = i; j < n; ++j) {
p *= nums[j];
g = gcd(g, nums[j]);
l = lcm(l, nums[j]);
if (p == (long) g * l) {
ans = Math.max(ans, j - i + 1);
}
if (p > maxP) {
break;
}
}
}
return ans;
}
private int gcd(int a, int b) {
while (b != 0) {
int tmp = b;
b = a % b;
a = tmp;
}
return a;
}
private int lcm(int a, int b) {
return a / gcd(a, b) * b;
}
// ---------- 解法二:朴素 O(n^2)(对照) ----------
public int maxLengthBrute(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0; i < n; ++i) {
long p = 1;
int g = 0, l = 1;
for (int j = i; j < n; ++j) {
p *= nums[j];
g = gcd(g, nums[j]);
l = lcm(l, nums[j]);
if (p == (long) g * l) {
ans = Math.max(ans, j - i + 1);
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(23);
System.out.println("示例1: " + sol.maxLength(new int[] {1, 2, 1, 2, 1, 1, 1})
+ " (期望 5)");
System.out.println("示例2: " + sol.maxLength(new int[] {2, 3, 4, 5, 6}) + " (期望 3)");
System.out.println("示例3: " + sol.maxLength(new int[] {1, 2, 3, 1, 4, 5, 1})
+ " (期望 5)");
int cases = 0, pass = 0;
for (int t = 0; t < 2000; ++t) {
int n = 2 + rand.nextInt(12);
int[] a = new int[n];
int range = 1 + rand.nextInt(10);
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(range);
}
int x = sol.maxLength(a);
int y = sol.maxLengthBrute(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
+ " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(n^2)(最坏),空间复杂度 O(1)。
- 时间复杂度:O(n^2)
- 空间复杂度:O(1)
3412. Find Mirror Score of a String(计算字符串的镜像分数)
题目描述
给你一个字符串 s。
英文字母中每个字母的镜像 定义为反转字母表之后对应位置上的字母。例如,'a' 的镜像是
'z','y' 的镜像是 'b'。
最初,字符串 s 中的所有字符都未标记 。字符串 s 的初始分数为 0,你需要对其执行以下过程:
- 从左到右遍历字符串。
- 对于每个下标
i,找到距离最近的未标记 下标j,下标j需要满足j < i且
s[j]是s[i]的镜像。然后标记 下标i和j,总分加上i - j的值。 - 如果对于下标
i,不存在满足条件的下标j,则跳过该下标,继续处理下一个下标。
返回最终的总分。
示例 1
s = "aczzx" -> 5(j=0 配 i=2 得 2;j=1 配 i=4 得 3)
示例 2
s = "abcdef" -> 0
提示:
1 <= s.length <= 10^5s仅由小写英文字母组成。
解题思路
解法一:26 个栈栈顶匹配,主提交版本
遍历 i,对字符 x = s[i],其镜像是 mirror(x) = 'a' + 'z' - x。若当前存在未标记的
mirror(x) 字符下标,取最近 的一个------用 26 个栈分别保存每种字符的未标记 下标,
最近即在栈顶。匹配成功则弹出栈顶、分数加 i - j(该字符对均已标记,无需其它记录);
否则把 i 压入字符 x 对应的栈(保留为未来「被匹配方」)。
由于每个下标入栈出栈至多一次,总复杂度 O(n)。空间 O(n)。
解法二:双端队列 + 模拟标记数组(对照)
同样用 26 个 List 存下标,但额外用 boolean[] marked 显式标记;匹配时从对应列表
尾部往前 找最近未标记下标(正常都是尾部,但因显式标记可以容忍中间有已标记者,
若尾部已标记则跳过)。行为与解法的"仅存未标记"略有差异但结果一致,交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:26 栈栈顶匹配(主提交版本) ----------
public long calculateScore(String s) {
Map<Character, List<Integer>> d = new HashMap<Character, List<Integer>>(26);
int n = s.length();
long ans = 0;
for (int i = 0; i < n; ++i) {
char x = s.charAt(i);
char y = (char) ('a' + 'z' - x); // 镜像
if (d.containsKey(y)) {
List<Integer> ls = d.get(y);
int j = ls.remove(ls.size() - 1); // 最近(栈顶)
if (ls.isEmpty()) {
d.remove(y);
}
ans += i - j;
} else {
if (!d.containsKey(x)) {
d.put(x, new ArrayList<Integer>());
}
d.get(x).add(i);
}
}
return ans;
}
// ---------- 解法二:显式标记 + 逆序查找(对照) ----------
public long calculateScoreMarked(String s) {
int n = s.length();
List<List<Integer>> pos = new ArrayList<List<Integer>>(26);
for (int c = 0; c < 26; ++c) {
pos.add(new ArrayList<Integer>());
}
boolean[] marked = new boolean[n];
long ans = 0;
for (int i = 0; i < n; ++i) {
char x = s.charAt(i);
char y = (char) ('a' + 'z' - x);
List<Integer> list = pos.get(y - 'a');
int j = -1;
// 从尾部找最近且未标记的下标(列表中可能含中间已被标记者)
for (int k = list.size() - 1; k >= 0; --k) {
int cand = list.get(k);
if (!marked[cand]) {
j = cand;
break;
}
}
if (j != -1) {
marked[i] = true;
marked[j] = true;
ans += i - j;
} else {
pos.get(x - 'a').add(i);
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(31);
System.out.println("示例1: " + sol.calculateScore("aczzx") + " (期望 5)");
System.out.println("示例2: " + sol.calculateScore("abcdef") + " (期望 0)");
int cases = 0, pass = 0;
for (int t = 0; t < 3000; ++t) {
int n = 1 + rand.nextInt(14);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rand.nextInt(4)));
}
String s = sb.toString();
long x = sol.calculateScore(s);
long y = sol.calculateScoreMarked(s);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH s=" + s + " a=" + x + " b=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
由于每个下标入栈出栈至多一次,总复杂度 O(n)。空间 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3413. Maximum Coins From K Consecutive Bags(收集连续 K 个袋子可以获得的最多硬币数量)
题目描述
在一条数轴上有无限多个袋子,每个坐标对应一个袋子。其中一些袋子里装有硬币。
给你一个二维数组 coins,其中 coins[i] = [li, ri, ci] 表示从坐标 li 到 ri 的每个
袋子中都有 ci 枚硬币。数组 coins 中的区间互不重叠。
另给你一个整数 k。返回通过收集连续 k 个袋子可以获得的最多硬币数量。
示例 1
coins = [[8,10,1],[1,3,2],[5,6,4]], k = 4 -> 10(选坐标 [3,4,5,6]:2+0+4+4)
示例 2
coins = [[1,10,3]], k = 2 -> 6(选坐标 [1,2]:3+3)
提示:
1 <= coins.length <= 10^51 <= k <= 10^91 <= li <= ri <= 10^91 <= ci <= 1000- 给定的区间互不重叠。
解题思路
解法一:双向滑动窗口,主提交版本
最优的连续 k 个袋子,其左端点必然能取到某个区间的左端点 li,或右端点能够到某个
区间的右端点 ri(即左端点为 ri - k + 1)。分别用两个滑动窗口:
- 左对齐扫描:以每个区间左端点为窗口起点,向右扩展完全落在
[li, li+k-1]内的区间,
全部计入;最后一个部分重叠的区间只计入重叠部分;窗口左端移到下一区间时减去离场区间。 - 右对齐扫描:以每个区间右端点为窗口终点,向左扩展完全落在
[ri-k+1, ri]内的区间
全部计入;第一个部分重叠区间只计入重叠部分;移动时同步增减。
两种方向各一次 O(n) 扫描,答案取两者最大值。空间 O(log n)(排序)。
解法二:候选起点枚举(对照)
对每个候选起点start(所有li与ri - k + 1),遍历所有区间累加
[start, start+k-1]与区间交集的硬币数,取最大值。复杂度 O(n^2),仅本地小数据对拍。
复杂度: - 时间复杂度:O(n log n)(排序主导)
- 空间复杂度:O(log n)
代码实现
java
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:双向滑动窗口(主提交版本) ----------
public long maximumCoins(int[][] coins, int k) {
Arrays.sort(coins, (a, b) -> Integer.compare(a[0], b[0]));
long ans = 0;
int n = coins.length;
// 左对齐窗口:窗口起点 = 某区间左端点 li,终点 = li + k - 1
long cur = 0;
int j = 0;
for (int i = 0; i < n; ++i) {
int li = coins[i][0];
long right = (long) li + k - 1;
// 扩展:完全落在窗口内的区间
while (j < n && coins[j][1] <= right) {
cur += (long) (coins[j][1] - coins[j][0] + 1) * coins[j][2];
++j;
}
// 部分重叠区间(起点仍在窗口内)
if (j < n && coins[j][0] <= right) {
long overlap = right - coins[j][0] + 1;
cur += overlap * coins[j][2];
ans = Math.max(ans, cur);
cur -= overlap * coins[j][2]; // 撤掉部分量,下一轮从完整区间继续
} else {
ans = Math.max(ans, cur);
}
// 窗口左端点移动到下一个区间左端点:减去本区间全部贡献
cur -= (long) (coins[i][1] - coins[i][0] + 1) * coins[i][2];
}
// 右对齐窗口:窗口终点 = 某区间右端点 ri,起点 = ri - k + 1
cur = 0;
j = n - 1;
for (int i = n - 1; i >= 0; --i) {
int ri = coins[i][1];
long left = (long) ri - k + 1;
// 扩展:完全落在窗口内的区间(向左)
while (j >= 0 && coins[j][0] >= left) {
cur += (long) (coins[j][1] - coins[j][0] + 1) * coins[j][2];
--j;
}
// 部分重叠区间(终点仍在窗口内)
if (j >= 0 && coins[j][1] >= left) {
long overlap = coins[j][1] - left + 1;
cur += overlap * coins[j][2];
ans = Math.max(ans, cur);
cur -= overlap * coins[j][2];
} else {
ans = Math.max(ans, cur);
}
// 窗口右端点移到下一个区间右端点:减去本区间全部贡献
cur -= (long) (coins[i][1] - coins[i][0] + 1) * coins[i][2];
}
return ans;
}
// ---------- 解法二:候选起点枚举(对照) ----------
public long maximumCoinsBrute(int[][] coins, int k) {
Set<Long> starts = new HashSet<Long>();
for (int[] c : coins) {
starts.add((long) c[0]);
starts.add((long) c[1] - k + 1);
}
long ans = 0;
for (long st : starts) {
long end = st + k - 1;
long sum = 0;
for (int[] c : coins) {
long l = Math.max(st, c[0]);
long r = Math.min(end, c[1]);
if (l <= r) {
sum += (r - l + 1) * c[2];
}
}
ans = Math.max(ans, sum);
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(37);
System.out.println("示例1: " + sol.maximumCoins(new int[][] {{8, 10, 1}, {1, 3, 2}, {5, 6, 4}}, 4)
+ " (期望 10)");
System.out.println("示例2: " + sol.maximumCoins(new int[][] {{1, 10, 3}}, 2) + " (期望 6)");
int cases = 0, pass = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rand.nextInt(6);
int[][] coins = new int[n][];
int pos = 1;
for (int i = 0; i < n; ++i) {
int len = 1 + rand.nextInt(8);
int l = pos;
int r = l + len - 1;
int c = 1 + rand.nextInt(6);
coins[i] = new int[] {l, r, c};
pos = r + 1 + rand.nextInt(4); // 保证不重叠
}
// 打乱顺序
for (int i = n - 1; i > 0; --i) {
int p = rand.nextInt(i + 1);
int[] tmp = coins[i];
coins[i] = coins[p];
coins[p] = tmp;
}
int k = 1 + rand.nextInt(15);
long x = sol.maximumCoins(coins, k);
long y = sol.maximumCoinsBrute(coins, k);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH k=" + k + " fast=" + x + " brute=" + y);
for (int[] c : coins) {
System.out.print(Arrays.toString(c) + " ");
}
System.out.println();
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
两种方向各一次 O(n) 扫描,答案取两者最大值。空间 O(log n)(排序)。
- 时间复杂度:O(n log n)(排序主导)
- 空间复杂度:O(log n)
3414. Maximum Score of Non-overlapping Intervals(不重叠区间的最大得分)
题目描述
给你一个二维整数数组 intervals,其中 intervals[i] = [li, ri, weighti]。区间 i 的起点
为 li,终点为 ri,权重为 weighti。你最多可以选择 4 个互不重叠的区间。所选择
区间的得分 定义为这些区间权重的总和。返回一个至多包含 4 个下标且字典序最小 的数组,
表示从 intervals 中选中的互不重叠且得分最大的区间。
如果两个区间没有任何重叠点,则称二者互不重叠。特别地,如果两个区间共享左边界或右边界,
也认为二者重叠。
示例 1
intervals = [[1,3,2],[4,5,2],[1,5,5],[6,9,3],[6,7,1],[8,9,1]] -> [2,3]
示例 2
intervals = [[5,8,1],[6,7,7],[4,7,3],[9,10,6],[7,8,2],[11,14,3],[3,5,5]] -> [1,3,5,6]
提示:
1 <= intervals.length <= 5 * 10^41 <= li <= ri <= 10^91 <= weighti <= 10^9
解题思路
解法一:排序 + DP + 字典序回溯,主提交版本
按左端点(次按右端点)排序。对每个区间求 nxt[i]:排序后第一个左端点大于 arr[i] 右端点
的区间索引(二分查找)。然后自后向前 DP:
f[i][k]:从第 i 个区间(含)起至多选 k 个不重叠区间的最大权重;g[i][k]:达到该最大权重且字典序最小的原始下标列表(按原始下标升序存储)。
转移:不选 i -> fi+1k;选 i -> fnxt\[i]k-1 + wi(新列表 = gnxt\[i]k-1 再插入
原始下标 i,保持升序)。两者权重更大者胜出;相等时比较列表字典序,较小的胜出。
答案即g[0][4]。时间复杂度 O(n * 4 * 4)(每次插入列表至多 4 个元素比较),空间 O(n*4)。
解法二:暴力枚举组合(对照)
递归枚举所有不重叠区间的组合(至多 4 个),计算权重与字典序最小的下标列表。
时间复杂度 O(n^4),仅用于本地小数据交叉验证。
复杂度:- 时间复杂度:O(n * 4^2)
- 空间复杂度:O(n * 4)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:排序 + DP + 字典序回溯(主提交版本) ----------
public int[] maximumWeight(List<List<Integer>> intervals) {
int n = intervals.size();
int[][] arr = new int[n][4]; // {l, r, w, 原始下标}
for (int i = 0; i < n; ++i) {
List<Integer> e = intervals.get(i);
arr[i][0] = e.get(0);
arr[i][1] = e.get(1);
arr[i][2] = e.get(2);
arr[i][3] = i;
}
Arrays.sort(arr, (a, b) -> a[0] != b[0] ? Integer.compare(a[0], b[0])
: Integer.compare(a[1], b[1]));
// nxt[i]:第一个左端点 > arr[i][1] 的索引
int[] nxt = new int[n];
for (int i = 0; i < n; ++i) {
nxt[i] = search(arr, arr[i][1], i + 1);
}
long[][] f = new long[n + 1][5];
int[][][] g = new int[n + 1][5][];
for (int k = 0; k < 5; ++k) {
g[n][k] = new int[0];
}
for (int i = n - 1; i >= 0; --i) {
g[i][0] = new int[0];
for (int k = 1; k < 5; ++k) {
long s1 = f[i + 1][k];
int[] a1 = g[i + 1][k];
// 选 i
long s2 = f[nxt[i]][k - 1] + arr[i][2];
int[] a2 = insert(g[nxt[i]][k - 1], arr[i][3]);
if (s2 > s1 || (s2 == s1 && less(a2, a1))) {
f[i][k] = s2;
g[i][k] = a2;
} else {
f[i][k] = s1;
g[i][k] = a1;
}
}
}
// 修正:长度为 0 的情况不会发生(至少选 1 个),但 g[0][4] 可能含 0 个?
// 只要 n >= 1,选一个总是优于不选;g[0][4] 因而非空。
return g[0][4];
}
private int search(int[][] arr, int x, int l) {
int r = arr.length;
while (l < r) {
int mid = (l + r) >> 1;
if (arr[mid][0] > x) {
r = mid;
} else {
l = mid + 1;
}
}
return l;
}
// 把 x 插入有序数组 a(保持升序)
private int[] insert(int[] a, int x) {
int n = a.length;
int[] b = new int[n + 1];
int i = 0;
while (i < n && a[i] < x) {
b[i] = a[i];
++i;
}
b[i] = x;
while (i < n) {
b[i + 1] = a[i];
++i;
}
return b;
}
// 字典序:逐位比较,前缀相同则较短者更小
private boolean less(int[] a, int[] b) {
int m = Math.min(a.length, b.length);
for (int i = 0; i < m; ++i) {
if (a[i] != b[i]) {
return a[i] < b[i];
}
}
return a.length < b.length;
}
// ---------- 解法二:暴力枚举组合(对照) ----------
private long bestW;
private int[] bestList;
public int[] maximumWeightBrute(List<List<Integer>> intervals) {
int n = intervals.size();
bestW = Long.MIN_VALUE;
bestList = null;
dfs(intervals, 0, new ArrayList<Integer>(), 0L);
return bestList;
}
private void dfs(List<List<Integer>> iv, int start, List<Integer> chosen, long w) {
// 更新最优(每次候选都参与比较:同权重取字典序最小)
int[] cand = new int[chosen.size()];
for (int i = 0; i < cand.length; ++i) {
cand[i] = chosen.get(i);
}
Arrays.sort(cand);
if (bestList == null || w > bestW || (w == bestW && less(cand, bestList))) {
bestW = w;
bestList = cand;
}
if (chosen.size() == 4) {
return;
}
for (int i = start; i < iv.size(); ++i) {
List<Integer> cur = iv.get(i);
if (canAdd(chosen, iv, cur)) {
chosen.add(i);
dfs(iv, i + 1, chosen, w + cur.get(2));
chosen.remove(chosen.size() - 1);
}
}
}
private boolean canAdd(List<Integer> chosen, List<List<Integer>> iv, List<Integer> cur) {
for (int idx : chosen) {
List<Integer> o = iv.get(idx);
// 共享端点视为重叠:只要 [l,r] 相交(含端点)即重叠
if (!(o.get(1) < cur.get(0) || cur.get(1) < o.get(0))) {
return false;
}
}
return true;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(41);
List<List<Integer>> ex1 = new ArrayList<List<Integer>>();
int[][] a1 = {{1, 3, 2}, {4, 5, 2}, {1, 5, 5}, {6, 9, 3}, {6, 7, 1}, {8, 9, 1}};
for (int[] e : a1) {
ex1.add(Arrays.asList(e[0], e[1], e[2]));
}
System.out.println("示例1: " + Arrays.toString(sol.maximumWeight(ex1)) + " (期望 [2, 3])");
List<List<Integer>> ex2 = new ArrayList<List<Integer>>();
int[][] a2 = {{5, 8, 1}, {6, 7, 7}, {4, 7, 3}, {9, 10, 6}, {7, 8, 2}, {11, 14, 3}, {3, 5, 5}};
for (int[] e : a2) {
ex2.add(Arrays.asList(e[0], e[1], e[2]));
}
System.out.println("示例2: " + Arrays.toString(sol.maximumWeight(ex2)) + " (期望 [1, 3, 5, 6])");
int cases = 0, pass = 0;
for (int t = 0; t < 2000; ++t) {
int n = 1 + rand.nextInt(9);
List<List<Integer>> iv = new ArrayList<List<Integer>>();
for (int i = 0; i < n; ++i) {
int l = 1 + rand.nextInt(15);
int r = l + rand.nextInt(6);
int w = 1 + rand.nextInt(12);
iv.add(Arrays.asList(l, r, w));
}
int[] x = sol.maximumWeight(iv);
int[] y = sol.maximumWeightBrute(iv);
cases++;
if (Arrays.equals(x, y)) {
pass++;
} else {
System.out.println("MISMATCH fast=" + Arrays.toString(x) + " brute="
+ Arrays.toString(y) + " iv=" + iv);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
答案即 g[0][4]。时间复杂度 O(n * 4 * 4)(每次插入列表至多 4 个元素比较),空间 O(n*4)。
时间复杂度 O(n^4),仅用于本地小数据交叉验证。
- 时间复杂度:O(n * 4^2)
- 空间复杂度:O(n * 4)
3415. Find Products with Three Consecutive Digits(查找名称中包含三位连续数字的产品)
题目类型:数据库(SQL)
题目描述
表:Products
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| product_id | int |
| name | varchar |
+-------------+---------+
product_id 是此表的主键。表的每一行包含产品的 ID 和名字。
编写解决方案找出名字中恰好 包含三位连续数字(即包含一段长度为 3 的数字串,且该数字串前后都不是数字,因此连续四位及以上数字不算)的所有产品。返回结果表以 product_id 升序排序。
示例 1:
输入:
products 表:
+-------------+--------------------+
| product_id | name |
+-------------+--------------------+
| 1 | ABC123XYZ |
| 2 | A12B34C |
| 3 | Product56789 |
| 4 | NoDigitsHere |
| 5 | 789Product |
| 6 | Item003Description |
| 7 | Product12X34 |
+-------------+--------------------+
输出:
+-------------+--------------------+
| product_id | name |
+-------------+--------------------+
| 1 | ABC123XYZ |
| 5 | 789Product |
| 6 | Item003Description |
+-------------+--------------------+
解释:
产品 1:ABC123XYZ 包含数字 123。
产品 5:789Product 包含数字 789。
产品 6:Item003Description 包含 003,恰好三位数字。
产品 3 的 56789 是五位连续数字,产品 7 的 12 与 34 都只有两位,均不满足。
解题思路
题目要求"恰好三位连续数字":既要有三位数字连在一起,又不能夹在四位及以上连续数字中。
解法一(推荐):正则匹配隔离的三位数字串
用正则 (^|[^0-9])[0-9]{3}([^0-9]|$):左边界要求是字符串开头或非数字字符,右边界要求是非数字字符或字符串结尾。这样连续四位 1234 中任意三位都会有一侧是数字,无法同时满足左右边界 → 只有被隔离出来的三位数字串才能命中。等价写法是把三种情况(开头三位、结尾三位、夹在中间的三位)用 OR 拆开写。
解法二(对照):三段 OR 展开
name REGEXP '^[0-9]{3}[^0-9]' OR name REGEXP '[^0-9][0-9]{3}[^0-9]' OR name REGEXP '[^0-9][0-9]{3}$' 逐点枚举"三位串的位置",作为对照理解,效果与解法一相同。
代码实现
sql
-- 解法一(推荐):带边界断言的正则,恰好三位数字串
SELECT product_id, name
FROM Products
WHERE name REGEXP '(^|[^0-9])[0-9]{3}([^0-9]|$)'
ORDER BY product_id;
-- 解法二(对照):拆三种位置等价的写法
SELECT product_id, name
FROM Products
WHERE name REGEXP '^[0-9]{3}[^0-9]'
OR name REGEXP '[^0-9][0-9]{3}[^0-9]'
OR name REGEXP '[^0-9][0-9]{3}$'
ORDER BY product_id;
复杂度分析
- 时间复杂度 :
O(n),其中n为Products行数;每行做一次正则匹配,与名字长度成正比。 - 空间复杂度 :
O(1),仅需少量常量级中间状态。
3416. Subsequences with a Unique Middle Mode II(唯一中间众数子序列 II 🔒)
题目描述
给你一个整数数组 nums,请你求出 nums 中大小为 5 的子序列 的数目,它是唯一中间众数序列 。
由于答案可能很大,请你将答案对 10^9 + 7 取余后返回。
- 众数 指的是一个数字序列中出现次数最多的元素。
- 如果一个数字序列众数只有一个,我们称这个序列有唯一众数。
- 一个大小为 5 的数字序列
seq,如果它中间的数字(seq[2])是唯一众数,那么称它是
唯一中间众数 序列。
示例 1
nums = [1,1,1,1,1,1] -> 6
示例 2
nums = [1,2,2,3,3,4] -> 4
示例 3
nums = [0,1,2,3,4,5,6,7,8] -> 0
提示:
5 <= nums.length <= 10^5-10^9 <= nums[i] <= 10^9
解题思路
解法一:枚举中心 + 聚合量补集计数,主提交版本
子序列长度为 5,其中间元素记为 seq[2]。固定中间元素在数组中的下标 i,则它在子序列
中作为第 3 个元素,左侧两个元素从 [0, i) 任选、右侧两个从 (i, n) 任选,一一对应。
令 a = nums[i]、p[x] 为左侧 x 的个数、s[x] 为右侧 x 的个数、l = i、r = n-1-i。
所有组合数 = C(l,2) * C(r,2),需要减去中间元素 a 不是唯一众数的组合:
-
a只出现中间那 1 次(左右都没选 a):C(l - p[a], 2) * C(r - s[a], 2); -
其余值中某个
b != a的出现次数 >=a的频次(破坏唯一众数)。
第二类无法对每个 b 枚举,改用聚合量:ps = Σ p[x]*s[x]、pp = Σ p[x]^2、
ss = Σ s[x]^2、pss = Σ p[x]*s[x]^2、spp = Σ s[x]*p[x]^2(均剔除 a 的贡献后参与运算),
由官方推导的补集公式:ans -= ps_ * (p_a * (r - s_a)) + pss_ * (-p_a)
ans -= ps_ * (s_a * (l - p_a)) + spp_ * (-s_a)
ans -= (pp_ - p_) * s_a * (r - s_a) / 2
ans -= (ss_ - s_) * p_a * (l - p_a) / 2
每个下标仅 O(1) 更新聚合量,总复杂度 O(n)。空间 O(n)(离散化)。
解法二:五重循环暴力(对照)
枚举所有 C(n,5) 个下标组合,统计 5 元素频次,检查中间元素是否唯一众数。
时间复杂度 O(n^5),仅用于本地小数据交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
private static final long MOD = 1_000_000_007L;
// ---------- 解法一:枚举中心 + 聚合量补集(主提交版本) ----------
public int subsequencesWithMiddleMode(int[] nums) {
int n = nums.length;
// 离散化
Map<Integer, Integer> comp = new HashMap<Integer, Integer>();
int[] arr = new int[n];
int id = 0;
for (int i = 0; i < n; ++i) {
Integer c = comp.get(nums[i]);
if (c == null) {
c = id++;
comp.put(nums[i], c);
}
arr[i] = c;
}
int m = id;
long[] p = new long[m]; // 左侧计数
long[] s = new long[m]; // 右侧计数
long pp = 0, ps = 0, ss = 0, pss = 0, spp = 0;
for (int i = 0; i < n; ++i) {
s[arr[i]]++;
}
for (int x = 0; x < m; ++x) {
ss += s[x] * s[x];
}
long ans = 0;
for (int i = 0; i < n; ++i) {
int a = arr[i];
// 1) 把 a 从右侧移出,更新聚合量
ss += -s[a] * s[a] + (s[a] - 1) * (s[a] - 1);
pss += p[a] * (-s[a] * s[a] + (s[a] - 1) * (s[a] - 1));
spp += -p[a] * p[a]; // (s[a]-1-s[a]) * p[a]^2
ps += -p[a]; // (s[a]-1-s[a]) * p[a]
s[a]--;
long l = i;
long r = n - 1 - i;
long pa = p[a], sa = s[a];
// 2) 全量:左右各任选 2
ans += c2(l) * c2(r);
// 3) 减:a 只出现中间 1 次(左右都不选 a)
ans -= c2(l - pa) * c2(r - sa);
// 4) 减:其他值 b 参与竞争(官方补集公式)
long pss_ = pss - pa * sa * sa;
long spp_ = spp - sa * pa * pa;
long pp_ = pp - pa * pa;
long ss_ = ss - sa * sa;
long ps_ = ps - pa * sa;
long p_ = l - pa;
long s_ = r - sa;
ans -= ps_ * (pa * (r - sa)) + pss_ * (-pa);
ans -= ps_ * (sa * (l - pa)) + spp_ * (-sa);
ans -= (pp_ - p_) * sa * (r - sa) / 2;
ans -= (ss_ - s_) * pa * (l - pa) / 2;
ans %= MOD;
// 5) 把 a 加入左侧,更新聚合量
pss += sa * sa; // (pa+1-pa) * s[a]^2
spp += sa * (-pa * pa + (pa + 1) * (pa + 1));
pp += -pa * pa + (pa + 1) * (pa + 1);
ps += sa; // (pa+1-pa) * s[a]
p[a]++;
}
ans %= MOD;
if (ans < 0) {
ans += MOD;
}
return (int) ans;
}
private long c2(long x) {
if (x < 2) {
return 0;
}
return x * (x - 1) / 2;
}
// ---------- 解法二:五重循环暴力(对照) ----------
public int bruteForce(int[] nums) {
int n = nums.length;
long ans = 0;
for (int a = 0; a < n - 4; ++a) {
for (int b = a + 1; b < n - 3; ++b) {
for (int c = b + 1; c < n - 2; ++c) {
for (int d = c + 1; d < n - 1; ++d) {
for (int e = d + 1; e < n; ++e) {
int[] seq = {nums[a], nums[b], nums[c], nums[d], nums[e]};
Map<Integer, Long> freq = new HashMap<Integer, Long>();
for (int x : seq) {
freq.put(x, freq.getOrDefault(x, 0L) + 1);
}
long midFreq = freq.get(seq[2]);
long maxFreq = 0;
for (long fv : freq.values()) {
maxFreq = Math.max(maxFreq, fv);
}
int cntMax = 0;
for (long fv : freq.values()) {
if (fv == maxFreq) {
cntMax++;
}
}
if (midFreq == maxFreq && cntMax == 1) {
ans++;
}
}
}
}
}
}
return (int) (ans % MOD);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(43);
System.out.println("示例1: " + sol.subsequencesWithMiddleMode(new int[] {1, 1, 1, 1, 1, 1})
+ " (期望 6)");
System.out.println("示例2: " + sol.subsequencesWithMiddleMode(new int[] {1, 2, 2, 3, 3, 4})
+ " (期望 4)");
System.out.println("示例3: "
+ sol.subsequencesWithMiddleMode(new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}) + " (期望 0)");
int cases = 0, pass = 0;
for (int t = 0; t < 300; ++t) {
int n = 5 + rand.nextInt(8);
int[] a = new int[n];
int range = 1 + rand.nextInt(6);
for (int i = 0; i < n; ++i) {
a[i] = rand.nextInt(range);
}
int x = sol.subsequencesWithMiddleMode(a);
int y = sol.bruteForce(a);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
+ " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
每个下标仅 O(1) 更新聚合量,总复杂度 O(n)。空间 O(n)(离散化)。
时间复杂度 O(n^5),仅用于本地小数据交叉验证。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3417. Zigzag Grid Traversal With Skip(跳过交替单元格的之字形遍历)
题目描述
给你一个 m x n 的二维数组 grid,数组由正整数 组成。
你的任务是以之字形 遍历 grid,同时跳过每个交替 的单元格。
之字形遍历的定义如下:
- 从左上角的单元格
(0, 0)开始。 - 在当前行中向右移动,直到到达该行的末尾。
- 下移到下一行,然后在该行中向左移动,直到到达该行的开头。
- 继续在行间交替向右和向左移动,直到所有行都被遍历完。
注意:在遍历过程中,必须跳过每个交替 的单元格。
返回一个整数数组result,其中包含按顺序记录的、且跳过交替单元格后的之字形遍历中
访问到的单元格值。
示例 1
grid = [[1,2],[3,4]] -> [1,4]
示例 2
grid = [[2,1],[2,1],[2,1]] -> [2,1,2]
示例 3
grid = [[1,2,3],[4,5,6],[7,8,9]] -> [1,3,5,7,9]
提示:
2 <= m == grid.length <= 502 <= n == grid[i].length <= 501 <= grid[i][j] <= 2500
解题思路
解法一:展开序列按奇偶取,主提交版本
之字形展开后得到一个长度 m*n 的线性序列(奇数行反向)。遍历该序列,从下标 0 起
每隔一个取一个(取第 0、2、4... 个),即跳过交替单元格。时间复杂度 O(mn),
空间复杂度 O(m n)(答案以外最多 O(m*n) 用于展开,可进一步省)。
解法二:坐标模拟访问(对照)
直接用行列游标模拟之字形路线,用一个计数器 decide 是否收录当前格子。
与解法一实现路径不同,交叉验证。
复杂度:
- 时间复杂度:O(m*n)
- 空间复杂度:O(m*n)(含答案,可 O(m) 实现)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:展开序列按奇偶取(主提交版本) ----------
public List<Integer> zigzagTraversal(int[][] grid) {
int m = grid.length, n = grid[0].length;
boolean ok = true;
List<Integer> ans = new ArrayList<Integer>();
for (int i = 0; i < m; ++i) {
if ((i & 1) == 1) {
// 奇数行从右往左
for (int j = n - 1; j >= 0; --j) {
if (ok) {
ans.add(grid[i][j]);
}
ok = !ok;
}
} else {
for (int j = 0; j < n; ++j) {
if (ok) {
ans.add(grid[i][j]);
}
ok = !ok;
}
}
}
return ans;
}
// ---------- 解法二:坐标游标模拟(对照) ----------
public List<Integer> zigzagTraversalSim(int[][] grid) {
int m = grid.length, n = grid[0].length;
List<Integer> ans = new ArrayList<Integer>();
int i = 0, j = 0, dir = 1; // dir=1 向右,-1 向左
boolean take = true;
int cnt = 0;
while (cnt < m * n) {
if (take) {
ans.add(grid[i][j]);
}
take = !take;
cnt++;
j += dir;
if (j < 0 || j >= n) {
// 换行
j = (j < 0) ? 0 : n - 1;
i++;
dir = -dir;
if (i >= m) {
break;
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(47);
System.out.println("示例1: " + sol.zigzagTraversal(new int[][] {{1, 2}, {3, 4}})
+ " (期望 [1, 4])");
System.out.println("示例2: " + sol.zigzagTraversal(new int[][] {{2, 1}, {2, 1}, {2, 1}})
+ " (期望 [2, 1, 2])");
System.out.println("示例3: " + sol.zigzagTraversal(new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}})
+ " (期望 [1, 3, 5, 7, 9])");
int cases = 0, pass = 0;
for (int t = 0; t < 2000; ++t) {
int m = 2 + rand.nextInt(6);
int n = 2 + rand.nextInt(6);
int[][] g = new int[m][n];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
g[i][j] = 1 + rand.nextInt(20);
}
}
List<Integer> x = sol.zigzagTraversal(g);
List<Integer> y = sol.zigzagTraversalSim(g);
cases++;
if (x.equals(y)) {
pass++;
} else {
System.out.println("MISMATCH a=" + x + " b=" + y);
for (int[] row : g) {
System.out.println(Arrays.toString(row));
}
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
每隔一个取一个(取第 0、2、4... 个),即跳过交替单元格。时间复杂度 O(mn),
空间复杂度 O(mn)(答案以外最多 O(m*n) 用于展开,可进一步省)。
- 时间复杂度:O(m*n)
- 空间复杂度:O(m*n)(含答案,可 O(m) 实现)
3418. Maximum Amount of Money Robot Can Earn(机器人可以获得的最大金币数)
题目描述
给你一个 m x n 的网格。一个机器人从网格的左上角 (0, 0) 出发,目标是到达网格的右下角
(m - 1, n - 1)。在任意时刻,机器人只能向右或向下移动。
网格中的每个单元格包含一个值 coins[i][j]:
- 如果
coins[i][j] >= 0,机器人可以获得该单元格的金币。 - 如果
coins[i][j] < 0,机器人会遇到一个强盗,强盗会抢走该单元格数值的绝对值 的金币。
机器人有一项特殊能力,可以在行程中最多感化 2 个 单元格的强盗,从而防止这些单元格的
金币被抢走。注意:机器人的总金币数可以是负数。
返回机器人在路径上可以获得的最大金币数。
示例 1
coins = [[0,1,-1],[1,-2,3],[2,-3,4]] -> 8
示例 2
coins = [[10,10,10],[10,10,10]] -> 40
提示:
m == coins.lengthn == coins[i].length1 <= m, n <= 500-1000 <= coins[i][j] <= 1000
解题思路
解法一:三维记忆化 DFS,主提交版本
状态 (i, j, k):到达 (i, j) 且还剩 k 次感化能力时,从当前位置走到终点能获得的最大
金币(含当前位置的获得值)。转移:
- 普通收获:
coins[i][j] + max(dfs(i+1,j,k), dfs(i,j+1,k)); - 若
coins[i][j] < 0且k > 0:感化该强盗(不扣金币),
max(dfs(i+1,j,k-1), dfs(i,j+1,k-1))。
边界:终点(m-1, n-1)处若k > 0且金币为负,可取max(0, coins)。
越界返回-INF。记忆化dp[i][j][k],总状态 O(mn 3),每状态 O(1) 转移。
时间复杂度 O(mn),空间复杂度 O(m n)。
解法二:递推 DP 三维滚动(对照)
自终点向起点方向改为自起点向终点递推:f[i][j][k]表示从起点到(i,j)且已感化
k个强盗(k 从 2 递减使用)的最大金币。用上、左两方向 + 每个 k 转移,滚动数组优化。
与解法一结果一致,路径不同,交叉验证。
复杂度: - 时间复杂度:O(m*n)
- 空间复杂度:O(m*n)
代码实现
java
import java.util.Random;
public class Solution {
private Integer[][][] f;
private int[][] coins;
private int m;
private int n;
// ---------- 解法一:三维记忆化 DFS(主提交版本) ----------
public int maximumAmount(int[][] coins) {
m = coins.length;
n = coins[0].length;
this.coins = coins;
f = new Integer[m][n][3];
return dfs(0, 0, 2);
}
private int dfs(int i, int j, int k) {
if (i >= m || j >= n) {
return Integer.MIN_VALUE / 2;
}
if (f[i][j][k] != null) {
return f[i][j][k];
}
if (i == m - 1 && j == n - 1) {
return k > 0 ? Math.max(0, coins[i][j]) : coins[i][j];
}
int ans = coins[i][j] + Math.max(dfs(i + 1, j, k), dfs(i, j + 1, k));
if (coins[i][j] < 0 && k > 0) {
ans = Math.max(ans, Math.max(dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1)));
}
return f[i][j][k] = ans;
}
// ---------- 解法二:正向递推三维 DP(对照) ----------
public int maximumAmountDp(int[][] coins) {
int m = coins.length, n = coins[0].length;
final int NEG = Integer.MIN_VALUE / 2;
// dp[j][k]:滚动到当前行,位于第 j 列、已感化 k 个强盗的最大金币
int[][] INF0 = new int[n][3];
for (int j = 0; j < n; ++j) {
for (int k = 0; k < 3; ++k) {
INF0[j][k] = NEG;
}
}
for (int i = 0; i < m; ++i) {
int[][] ndp = new int[n][3];
for (int j = 0; j < n; ++j) {
for (int k = 0; k < 3; ++k) {
ndp[j][k] = NEG;
}
}
for (int j = 0; j < n; ++j) {
for (int k = 0; k < 3; ++k) {
int best = NEG;
if (i == 0 && j == 0) {
best = 0;
}
if (i > 0) {
best = Math.max(best, INF0[j][k]);
}
if (j > 0) {
best = Math.max(best, ndp[j - 1][k]);
}
if (best == NEG) {
continue;
}
int v = coins[i][j];
// 不感化
ndp[j][k] = Math.max(ndp[j][k], best + v);
// 感化当前强盗:必须从"已感化 k-1 个"的状态接过来
if (v < 0 && k > 0) {
int b2 = NEG;
if (i == 0 && j == 0) {
b2 = 0;
}
if (i > 0) {
b2 = Math.max(b2, INF0[j][k - 1]);
}
if (j > 0) {
b2 = Math.max(b2, ndp[j - 1][k - 1]);
}
if (b2 != NEG) {
ndp[j][k] = Math.max(ndp[j][k], b2);
}
}
}
}
INF0 = ndp;
}
int ans = NEG;
for (int k = 0; k < 3; ++k) {
ans = Math.max(ans, INF0[n - 1][k]);
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(53);
System.out.println("示例1: " + sol.maximumAmount(new int[][] {{0, 1, -1}, {1, -2, 3},
{2, -3, 4}}) + " (期望 8)");
System.out.println("示例2: " + sol.maximumAmount(new int[][] {{10, 10, 10}, {10, 10, 10}})
+ " (期望 40)");
int cases = 0, pass = 0;
for (int t = 0; t < 500; ++t) {
int m = 1 + rand.nextInt(6);
int n = 1 + rand.nextInt(6);
int[][] g = new int[m][n];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
g[i][j] = -5 + rand.nextInt(11);
}
}
int x = sol.maximumAmount(g);
int y = sol.maximumAmountDp(g);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH fast=" + x + " dp=" + y);
for (int[] row : g) {
System.out.println(java.util.Arrays.toString(row));
}
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O(mn),空间复杂度 O(mn)。
- 时间复杂度:O(m*n)
- 空间复杂度:O(m*n)
3419. Minimize the Maximum Edge Weight of Graph(图的最大边权的最小值)
题目描述
给你两个整数 n 和 threshold,同时给你一个 n 个节点的有向 带权图,节点编号为 0
到 n - 1。这个图用二维整数数组 edges 表示,其中 edges[i] = [Ai, Bi, Wi] 表示节点
Ai 到节点 Bi 之间有一条边权为 Wi 的有向边。
你需要从这个图中删除一些边(也可能不删除任何边),使得这个图满足以下条件:
- 所有其他节点都可以到达节点 0。
- 图中剩余边的最大边权值尽可能小。
- 每个节点都至多 有
threshold条出去的边。
请你返回删除必要的边后,最大 边权的最小值为多少。如果无法满足所有的条件,返回 -1。
示例 1
n=5, edges=[[1,0,1],[2,0,2],[3,0,1],[4,3,1],[2,1,1]], threshold=2 -> 1
示例 2
n=5, edges=[[0,1,1],[0,2,2],[0,3,1],[0,4,1],[1,2,1],[1,4,1]], threshold=1 -> -1
示例 3
n=5, edges=[[1,2,1],[1,3,3],[1,4,5],[2,3,2],[3,4,2],[4,0,1]], threshold=1 -> 2
示例 4
n=5, edges=[[1,2,1],[1,3,3],[1,4,5],[2,3,2],[4,0,1]], threshold=1 -> -1
提示:
2 <= n <= 10^51 <= threshold <= n - 11 <= edges.length <= min(10^5, n*(n-1)/2)0 <= Ai, Bi < n,Ai != Bi1 <= Wi <= 10^6
解题思路
解法一:二分答案 + 反向 BFS 连通性,主提交版本
"所有节点都能到达 0" 等价于在反向图 上从 0 出发能到达所有节点。而"删除边使最大边权
最小"是典型的二分答案:判定 limit 是否可行------只用边权 <= limit 的反向边,从 0 出发
BFS/DFS,若所有节点可达则可行。关于 threshold:在反向图中每个节点的出边对应原图的入边;
若能从 0 到所有节点,每个节点可达即可,且原条件"每个节点至多 threshold 条出边"------可以
通过删除多余边满足(只要 threshold >= 1,去掉多余边后每个节点保留不超过 threshold 条
出边即可达到;若某节点原图不可达 0 则无论如何不行)。因此阈值只需考虑连通性。
二分下界 0、上界最大边权;check 可行则收窄上界。最终若最小可行值不存在返回 -1。
时间复杂度 O((n + m) * log W),空间 O(n + m)。
解法二:Kruskal 式并查集(对照)
把边按权值升序排序,并查集维护"反向图上可达 0 的节点集合":将反向边端点加入,当且仅当
所有节点都与 0 连通时的最大边权即最小可行上限。结果与二分一致,路径独立交叉验证。
复杂度:
- 时间复杂度:O((n + m) * log W)
- 空间复杂度:O(n + m)
代码实现
java
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:二分答案 + 反向 BFS(主提交版本) ----------
public int minMaxWeight(int n, int[][] edges, int threshold) {
// 建反向图
List<List<int[]>> rev = new ArrayList<List<int[]>>();
for (int i = 0; i < n; ++i) {
rev.add(new ArrayList<int[]>());
}
int maxW = 0;
for (int[] e : edges) {
rev.get(e[1]).add(new int[] {e[0], e[2]});
if (e[2] > maxW) {
maxW = e[2];
}
}
// 先验证完全不加限制是否可达(不可达则 -1)
if (!can(rev, n, maxW)) {
return -1;
}
int lo = 0, hi = maxW;
while (lo < hi) {
int mid = (lo + hi) >>> 1;
if (can(rev, n, mid)) {
hi = mid;
} else {
lo = mid + 1;
}
}
return lo;
}
// 反向图上从 0 出发,只用边权 <= limit 的边,能否到达所有节点
private boolean can(List<List<int[]>> rev, int n, int limit) {
boolean[] vis = new boolean[n];
int[] q = new int[n];
int head = 0, tail = 0;
q[tail++] = 0;
vis[0] = true;
int cnt = 1;
while (head < tail) {
int u = q[head++];
for (int[] e : rev.get(u)) {
int v = e[0], w = e[1];
if (!vis[v] && w <= limit) {
vis[v] = true;
cnt++;
q[tail++] = v;
}
}
}
return cnt == n;
}
// ---------- 解法二:Dijkstra 瓶颈最短路(对照) ----------
public int minMaxWeightDijkstra(int n, int[][] edges, int threshold) {
// 反向图
List<List<int[]>> rev = new ArrayList<List<int[]>>();
for (int i = 0; i < n; ++i) {
rev.add(new ArrayList<int[]>());
}
int maxW = 0;
for (int[] e : edges) {
rev.get(e[1]).add(new int[] {e[0], e[2]});
if (e[2] > maxW) {
maxW = e[2];
}
}
// 先验证完全放行是否可达
if (!can(rev, n, maxW)) {
return -1;
}
// dist[v] = 从 0 到 v 的路径上的最小瓶颈(最大边权最小化)
// 用 Dijkstra 变体:路径代价取 max,堆按代价升序
final int INF = Integer.MAX_VALUE / 2;
int[] dist = new int[n];
java.util.Arrays.fill(dist, INF);
dist[0] = 0;
java.util.PriorityQueue<int[]> pq =
new java.util.PriorityQueue<int[]>(new java.util.Comparator<int[]>() {
public int compare(int[] a, int[] b) {
return Integer.compare(a[0], b[0]);
}
});
pq.offer(new int[] {0, 0});
boolean[] done = new boolean[n];
while (!pq.isEmpty()) {
int[] top = pq.poll();
int u = top[1];
if (done[u]) {
continue;
}
done[u] = true;
for (int[] e : rev.get(u)) {
int v = e[0], w = e[1];
int nd = Math.max(dist[u], w);
if (nd < dist[v]) {
dist[v] = nd;
pq.offer(new int[] {nd, v});
}
}
}
int ans = 0;
for (int i = 0; i < n; ++i) {
ans = Math.max(ans, dist[i]);
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(59);
System.out.println("示例1: "
+ sol.minMaxWeight(5, new int[][] {{1, 0, 1}, {2, 0, 2}, {3, 0, 1}, {4, 3, 1},
{2, 1, 1}}, 2) + " (期望 1)");
System.out.println("示例2: "
+ sol.minMaxWeight(5, new int[][] {{0, 1, 1}, {0, 2, 2}, {0, 3, 1}, {0, 4, 1},
{1, 2, 1}, {1, 4, 1}}, 1) + " (期望 -1)");
System.out.println("示例3: "
+ sol.minMaxWeight(5, new int[][] {{1, 2, 1}, {1, 3, 3}, {1, 4, 5}, {2, 3, 2},
{3, 4, 2}, {4, 0, 1}}, 1) + " (期望 2)");
System.out.println("示例4: "
+ sol.minMaxWeight(5, new int[][] {{1, 2, 1}, {1, 3, 3}, {1, 4, 5}, {2, 3, 2},
{4, 0, 1}}, 1) + " (期望 -1)");
int cases = 0, pass = 0;
for (int t = 0; t < 2000; ++t) {
int n = 2 + rand.nextInt(8);
int threshold = 1 + rand.nextInt(n);
int m = 1 + rand.nextInt(Math.max(1, (int) Math.min(30, (long) n * (n - 1) / 2)));
int[][] es = new int[m][];
for (int i = 0; i < m; ++i) {
int a = rand.nextInt(n), b = rand.nextInt(n);
while (b == a) {
b = rand.nextInt(n);
}
es[i] = new int[] {a, b, 1 + rand.nextInt(15)};
}
int x = sol.minMaxWeight(n, es, threshold);
int y = sol.minMaxWeightDijkstra(n, es, threshold);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH n=" + n + " th=" + threshold + " bisearch=" + x
+ " union=" + y);
for (int[] e : es) {
System.out.print(java.util.Arrays.toString(e) + " ");
}
System.out.println();
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
时间复杂度 O((n + m) * log W),空间 O(n + m)。
- 时间复杂度:O((n + m) * log W)
- 空间复杂度:O(n + m)
3420. Count Non-Decreasing Subarrays After K Operations(统计 K 次操作以内得到非递减子数组的数目)
题目描述
给你一个长度为 n 的数组 nums 和一个整数 k。
对于 nums 中的每一个子数组,你可以对它进行至多 k 次操作。每次操作中,你可以将
子数组中的任意一个元素增加 1。注意 ,每个子数组都是独立的,也就是说你对一个子数组的
修改不会保留到另一个子数组中。
请你返回最多 k 次操作以内,有多少个子数组可以变成非递减 的。
如果一个数组中的每一个元素都大于等于前一个元素(如果前一个元素存在),那么我们称这个
数组是非递减的。
示例 1
nums = [6,3,1,2,4,4], k = 7 -> 17
示例 2
nums = [6,3,1,3,6], k = 4 -> 12
提示:
1 <= nums.length <= 10^51 <= nums[i] <= 10^91 <= k <= 10^9
解题思路
解法一:双指针 + 单调平台栈,主提交版本
对固定左端点 l,定义 cost(l, r) 为把子数组 [l, r] 变成非递减的最小操作数。它随 r
增大单调不减,因此对每个 l,最大可行 r 可用双指针维护。
核心是增量维护 cost:从右往左扫描 l,用单调栈维护"平台"结构。每个平台
(val, size) 表示一段被调整成同一高度 val 的连续元素:
- 新元素
x进入后,若x >= 栈顶平台值,则栈顶平台(值较小、位于右侧)必须整体抬到
x才能保持左小右大的非递减顺序,代价增加(x - val) * size,并合并为一个大小
更大的平台;重复直到栈顶值> x,再把(x, 合并大小)压栈。 - 当总代价超过
k时收缩右边界r:最右元素恰在栈底(值最大)平台中,去掉它减少
栈底值 - nums[r]的代价;若该平台大小归零则弹掉栈底。 - 对当前
l,所有r' in [l, r]的子数组都可行,答案累加r - l + 1。
每个元素入栈出栈各一次,总复杂度 O(n),空间 O(n)。
解法二:暴力枚举子数组贪心(对照)
对每个子数组[l, r],从左到右贪心:维护cur(当前必需高度,初始nums[l]),
若nums[i] < cur则代价加cur - nums[i],否则cur = nums[i]。代价不超过k即可行。
时间复杂度 O(n^2),仅用于本地小数据交叉验证。
复杂度: - 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:双指针 + 单调平台栈(主提交版本) ----------
public long countNonDecreasingSubarrays(int[] nums, int k) {
int n = nums.length;
long cost = 0;
long ans = 0;
// 数组模拟双端队列(head..top),值从栈底到栈顶单调递减
int[] val = new int[n + 2];
int[] size = new int[n + 2];
int head = 0, top = -1;
int r = n - 1;
for (int l = n - 1; l >= 0; --l) {
int x = nums[l];
int mergeSz = 1;
while (top >= head && x >= val[top]) {
cost += (long) (x - val[top]) * size[top]; // 抬升右侧平台到 x
mergeSz += size[top];
--top;
}
++top;
val[top] = x;
size[top] = mergeSz;
// 收缩右边界,使代价回到 k 以内
while (cost > k) {
cost -= (long) val[head] - nums[r]; // 去掉最右元素
--size[head];
if (size[head] == 0) {
++head;
if (head > top) {
head = 0;
top = -1;
}
}
--r;
}
ans += (long) (r - l + 1);
}
return ans;
}
// ---------- 解法二:暴力枚举子数组(对照) ----------
public long countNonDecreasingSubarraysBrute(int[] nums, int k) {
int n = nums.length;
long ans = 0;
for (int l = 0; l < n; ++l) {
long cost = 0;
int cur = nums[l]; // 当前必需高度
for (int r = l; r < n; ++r) {
if (nums[r] < cur) {
cost += cur - nums[r];
} else {
cur = nums[r];
}
if (cost <= k) {
++ans;
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
Random rand = new Random(61);
System.out.println("示例1: "
+ sol.countNonDecreasingSubarrays(new int[] {6, 3, 1, 2, 4, 4}, 7) + " (期望 17)");
System.out.println("示例2: "
+ sol.countNonDecreasingSubarrays(new int[] {6, 3, 1, 3, 6}, 4) + " (期望 12)");
int cases = 0, pass = 0;
for (int t = 0; t < 3000; ++t) {
int n = 1 + rand.nextInt(12);
int[] a = new int[n];
int range = 1 + rand.nextInt(8);
for (int i = 0; i < n; ++i) {
a[i] = 1 + rand.nextInt(range);
}
long kk = 1 + rand.nextInt(40);
long x = sol.countNonDecreasingSubarrays(a, (int) kk);
long y = sol.countNonDecreasingSubarraysBrute(a, (int) kk);
cases++;
if (x == y) {
pass++;
} else {
System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " k=" + kk
+ " fast=" + x + " brute=" + y);
}
}
System.out.println("ALL PASS (" + pass + "/" + cases + ")");
}
}
复杂度分析
每个元素入栈出栈各一次,总复杂度 O(n),空间 O(n)。
时间复杂度 O(n^2),仅用于本地小数据交叉验证。
- 时间复杂度:O(n)
- 空间复杂度:O(n)