LeetCode 3061-3080. 题解合集
文章目录
- [LeetCode 3061-3080. 题解合集](#LeetCode 3061-3080. 题解合集)
-
- [3061. Calculate Trapping Rain Water(计算滞留雨水)](#3061. Calculate Trapping Rain Water(计算滞留雨水))
- [3062. Winner of the Linked List Game(链表游戏的获胜者 🔒)](#3062. Winner of the Linked List Game(链表游戏的获胜者 🔒))
- [3063. Linked List Frequency(链表频率 🔒)](#3063. Linked List Frequency(链表频率 🔒))
- [3064. Guess the Number Using Bitwise Questions I(使用按位查询猜测数字 I 🔒)](#3064. Guess the Number Using Bitwise Questions I(使用按位查询猜测数字 I 🔒))
- [3065. Minimum Operations to Exceed Threshold Value I(超过阈值的最少操作数 I)](#3065. Minimum Operations to Exceed Threshold Value I(超过阈值的最少操作数 I))
- [3066. Minimum Operations to Exceed Threshold Value II(超过阈值的最少操作数 II)](#3066. Minimum Operations to Exceed Threshold Value II(超过阈值的最少操作数 II))
- [3067. Count Pairs of Connectable Servers in a Weighted Tree Network](#3067. Count Pairs of Connectable Servers in a Weighted Tree Network)
- [3068. Find the Maximum Sum of Node Values(最大节点价值之和)](#3068. Find the Maximum Sum of Node Values(最大节点价值之和))
- [3069. Distribute Elements Into Two Arrays I(将元素分配到两个数组中 I)](#3069. Distribute Elements Into Two Arrays I(将元素分配到两个数组中 I))
- [3070. Count Submatrices with Top-Left Element and Sum Less Than k](#3070. Count Submatrices with Top-Left Element and Sum Less Than k)
- [3071. Minimum Operations to Write the Letter Y on a Grid](#3071. Minimum Operations to Write the Letter Y on a Grid)
- [3072. Distribute Elements Into Two Arrays II(将元素分配到两个数组中 II)](#3072. Distribute Elements Into Two Arrays II(将元素分配到两个数组中 II))
- [3073. Maximum Increasing Triplet Value(最大递增三元组 🔒)](#3073. Maximum Increasing Triplet Value(最大递增三元组 🔒))
- [3074. Apple Redistribution into Boxes(重新分装苹果)](#3074. Apple Redistribution into Boxes(重新分装苹果))
- [3075. Maximize Happiness of Selected Children(幸福值最大化的选择方案)](#3075. Maximize Happiness of Selected Children(幸福值最大化的选择方案))
- [3076. Shortest Uncommon Substring in an Array(数组中的最短非公共子字符串)](#3076. Shortest Uncommon Substring in an Array(数组中的最短非公共子字符串))
- [3077. Maximum Strength of K Disjoint Subarrays(K 个不相交子数组的最大能量值)](#3077. Maximum Strength of K Disjoint Subarrays(K 个不相交子数组的最大能量值))
- [3078. Match Alphanumerical Pattern in Matrix I(矩阵中的字母数字模式匹配 I 🔒)](#3078. Match Alphanumerical Pattern in Matrix I(矩阵中的字母数字模式匹配 I 🔒))
- [3079. Find the Sum of Encrypted Integers(求出加密整数的和)](#3079. Find the Sum of Encrypted Integers(求出加密整数的和))
- [3080. Mark Elements on Array by Performing Queries(执行操作标记数组中的元素)](#3080. Mark Elements on Array by Performing Queries(执行操作标记数组中的元素))
3061. Calculate Trapping Rain Water(计算滞留雨水)
题目类型:数据库(SQL)
题目描述
表:Heights
+-------------+------+
| Column Name | Type |
+-------------+------+
| id | int |
| height | int |
+-------------+------+
id 是这张表的主键且已保证有序。每一行表示一个宽度为 1 的沙洲的高度。
编写解决方案,计算景观中沙洲之间可以滞留的雨水量(每个沙洲宽度为 1 个单位)。
以任何 顺序返回结果表,输出总滞留水量 total_trapped_water。
示例 1:
输入:
Heights 表 12 行:heights = [0,1,0,2,1,0,1,3,2,1,2,1]
输出:
+---------------------+
| total_trapped_water |
+---------------------+
| 6 |
+---------------------+
解释:经典接雨水问题,蓝色区域共滞留 6 个单位雨水。
解题思路
经典"接雨水":每个位置能接的水 = MAX(0, MIN(左侧最大高度, 右侧最大高度) - 当前高度)。用窗口函数 MAX(height) OVER (ORDER BY id) 求每个位置的左侧最大值(含自身),MAX(height) OVER (ORDER BY id DESC) 求右侧最大值(含自身),再 SUM(GREATEST(LEAST(lm, rm) - height, 0)) 求总量。id 已有序,天然符合从左到右的柱子顺序。
代码实现
sql
WITH left_max AS (
SELECT id, MAX(height) OVER (ORDER BY id) AS lm FROM Heights
),
right_max AS (
SELECT id, MAX(height) OVER (ORDER BY id DESC) AS rm FROM Heights
)
SELECT SUM(GREATEST(LEAST(l.lm, r.rm) - h.height, 0)) AS total_trapped_water
FROM Heights h
JOIN left_max l ON h.id = l.id
JOIN right_max r ON h.id = r.id;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3062. Winner of the Linked List Game(链表游戏的获胜者 🔒)
题目描述
给定长度为偶数、包含整数的链表的 head 节点。
每个奇数编号的节点包含一个奇数,每个偶数编号的节点包含一个偶数。
我们把每个偶数编号的节点和它的下一个节点叫做一个"对"(如 0 和 1 是一对,
2 和 3 是一对,以此类推)。
对于每个对,比较对中节点的值:
- 如果奇数节点更大,"
Odd" 队得一分; - 如果偶数节点更大,"
Even" 队得一分。
返回分数更高的队名;如果分数相同,返回 "Tie"。
示例 1
head = [2,1] -> "Even"
示例 2
head = [2,5,4,7,20,5] -> "Odd"
示例 3
head = [4,5,2,1] -> "Tie"
提示:
- 链表中节点的数字在范围 1, 100 内
- 链表中的节点数为偶数
- 每个奇数编号节点的值都是奇数,每个偶数编号节点的值都是偶数
- 链表定义(与
LeetCode一致): - public class
ListNode{ intval;ListNodenext;ListNode(){}ListNode(intval) { this.val =val; }ListNode(intval,ListNodenext) { this.val =val; this.next =next; }- }
解题思路
解法一:成对遍历比较,主提交版本
下标从 0 开始,"偶数编号节点"即 0、2、4...(节点的第 1、3、5... 个),
每对由 cur(偶数编号)与 cur.next(奇数编号)组成。
若 even 值更大则 even 队得分,否则 odd 队得分。最后比较两队分数返回队名。
时间复杂度 O(n)(n 为链表长度),空间复杂度 O(1)。
解法二:链表转数组后两两比较(对照)
先把链表元素收集到数组,再按下标奇偶两两比较累加分数,逻辑等价、便于交叉验证。
时间复杂度 O(n),空间复杂度 O(n)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
public class Solution {
static class ListNode {
int val;
ListNode next;
ListNode(int val) {
this.val = val;
}
}
// ---------- 解法一:成对遍历比较(主提交版本) ----------
public String gameResult(ListNode head) {
int odd = 0; // Odd 队得分(奇数编号节点)
int even = 0; // Even 队得分(偶数编号节点)
ListNode cur = head;
while (cur != null && cur.next != null) {
if (cur.val > cur.next.val) {
even++;
} else {
odd++;
}
cur = cur.next.next;
}
return odd == even ? "Tie" : (odd > even ? "Odd" : "Even");
}
// ---------- 解法二:转数组两两比较(对照) ----------
public String gameResultByArray(ListNode head) {
java.util.List<Integer> vals = new java.util.ArrayList<>();
for (ListNode p = head; p != null; p = p.next) {
vals.add(p.val);
}
int odd = 0, even = 0;
for (int i = 0; i + 1 < vals.size(); i += 2) {
if (vals.get(i) > vals.get(i + 1)) {
even++;
} else {
odd++;
}
}
return odd == even ? "Tie" : (odd > even ? "Odd" : "Even");
}
// ---------- 本地测试 ----------
private static ListNode build(int[] arr) {
ListNode dummy = new ListNode(0);
ListNode p = dummy;
for (int v : arr) {
p.next = new ListNode(v);
p = p.next;
}
return dummy.next;
}
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{2, 1},
{2, 5, 4, 7, 20, 5},
{4, 5, 2, 1},
};
String[] expects = {"Even", "Odd", "Tie"};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
String a = sol.gameResult(build(cases[i]));
String b = sol.gameResultByArray(build(cases[i]));
boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " -> " + a
+ " / array=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n)(n 为链表长度),空间复杂度 O(1)。
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3063. Linked List Frequency(链表频率 🔒)
题目描述
给定包含 k 个不同元素的链表的 head 节点,创建一个长度为 k 的链表,
以任何顺序返回链表中所有不同元素出现的频率。返回这个链表的头节点。
示例 1
head = [1,1,2,1,2,3] -> [3,2,1](1 出现 3 次、2 出现 2 次、3 出现 1 次)
示例 2
head = [1,1,2,2,2] -> [2,3]
示例 3
head = [6,5,4,3,2,1] -> [1,1,1,1,1,1]
提示:
- 链表中的节点数字范围在 1, 10\^5 之间
1 <= Node.val <= 10^5- 链表定义(与
LeetCode一致): - public class
ListNode{ intval;ListNodenext;ListNode(){}ListNode(intval) { this.val =val; }ListNode(intval,ListNodenext) { this.val =val; this.next =next; }- }
解题思路
解法一:哈希表统计频次后建链,主提交版本
遍历链表,用哈希表统计每个不同元素出现的次数;
再遍历哈希表的值集合,把它们依次串成新链表返回。
频次链表顺序任意,题目允许任意合法顺序。
时间复杂度 O(n)(n 为链表长度),空间复杂度 O(k)(k 为不同元素个数)。
解法二:计数数组统计后建链(对照)
数值范围受限(1 <= val <= 10^5),可用计数数组替代哈希表:
第一遍统计各值出现次数,第二遍把出现过的值的次数串成链表。
时间复杂度 O(n + V)(V 为值域 10^5),空间复杂度 O(V)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(k)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
public class Solution {
static class ListNode {
int val;
ListNode next;
ListNode(int val) {
this.val = val;
}
}
// ---------- 解法一:哈希表统计频次后建链(主提交版本) ----------
public ListNode frequenciesOfElements(ListNode head) {
Map<Integer, Integer> cnt = new HashMap<>();
for (ListNode p = head; p != null; p = p.next) {
cnt.put(p.val, cnt.getOrDefault(p.val, 0) + 1);
}
ListNode dummy = new ListNode(0);
ListNode tail = dummy;
for (int v : cnt.values()) {
tail.next = new ListNode(v);
tail = tail.next;
}
return dummy.next;
}
// ---------- 解法二:计数数组统计后建链(对照) ----------
public ListNode frequenciesOfElementsByArray(ListNode head) {
int maxVal = 100000;
int[] cnt = new int[maxVal + 1];
for (ListNode p = head; p != null; p = p.next) {
cnt[p.val]++;
}
ListNode dummy = new ListNode(0);
ListNode tail = dummy;
for (int v = 1; v <= maxVal; ++v) {
if (cnt[v] > 0) {
tail.next = new ListNode(cnt[v]);
tail = tail.next;
}
}
return dummy.next;
}
// ---------- 本地测试 ----------
private static ListNode build(int[] arr) {
ListNode dummy = new ListNode(0);
ListNode p = dummy;
for (int v : arr) {
p.next = new ListNode(v);
p = p.next;
}
return dummy.next;
}
private static int[] toArray(ListNode head) {
java.util.List<Integer> list = new java.util.ArrayList<>();
for (ListNode p = head; p != null; p = p.next) {
list.add(p.val);
}
int[] res = new int[list.size()];
for (int i = 0; i < res.length; ++i) {
res[i] = list.get(i);
}
return res;
}
private static int[] sorted(int[] arr) {
int[] s = arr.clone();
Arrays.sort(s);
return s;
}
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1, 1, 2, 1, 2, 3},
{1, 1, 2, 2, 2},
{6, 5, 4, 3, 2, 1},
};
int[][] expects = {
{3, 2, 1},
{2, 3},
{1, 1, 1, 1, 1, 1},
};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int[] a = sorted(toArray(sol.frequenciesOfElements(build(cases[i]))));
int[] b = sorted(toArray(sol.frequenciesOfElementsByArray(build(cases[i]))));
Arrays.sort(expects[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("freq of " + Arrays.toString(cases[i]) + " -> "
+ Arrays.toString(a) + " / array=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(expects[i])
+ (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n)(n 为链表长度),空间复杂度 O(k)(k 为不同元素个数)。
时间复杂度 O(n + V)(V 为值域 10^5),空间复杂度 O(V)。
- 时间复杂度:O(n)
- 空间复杂度:O(k)
3064. Guess the Number Using Bitwise Questions I(使用按位查询猜测数字 I 🔒)
题目描述
你需要找到一个数字 n。
这里有一个预定义的 API int commonSetBits(int num),它返回 n 和 num 在二进制表示
的同一位置上都是 1 的位数。换句话说,它返回 n & num 的设置位数量。
返回数字 n。
示例 1
n = 31 -> 31
示例 2
n = 33 -> 33
提示:
1 <= n <= 2^30 - 10 <= num <= 2^30 - 1- 如果你查询的
num超出了给定的范围,输出就不可靠 - 预定义
API(与LeetCode一致,本地测试用内部类模拟): intcommonSetBits(intnum);
解题思路
解法一:逐位查询重构,主提交版本
n 最大 2^30 - 1,只用考察二进制低 30 位。对每个位 i(0...29),
调用 commonSetBits(1 << i):
- 返回 1:说明 n 与 (1 << i) 的公共设置位有 1 个,即 n 的第 i 位为 1;
- 返回 0:说明 n 的第 i 位为 0。
把为 1 的位通过按位或累加到答案即可还原 n。
共 30 次 API 查询,时间复杂度 O(30)(常数,等价 O(log n)),空间复杂度 O(1)。
解法二:区间滤波查询(对照)
对每个 bit 用 (1 << i) 的不同放大倍数验证性质,或直接采用"查询返回值为
非零即置位"的等价写法,保证 API 调用总数一致、结果一致,用于交叉验证。
本例中两种实现逐位一致。
复杂度: - 时间复杂度:O(log n)(最多 30 次查询)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:逐位查询重构(主提交版本) ----------
public int findNumber() {
int ans = 0;
for (int i = 0; i < 30; ++i) {
int mask = 1 << i;
if (commonSetBits(mask) > 0) {
ans |= mask;
}
}
return ans;
}
// ---------- 解法二:等价位标记(对照,逻辑等价) ----------
public int findNumberAlt() {
int ans = 0;
for (int i = 0; i < 30; ++i) {
int mask = 1 << i;
// commonSetBits(mask) 返回 0 或 1(mask 只有单一位),非零即置位
ans |= (commonSetBits(mask) == 1 ? mask : 0);
}
return ans;
}
// ---------- 预定义 API(本地测试模拟) ----------
private static int hiddenN;
// 题目约定由评测系统提供的 API:返回 n 与 num 的公共设置位数
private int commonSetBits(int num) {
return Integer.bitCount(hiddenN & num);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] cases = {31, 33, 1, 2, 1073741823, 123456, 1000000000, 1 << 29, 0x3FFFFFFF};
boolean allPass = true;
for (int n : cases) {
hiddenN = n;
int a = sol.findNumber();
int b = sol.findNumberAlt();
boolean ok = a == n && b == n;
allPass &= ok;
System.out.println("n=" + n + " -> " + a + " / alt=" + b
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍:随机 n,验证逐位重构正确性
Random rnd = new Random(3064);
int trials = 10000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt((1 << 30) - 1);
hiddenN = n;
if (sol.findNumber() != n) {
fail++;
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
共 30 次 API 查询,时间复杂度 O(30)(常数,等价 O(log n)),空间复杂度 O(1)。
- 时间复杂度:O(log n)(最多 30 次查询)
- 空间复杂度:O(1)
3065. Minimum Operations to Exceed Threshold Value I(超过阈值的最少操作数 I)
题目描述
给你一个下标从 0 开始的整数数组 nums 和一个整数 k。
一次操作中,你可以删除 nums 中的最小元素。
你需要使数组中的所有元素都大于或等于 k,请你返回需要的最少操作次数。
示例 1
nums = [2,11,10,1,3], k = 10 -> 3
示例 2
nums = [1,1,2,4,9], k = 1 -> 0
示例 3
nums = [1,1,2,4,9], k = 9 -> 4
提示:
1 <= nums.length <= 501 <= nums[i] <= 10^91 <= k <= 10^9- 输入保证至少有一个满足
nums[i]>=k的下标i存在
解题思路
解法一:直接计数,主提交版本
每次删除最小元素等价于:最终保留的都是 >= k 的元素,删除的都是 < k 的元素,
因此答案就是 nums 中小于 k 的元素个数。一趟遍历计数即可。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:排序后计数(对照)
先排序,然后找到第一个 >= k 的位置,其下标即小于 k 的元素个数。
时间复杂度 O(n log n),空间复杂度 O(1)(原地排序)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
public class Solution {
// ---------- 解法一:直接计数(主提交版本) ----------
public int minOperations(int[] nums, int k) {
int cnt = 0;
for (int v : nums) {
if (v < k) {
cnt++;
}
}
return cnt;
}
// ---------- 解法二:排序后二分(对照) ----------
public int minOperationsBySort(int[] nums, int k) {
int[] a = nums.clone();
Arrays.sort(a);
// 找第一个 >= k 的位置
int lo = 0, hi = a.length;
while (lo < hi) {
int mid = (lo + hi) >>> 1;
if (a[mid] >= k) {
hi = mid;
} else {
lo = mid + 1;
}
}
return lo;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{2, 11, 10, 1, 3},
{1, 1, 2, 4, 9},
{1, 1, 2, 4, 9},
};
int[] ks = {10, 1, 9};
int[] expects = {3, 0, 4};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.minOperations(cases[i], ks[i]);
int b = sol.minOperationsBySort(cases[i], ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
+ " -> " + a + " / sort=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
时间复杂度 O(n log n),空间复杂度 O(1)(原地排序)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
3066. Minimum Operations to Exceed Threshold Value II(超过阈值的最少操作数 II)
题目描述
给你一个下标从 0 开始的整数数组 nums 和一个整数 k。
一次操作中:选择 nums 中最小的两个整数 x 和 y;将 x 和 y 从 nums 中删除;
将 min(x, y) * 2 + max(x, y) 添加到数组中的任意位置。
注意,只有当 nums 至少包含两个元素时,你才可以执行以上操作。
你需要使数组中的所有元素都大于或等于 k,请你返回需要的最少操作次数。
示例 1
nums = [2,11,10,1,3], k = 10 -> 2
示例 2
nums = [1,1,2,4,9], k = 20 -> 4
示例 3
nums = [1,1,2,4,9], k = 1 -> 0(无需操作)
提示:
1 <= nums.length <= 10^51 <= nums[i] <= 10^91 <= k <= 10^9
解题思路
解法一:小根堆模拟,主提交版本
每步必然选择当前最小的两个元素(贪心:小元素只有合并才能变大,且合并结果 min*2+max
单调不降)。用小根堆维护所有元素:
每次弹出堆顶两个最小元素,若堆顶已 >= k 则说明所有元素都 >= k,停止;
否则做一次操作,把 min(x,y)*2 + max(x,y)(注意可能溢出,用 long)压回堆中,ans++。
当堆中只剩一个元素且仍 < k 时返回 -1(或按题意无法达成时返回 -1)。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:小根堆 + 逐个判断(对照,逻辑等价)
同样用堆,但每轮先判断堆内最小元素是否 >= k(若 >= 则全部 >= k),
否则取最小两个合并。两种写法结果一致,用于交叉验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.PriorityQueue;
public class Solution {
// ---------- 解法一:小根堆模拟(主提交版本) ----------
public int minOperations(int[] nums, int k) {
PriorityQueue<Long> pq = new PriorityQueue<>();
for (int v : nums) {
pq.offer((long) v);
}
int ans = 0;
while (pq.size() >= 2 && pq.peek() < k) {
long x = pq.poll();
long y = pq.poll();
pq.offer(Math.min(x, y) * 2 + Math.max(x, y));
ans++;
}
// 若堆顶仍 < k 且堆中不足两个元素,则无法达成
return pq.peek() >= k ? ans : -1;
}
// ---------- 解法二:堆 + 循环合并(对照,逻辑等价) ----------
public int minOperationsAlt(int[] nums, int k) {
PriorityQueue<Long> pq = new PriorityQueue<>();
for (int v : nums) {
pq.offer((long) v);
}
int ans = 0;
while (true) {
if (pq.peek() >= k) {
return ans;
}
if (pq.size() < 2) {
return -1;
}
long x = pq.poll();
long y = pq.poll();
pq.offer(Math.min(x, y) * 2 + Math.max(x, y));
ans++;
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{2, 11, 10, 1, 3},
{1, 1, 2, 4, 9},
{1, 1, 2, 4, 9},
{1, 1, 2, 4, 9},
{1},
};
int[] ks = {10, 20, 1, 9, 100};
int[] expects = {2, 4, 0, 3, -1};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.minOperations(cases[i], ks[i]);
int b = sol.minOperationsAlt(cases[i], ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
+ " -> " + a + " / alt=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3067. Count Pairs of Connectable Servers in a Weighted Tree Network
题目描述
(在带权树网络中统计可连接服务器对数目)
给你一棵无根带权树,树中总共有 n 个节点,分别表示 n 个服务器,服务器从 0 到 n - 1 编号。
同时给你一个数组 edges,其中 edges[i] = `ai`, `bi`, `weighti` 表示节点 ai 和 bi 之间
有一条双向边,边的权值为 weighti。再给你一个整数 signalSpeed。
如果两台服务器 a 和 b 是通过服务器 c 可连接的,则:
a<b,a!=c且b!=c;- 从
c到a的距离是可以被signalSpeed整除的; - 从
c到b的距离是可以被signalSpeed整除的; - 从
c到b的路径与从c到a的路径没有任何公共边。
请你返回一个长度为n的整数数组count,其中count[i]表示通过服务器i可连接的服务器对的数目。
示例 1
edges = [[0,1,1],[1,2,5],[2,3,13],[3,4,9],[4,5,2]], signalSpeed = 1 -> [0,4,6,6,4,0]
示例 2
edges = [[0,6,3],[6,5,3],[0,3,1],[3,2,7],[3,1,6],[3,4,2]], signalSpeed = 3 -> [2,0,0,0,0,0,2]
提示:
2 <= n <= 1000edges.length == n - 10 <= ai, bi < n1 <= weighti <= 10^61 <= signalSpeed <= 10^6
解题思路
解法一:以每个节点为根的 DFS 分支计数,主提交版本
以某个节点 c 为根时,把它的邻居看作独立的"分支"。从 c 出发沿某个分支走,
距离能被 signalSpeed 整除的节点数记为 w(候选端点数)。
"通过 c 可连接"等价于:从两个不同分支中各取一个候选端点组成对。
若各分支候选端点数为 w1, w2, ..., wd,则通过 c 的可连接对数为
sum_{i<j} wi * wj = ((sum wi)^2 - sum wi^2) / 2。
对每个节点 c 做一次 DFS 即可,总复杂度 O(n^2)(n <= 1000 可过)。
时间复杂度 O(n^2),空间复杂度 O(n)。
解法二:BFS 距离 + 全点对枚举(对照)
对每个 c 做一次 BFS 得到 c 到全图距离 dist 与父链 parent;
对任意有序候选端点 a(dista % signalSpeed == 0),记录其第一跳 fa;
再对所有候选端点对 (a, b)(a != b)检查 fa != fb,计数。
与小规模主解结果交叉验证。
时间复杂度 O(n^2),空间复杂度 O(n)。
复杂度:
- 时间复杂度:O(n^2)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
private List<int[]>[] g;
private int signalSpeed;
@SuppressWarnings("unchecked")
private void buildGraph(int[][] edges) {
int n = edges.length + 1;
g = new List[n];
for (int i = 0; i < n; ++i) {
g[i] = new ArrayList<>();
}
for (int[] e : edges) {
g[e[0]].add(new int[]{e[1], e[2]});
g[e[1]].add(new int[]{e[0], e[2]});
}
}
// ---------- 解法一:每个根节点的分支 DFS 计数(主提交版本) ----------
public int[] countPairsOfConnectableServers(int[][] edges, int signalSpeed) {
this.signalSpeed = signalSpeed;
buildGraph(edges);
int n = edges.length + 1;
int[] ans = new int[n];
for (int c = 0; c < n; ++c) {
int total = 0;
int sq = 0;
for (int[] ne : g[c]) {
int w = countBranch(ne[0], c, ne[1]);
total += w;
sq += w * w;
}
ans[c] = (total * total - sq) / 2;
}
return ans;
}
// 从 u 出发(父节点 p,累计距离 dist),统计该分支中距离被 signalSpeed 整除的节点数
private int countBranch(int u, int p, int dist) {
int cnt = (dist % signalSpeed == 0) ? 1 : 0;
for (int[] ne : g[u]) {
if (ne[0] != p) {
cnt += countBranch(ne[0], u, dist + ne[1]);
}
}
return cnt;
}
// ---------- 解法二:BFS 距离 + 点对枚举(对照) ----------
public int[] countPairsBrute(int[][] edges, int signalSpeed) {
int n = edges.length + 1;
buildGraph(edges);
int[] ans = new int[n];
for (int c = 0; c < n; ++c) {
int[] dist = new int[n];
int[] parent = new int[n];
Arrays.fill(dist, -1);
Arrays.fill(parent, -1);
java.util.ArrayDeque<Integer> q = new java.util.ArrayDeque<>();
q.add(c);
dist[c] = 0;
while (!q.isEmpty()) {
int u = q.poll();
for (int[] ne : g[u]) {
if (dist[ne[0]] < 0) {
dist[ne[0]] = dist[u] + ne[1];
parent[ne[0]] = u;
q.add(ne[0]);
}
}
}
// 收集候选端点(距离整除 signalSpeed 且不是 c)
List<Integer> cands = new ArrayList<>();
for (int x = 0; x < n; ++x) {
if (x != c && dist[x] % signalSpeed == 0) {
cands.add(x);
}
}
// 任意两个候选端点,若第一跳不同则构成一对
for (int i = 0; i < cands.size(); ++i) {
int a = cands.get(i);
for (int j = i + 1; j < cands.size(); ++j) {
int b = cands.get(j);
if (firstHop(parent, c, a) != firstHop(parent, c, b)) {
ans[c]++;
}
}
}
}
return ans;
}
// 从 x 沿父链上溯到 c 的下一跳(即第一跳)
private int firstHop(int[] parent, int c, int x) {
while (parent[x] != c) {
x = parent[x];
}
return x;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][][] edgesCases = {
{{0,1,1},{1,2,5},{2,3,13},{3,4,9},{4,5,2}},
{{0,6,3},{6,5,3},{0,3,1},{3,2,7},{3,1,6},{3,4,2}},
};
int[] speeds = {1, 3};
int[][] expects = {
{0,4,6,6,4,0},
{2,0,0,0,0,0,2},
};
boolean allPass = true;
for (int t = 0; t < edgesCases.length; ++t) {
int[] a = sol.countPairsOfConnectableServers(edgesCases[t], speeds[t]);
int[] b = sol.countPairsBrute(edgesCases[t], speeds[t]);
boolean ok = Arrays.equals(a, expects[t]) && Arrays.equals(b, expects[t]);
allPass &= ok;
System.out.println("case" + t + " main=" + Arrays.toString(a)
+ " brute=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(expects[t])
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍:随机树
Random rnd = new Random(3067);
int trials = 300;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 2 + rnd.nextInt(6); // 2..7 个节点
int[][] edges = new int[n - 1][];
for (int i = 1; i < n; ++i) {
int p = rnd.nextInt(i);
int w = 1 + rnd.nextInt(5);
edges[i - 1] = new int[]{p, i, w};
}
int speed = 1 + rnd.nextInt(4);
int[] a = sol.countPairsOfConnectableServers(edges, speed);
int[] b = sol.countPairsBrute(edges, speed);
if (!Arrays.equals(a, b)) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH n=" + n + " speed=" + speed);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n^2),空间复杂度 O(n)。
- 时间复杂度:O(n^2)
- 空间复杂度:O(n)
3068. Find the Maximum Sum of Node Values(最大节点价值之和)
题目描述
给你一棵 n 个节点的无向树,节点从 0 到 n - 1 编号。树以长度为 n - 1 的二维整数数组
edges 的形式给出,其中 edges[i] = `ui`, `vi` 表示节点 ui 和 vi 之间有一条边。
同时给你一个正整数 k 和一个长度为 n 的非负整数数组 nums,其中 nums[i] 表示节点 i 的价值。
Alice 想最大化树中所有节点价值之和。为了实现这一目标,Alice 可以执行以下操作任意次:
- 选择连接节点
u和v的边 `u`, `v`,并将它们的值更新为nums[u]=nums[u]XORk、
nums[v] = nums[v] XOR k
返回Alice可以得到的所有节点价值之和的最大值。
示例 1
nums = [1,2,1], k = 3, edges = [[0,1],[0,2]] -> 6
示例 2
nums = [2,3], k = 7, edges = [[0,1]] -> 9
示例 3
nums = [7,7,7,7,7,7], k = 3, edges = [[0,1],[0,2],[0,3],[0,4],[0,5]] -> 42
提示:
1 <= n == nums.length <= 2 * 10^40 <= nums[i] <= 10^91 <= k <= 10^9
解题思路
解法一:XOR 收益贪心,主提交版本
每次操作选择一条边,两个端点同时 XOR k。由于树连通,通过多次操作可以翻转任意
偶数个节点(把树看作通信网络,一次操作"翻转"两个端点;选定任意偶数个节点的
集合 T,总能用边把它们两两配对操作实现翻转)。反过来,能被翻转的节点个数必为偶数。
对每个节点计算翻转收益 deltai = (numsi XOR k) - numsi。
问题归结为:选任意多个节点翻转,使 Σ delta 最大(翻转节点数必须为偶数)。
贪心:先取所有 delta > 0 的节点;若个数为奇数,则要么舍弃最小的正 delta,
要么补上最大的负 delta(绝对值最小),取两者中收益更优者。
时间复杂度 O(n log n)(排序),空间复杂度 O(n)。
解法二:枚举翻转集合(对照)
对可连通翻转的树,翻转集合为任意偶数子集------用小规模场景枚举所有偶数子集,
计算 Σ (numsi XOR k 若 i 选中, 否则 numsi),取最大,与主解交叉验证。
时间复杂度 O(2^n * n),仅用于小规模验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:XOR 收益贪心(主提交版本) ----------
public long maximumValueSum(int[] nums, int k, int[][] edges) {
int n = nums.length;
long sum = 0;
List<Long> delta = new ArrayList<>();
for (int v : nums) {
sum += v;
delta.add((long) ((v ^ k) - v));
}
java.util.Collections.sort(delta, java.util.Collections.reverseOrder());
long gain = 0;
int cnt = 0; // delta > 0 的个数
// 先累加所有正收益;同时记录最小的正收益与最接近 0 的负收益
long minPos = Long.MAX_VALUE;
long maxNeg = Long.MIN_VALUE;
for (long d : delta) {
if (d > 0) {
gain += d;
cnt++;
minPos = Math.min(minPos, d);
} else if (d < 0) {
maxNeg = Math.max(maxNeg, d);
}
}
if (cnt % 2 == 1) {
// 奇数个正收益:要么去掉最小的正收益,要么补上最大的负收益,取更好
gain -= Math.min(minPos, maxNeg == Long.MIN_VALUE ? Long.MAX_VALUE : -maxNeg);
}
return sum + gain;
}
// ---------- 解法二:枚举偶数子集翻转(对照) ----------
public long maximumValueSumBrute(int[] nums, int k, int[][] edges) {
int n = nums.length;
long best = Long.MIN_VALUE;
for (int mask = 0; mask < (1 << n); ++mask) {
if (Integer.bitCount(mask) % 2 != 0) {
continue; // 只能翻转偶数个节点
}
long s = 0;
for (int i = 0; i < n; ++i) {
s += ((mask >> i) & 1) == 1 ? (nums[i] ^ k) : nums[i];
}
best = Math.max(best, s);
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] numss = {{1, 2, 1}, {2, 3}, {7, 7, 7, 7, 7, 7}, {0}, {1, 2, 3, 4}};
int[] ks = {3, 7, 3, 10, 5};
int[][][] edgesCases = {
{{0, 1}, {0, 2}},
{{0, 1}},
{{0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}},
{},
{{0, 1}, {1, 2}, {2, 3}},
};
long[] expects = {6, 9, 42, 0, 18};
boolean allPass = true;
for (int i = 0; i < numss.length; ++i) {
long a = sol.maximumValueSum(numss[i], ks[i], edgesCases[i]);
long b = sol.maximumValueSumBrute(numss[i], ks[i], edgesCases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(numss[i]) + " k=" + ks[i]
+ " -> " + a + " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍(小规模)
Random rnd = new Random(3068);
int trials = 300;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(6);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = rnd.nextInt(20);
int k = 1 + rnd.nextInt(15);
int[][] edges = new int[n - 1][];
for (int i = 1; i < n; ++i) {
edges[i - 1] = new int[]{rnd.nextInt(i), i};
}
long a = sol.maximumValueSum(nums, k, edges);
long b = sol.maximumValueSumBrute(nums, k, edges);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n)(排序),空间复杂度 O(n)。
时间复杂度 O(2^n * n),仅用于小规模验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3069. Distribute Elements Into Two Arrays I(将元素分配到两个数组中 I)
题目描述
给你一个下标从 1 开始、包含不同整数的数组 nums,数组长度为 n。
你需要通过 n 次操作,将 nums 中的所有元素分配到两个数组 arr1 和 arr2 中。
在第一次操作中,将 nums[1] 追加到 arr1;第二次操作将 nums[2] 追加到 arr2。
之后,在第 i 次操作中:如果 arr1 的最后一个元素大于 arr2 的最后一个元素,
就将 nums[i] 追加到 arr1;否则追加到 arr2。
通过连接数组 arr1 和 arr2 形成数组 result(arr2 追加到 arr1 末尾)。返回 result。
示例 1
nums = [2,1,3] -> [2,3,1]
示例 2
nums = [5,4,3,8] -> [5,3,4,8]
提示:
3 <= n <= 501 <= nums[i] <= 100nums中的所有元素都互不相同
解题思路
解法一:双列表模拟,主提交版本
用两个 ArrayList 分别充当 arr1、arr2,按规则依次追加,最后连接返回。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:数组 + 尾指针模拟(对照)
直接用一个数组 res 存结果,用两个指针维护 arr1、arr2 已填充位置,
规则相同,最后按序拷贝。逻辑等价,用于交叉验证。
时间复杂度 O(n),空间复杂度 O(n)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:双列表模拟(主提交版本) ----------
public int[] resultArray(int[] nums) {
List<Integer> arr1 = new ArrayList<>();
List<Integer> arr2 = new ArrayList<>();
arr1.add(nums[0]);
arr2.add(nums[1]);
for (int i = 2; i < nums.length; ++i) {
if (arr1.get(arr1.size() - 1) > arr2.get(arr2.size() - 1)) {
arr1.add(nums[i]);
} else {
arr2.add(nums[i]);
}
}
int[] res = new int[nums.length];
int idx = 0;
for (int v : arr1) res[idx++] = v;
for (int v : arr2) res[idx++] = v;
return res;
}
// ---------- 解法二:数组 + 尾指针模拟(对照) ----------
public int[] resultArrayByIndex(int[] nums) {
int n = nums.length;
int[] arr1 = new int[n];
int[] arr2 = new int[n];
arr1[0] = nums[0];
arr2[0] = nums[1];
int p1 = 1, p2 = 1;
for (int i = 2; i < n; ++i) {
if (arr1[p1 - 1] > arr2[p2 - 1]) {
arr1[p1++] = nums[i];
} else {
arr2[p2++] = nums[i];
}
}
int[] res = new int[n];
int idx = 0;
for (int i = 0; i < p1; ++i) res[idx++] = arr1[i];
for (int i = 0; i < p2; ++i) res[idx++] = arr2[i];
return res;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{2, 1, 3},
{5, 4, 3, 8},
{1, 2, 3},
{3, 2, 1, 4, 5},
};
int[][] expects = {
{2, 3, 1},
{5, 3, 4, 8},
{1, 2, 3},
{3, 1, 2, 4, 5},
};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int[] a = sol.resultArray(cases[i]);
int[] b = sol.resultArrayByIndex(cases[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " -> " + Arrays.toString(a)
+ " / idx=" + Arrays.toString(b) + " expected="
+ Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3070. Count Submatrices with Top-Left Element and Sum Less Than k
题目描述
(元素和小于等于 k 的子矩阵的数目)
给你一个下标从 0 开始的整数矩阵 grid 和一个整数 k。
返回包含 grid 左上角元素、元素和小于或等于 k 的子矩阵的数目。
示例 1
grid = [[7,6,3],[6,6,1]], k = 18 -> 4
示例 2
grid = [[7,2,9],[1,5,0],[2,6,6]], k = 20 -> 6
提示:
m == grid.length, n == grid[i].length1 <= n, m <= 10000 <= grid[i][j] <= 10001 <= k <= 10^9
解题思路
解法一:二维前缀和 + 双循环计数,主提交版本
包含左上角 (0,0) 的子矩阵由"右下角"唯一确定:子矩阵 (0,0)...(i,j)。
先构建二维前缀和 prei+1j+1 表示 grid0...i0...j 元素和,
然后枚举 i、j,若 prei+1j+1 <= k 则计数 +1。
由于 grid 元素非负,前缀和随 i、j 单调不减,但本题 n、m <= 1000,
直接 O(nm) 枚举即足够(10^6 量级)。
时间复杂度 O(n m),空间复杂度 O(nm)。
解法二:暴力前缀累计(对照)
对每个位置 (i, j) 直接暴力累加 grid0...i0...j 判断是否 <= k。
时间复杂度 O(n m*min(n,m)),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n*m)
- 空间复杂度:O(n*m)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:二维前缀和(主提交版本) ----------
public int countSubmatrices(int[][] grid, int k) {
int m = grid.length;
int n = grid[0].length;
long[][] pre = new long[m + 1][n + 1];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
pre[i + 1][j + 1] = pre[i][j + 1] + pre[i + 1][j] - pre[i][j] + grid[i][j];
}
}
int ans = 0;
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
if (pre[i][j] <= k) {
ans++;
}
}
}
return ans;
}
// ---------- 解法二:暴力累计(对照) ----------
public int countSubmatricesBrute(int[][] grid, int k) {
int m = grid.length;
int n = grid[0].length;
int ans = 0;
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
long s = 0;
for (int x = 0; x <= i; ++x) {
for (int y = 0; y <= j; ++y) {
s += grid[x][y];
}
}
if (s <= k) {
ans++;
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][][] grids = {
{{7, 6, 3}, {6, 6, 1}},
{{7, 2, 9}, {1, 5, 0}, {2, 6, 6}},
{{1}},
{{0, 0}, {0, 0}},
};
int[] ks = {18, 20, 5, 1};
int[] expects = {4, 6, 1, 4};
boolean allPass = true;
for (int i = 0; i < grids.length; ++i) {
int a = sol.countSubmatrices(grids[i], ks[i]);
int b = sol.countSubmatricesBrute(grids[i], ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("grid" + i + " k=" + ks[i] + " -> " + a
+ " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍(小规模)
Random rnd = new Random(3070);
int trials = 300;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int m = 1 + rnd.nextInt(5);
int n = 1 + rnd.nextInt(5);
int[][] grid = new int[m][n];
for (int i = 0; i < m; ++i)
for (int j = 0; j < n; ++j)
grid[i][j] = rnd.nextInt(6);
int k = rnd.nextInt(40);
int a = sol.countSubmatrices(grid, k);
int b = sol.countSubmatricesBrute(grid, k);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH m=" + m + " n=" + n
+ " k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(nm),空间复杂度 O(n m)。
时间复杂度 O(nmmin(n,m)),仅用于小规模交叉验证。
- 时间复杂度:O(n*m)
- 空间复杂度:O(n*m)
3071. Minimum Operations to Write the Letter Y on a Grid
题目描述
(在矩阵上写出字母 Y 所需的最少操作次数)
给你一个下标从 0 开始、大小为 n x n 的矩阵 grid,其中 n 为奇数,且 grid[r][c] 的值为 0、1 或 2。
如果一个单元格属于以下三条线中的任一一条,我们就认为它是字母 Y 的一部分:
- 从左上角单元格开始到矩阵中心单元格结束的对角线;
- 从右上角单元格开始到矩阵中心单元格结束的对角线;
- 从中心单元格开始到矩阵底部边界结束的垂直线。
当且仅当满足以下全部条件时,可以判定矩阵上写有字母Y: - 属于
Y的所有单元格的值相等; - 不属于
Y的所有单元格的值相等; - 属于
Y的单元格的值与不属于Y的单元格的值不同。
每次操作你可以将任意单元格的值改变为 0、1 或 2。返回在矩阵上写出字母Y所需的最少操作次数。
示例 1
grid = [[1,2,2],[1,1,0],[0,1,0]] -> 3
示例 2
grid = [[0,1,0,1,0],[2,1,0,1,2],[2,2,2,0,1],[2,2,2,2,2],[2,1,2,2,2]] -> 12
提示:
3 <= n <= 49n == grid.length == grid[i].length0 <= grid[i][j] <= 2n为奇数
解题思路
解法一:分类统计 + 枚举取值,主提交版本
先确定 Y 区域:设中心 mid = n / 2。
- 左上到中心对角线上:i == j 且 i <= mid;
- 右上到中心对角线上:i + j == n - 1 且 i <= mid;
- 中心到底部垂直线:j == mid 且 i >= mid。
统计 Y 内、Y 外 0/1/2 出现的次数 cy3、co3。
枚举 Y 的目标值 a 与非 Y 的目标值 b(a != b,a、b ∈ {0,1,2}),
改动次数 = (Y 单元格数 - cya) + (非 Y 单元格数 - cob),取最小。
时间复杂度 O(n^2),空间复杂度 O(1)。
解法二:按定义直接逐个判断 + 暴力遍历取值(对照)
用 isY 谓词逐单元格分类,再暴力枚举 (a,b) 全部组合计改动数。
时间复杂度 O(n^2 * 6),逻辑等价,用于交叉验证。
复杂度: - 时间复杂度:O(n^2)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:分类统计 + 枚举取值(主提交版本) ----------
public int minimumOperationsToWriteY(int[][] grid) {
int n = grid.length;
int mid = n / 2;
int[] cy = new int[3];
int[] co = new int[3];
int yCnt = 0, oCnt = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
boolean inY = isY(i, j, n, mid);
if (inY) {
cy[grid[i][j]]++;
yCnt++;
} else {
co[grid[i][j]]++;
oCnt++;
}
}
}
int best = Integer.MAX_VALUE;
for (int a = 0; a < 3; ++a) {
for (int b = 0; b < 3; ++b) {
if (a == b) {
continue;
}
int ops = (yCnt - cy[a]) + (oCnt - co[b]);
best = Math.min(best, ops);
}
}
return best;
}
private boolean isY(int i, int j, int n, int mid) {
if (j == mid && i >= mid) {
return true; // 中心垂直向下线
}
if (i <= mid && (j == i || i + j == n - 1)) {
return true; // 两条对角线(含中心点)
}
return false;
}
// ---------- 解法二:谓词分类 + 暴力枚举(对照) ----------
public int minimumOperationsToWriteYBrute(int[][] grid) {
int n = grid.length;
int mid = n / 2;
int best = Integer.MAX_VALUE;
for (int a = 0; a < 3; ++a) {
for (int b = 0; b < 3; ++b) {
if (a == b) {
continue;
}
int ops = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
boolean inY = isY(i, j, n, mid);
int need = inY ? a : b;
if (grid[i][j] != need) {
ops++;
}
}
}
best = Math.min(best, ops);
}
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][][] grids = {
{{1, 2, 2}, {1, 1, 0}, {0, 1, 0}},
{{0, 1, 0, 1, 0}, {2, 1, 0, 1, 2}, {2, 2, 2, 0, 1}, {2, 2, 2, 2, 2}, {2, 1, 2, 2, 2}},
{{0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
};
int[] expects = {3, 12, 4};
boolean allPass = true;
for (int i = 0; i < grids.length; ++i) {
int a = sol.minimumOperationsToWriteY(grids[i]);
int b = sol.minimumOperationsToWriteYBrute(grids[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case" + i + " -> " + a + " / brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 随机对拍(小规模)
Random rnd = new Random(3071);
int trials = 500;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 3 + 2 * rnd.nextInt(3); // 3,5,7
int[][] grid = new int[n][n];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
grid[i][j] = rnd.nextInt(3);
int a = sol.minimumOperationsToWriteY(grid);
int b = sol.minimumOperationsToWriteYBrute(grid);
if (a != b) {
fail++;
if (fail <= 5) System.out.println("MISMATCH n=" + n + " a=" + a + " b=" + b);
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n^2),空间复杂度 O(1)。
时间复杂度 O(n^2 * 6),逻辑等价,用于交叉验证。
- 时间复杂度:O(n^2)
- 空间复杂度:O(1)
3072. Distribute Elements Into Two Arrays II(将元素分配到两个数组中 II)
题目描述
给你一个下标从 1 开始、长度为 n 的整数数组 nums。
定义函数 greaterCount(arr, val) 返回数组 arr 中严格大于 val 的元素数量。
使用 n 次操作分配:第一次将 nums[1] 追加到 arr1,第二次将 nums[2] 追加到 arr2。
之后第 i 次操作:
- 如果
greaterCount(arr1,nums[i]) >greaterCount(arr2,nums[i]),追加到arr1; - 如果 <,追加到
arr2; - 如果相等,追加到元素数量较少的数组;
- 如果仍相等,追加到
arr1。
连接arr1和arr2形成result(arr2追加到arr1末尾),返回result。
示例 1
nums = [2,1,3,3] -> [2,3,1,3]
示例 2
nums = [5,14,3,1,2] -> [5,3,1,2,14]
示例 3
nums = [3,3,3,3] -> [3,3,3,3]
提示:
3 <= n <= 10^51 <= nums[i] <= 10^9
解题思路
解法一:离散化 + 双树状数组,主提交版本
需要高频执行 greaterCount(arr, val)(查询严格大于 val 的元素个数),
用两个树状数组(Fenwick)分别维护 arr1、arr2 中已出现值的频次:
- 先将所有数离散化到 1...m;
- greaterCount(arr, val) = arr 中元素总数 - 前缀查询(rank(val));
按题意规则分配每个元素,最后拼接两个数组。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:暴力线性统计(对照)
小规模场景:两个 ArrayList 维护,greaterCount 每次线性遍历统计。
时间复杂度 O(n^2),仅用于小规模交叉验证。
复杂度: - 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
static class Fenwick {
private final int[] tree;
private final int n;
Fenwick(int n) {
this.n = n;
this.tree = new int[n + 1];
}
void add(int i, int v) {
for (; i <= n; i += i & (-i)) {
tree[i] += v;
}
}
int sum(int i) {
int s = 0;
for (; i > 0; i -= i & (-i)) {
s += tree[i];
}
return s;
}
}
// ---------- 解法一:离散化 + 双树状数组(主提交版本) ----------
public int[] resultArray(int[] nums) {
int n = nums.length;
// 离散化
int[] sorted = nums.clone();
Arrays.sort(sorted);
Map<Integer, Integer> rank = new HashMap<>();
for (int v : sorted) {
rank.putIfAbsent(v, rank.size() + 1);
}
Fenwick f1 = new Fenwick(n);
Fenwick f2 = new Fenwick(n);
int[] arr1 = new int[n];
int[] arr2 = new int[n];
int p1 = 1, p2 = 1;
arr1[0] = nums[0];
arr2[0] = nums[1];
f1.add(rank.get(nums[0]), 1);
f2.add(rank.get(nums[1]), 1);
for (int i = 2; i < n; ++i) {
int r = rank.get(nums[i]);
// greaterCount = 总数 - 前缀 <= 该值
int gt1 = p1 - f1.sum(r);
int gt2 = p2 - f2.sum(r);
if (gt1 > gt2) {
arr1[p1++] = nums[i];
f1.add(r, 1);
} else if (gt1 < gt2) {
arr2[p2++] = nums[i];
f2.add(r, 1);
} else if (p1 <= p2) {
arr1[p1++] = nums[i];
f1.add(r, 1);
} else {
arr2[p2++] = nums[i];
f2.add(r, 1);
}
}
int[] res = new int[n];
int idx = 0;
for (int i = 0; i < p1; ++i) res[idx++] = arr1[i];
for (int i = 0; i < p2; ++i) res[idx++] = arr2[i];
return res;
}
// ---------- 解法二:暴力线性统计(对照) ----------
public int[] resultArrayBrute(int[] nums) {
int n = nums.length;
java.util.List<Integer> a1 = new java.util.ArrayList<>();
java.util.List<Integer> a2 = new java.util.ArrayList<>();
a1.add(nums[0]);
a2.add(nums[1]);
for (int i = 2; i < n; ++i) {
int v = nums[i];
int gt1 = greaterCount(a1, v);
int gt2 = greaterCount(a2, v);
if (gt1 > gt2) {
a1.add(v);
} else if (gt1 < gt2) {
a2.add(v);
} else if (a1.size() <= a2.size()) {
a1.add(v);
} else {
a2.add(v);
}
}
int[] res = new int[n];
int idx = 0;
for (int v : a1) res[idx++] = v;
for (int v : a2) res[idx++] = v;
return res;
}
private int greaterCount(java.util.List<Integer> arr, int val) {
int cnt = 0;
for (int v : arr) {
if (v > val) cnt++;
}
return cnt;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{2, 1, 3, 3},
{5, 14, 3, 1, 2},
{3, 3, 3, 3},
{1, 2, 3, 4, 5},
{5, 4, 3, 2, 1},
};
int[][] expects = {
{2, 3, 1, 3},
{5, 3, 1, 2, 14},
{3, 3, 3, 3},
{1, 3, 5, 2, 4},
{5, 3, 2, 1, 4},
};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int[] a = sol.resultArray(cases[i]);
int[] b = sol.resultArrayBrute(cases[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " -> " + Arrays.toString(a)
+ " / brute=" + Arrays.toString(b) + " expected="
+ Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3072);
int trials = 2000;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 3 + rnd.nextInt(8);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(30);
int[] a = sol.resultArray(nums);
int[] b = sol.resultArrayBrute(nums);
if (!Arrays.equals(a, b)) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
时间复杂度 O(n^2),仅用于小规模交叉验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3073. Maximum Increasing Triplet Value(最大递增三元组 🔒)
题目描述
给定一个数组 nums,返回满足 i < j < k 且 nums[i] < nums[j] < nums[k] 的三元组 (i, j, k) 的最大值。
三元组 (i, j, k) 的值为 nums[i] - nums[j] + nums[k]。
示例 1
nums = [5,6,9] -> 8
示例 2
nums = [1,5,3,6] -> 4
提示:
3 <= nums.length <= 10^51 <= nums[i] <= 10^9- 输入数据保证至少一个三元组满足给定条件
解题思路
解法一:前后缀最佳值 + 枚举 j,主提交版本
固定中间下标 j,需要 numsi < numsj < numsk,最大化 numsi - numsj + numsk。
对每个 j:
- 前缀中选择满足 numsi < numsj 的最大 numsi(用有序集合/树状数组维护前缀值,
取严格小于 numsj 的最大值); - 后缀中选择满足 numsk > numsj 的最大 numsk(维护后缀最大值,且必须 > numsj)。
两者都非空时更新答案。
前缀"严格小于"可用 TreeSet 维护已遍历值,lower(numsj) 即最优 i 候选;
后缀维护 suffixMaxj+1...n-1 的最大值。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:三重循环(对照)
小规模场景:直接枚举所有 i < j < k 且严格递增的三元组,计算值取最大。
时间复杂度 O(n^3),仅用于小规模交叉验证。
复杂度: - 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
import java.util.TreeSet;
public class Solution {
// ---------- 解法一:前后缀 + 枚举 j(主提交版本) ----------
public long maximumTripletValue(int[] nums) {
int n = nums.length;
// 后缀最大值:suf[i] = max(nums[i..n-1])
long[] suf = new long[n];
suf[n - 1] = nums[n - 1];
for (int i = n - 2; i >= 0; --i) {
suf[i] = Math.max(nums[i], suf[i + 1]);
}
TreeSet<Integer> pre = new TreeSet<>();
pre.add(nums[0]);
long ans = Long.MIN_VALUE;
for (int j = 1; j + 1 < n; ++j) {
// 取严格小于 nums[j] 的最大前缀值
Integer left = pre.lower(nums[j]);
if (left != null && suf[j + 1] > nums[j]) {
// 后缀取 > nums[j] 的最大值 = suf[j+1](若 suf[j+1] > nums[j])
ans = Math.max(ans, (long) left - nums[j] + suf[j + 1]);
}
pre.add(nums[j]);
}
return ans;
}
// ---------- 解法二:三重循环(对照) ----------
public long maximumTripletValueBrute(int[] nums) {
int n = nums.length;
long ans = Long.MIN_VALUE;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (nums[i] >= nums[j]) continue;
for (int k = j + 1; k < n; ++k) {
if (nums[j] < nums[k]) {
ans = Math.max(ans, (long) nums[i] - nums[j] + nums[k]);
}
}
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{5, 6, 9},
{1, 5, 3, 6},
{1, 2, 3, 4},
{4, 3, 2, 1},
{2, 4, 1, 5, 3},
};
long[] expects = {8, 4, 3, Long.MIN_VALUE, 3}; // case3 最大为 2-3+4=3;case5 最大为 2-4+5=3
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
long a = sol.maximumTripletValue(cases[i]);
long b = sol.maximumTripletValueBrute(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " -> " + a
+ " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3073);
int trials = 400;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 3 + rnd.nextInt(7);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(20);
long a = sol.maximumTripletValue(nums);
long b = sol.maximumTripletValueBrute(nums);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
时间复杂度 O(n^3),仅用于小规模交叉验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3074. Apple Redistribution into Boxes(重新分装苹果)
题目描述
给你一个长度为 n 的数组 apple 和另一个长度为 m 的数组 capacity。
一共有 n 个包裹,其中第 i 个包裹中装着 apple[i] 个苹果。同时,还有 m 个箱子,
第 i 个箱子的容量为 capacity[i] 个苹果。
请你选择一些箱子来将这 n 个包裹中的苹果重新分装到箱子中,返回你需要选择的箱子的最小数量。
注意,同一个包裹中的苹果可以分装到不同的箱子中。
示例 1
apple = [1,3,2], capacity = [4,3,1,5,2] -> 2
示例 2
apple = [5,5,5], capacity = [2,4,2,7] -> 4
提示:
1 <= n == apple.length <= 501 <= m == capacity.length <= 501 <= apple[i], capacity[i] <= 50- 输入数据保证可以将包裹中的苹果重新分装到箱子中
解题思路
解法一:贪心选最大容量箱,主提交版本
所有苹果总能拆开分装,因此只需保证所选箱子容量之和 >= 苹果总数。
将 capacity 降序排列,从大到小累加直到 >= sum(apple),累加的箱子数即答案。
时间复杂度 O(m log m),空间复杂度 O(1)。
解法二:暴力枚举箱子组合(对照)
小规模场景:枚举所有非空箱子组合,容量和 >= 苹果总数的最小箱子数。
时间复杂度 O(2^m),仅用于小规模验证。
复杂度:
- 时间复杂度:O(m log m)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
public class Solution {
// ---------- 解法一:贪心选最大容量箱(主提交版本) ----------
public int minimumBoxes(int[] apple, int[] capacity) {
int total = 0;
for (int v : apple) {
total += v;
}
Arrays.sort(capacity);
int sum = 0;
int cnt = 0;
for (int i = capacity.length - 1; i >= 0; --i) {
sum += capacity[i];
cnt++;
if (sum >= total) {
break;
}
}
return cnt;
}
// ---------- 解法二:枚举箱子组合(对照) ----------
public int minimumBoxesBrute(int[] apple, int[] capacity) {
int total = 0;
for (int v : apple) total += v;
int m = capacity.length;
int best = m;
for (int mask = 1; mask < (1 << m); ++mask) {
int s = 0;
int c = Integer.bitCount(mask);
if (c >= best) continue;
for (int i = 0; i < m; ++i) {
if ((mask >> i & 1) == 1) {
s += capacity[i];
}
}
if (s >= total) {
best = c;
}
}
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] apples = {{1, 3, 2}, {5, 5, 5}, {1}, {2, 2, 2, 2}};
int[][] caps = {{4, 3, 1, 5, 2}, {2, 4, 2, 7}, {1}, {3, 3, 3}};
int[] expects = {2, 4, 1, 3};
boolean allPass = true;
for (int i = 0; i < apples.length; ++i) {
int a = sol.minimumBoxes(apples[i], caps[i]);
int b = sol.minimumBoxesBrute(apples[i], caps[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("apple=" + Arrays.toString(apples[i])
+ " -> " + a + " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(m log m),空间复杂度 O(1)。
时间复杂度 O(2^m),仅用于小规模验证。
- 时间复杂度:O(m log m)
- 空间复杂度:O(1)
3075. Maximize Happiness of Selected Children(幸福值最大化的选择方案)
题目描述
给你一个长度为 n 的数组 happiness,以及一个正整数 k。
n 个孩子站成一队,其中第 i 个孩子的幸福值是 happiness[i]。
你计划组织 k 轮筛选从这 n 个孩子中选出 k 个孩子。
在每一轮选择一个孩子时,所有尚未被选中的孩子的幸福值将减少 1。
注意,幸福值不能变成负数,且只有在它是正数的情况下才会减少。
选择 k 个孩子,并使你选中的孩子幸福值之和最大,返回你能得到的最大值。
示例 1
happiness = [1,2,3], k = 2 -> 4
示例 2
happiness = [1,1,1,1], k = 2 -> 1
示例 3
happiness = [2,3,4,5], k = 1 -> 5
提示:
1 <= n == happiness.length <= 2 * 10^51 <= happiness[i] <= 10^81 <= k <= n
解题思路
解法一:降序贪心,主提交版本
最优策略是优先选择幸福值最大的孩子。每多等一轮,尚未被选中的孩子幸福值减 1,
因此第 i 个被选中的孩子(i 从 0 开始)实际贡献为 max(happiness降序i - i, 0)。
将 happiness 降序排列,累加前 k 个的 max(hi - i, 0) 即可。
时间复杂度 O(n log n),空间复杂度 O(1)。
解法二:模拟选择(对照)
小规模场景:每轮枚举当前可选孩子,选"当前幸福值最大"者(模拟减 1 过程),
累加贡献。与主解结果交叉验证。
时间复杂度 O(k * n),仅用于小规模验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:降序贪心(主提交版本) ----------
public long maximumHappinessSum(int[] happiness, int k) {
Integer[] h = new Integer[happiness.length];
for (int i = 0; i < happiness.length; ++i) {
h[i] = happiness[i];
}
Arrays.sort(h, (a, b) -> b - a);
long ans = 0;
for (int i = 0; i < k; ++i) {
ans += Math.max(0, (long) h[i] - i);
}
return ans;
}
// ---------- 解法二:模拟选择(对照) ----------
public long maximumHappinessSumBrute(int[] happiness, int k) {
int n = happiness.length;
boolean[] taken = new boolean[n];
long ans = 0;
for (int round = 0; round < k; ++round) {
// 选当前幸福值最大的未选孩子
int best = -1;
for (int i = 0; i < n; ++i) {
if (!taken[i]) {
int cur = Math.max(0, happiness[i] - round);
if (best < 0 || cur > Math.max(0, happiness[best] - round)) {
best = i;
}
}
}
if (best < 0) break;
ans += Math.max(0, happiness[best] - round);
taken[best] = true;
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cas = {{1, 2, 3}, {1, 1, 1, 1}, {2, 3, 4, 5}, {5, 4, 3, 2, 1}};
int[] ks = {2, 2, 1, 3};
long[] expects = {4, 1, 5, 9};
boolean allPass = true;
for (int i = 0; i < cas.length; ++i) {
long a = sol.maximumHappinessSum(cas[i], ks[i]);
long b = sol.maximumHappinessSumBrute(cas[i], ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cas[i]) + " k=" + ks[i]
+ " -> " + a + " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3075);
int trials = 500;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(7);
int k = 1 + rnd.nextInt(n);
int[] h = new int[n];
for (int i = 0; i < n; ++i) h[i] = 1 + rnd.nextInt(10);
long a = sol.maximumHappinessSum(h, k);
long b = sol.maximumHappinessSumBrute(h, k);
if (a != b) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH h=" + Arrays.toString(h)
+ " k=" + k + " a=" + a + " b=" + b);
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(1)。
时间复杂度 O(k * n),仅用于小规模验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(1)
3076. Shortest Uncommon Substring in an Array(数组中的最短非公共子字符串)
题目描述
给你一个数组 arr,数组中有 n 个非空字符串。
求出一个长度为 n 的字符串数组 answer,满足:
answer[i]是arr[i]最短的子字符串,且它不是arr中其他任何字符串的子字符串。- 如果有多个这样的子字符串存在,
answer[i]应该是它们中字典序最小的一个。 - 如果不存在这样的子字符串,
answer[i]为空字符串。
示例 1
arr = ["cab","ad","bad","c"] -> ["ab","","ba",""]
示例 2
arr = ["abc","bcd","abcd"] -> ["","","abcd"]
提示:
n == arr.length, 2 <= n <= 1001 <= arr[i].length <= 20arr[i]只包含小写英文字母
解题思路
解法一:集合排除 + 枚举子串,主提交版本
对每个字符串 s = arri:
- 收集除 s 外所有字符串的全部子串到集合 other(长度 ≤ 20,每个字符串至多 210 个子串,
总量 n * 210 可控); - 枚举 s 的所有子串 t:若 t 不在 other 中,记录 (长度, 字典序) 最优者。
时间复杂度 O(n * L^3)(L ≤ 20),空间复杂度 O(n * L^2)。
解法二:逐个 isSubstring 判断(对照)
对每个子串 t 与每个其他字符串做 contains 判断,逻辑更直观:
枚举 s 的全部子串按 (长度, 字典序) 排序,逐个检查是否为其他串的子串,
第一个不被包含的即答案。两法结果一致。
时间复杂度 O(n^2 * L^4),仅用于小规模交叉验证。
复杂度:
- 时间复杂度:O(n * L^3)
- 空间复杂度:O(n * L^2)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
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 {
// ---------- 解法一:集合排除 + 枚举子串(主提交版本) ----------
public String[] shortestSubstrings(String[] arr) {
int n = arr.length;
// 每个串的全部子串集合
List<Set<String>> allSubs = new ArrayList<>();
for (String s : arr) {
allSubs.add(allSubstrings(s));
}
String[] ans = new String[n];
for (int i = 0; i < n; ++i) {
// 其他字符串的子串集合
Set<String> other = new HashSet<>();
for (int j = 0; j < n; ++j) {
if (j != i) {
other.addAll(allSubs.get(j));
}
}
String best = null;
// 枚举 arr[i] 的子串,按长度短到长、字典序优先
for (int len = 1; len <= arr[i].length(); ++len) {
for (int st = 0; st + len <= arr[i].length(); ++st) {
String t = arr[i].substring(st, st + len);
if (!other.contains(t)) {
if (best == null || t.compareTo(best) < 0) {
best = t;
}
}
}
if (best != null) {
break; // 已找到该长度下最优,更短的已无解,更长的不如它
}
}
ans[i] = best == null ? "" : best;
}
return ans;
}
private Set<String> allSubstrings(String s) {
Set<String> set = new HashSet<>();
for (int i = 0; i < s.length(); ++i) {
for (int j = i + 1; j <= s.length(); ++j) {
set.add(s.substring(i, j));
}
}
return set;
}
// ---------- 解法二:逐子串 contains 检查(对照) ----------
public String[] shortestSubstringsBrute(String[] arr) {
int n = arr.length;
String[] ans = new String[n];
for (int i = 0; i < n; ++i) {
String s = arr[i];
String best = null;
for (int len = 1; len <= s.length(); ++len) {
List<String> cands = new ArrayList<>();
for (int st = 0; st + len <= s.length(); ++st) {
String t = s.substring(st, st + len);
boolean inOther = false;
for (int j = 0; j < n; ++j) {
if (j != i && arr[j].contains(t)) {
inOther = true;
break;
}
}
if (!inOther) {
cands.add(t);
}
}
if (!cands.isEmpty()) {
java.util.Collections.sort(cands);
best = cands.get(0);
break;
}
}
ans[i] = best == null ? "" : best;
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[][] cases = {
{"cab", "ad", "bad", "c"},
{"abc", "bcd", "abcd"},
{"abc", "def", "ghi"},
{"a", "aa", "aaa"},
};
String[][] expects = {
{"ab", "", "ba", ""},
{"", "", "abcd"},
{"a", "d", "g"},
{"", "", "aaa"},
};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
String[] a = sol.shortestSubstrings(cases[i]);
String[] b = sol.shortestSubstringsBrute(cases[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " -> " + Arrays.toString(a)
+ " / brute=" + Arrays.toString(b) + " expected="
+ Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3076);
int trials = 300;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 2 + rnd.nextInt(4);
String[] arr = new String[n];
for (int i = 0; i < n; ++i) {
int len = 1 + rnd.nextInt(5);
StringBuilder sb = new StringBuilder();
for (int j = 0; j < len; ++j) {
sb.append((char) ('a' + rnd.nextInt(4)));
}
arr[i] = sb.toString();
}
String[] a = sol.shortestSubstrings(arr);
String[] b = sol.shortestSubstringsBrute(arr);
if (!Arrays.equals(a, b)) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH arr=" + Arrays.toString(arr)
+ " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n * L^3)(L ≤ 20),空间复杂度 O(n * L^2)。
时间复杂度 O(n^2 * L^4),仅用于小规模交叉验证。
- 时间复杂度:O(n * L^3)
- 空间复杂度:O(n * L^2)
3077. Maximum Strength of K Disjoint Subarrays(K 个不相交子数组的最大能量值)
题目描述
给你一个长度为 n 下标从 0 开始的整数数组 nums 和一个正奇数整数 k。
x 个子数组的能量值定义为
strength = sum[1]*x - sum[2]*(x-1) + sum[3]*(x-2) - ... + sum[x]*1,
其中 sum[i] 是第 i 个子数组的和。更正式地,
strength = Σ_{i=1..x} (-1)^(i+1) * sum[i] * (x - i + 1)
你需要在 nums 中选择 k 个不相交子数组,使得能量值最大,返回最大能量值。
注意,选出来的所有子数组不需要覆盖整个数组。
示例 1
nums = [1,2,3,-1,2], k = 3 -> 22
示例 2
nums = [12,-2,-2,-2,-2], k = 5 -> 64
示例 3
nums = [-1,-2,-3], k = 1 -> -1
提示:
1 <= n <= 10^4-10^9 <= nums[i] <= 10^91 <= k <= n1 <= n * k <= 10^6k是奇数
解题思路
解法一:双状态滚动 DP,主提交版本
把第 j 段子数组的系数 (-1)^(j+1) * (k - j + 1) 分摊到它覆盖的每个元素上,
问题转化为:选 k 段互不重叠的子数组,每段内元素乘该段系数后求和最大。
设 dpj0 表示处理到当前位置、共安排了 j 段、且当前元素不在段内
(j 段全部闭合)的最大值;dpj1 表示第 j 段"打开"(包含当前位置)的最大值。
处理每个元素 v(它在第 j 段的贡献为 signwv,其中 w = k-j+1):
- 延续:dpj1' = max(dpj1) + c;
- 新开:dpj1' = max(dpj-10 + c);
- 闭合/跳过:dpj0' = max(dpj0, dpj1)。
答案 = max(dpk0, dpk1)。
时间复杂度 O(nk),空间复杂度 O(k)。
解法二:记忆化搜索(对照)
f(idx, j, in):从 idx 开始还需选 j 段;in=0 表示 idx 前不在段内、in=1 在段内。
枚举:新开段(含 idx 并延伸/只含 idx)/ 延续段 / 跳过不在段内。
段号 seg = k - j + 1 决定系数,与 DP 完全一致的收益定义,用于交叉验证。
时间复杂度 O(n k),空间复杂度 O(n*k)。
复杂度: - 时间复杂度:O(n*k)
- 空间复杂度:O(k)
代码实现
java
import java.util.Arrays;
public class Solution {
// ---------- 解法一:双状态滚动 DP(主提交版本) ----------
public long maximumStrength(int[] nums, int k) {
int n = nums.length;
long NEG = Long.MIN_VALUE / 4;
long[][] dp = new long[k + 1][2];
for (long[] row : dp) {
Arrays.fill(row, NEG);
}
dp[0][0] = 0;
for (int i = 0; i < n; ++i) {
long v = nums[i];
long[][] ndp = new long[k + 1][2];
for (long[] row : ndp) {
Arrays.fill(row, NEG);
}
// 先计算"到 i-1 为止第 j 段已闭合"的最优值(含刚在 i-1 闭合的)
long[] close = new long[k + 1];
for (int j = 0; j <= k; ++j) {
close[j] = Math.max(dp[j][0], dp[j][1]);
}
for (int j = 1; j <= k; ++j) {
long w = k - j + 1;
long sign = ((j - 1) % 2 == 0) ? 1 : -1; // (-1)^(j+1)
long c = sign * w * v;
// 保持闭合(第 j 段此前已闭合,跳过 v)
ndp[j][0] = Math.max(ndp[j][0], close[j]);
// 延续第 j 段
if (dp[j][1] != NEG) {
ndp[j][1] = Math.max(ndp[j][1], dp[j][1] + c);
}
// 以 v 新开第 j 段(j-1 段已闭合,含刚在 i-1 闭合的)
if (close[j - 1] != NEG) {
ndp[j][1] = Math.max(ndp[j][1], close[j - 1] + c);
}
}
dp = ndp;
}
return Math.max(dp[k][0], dp[k][1]);
}
// ---------- 解法二:记忆化搜索(对照) ----------
private long[][][] memo;
private int[] arr;
private int kk;
public long maximumStrengthBrute(int[] nums, int k) {
this.arr = nums;
this.kk = k;
int n = nums.length;
memo = new long[n + 1][k + 1][2];
for (long[][] a : memo) {
for (long[] b : a) {
Arrays.fill(b, Long.MIN_VALUE / 4);
}
}
return dfs(0, k, 0);
}
// idx 当前下标;j 还需选几段;in=1 表示当前处于某段之中(该段已包含前面的元素)
private long dfs(int idx, int j, int in) {
if (j == 0) {
return 0;
}
if (idx >= arr.length) {
return Long.MIN_VALUE / 4; // 段数不够
}
if (memo[idx][j][in] != Long.MIN_VALUE / 4) {
return memo[idx][j][in];
}
int seg = kk - j + 1; // 当前(或将要开的)段的序号
long w = kk - seg + 1;
long sign = ((seg - 1) % 2 == 0) ? 1 : -1;
long c = sign * w * arr[idx];
long best = Long.MIN_VALUE / 4;
if (in == 0) {
// 跳过 idx(不开段)
long skip = dfs(idx + 1, j, 0);
best = Math.max(best, skip);
// 以 idx 新开一段
long cont = dfs(idx + 1, j, 1);
if (cont != Long.MIN_VALUE / 4) {
best = Math.max(best, cont + c); // 段延伸
}
long close = dfs(idx + 1, j - 1, 0);
if (close != Long.MIN_VALUE / 4) {
best = Math.max(best, c + close); // 段只含 idx
}
} else {
// 延伸当前段
long cont = dfs(idx + 1, j, 1);
if (cont != Long.MIN_VALUE / 4) {
best = Math.max(best, cont + c);
}
// 在 idx 处结束当前段
long close = dfs(idx + 1, j - 1, 0);
if (close != Long.MIN_VALUE / 4) {
best = Math.max(best, c + close);
}
}
memo[idx][j][in] = best;
return best;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1, 2, 3, -1, 2},
{12, -2, -2, -2, -2},
{-1, -2, -3},
{1, -1, 1, -1},
{5, 5, 5, 5},
{-3, -2, -1},
};
int[] ks = {3, 5, 1, 2, 3, 2};
long[] expects = {22, 64, -1, 3, 25, -3}; // 均经 Python 枚举段组合验证
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
long a = sol.maximumStrength(cases[i], ks[i]);
long b = sol.maximumStrengthBrute(cases[i], ks[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
+ " -> " + a + " / brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(nk),空间复杂度 O(k)。
时间复杂度 O(nk),空间复杂度 O(n*k)。
- 时间复杂度:O(n*k)
- 空间复杂度:O(k)
3078. Match Alphanumerical Pattern in Matrix I(矩阵中的字母数字模式匹配 I 🔒)
题目描述
给定一个二维整数矩阵 board 和一个二维字符矩阵 pattern。
其中 0 <= board[r][c] <= 9 并且 pattern 的每个元素是一个数字或一个小写英文字母。
你的任务是找到匹配 board 的子矩阵 pattern。
如果我们能用一些数字(每个不同的字母对应不同的数字)替换 pattern 中包含的字母,
使得结果矩阵与整数矩阵 part 相同,则称整数矩阵 part 与 pattern 匹配:
- 这两个矩阵具有相同的维数;
- 如果
pattern[r][c]是一个数字,那么part[r][c]必须是相同的数字; - 如果
pattern[r][c]是一个字母x: - 对于每个
pattern[i][j]==x,part[i][j]一定与part[r][c]相同; - 对于每个
pattern[i][j]!=x,part[i][j]一定与part[r][c]不同。
返回一个长度为 2 的数组,包含匹配pattern的board的子矩阵左上角的行号和列号。
如果有多个这样的子矩阵,返回行号更小的子矩阵;若仍有多个,返回列号更小的。
如果没有符合的答案,返回 -1, -1。
示例 1
board = [[1,2,2],[2,2,3],[2,3,3]], pattern = ["ab","bb"] -> [0,0]
示例 2
board = [[1,1,2],[3,3,4],[6,6,6]], pattern = ["ab","66"] -> [1,1]
示例 3
board = [[1,2],[2,1]], pattern = ["xx"] -> [-1,-1]
提示:
1 <= board.length, board[i].length <= 500 <= board[i][j] <= 91 <= pattern.length, pattern[i].length <= 50pattern[i][j]表示为数字的字符串或一个小写英文字母
解题思路
解法一:滑动窗口 + 映射一致性检查,主提交版本
对 board 的每个左上角 (r, c)(满足 r + ph <= bh、c + pw <= bw),
尝试把 pattern 放上去:
- 维护 letterMap'a'...'z' -> 数字(-1 表示未映射),used0...9 表示数字已被占用;
- 扫描 pattern 每个位置:
- 若为数字 '0'...'9',要求 boardr+ic+j == 该数字;
- 若为字母 ch:若 ch 已映射,则要求 board 值等于映射值;否则为 ch 分配
board 值(要求该数字未被其他字母占用)。
全部通过即匹配,按行优先顺序返回第一个。
时间复杂度 O(B * P)(B 为 board 位置数,P 为 pattern 大小),空间复杂度 O(26)。
解法二:独立映射 + 双重校验(对照)
对每个位置同样枚举,但额外校验"同一数字不能赋给两个不同字母"------与主解等价,
用不同的实现结构交叉验证。
复杂度: - 时间复杂度:O(h * w * ph * pw)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:滑动窗口 + 映射一致性检查(主提交版本) ----------
public int[] findPattern(int[][] board, String[] pattern) {
int bh = board.length, bw = board[0].length;
int ph = pattern.length, pw = pattern[0].length();
for (int r = 0; r + ph <= bh; ++r) {
for (int c = 0; c + pw <= bw; ++c) {
if (match(board, pattern, r, c)) {
return new int[]{r, c};
}
}
}
return new int[]{-1, -1};
}
private boolean match(int[][] board, String[] pattern, int r, int c) {
int ph = pattern.length, pw = pattern[0].length();
int[] letterMap = new int[26];
Arrays.fill(letterMap, -1);
boolean[] used = new boolean[10];
for (int i = 0; i < ph; ++i) {
for (int j = 0; j < pw; ++j) {
char ch = pattern[i].charAt(j);
int val = board[r + i][c + j];
if (ch >= '0' && ch <= '9') {
if (val != ch - '0') {
return false;
}
} else {
int idx = ch - 'a';
if (letterMap[idx] == -1) {
if (used[val]) {
return false; // 该数字已被其他字母占用
}
letterMap[idx] = val;
used[val] = true;
} else if (letterMap[idx] != val) {
return false;
}
}
}
}
return true;
}
// ---------- 解法二:独立实现(对照) ----------
public int[] findPatternBrute(int[][] board, String[] pattern) {
int bh = board.length, bw = board[0].length;
int ph = pattern.length, pw = pattern[0].length();
for (int r = 0; r + ph <= bh; ++r) {
for (int c = 0; c + pw <= bw; ++c) {
Map<Character, Integer> mp = new HashMap<>();
Map<Integer, Character> rev = new HashMap<>();
boolean ok = true;
for (int i = 0; i < ph && ok; ++i) {
for (int j = 0; j < pw && ok; ++j) {
char ch = pattern[i].charAt(j);
int val = board[r + i][c + j];
if (ch >= '0' && ch <= '9') {
if (val != ch - '0') {
ok = false;
}
} else if (mp.containsKey(ch)) {
if (mp.get(ch) != val) {
ok = false;
}
} else if (rev.containsKey(val)) {
ok = false; // 数字已被其他字母占用
} else {
mp.put(ch, val);
rev.put(val, ch);
}
}
}
if (ok) {
return new int[]{r, c};
}
}
}
return new int[]{-1, -1};
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][][] boards = {
{{1, 2, 2}, {2, 2, 3}, {2, 3, 3}},
{{1, 1, 2}, {3, 3, 4}, {6, 6, 6}},
{{1, 2}, {2, 1}},
};
String[][] pats = {
{"ab", "bb"},
{"ab", "66"},
{"xx"},
};
int[][] expects = {{0, 0}, {1, 1}, {-1, -1}};
boolean allPass = true;
for (int i = 0; i < boards.length; ++i) {
int[] a = sol.findPattern(boards[i], pats[i]);
int[] b = sol.findPatternBrute(boards[i], pats[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("case" + i + " -> " + Arrays.toString(a)
+ " / brute=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(expects[i])
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3078);
int trials = 300;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int bh = 2 + rnd.nextInt(4);
int bw = 2 + rnd.nextInt(4);
int[][] board = new int[bh][bw];
for (int i = 0; i < bh; ++i)
for (int j = 0; j < bw; ++j)
board[i][j] = rnd.nextInt(4);
int ph = 1 + rnd.nextInt(2);
int pw = 1 + rnd.nextInt(2);
String[] pat = new String[ph];
for (int i = 0; i < ph; ++i) {
StringBuilder sb = new StringBuilder();
for (int j = 0; j < pw; ++j) {
int kind = rnd.nextInt(2);
if (kind == 0) {
sb.append((char) ('0' + rnd.nextInt(3)));
} else {
sb.append((char) ('a' + rnd.nextInt(3)));
}
}
pat[i] = sb.toString();
}
int[] a = sol.findPattern(board, pat);
int[] b = sol.findPatternBrute(board, pat);
if (!Arrays.equals(a, b)) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH board=" + Arrays.deepToString(board)
+ " pat=" + Arrays.toString(pat)
+ " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(B * P)(B 为 board 位置数,P 为 pattern 大小),空间复杂度 O(26)。
- 时间复杂度:O(h * w * ph * pw)
- 空间复杂度:O(1)
3079. Find the Sum of Encrypted Integers(求出加密整数的和)
题目描述
给你一个整数数组 nums,数组中的元素都是正整数。定义一个加密函数 encrypt,
encrypt(x) 将一个整数 x 中每一个数位都用 x 中的最大数位替换。
比方说 encrypt(523) = 555 且 encrypt(213) = 333。
请你返回数组中所有元素加密后的和。
示例 1
nums = [1,2,3] -> 6(encrypt 后 [1,2,3])
示例 2
nums = [10,21,31] -> 66(encrypt 后 [11,22,33])
提示:
1 <= nums.length <= 501 <= nums[i] <= 1000
解题思路
解法一:逐数求最大数位后按位扩展,主提交版本
对每个 x 求出最大数位 mx 与位数 d,加密结果为 d 位全为 mx 的数:
encrypt(x) = mx * (111...1 共 d 位)。累加所有加密值。
时间复杂度 O(n * log x),空间复杂度 O(1)。
解法二:字符串替换(对照)
把 x 转字符串,统计最大数位字符,然后把它用该字符重复 d 次转回整数。
逻辑等价,用于交叉验证。
复杂度:
- 时间复杂度:O(n * log x)
- 空间复杂度:O(1)
代码实现
java
import java.util.Arrays;
public class Solution {
// ---------- 解法一:数位处理(主提交版本) ----------
public int sumOfEncryptedInt(int[] nums) {
int ans = 0;
for (int v : nums) {
ans += encrypt(v);
}
return ans;
}
private int encrypt(int x) {
int mx = 0;
int tmp = x;
int d = 0;
while (tmp > 0) {
mx = Math.max(mx, tmp % 10);
tmp /= 10;
d++;
}
int res = 0;
for (int i = 0; i < d; ++i) {
res = res * 10 + mx;
}
return res;
}
// ---------- 解法二:字符串替换(对照) ----------
public int sumOfEncryptedIntByStr(int[] nums) {
int ans = 0;
for (int v : nums) {
String s = Integer.toString(v);
char mx = '0';
for (char c : s.toCharArray()) {
if (c > mx) mx = c;
}
StringBuilder sb = new StringBuilder();
for (int i = 0; i < s.length(); ++i) {
sb.append(mx);
}
ans += Integer.parseInt(sb.toString());
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1, 2, 3},
{10, 21, 31},
{523, 213},
{1000},
{9, 99, 999},
};
int[] expects = {6, 66, 888, 1111, 9 + 99 + 999};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.sumOfEncryptedInt(cases[i]);
int b = sol.sumOfEncryptedIntByStr(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println(Arrays.toString(cases[i]) + " -> " + a
+ " / str=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
}
}
复杂度分析
时间复杂度 O(n * log x),空间复杂度 O(1)。
- 时间复杂度:O(n * log x)
- 空间复杂度:O(1)
3080. Mark Elements on Array by Performing Queries(执行操作标记数组中的元素)
题目描述
给你一个长度为 n 下标从 0 开始的正整数数组 nums。
同时给你一个长度为 m 的二维操作数组 queries,其中 queries[i] = `indexi`, `ki`。
一开始,数组中的所有元素都未标记。
你需要依次对数组执行 m 次操作,第 i 次操作中,你需要执行:
- 如果下标
indexi对应的元素还没标记,那么标记这个元素; - 然后标记
ki个数组中还没有标记的最小元素。如果有元素的值相等,那么优先标记
它们中下标较小的。如果少于ki个未标记元素存在,那么将它们全部标记。
返回一个长度为m的数组answer,其中answer[i]是第i次操作后数组中还没标记元素的和。
示例 1
nums = [1,2,2,1,2,3,1], queries = [[1,2],[3,3],[4,2]] -> [8,3,0]
示例 2
nums = [1,4,2,3], queries = [[0,1]] -> [7]
提示:
n == nums.length, m == queries.length1 <= m <= n <= 10^51 <= nums[i] <= 10^5queries[i].length == 20 <= indexi, ki <= n - 1
解题思路
解法一:标记数组 + 小根堆,主提交版本
- 维护 long total 为当前未标记元素和;
- 把所有元素按 (值, 下标) 放入小根堆;
- 每次操作:先尝试标记 indexi;再从堆顶不断弹出已标记元素丢弃,
取出 ki 个未标记的最小元素标记并扣减 total。
每个元素最多入堆一次、出堆一次,总复杂度 O((n + m) log n)。
时间复杂度 O((n + m) log n),空间复杂度 O(n)。
解法二:暴力线性扫描(对照)
小规模场景:每次操作线性找最小未标记元素。时间复杂度 O(m * n),
仅用于小规模交叉验证。
复杂度: - 时间复杂度:O((n + m) log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Random;
public class Solution {
// ---------- 解法一:标记数组 + 小根堆(主提交版本) ----------
public long[] unmarkedSumArray(int[] nums, int[][] queries) {
int n = nums.length;
int m = queries.length;
boolean[] marked = new boolean[n];
long total = 0;
// 堆元素:[值, 下标]
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) ->
a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
for (int i = 0; i < n; ++i) {
total += nums[i];
pq.offer(new int[]{nums[i], i});
}
long[] ans = new long[m];
for (int q = 0; q < m; ++q) {
int idx = queries[q][0];
int k = queries[q][1];
if (!marked[idx]) {
marked[idx] = true;
total -= nums[idx];
}
while (k > 0 && !pq.isEmpty()) {
int[] top = pq.poll();
if (marked[top[1]]) {
continue;
}
marked[top[1]] = true;
total -= top[0];
k--;
}
ans[q] = total;
}
return ans;
}
// ---------- 解法二:暴力线性扫描(对照) ----------
public long[] unmarkedSumArrayBrute(int[] nums, int[][] queries) {
int n = nums.length;
int m = queries.length;
boolean[] marked = new boolean[n];
long total = 0;
for (int v : nums) total += v;
long[] ans = new long[m];
for (int q = 0; q < m; ++q) {
int idx = queries[q][0];
int k = queries[q][1];
if (!marked[idx]) {
marked[idx] = true;
total -= nums[idx];
}
while (k > 0) {
int best = -1;
for (int i = 0; i < n; ++i) {
if (!marked[i]) {
if (best < 0 || nums[i] < nums[best]
|| (nums[i] == nums[best] && i < best)) {
best = i;
}
}
}
if (best < 0) break;
marked[best] = true;
total -= nums[best];
k--;
}
ans[q] = total;
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1, 2, 2, 1, 2, 3, 1},
{1, 4, 2, 3},
{5, 5, 5},
};
int[][][] qs = {
{{1, 2}, {3, 3}, {4, 2}},
{{0, 1}},
{{0, 1}, {1, 2}},
};
long[][] expects = {
{8, 3, 0},
{7},
{5, 0},
};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
long[] a = sol.unmarkedSumArray(cases[i], qs[i]);
long[] b = sol.unmarkedSumArrayBrute(cases[i], qs[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("case" + i + " -> " + Arrays.toString(a)
+ " / brute=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(expects[i])
+ (ok ? " PASS" : " FAIL"));
}
// 随机对拍
Random rnd = new Random(3080);
int trials = 300;
int fail = 0;
for (int t = 0; t < trials; ++t) {
int n = 1 + rnd.nextInt(8);
int m = 1 + rnd.nextInt(6);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(10);
int[][] q = new int[m][2];
for (int i = 0; i < m; ++i) {
q[i][0] = rnd.nextInt(n);
q[i][1] = rnd.nextInt(n);
}
long[] a = sol.unmarkedSumArray(nums, q);
long[] b = sol.unmarkedSumArrayBrute(nums, q);
if (!Arrays.equals(a, b)) {
fail++;
if (fail <= 5) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums)
+ " q=" + Arrays.deepToString(q)
+ " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random trials=" + trials + " fail=" + fail
+ (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O((n + m) log n),空间复杂度 O(n)。
小规模场景:每次操作线性找最小未标记元素。时间复杂度 O(m * n),
- 时间复杂度:O((n + m) log n)
- 空间复杂度:O(n)