LeetCode 3261-3280. 题解合集
文章目录
- [LeetCode 3261-3280. 题解合集](#LeetCode 3261-3280. 题解合集)
-
- [3261. Count Substrings That Satisfy K-Constraint II(统计满足 K 约束的子字符串数量 II)](#3261. Count Substrings That Satisfy K-Constraint II(统计满足 K 约束的子字符串数量 II))
- [3262. Find Overlapping Shifts(查找重叠的班次)](#3262. Find Overlapping Shifts(查找重叠的班次))
- [3263. Convert Doubly Linked List to Array I(将双链表转换为数组 I 🔒)](#3263. Convert Doubly Linked List to Array I(将双链表转换为数组 I 🔒))
- [3264. Final Array State After K Multiplication Operations I(K 次乘运算后的最终数组 I)](#3264. Final Array State After K Multiplication Operations I(K 次乘运算后的最终数组 I))
- [3265. Count Almost Equal Pairs I(统计近似相等数对 I)](#3265. Count Almost Equal Pairs I(统计近似相等数对 I))
- [3266. Final Array State After K Multiplication Operations II(K 次乘运算后的最终数组 II)](#3266. Final Array State After K Multiplication Operations II(K 次乘运算后的最终数组 II))
- [3267. Count Almost Equal Pairs II(统计近似相等数对 II)](#3267. Count Almost Equal Pairs II(统计近似相等数对 II))
- [3268. Find Overlapping Shifts II(查找重叠的班次 II)](#3268. Find Overlapping Shifts II(查找重叠的班次 II))
- [3269. Constructing Two Increasing Arrays(构建两个递增数组)](#3269. Constructing Two Increasing Arrays(构建两个递增数组))
- [3270. Find the Key of the Numbers(求出数字答案)](#3270. Find the Key of the Numbers(求出数字答案))
- [3271. Hash Divided String(哈希分割字符串)](#3271. Hash Divided String(哈希分割字符串))
- [3272. Find the Count of Good Integers(统计好整数的数目)](#3272. Find the Count of Good Integers(统计好整数的数目))
- [3273. Minimum Amount of Damage Dealt to Bob(对 Bob 造成的最少伤害)](#3273. Minimum Amount of Damage Dealt to Bob(对 Bob 造成的最少伤害))
- [3274. Check if Two Chessboard Squares Have the Same Color(检查棋盘方格颜色是否相同)](#3274. Check if Two Chessboard Squares Have the Same Color(检查棋盘方格颜色是否相同))
- [3275. K-th Nearest Obstacle Queries(第 K 近障碍物查询)](#3275. K-th Nearest Obstacle Queries(第 K 近障碍物查询))
- [3276. Select Cells in Grid With Maximum Score(选择矩阵中单元格的最大得分)](#3276. Select Cells in Grid With Maximum Score(选择矩阵中单元格的最大得分))
- [3277. Maximum XOR Score Subarray Queries(查询子数组最大异或分数)](#3277. Maximum XOR Score Subarray Queries(查询子数组最大异或分数))
- [3278. Find Candidates for Data Scientist Position II(寻找数据科学家职位的候选人 II)](#3278. Find Candidates for Data Scientist Position II(寻找数据科学家职位的候选人 II))
- [3279. Maximum Total Area Occupied by Pistons(活塞占据的最大总区域)](#3279. Maximum Total Area Occupied by Pistons(活塞占据的最大总区域))
- [3280. Convert Date to Binary(将日期转换为二进制表示)](#3280. Convert Date to Binary(将日期转换为二进制表示))
3261. Count Substrings That Satisfy K-Constraint II(统计满足 K 约束的子字符串数量 II)
题目描述
给你一个二进制字符串 s 和一个整数 k。如果一个二进制字符串满足以下任一条件(0 的数量最多为 k,
或 1 的数量最多为 k),则认为该字符串满足 k 约束。
另给你一个二维整数数组 queries,其中 queries[i] = `li`, `ri`。
返回一个整数数组 answer,其中 answer[i] 表示 s`li`...`ri` 中满足 k 约束的子字符串的数量。
示例 1
s = "0001111", k = 2, queries = [[0,6]] -> [26]
示例 2
s = "010101", k = 1, queries = [[0,5],[1,4],[2,3]] -> [15,9,3]
提示:
1 <= s.length <= 10^51 <= k <= s.length1 <= queries.length <= 10^5
解题思路
解法一:单调划界 + 前缀和 + 二分,主提交版本
对每个左端点 l,定义 dl = 满足 k 约束的最长子串的右端点 + 1(即从 l 出发能到的最远位置)。
用双指针滑动窗口求出 dl:窗口内 cnt0 > k && cnt1 > k 不满足约束,右指针 r 扩展时收缩左指针 l,
记录右端点恰好是 r 处最早可收缩的 l。
定义 prei = Σ (dj - j),j < i,表示区间 0, i-1 中所有"以某个左端点为起点到 dj 前为止"的
满足约束的子串总数。
对查询 l, r:设 p = min(r + 1, dl),l, p-1 内所有左端点的最远右端都 >= p-1 >= 自己的 l,
这些左端点贡献的子串数 = (p - l)(p - l + 1) / 2;剩余左端点 p, r 每个贡献 dj - j 个,
用前缀和求和 prer+1 - prep。
时间复杂度 O(n + q log n)(求 p 用二分或直接 min),空间复杂度 O(n)。
解法二:暴力枚举(对照,小规模)
对每个查询区间直接枚举其所有子串统计是否满足约束。
时间复杂度 O(q * len^2),仅小规模验证。
复杂度:
- 时间复杂度:O(n + q)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:滑动窗口 + 前缀和(主提交版本) ----------
public long[] countKConstraintSubstrings(String s, int k, int[][] queries) {
int n = s.length();
int[] d = new int[n];
Arrays.fill(d, n);
int[] cnt = new int[2];
long[] pre = new long[n + 1];
for (int l = 0, r = 0; r < n; ++r) {
++cnt[s.charAt(r) - '0'];
while (cnt[0] > k && cnt[1] > k) {
d[l] = r; // 左端点 l 的最远右端点(不含)为 r
--cnt[s.charAt(l) - '0'];
++l;
}
pre[r + 1] = pre[r] + (r - l + 1);
}
int m = queries.length;
long[] ans = new long[m];
for (int i = 0; i < m; ++i) {
int l = queries[i][0];
int r = queries[i][1];
int p = Math.min(r + 1, d[l]);
long a = (long) (p - l) * (p - l + 1) / 2;
long b = pre[r + 1] - pre[p];
ans[i] = a + b;
}
return ans;
}
// ---------- 解法二:暴力枚举(对照,小规模) ----------
public long[] countKConstraintSubstringsBrute(String s, int k, int[][] queries) {
int n = s.length();
int m = queries.length;
long[] ans = new long[m];
for (int qi = 0; qi < m; ++qi) {
int l = queries[qi][0];
int r = queries[qi][1];
long cnt = 0;
for (int i = l; i <= r; ++i) {
int c0 = 0;
int c1 = 0;
for (int j = i; j <= r; ++j) {
if (s.charAt(j) == '0') {
++c0;
} else {
++c1;
}
if (c0 <= k || c1 <= k) {
++cnt;
}
}
}
ans[qi] = cnt;
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] ss = {"0001111", "010101", "10101", "0000"};
int[] ks = {2, 1, 1, 1};
int[][][] qs = {
{{0, 6}},
{{0, 5}, {1, 4}, {2, 3}},
{{0, 4}, {1, 3}},
{{0, 2}, {1, 3}}
};
long[][] expects = {
{26},
{15, 9, 3},
{12, 6},
{6, 6}
};
boolean allPass = true;
for (int i = 0; i < ss.length; ++i) {
long[] a = sol.countKConstraintSubstrings(ss[i], ks[i], qs[i]);
long[] b = sol.countKConstraintSubstringsBrute(ss[i], ks[i], qs[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> main=" + Arrays.toString(a) + " brute=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 1 + rnd.nextInt(14);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append(rnd.nextInt(2));
}
int k = 1 + rnd.nextInt(Math.max(1, n));
int qn = 1 + rnd.nextInt(5);
int[][] q = new int[qn][2];
for (int i = 0; i < qn; ++i) {
int l = rnd.nextInt(n);
int r = l + rnd.nextInt(n - l);
q[i][0] = l;
q[i][1] = r;
}
long[] a = sol.countKConstraintSubstrings(sb.toString(), k, q);
long[] b = sol.countKConstraintSubstringsBrute(sb.toString(), k, q);
if (!Arrays.equals(a, b)) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH s=" + sb + " k=" + k + " a=" + Arrays.toString(a)
+ " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n + q log n)(求 p 用二分或直接 min),空间复杂度 O(n)。
时间复杂度 O(q * len^2),仅小规模验证。
- 时间复杂度:O(n + q)
- 空间复杂度:O(n)
3262. Find Overlapping Shifts(查找重叠的班次)
题目类型:数据库(SQL)
题目描述
表:EmployeeShifts
+------------------+---------+
| Column Name | Type |
+------------------+---------+
| employee_id | int |
| start_time | time |
| end_time | time |
+------------------+---------+
(employee_id, start_time) 是这张表的唯一主键。这张表包含员工的排班工作,包括特定日期的开始和结束时间。
编写一个解决方案来为每个员工 计算重叠排班 的数量。如果一个排班的 end_time 比另一个排班的 start_time 更晚则认为两个排班重叠。
返回结果表以 employee_id 升序排序。没有重叠排班的员工不输出。
示例 1:
输入:
EmployeeShifts 表:
+-------------+------------+----------+
| employee_id | start_time | end_time |
+-------------+------------+----------+
| 1 | 08:00:00 | 12:00:00 |
| 1 | 11:00:00 | 15:00:00 |
| 1 | 14:00:00 | 18:00:00 |
| 2 | 09:00:00 | 17:00:00 |
| 2 | 16:00:00 | 20:00:00 |
| 3 | 10:00:00 | 12:00:00 |
| 3 | 13:00:00 | 15:00:00 |
| 3 | 16:00:00 | 18:00:00 |
| 4 | 08:00:00 | 10:00:00 |
| 4 | 09:00:00 | 11:00:00 |
+-------------+------------+----------+
输出:
+-------------+--------------------+
| employee_id | overlapping_shifts |
+-------------+--------------------+
| 1 | 2 |
| 2 | 1 |
| 4 | 1 |
+-------------+--------------------+
解释:员工 1 有 3 个排班 08-12、11-15、14-18,其中 (08-12, 11-15) 与 (11-15, 14-18) 两对重叠((08-12, 14-18) 不重叠),共 2 对;员工 3 三个排班依次相连互不重叠,不输出。
解题思路
「重叠对」计数:排班 A 与 B 重叠当且仅当两者时间交叉,即 A.start_time < B.start_time 且 A.end_time > B.start_time。用自连接 让每对排班比较一次(通过 a.start_time < b.start_time 避免重复计数),统计重叠对的数量。只有 COUNT >= 1 的员工才会出现在 INNER JOIN 后的结果中,天然满足「无重叠则不输出」;最后按 employee_id 升序输出。
代码实现
sql
SELECT a.employee_id,
COUNT(*) AS overlapping_shifts
FROM EmployeeShifts a
JOIN EmployeeShifts b
ON a.employee_id = b.employee_id
AND a.start_time < b.start_time
AND a.end_time > b.start_time
GROUP BY a.employee_id
ORDER BY a.employee_id;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3263. Convert Doubly Linked List to Array I(将双链表转换为数组 I 🔒)
题目描述
给定一个双链表的 head 节点,其中的节点具有指向下一个节点的指针和上一个节点的指针。
返回一个按顺序包含链表中元素的整数数组。
示例 1
head = [1,2,3,4,3,2,1] -> [1,2,3,4,3,2,1]
示例 2
head = [2,2,2,2,2] -> [2,2,2,2,2]
示例 3
head = [3,2,3,2,3,2] -> [3,2,3,2,3,2]
提示:
- 节点数量在 1, 50 范围
1 <= Node.val <= 50
解题思路
解法一:沿 next 正向遍历,主提交版本
从 head 出发沿 next 指针遍历收集 val 到 List,再转 int\[\]。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:先求长度再填充(对照)
第一遍遍历数长度,第二遍遍历填充数组;逻辑独立于 List 写法。
时间复杂度 O(n),空间复杂度 O(1)(除结果外)。
复杂度:
- 时间复杂度: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 static class Node {
public int val;
public Node prev;
public Node next;
public Node(int val) {
this.val = val;
}
}
// ---------- 解法一:List 收集(主提交版本) ----------
public int[] toArray(Node head) {
List<Integer> ans = new ArrayList<>();
for (Node cur = head; cur != null; cur = cur.next) {
ans.add(cur.val);
}
int[] res = new int[ans.size()];
for (int i = 0; i < ans.size(); ++i) {
res[i] = ans.get(i);
}
return res;
}
// ---------- 解法二:先数长度再填充(对照) ----------
public int[] toArrayCount(Node head) {
int len = 0;
for (Node cur = head; cur != null; cur = cur.next) {
++len;
}
int[] res = new int[len];
int i = 0;
for (Node cur = head; cur != null; cur = cur.next) {
res[i++] = cur.val;
}
return res;
}
// 构造双向链表(辅助)
private static Node build(int[] vals) {
Node head = new Node(vals[0]);
Node pre = head;
for (int i = 1; i < vals.length; ++i) {
Node cur = new Node(vals[i]);
pre.next = cur;
cur.prev = pre;
pre = cur;
}
return head;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1, 2, 3, 4, 3, 2, 1},
{2, 2, 2, 2, 2},
{3, 2, 3, 2, 3, 2},
{7}
};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
Node head = build(cases[i]);
int[] a = sol.toArray(head);
int[] b = sol.toArrayCount(head);
boolean ok = Arrays.equals(a, cases[i]) && Arrays.equals(b, cases[i]);
allPass &= ok;
System.out.println("case " + i + " -> " + Arrays.toString(a) + " / " + Arrays.toString(b)
+ (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 1 + rnd.nextInt(20);
int[] vals = new int[n];
for (int i = 0; i < n; ++i) {
vals[i] = 1 + rnd.nextInt(50);
}
Node head = build(vals);
int[] a = sol.toArray(head);
int[] b = sol.toArrayCount(head);
if (!Arrays.equals(a, vals) || !Arrays.equals(b, vals)) {
++fail;
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
时间复杂度 O(n),空间复杂度 O(1)(除结果外)。
- 时间复杂度:O(n)
- 空间复杂度:O(n)
3264. Final Array State After K Multiplication Operations I(K 次乘运算后的最终数组 I)
题目描述
给你一个整数数组 nums、一个整数 k 和一个整数 multiplier。
你需要对 nums 执行 k 次操作,每次操作中:
- 找到
nums中的最小值x,如果存在多个最小值,选择最前面的一个; - 将
x替换为x*multiplier。
请你返回执行完k次乘运算之后,最终的nums数组。
示例 1
nums = [2,1,3,5,6], k = 5, multiplier = 2 -> [8,4,6,5,6]
示例 2
nums = [1,2], k = 3, multiplier = 4 -> [16,8]
提示:
1 <= nums.length <= 1001 <= nums[i] <= 1001 <= k <= 101 <= multiplier <= 5
解题思路
解法一:优先队列,主提交版本
维护小顶堆,按"值升序,值相同按下标升序"排序。执行 k 次:弹出堆顶(最小且最前),
乘 multiplier 后重新入堆。最后按原下标把堆中的值写回 nums。
时间复杂度 O((n + k) log n),空间复杂度 O(n)。
解法二:每次线性扫描(对照)
每轮扫描整个数组找最小值下标(同值取更小下标),乘 multiplier。
时间复杂度 O(k * n),仅小规模验证。
复杂度:
- 时间复杂度:O((n + k) log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Random;
public class Solution {
// ---------- 解法一:优先队列(主提交版本) ----------
public int[] getFinalState(int[] nums, int k, int multiplier) {
int n = nums.length;
PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] != b[0]
? Integer.compare(a[0], b[0]) : Integer.compare(a[1], b[1]));
for (int i = 0; i < n; ++i) {
pq.offer(new int[] {nums[i], i});
}
for (int step = 0; step < k; ++step) {
int[] p = pq.poll();
p[0] *= multiplier;
pq.offer(p);
}
int[] ans = new int[n];
for (int[] p : pq) {
ans[p[1]] = p[0];
}
return ans;
}
// ---------- 解法二:线性扫描(对照) ----------
public int[] getFinalStateBrute(int[] nums, int k, int multiplier) {
int n = nums.length;
int[] arr = nums.clone();
for (int step = 0; step < k; ++step) {
int idx = 0;
for (int i = 1; i < n; ++i) {
if (arr[i] < arr[idx]) {
idx = i;
}
}
arr[idx] *= multiplier;
}
return arr;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] numsList = {
{2, 1, 3, 5, 6},
{1, 2},
{5, 5, 5},
{3}
};
int[] ks = {5, 3, 2, 4};
int[] mults = {2, 4, 3, 7};
int[][] expects = {
{8, 4, 6, 5, 6},
{16, 8},
{15, 15, 5},
{7203} // 3*7*7*7*7 = 7203
};
boolean allPass = true;
for (int i = 0; i < numsList.length; ++i) {
int[] a = sol.getFinalState(numsList[i], ks[i], mults[i]);
int[] b = sol.getFinalStateBrute(numsList[i], ks[i], mults[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> main=" + Arrays.toString(a) + " brute=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 1000; ++t) {
int n = 1 + rnd.nextInt(10);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = 1 + rnd.nextInt(20);
}
int k = 1 + rnd.nextInt(8);
int mult = 1 + rnd.nextInt(5);
int[] a = sol.getFinalState(nums, k, mult);
int[] b = sol.getFinalStateBrute(nums, k, mult);
if (!Arrays.equals(a, b)) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O((n + k) log n),空间复杂度 O(n)。
时间复杂度 O(k * n),仅小规模验证。
- 时间复杂度:O((n + k) log n)
- 空间复杂度:O(n)
3265. Count Almost Equal Pairs I(统计近似相等数对 I)
题目描述
给你一个正整数数组 nums。如果我们执行以下操作至多一次可以让两个整数 x 和 y 相等,
那么我们称这个数对是近似相等的:
- 选择
x或者y之一,将这个数字中的两个数位交换。
请你返回nums中,下标i和j满足i<j且nums[i]和nums[j]近似相等的数对数目。
注意,执行操作后一个整数可以有前导 0。
示例 1
nums = [3,12,30,17,21] -> 2
示例 2
nums = [1,1,1,1,1] -> 10
示例 3
nums = [123,231] -> 0
提示:
2 <= nums.length <= 1001 <= nums[i] <= 10^6
解题思路
解法一:枚举可达数 + 计数累积,主提交版本
对每个数 x,枚举 x 通过"至多一次交换两位"能变成的所有整数集合 vis(含自身):
交换任意两个数位(若两个数位相同则不变,用 Set 去重)。数对 (x 在前) 贡献 = 之前已出现的、
属于 vis 中的数的计数之和。由于每次都统计 x 的所有可达数,恰好把"x 可达 y 或 y 可达 x"
的所有前置 y 都计入,无重复无遗漏。
时间复杂度 O(n * d^2)(d 为数位长度 <= 7),空间复杂度 O(10^6)。
解法二:两两暴力判定(对照,小规模)
对每个数对直接枚举一方一次交换的所有结果检查是否等于另一方。
时间复杂度 O(n^2 * d^2),仅小规模验证。
复杂度:
- 时间复杂度:O(n * d^2)
- 空间复杂度:O(d^2)(集合)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:可达数计数(主提交版本) ----------
public int countPairs(int[] nums) {
Arrays.sort(nums); // 排序后可先去重统计,但此处直接两两枚举前序计数
Map<Integer, Integer> cnt = new HashMap<>();
int ans = 0;
for (int x : nums) {
Set<Integer> vis = new HashSet<>();
vis.add(x);
char[] s = String.valueOf(x).toCharArray();
for (int i = 0; i < s.length; ++i) {
for (int j = i + 1; j < s.length; ++j) {
swap(s, i, j);
vis.add(Integer.parseInt(String.valueOf(s)));
swap(s, i, j);
}
}
for (int y : vis) {
ans += cnt.getOrDefault(y, 0);
}
cnt.merge(x, 1, Integer::sum);
}
return ans;
}
private void swap(char[] s, int i, int j) {
char t = s[i];
s[i] = s[j];
s[j] = t;
}
// ---------- 解法二:两两暴力判定(对照) ----------
public int countPairsBrute(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (canEqual(nums[i], nums[j])) {
++ans;
}
}
}
return ans;
}
// x 经至多一次交换能否变成 y(或反之)
private boolean canEqual(int x, int y) {
if (x == y) {
return true;
}
// 注意:交换后可能出现前导 0(如 "010"),必须用 Integer.parseInt 归一化为整数再比较
Set<Integer> vs = new HashSet<>();
vs.add(y);
char[] c = String.valueOf(y).toCharArray();
for (int i = 0; i < c.length; ++i) {
for (int j = i + 1; j < c.length; ++j) {
swap(c, i, j);
vs.add(Integer.parseInt(String.valueOf(c)));
swap(c, i, j);
}
}
if (vs.contains(x)) {
return true;
}
// 也检查 x 的交换是否能等于 y
vs.clear();
vs.add(x);
c = String.valueOf(x).toCharArray();
for (int i = 0; i < c.length; ++i) {
for (int j = i + 1; j < c.length; ++j) {
swap(c, i, j);
vs.add(Integer.parseInt(String.valueOf(c)));
swap(c, i, j);
}
}
return vs.contains(y);
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{3, 12, 30, 17, 21},
{1, 1, 1, 1, 1},
{123, 231},
{10, 1, 100}
};
int[] expects = {2, 10, 0, 3};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.countPairs(cases[i]);
int b = sol.countPairsBrute(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 2 + rnd.nextInt(8);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = 1 + rnd.nextInt(10000);
}
int a = sol.countPairs(nums);
int b = sol.countPairsBrute(nums);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH a=" + a + " b=" + b + " nums=" + Arrays.toString(nums));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n * d^2)(d 为数位长度 <= 7),空间复杂度 O(10^6)。
时间复杂度 O(n^2 * d^2),仅小规模验证。
- 时间复杂度:O(n * d^2)
- 空间复杂度:O(d^2)(集合)
3266. Final Array State After K Multiplication Operations II(K 次乘运算后的最终数组 II)
题目描述
给你一个整数数组 nums、一个整数 k 和一个整数 multiplier。
你需要对 nums 执行 k 次操作,每次操作中:
- 找到
nums中的最小值x,如果存在多个最小值,选择最前面的一个; - 将
x替换为x*multiplier。
k次操作以后,你需要将nums中每一个数值对 10^9 + 7 取余。
请你返回执行完k次乘运算以及取余运算之后,最终的nums数组。
示例 1
nums = [2,1,3,5,6], k = 5, multiplier = 2 -> [8,4,6,5,6]
示例 2
nums = [100000,2000], k = 2, multiplier = 1000000 -> [999999307,999999993]
提示:
1 <= nums.length <= 10^41 <= nums[i] <= 10^91 <= k <= 10^91 <= multiplier <= 10^6
解题思路
解法一:优先队列 + 快速幂循环节,主提交版本
k 可能高达 10^9,不能逐次模拟。观察:优先队列按值(同值按下标)取最小。
设初始最大值为 mx。执行若干次后所有值都会 >= mx,之后的操作变为"各元素轮流乘 multiplier":
每 n 次操作构成一轮,每个元素都乘一次 multiplier(相对顺序由下标决定)。
具体做法:
- 先用堆模拟直到堆顶 >= mx(最多 n * log 级别次),把 k 消耗掉一部分;
- 剩余 k' 次:每 n 次让每个元素都乘上 multiplier 一次------等价于每个元素乘上
multiplier^(k'/n) 次,"余数轮"中下标最小的 k'%n 个元素再多乘一次;
(因为堆在值相同时按下标取最小,会先轮到更小下标。) - 用快速幂计算 multiplier 的幂(对 mod 取模),把各最终值乘上对应幂次。
时间复杂度 O(n log n log k),空间复杂度 O(n)。
解法二:直接模拟(对照,小规模)
逐次用线性扫描找最小值乘 multiplier,最后统一取模。
时间复杂度 O(k * n),仅 k 较小时验证。
复杂度:
- 时间复杂度:O((n + log k) * log n)
- 空间复杂度:O(n)
代码实现
java
import java.math.BigInteger;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Random;
public class Solution {
private static final int MOD = (int) 1e9 + 7;
// ---------- 解法一:优先队列 + 循环节快速幂(主提交版本) ----------
public int[] getFinalState(int[] nums, int k, int multiplier) {
nums = nums.clone(); // 不污染调用方数组
int n = nums.length;
if (multiplier == 1) {
return nums.clone();
}
PriorityQueue<long[]> pq = new PriorityQueue<>((a, b) -> a[0] == b[0]
? Long.compare(a[1], b[1]) : Long.compare(a[0], b[0]));
long mx = 0;
for (int i = 0; i < n; ++i) {
pq.offer(new long[] {nums[i], i});
mx = Math.max(mx, nums[i]);
}
long kk = k;
// 阶段 1:堆顶 < mx 时逐次乘
while (kk > 0 && pq.peek()[0] < mx) {
long[] p = pq.poll();
p[0] *= multiplier;
pq.offer(p);
--kk;
}
// 阶段 2:循环节
long full = kk / n; // 每个元素都乘 multiplier^full 次
int rem = (int) (kk % n); // 前 rem 个(按下标)再多乘一次
long[] vals = new long[n];
int[] idxs = new int[n];
for (int i = 0; i < n; ++i) {
long[] p = pq.poll();
vals[i] = p[0];
idxs[i] = (int) p[1];
}
// 注意:阶段 2 的相对顺序------堆里值相同时按下标取最小,
// 剩余 rem 次会轮到下标最小的 rem 个元素。但若值不同,则是按值排序。
// 对"轮到谁"的精确处理:堆中元素按值排,rem 次取最小后,
// 若值不同,前面 rem 个最小值的元素各乘一次。为严谨,再按堆序让 rem 个
// 先被取出者多乘一次。做法:vals 已按取出的顺序(即堆序)排列,
// 前 rem 个元素各多乘一次 multiplier。
long powFull = qpow(multiplier % MOD, full);
long powRem = powFull * (multiplier % MOD) % MOD;
for (int i = 0; i < n; ++i) {
long base = vals[i] % MOD;
long times = (i < rem) ? powRem : powFull;
nums[idxs[i]] = (int) (base * times % MOD);
}
return nums;
}
private long qpow(long a, long e) {
long r = 1;
while (e > 0) {
if ((e & 1) == 1) {
r = r * a % MOD;
}
a = a * a % MOD;
e >>= 1;
}
return r;
}
// ---------- 解法二:直接模拟(对照,小规模) ----------
// 注意:中间过程不能取模!比较必须基于真实值,只在最后统一取模。
// 用 BigInteger 避免溢出(小规模验证用)。
public int[] getFinalStateBrute(int[] nums, int k, int multiplier) {
int n = nums.length;
BigInteger[] arr = new BigInteger[n];
for (int i = 0; i < n; ++i) {
arr[i] = BigInteger.valueOf(nums[i]);
}
BigInteger m = BigInteger.valueOf(multiplier);
for (int step = 0; step < k; ++step) {
int idx = 0;
for (int i = 1; i < n; ++i) {
if (arr[i].compareTo(arr[idx]) < 0) {
idx = i;
}
}
arr[idx] = arr[idx].multiply(m);
}
BigInteger mod = BigInteger.valueOf(MOD);
int[] ans = new int[n];
for (int i = 0; i < n; ++i) {
ans[i] = arr[i].mod(mod).intValue();
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] numsList = {
{2, 1, 3, 5, 6},
{100000, 2000},
{1, 2},
{5, 5, 5}
};
int[] ks = {5, 2, 3, 2};
int[] mults = {2, 1000000, 4, 3};
int[][] expects = {
{8, 4, 6, 5, 6},
{999999307, 999999993},
{16, 8},
{15, 15, 5}
};
boolean allPass = true;
for (int i = 0; i < numsList.length; ++i) {
int[] a = sol.getFinalState(numsList[i], ks[i], mults[i]);
int[] b = sol.getFinalStateBrute(numsList[i], ks[i], mults[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> main=" + Arrays.toString(a) + " brute=" + Arrays.toString(b)
+ " expected=" + Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 1 + rnd.nextInt(6);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = 1 + rnd.nextInt(30);
}
int k = 1 + rnd.nextInt(80);
int mult = 2 + rnd.nextInt(6);
int[] a = sol.getFinalState(nums, k, mult);
int[] b = sol.getFinalStateBrute(nums, k, mult);
if (!Arrays.equals(a, b)) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH k=" + k + " mult=" + mult + " a=" + Arrays.toString(a)
+ " b=" + Arrays.toString(b));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n log k),空间复杂度 O(n)。
时间复杂度 O(k * n),仅 k 较小时验证。
- 时间复杂度:O((n + log k) * log n)
- 空间复杂度:O(n)
3267. Count Almost Equal Pairs II(统计近似相等数对 II)
题目描述
注意:在这个问题中,操作次数增加为至多两次。
给你一个正整数数组 nums。如果我们执行以下操作至多两次可以让两个整数 x 和 y 相等,
那么我们称这个数对是近似相等的:
- 选择
x或者y之一,将这个数字中的两个数位交换。
请你返回nums中,下标i和j满足i<j且nums[i]和nums[j]近似相等的数对数目。
注意,执行操作后得到的整数可以有前导 0。
示例 1
nums = [1023,2310,2130,213] -> 4
示例 2
nums = [1,10,100] -> 3
解题思路
解法一:双向可达集合计数,主提交版本
对每个数 x,枚举"至多交换两次"能变成的所有整数集合 vis:
第一次交换任意两个数位(若相同则不变),第二次同样交换任意两个数位,
用 Set 去重(把每次交换后的 parseInt 结果加入)。数对 (x 在前) 贡献 =
之前已出现、且属于 vis 中的数的计数之和。由于统计的是 x 的全部可达数,
恰好覆盖"x 可达 y 或 y 可达 x"的所有前置 y,无重复无遗漏。
数位最长 7 位,两次交换 O(d^2 * d^2) = O(d^4)(d <= 7,常数小)。
时间复杂度 O(n * d^4),空间复杂度 O(n)。
解法二:两两暴力判定(对照,小规模)
对每个数对 (x, y),分别枚举 x 与 y 的两次交换可达集合,交集非空即可达。
时间复杂度 O(n^2 * d^4),仅小规模验证。
复杂度:
- 时间复杂度:O(n * d^4)(d 为数位长度,d <= 7)
- 空间复杂度:O(n + d^4)
代码实现
java
import java.util.Arrays;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:排序 + 单向可达集合计数(主提交版本) ----------
public int countPairs(int[] nums) {
// 关键:先按值升序排序。近似相等存在方向性(如 2310 交换两位可得 0213=213,
// 而 213 无法反向变回 2310)。升序处理保证:若 (a,b) 近似且 a < b,
// 必有 a ∈ R2(b)(同长度可逆;不同长度时只能是"长数经前导 0 缩短为短数",
// 即短数必在长数的可达集合中),故对每个 x 只需检查其可达集合即可不重不漏。
Arrays.sort(nums);
Map<Integer, Integer> cnt = new HashMap<>();
int ans = 0;
for (int x : nums) {
Set<Integer> vis = new HashSet<>();
vis.add(x);
char[] s = String.valueOf(x).toCharArray();
// 第一次交换
for (int i = 0; i < s.length; ++i) {
for (int j = i + 1; j < s.length; ++j) {
swap(s, i, j);
vis.add(parse(s));
// 第二次交换(在第一次的基础上)
for (int p = 0; p < s.length; ++p) {
for (int q = p + 1; q < s.length; ++q) {
swap(s, p, q);
vis.add(parse(s));
swap(s, p, q);
}
}
swap(s, i, j);
}
}
for (int y : vis) {
ans += cnt.getOrDefault(y, 0);
}
cnt.merge(x, 1, Integer::sum);
}
return ans;
}
// 解析 char[] 为 int(自动处理前导 0,如 "0213" -> 213)
private int parse(char[] s) {
return Integer.parseInt(String.valueOf(s));
}
private void swap(char[] s, int i, int j) {
char t = s[i];
s[i] = s[j];
s[j] = t;
}
// ---------- 解法二:两两暴力判定(对照) ----------
public int countPairsBrute(int[] nums) {
int n = nums.length;
int ans = 0;
for (int i = 0; i < n; ++i) {
for (int j = i + 1; j < n; ++j) {
if (canEqual(nums[i], nums[j])) {
++ans;
}
}
}
return ans;
}
// x 经至多两次交换能否变成 y(交换可逆:x→y 与 y→x 距离相同)
private boolean canEqual(int x, int y) {
return reachable(x).contains(y) || reachable(y).contains(x);
}
// 返回 z 经至多两次交换可达的所有整数(含自身)
// 说明:近似相等 ⟺ D(x,y) ≤ 2(交换对称可逆,(1,1) 分布情况可合并到
// "x 经 2 次到 y",故只需单侧可达集合包含即可)
private Set<Integer> reachable(int z) {
Set<Integer> res = new HashSet<>();
res.add(z);
char[] s = String.valueOf(z).toCharArray();
for (int i = 0; i < s.length; ++i) {
for (int j = i + 1; j < s.length; ++j) {
swap(s, i, j);
res.add(parse(s));
// 第二次交换
for (int p = 0; p < s.length; ++p) {
for (int q = p + 1; q < s.length; ++q) {
swap(s, p, q);
res.add(parse(s));
swap(s, p, q);
}
}
swap(s, i, j);
}
}
return res;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{1023, 2310, 2130, 213},
{1, 10, 100},
{123, 231},
{5, 5, 5}
};
int[] expects = {4, 3, 1, 3};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
int a = sol.countPairs(cases[i]);
int b = sol.countPairsBrute(cases[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 300; ++t) {
int n = 2 + rnd.nextInt(6);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = 1 + rnd.nextInt(10000);
}
int a = sol.countPairs(nums);
int b = sol.countPairsBrute(nums);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH a=" + a + " b=" + b + " nums=" + Arrays.toString(nums));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n * d^4),空间复杂度 O(n)。
时间复杂度 O(n^2 * d^4),仅小规模验证。
- 时间复杂度:O(n * d^4)(d 为数位长度,d <= 7)
- 空间复杂度:O(n + d^4)
3268. Find Overlapping Shifts II(查找重叠的班次 II)
题目类型:数据库(SQL)
题目描述
表:EmployeeShifts
+------------------+----------+
| Column Name | Type |
+------------------+----------+
| employee_id | int |
| start_time | datetime |
| end_time | datetime |
+------------------+----------+
(employee_id, start_time) 是这张表的唯一主键。这张表包含员工的排班工作,包括特定日期的开始和结束时间。
编写一个解决方案来为每个员工分析重叠排班。如果两个排班在同一天 且一个排班的 end_time 比另一个排班的 start_time 更晚则认为两个排班重叠。
对于每个员工,计算如下内容:
- 任何给定时间 的最多重叠班次数。
- 所有重叠班次的总持续时间,以分钟为单位。
返回结果表以 employee_id 升序排序。
示例 1:
输入:
EmployeeShifts 表:
+-------------+---------------------+---------------------+
| employee_id | start_time | end_time |
+-------------+---------------------+---------------------+
| 1 | 2023-10-01 09:00:00 | 2023-10-01 17:00:00 |
| 1 | 2023-10-01 15:00:00 | 2023-10-01 23:00:00 |
| 1 | 2023-10-01 16:00:00 | 2023-10-02 00:00:00 |
| 2 | 2023-10-01 09:00:00 | 2023-10-01 17:00:00 |
| 2 | 2023-10-01 11:00:00 | 2023-10-01 19:00:00 |
| 3 | 2023-10-01 09:00:00 | 2023-10-01 17:00:00 |
+-------------+---------------------+---------------------+
输出:
+-------------+---------------------------+------------------------+
| employee_id | max_overlapping_shifts | total_overlap_duration |
+-------------+---------------------------+------------------------+
| 1 | 3 | 600 |
| 2 | 2 | 360 |
| 3 | 1 | 0 |
+-------------+---------------------------+------------------------+
解释:员工 1 三个排班在 16:00-17:00 同时重叠,最大重叠数为 3;重叠总时长 = 排班 1&2 重叠 2 小时 + 排班 1&3 重叠 1 小时 + 排班 2&3 重叠 7 小时 = 10 小时 = 600 分钟。员工 3 只有 1 个排班,无重叠,最大重叠数为 1、时长为 0。
解题思路
本题是两个统计的组合:
- 最多重叠班次数 :把每个班次拆成两个事件------
start_time记+1、end_time记-1,按时间升序做前缀和即得到任意时刻在岗的班次数,对每个员工取最大值(单班次员工最大值为 1)。 - 重叠总时长 :所有重叠对 的重叠分钟之和(每对独立计一次,不合并重复区间)。用自连接找重叠对:
a.start_time < b.start_time AND a.end_time > b.start_time,每对的重叠时长 =TIMESTAMPDIFF(MINUTE, GREATEST(起), LEAST(止)),按员工求和。
注意同时间戳事件需先处理 -1(结束)再处理 +1(开始),避免「首尾相接」的班次被误判为重叠。最后用 LEFT JOIN 保证无重叠对的员工也输出(时长补 0)。
代码实现
sql
WITH events AS (
SELECT employee_id, start_time AS ts, 1 AS delta FROM EmployeeShifts
UNION ALL
SELECT employee_id, end_time AS ts, -1 AS delta FROM EmployeeShifts
),
running AS (
SELECT employee_id, ts,
SUM(delta) OVER (PARTITION BY employee_id ORDER BY ts, delta) AS active
FROM events
),
mx AS (
SELECT employee_id, MAX(active) AS max_overlapping_shifts
FROM running
GROUP BY employee_id
),
pairs AS (
SELECT a.employee_id,
TIMESTAMPDIFF(MINUTE,
GREATEST(a.start_time, b.start_time),
LEAST(a.end_time, b.end_time)) AS overlap_min
FROM EmployeeShifts a
JOIN EmployeeShifts b
ON a.employee_id = b.employee_id
AND a.start_time < b.start_time
AND a.end_time > b.start_time
),
du AS (
SELECT employee_id, COALESCE(SUM(overlap_min), 0) AS total_overlap_duration
FROM pairs
GROUP BY employee_id
)
SELECT m.employee_id,
m.max_overlapping_shifts,
COALESCE(d.total_overlap_duration, 0) AS total_overlap_duration
FROM mx m
LEFT JOIN du d ON d.employee_id = m.employee_id
ORDER BY m.employee_id;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3269. Constructing Two Increasing Arrays(构建两个递增数组)
题目描述
给定两个只包含 0 和 1 的整数数组 nums1 和 nums2,你的任务是执行下面操作后
使数组 nums1 和 nums2 中最大可达数字尽可能小。
将每个 0 替换为正偶数,将每个 1 替换为正奇数。在替换后,两个数组都应该递增
并且每个整数至多被使用一次。
返回执行操作后最小的最大可达数字。
示例 1
nums1 = [], nums2 = [1,0,1,1] -> 5(nums2 = [1,2,3,5])
示例 2
nums1 = [0,1,0,1], nums2 = [1,0,0,1] -> 9(nums1 = [2,3,8,9],nums2 = [1,4,6,7])
示例 3
nums1 = [0,1,0,0,1], nums2 = [0,0,0,1] -> 13
解题思路
解法一:DP 求最优交错,主提交版本
关键观察:把所有替换后的数字按"来源于 nums1 的相对顺序 + 来源于 nums2 的相对顺序"
交错合并成一条递增序列,问题等价于求交错合并后序列最后值的最小值。
fij 表示从 nums1 取前 i 个、nums2 取前 j 个交错合并成递增序列时,
序列最后(最大)元素的最小值。
转移:最后一个元素要么是 nums1 的第 i 个(值为 fi-1j 之后的最小同奇偶后继),
要么是 nums2 的第 j 个(值为 fij-1 之后的最小同奇偶后继),取二者较小:
fij = min(nxt(fi-1j, nums1i-1), nxt(fij-1, nums2j-1))
其中 nxt(x, par) 返回严格大于 x、且奇偶性与 par(0 偶 / 1 奇)相同的最小正整数:
若 x 与 par 同奇偶则 x + 2,否则 x + 1。f00 = 0 作为哨兵(保证每个整数为正)。
时间复杂度 O(nm),空间复杂度 O(n m)。
解法二:枚举全部交错排列(对照,小规模)
递归枚举所有 C(n+m, n) 种交错方式(每一步选择下一个取自 nums1 还是 nums2),
对每种固定的奇偶序列,贪心地令每个位置取"大于前一值且奇偶匹配"的最小值,
最后值取各交错方式的最小值。
时间复杂度指数级,仅小规模验证。
复杂度:
- 时间复杂度:O(n * m)
- 空间复杂度:O(n * m)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:DP 求最优交错(主提交版本) ----------
public int minLargest(int[] nums1, int[] nums2) {
int m = nums1.length, n = nums2.length;
int[][] f = new int[m + 1][n + 1];
for (int i = 1; i <= m; ++i) {
f[i][0] = nxt(f[i - 1][0], nums1[i - 1]);
}
for (int j = 1; j <= n; ++j) {
f[0][j] = nxt(f[0][j - 1], nums2[j - 1]);
}
for (int i = 1; i <= m; ++i) {
for (int j = 1; j <= n; ++j) {
int x = nxt(f[i - 1][j], nums1[i - 1]); // 最后一个取自 nums1
int y = nxt(f[i][j - 1], nums2[j - 1]); // 最后一个取自 nums2
f[i][j] = Math.min(x, y);
}
}
return f[m][n];
}
// 返回严格大于 x、与 par 同奇偶(par = 0 偶 / 1 奇)的最小正整数
private int nxt(int x, int par) {
return ((x & 1) ^ par) == 1 ? x + 1 : x + 2;
}
// ---------- 解法二:枚举全部交错排列(对照,小规模) ----------
private int best;
public int minLargestBrute(int[] nums1, int[] nums2) {
best = Integer.MAX_VALUE;
dfs(nums1, nums2, 0, 0, 0, 0);
return best;
}
// 当前合并序列最后值为 last,已用 nums1 前 i 个、nums2 前 j 个
private void dfs(int[] a, int[] b, int i, int j, int last, int cnt) {
if (i == a.length && j == b.length) {
best = Math.min(best, last);
return;
}
if (cnt > 0 && last >= best) {
return; // 剪枝:当前最后值已不小于已有解
}
if (i < a.length) {
dfs(a, b, i + 1, j, nxt(last, a[i]), cnt + 1);
}
if (j < b.length) {
dfs(a, b, i, j + 1, nxt(last, b[j]), cnt + 1);
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] empty = new int[] {};
int[][] c1a = {empty, {1, 0, 1, 1}}; // -> 5
int[][] c2a = {{0, 1, 0, 1}, {1, 0, 0, 1}}; // -> 9
int[][] c3a = {{0, 1, 0, 0, 1}, {0, 0, 0, 1}}; // -> 13
int[][][] cases = {c1a, c2a, c3a};
int[] expects = {5, 9, 13};
boolean allPass = true;
for (int t = 0; t < cases.length; ++t) {
int m = sol.minLargest(cases[t][0], cases[t][1]);
int w = sol.minLargestBrute(cases[t][0], cases[t][1]);
boolean ok = m == expects[t] && w == expects[t];
allPass &= ok;
System.out.println("case " + t + " -> main=" + m + " brute=" + w
+ " expected=" + expects[t] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 300; ++t) {
int m = rnd.nextInt(5);
int n = 1 + rnd.nextInt(5);
int[] a = new int[m];
int[] b = new int[n];
for (int i = 0; i < m; ++i) {
a[i] = rnd.nextInt(2);
}
for (int i = 0; i < n; ++i) {
b[i] = rnd.nextInt(2);
}
int x = sol.minLargest(a, b);
int y = sol.minLargestBrute(a, b);
if (x != y) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b)
+ " main=" + x + " brute=" + y);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(nm),空间复杂度 O(n m)。
时间复杂度指数级,仅小规模验证。
- 时间复杂度:O(n * m)
- 空间复杂度:O(n * m)
3270. Find the Key of the Numbers(求出数字答案)
题目描述
给你三个正整数 num1,num2 和 num3。数字 num1,num2 和 num3 的数字答案 key 是一个四位数,定义如下:
- 一开始,如果有数字少于四位数,给它补前导 0。
- 答案
key的第i个数位(1 <=i<= 4)为num1,num2和num3第i个数位中的最小值。
请你返回三个数字没有前导 0 的数字答案。
示例 1
num1 = 1, num2 = 10, num3 = 1000 -> 0(0001/0010/1000 逐位取 min 得 0000)
示例 2
num1 = 987, num2 = 879, num3 = 798 -> 777
示例 3
num1 = 1, num2 = 2, num3 = 3 -> 1
解题思路
解法一:按位分解取最小值,主提交版本
由于要求四位数结果,分别提取三个数字 4 个数位(第 k 位 = x / k % 10,k = 1, 10, 100, 1000),
对每一位取三个数字该位的最小值累加进答案。时间复杂度 O(1),空间复杂度 O(1)。
解法二:补齐前导零后字符串逐位取 min(对照)
将三个数格式化为 4 位补 0 字符串,逐位比较三个字符取最小字符拼接后转 int。
时间复杂度 O(1),空间复杂度 O(1)。
复杂度:
- 时间复杂度:O(1)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:按位分解(主提交版本) ----------
public int generateKey(int num1, int num2, int num3) {
int ans = 0, k = 1;
for (int i = 0; i < 4; ++i) {
int d1 = num1 / k % 10;
int d2 = num2 / k % 10;
int d3 = num3 / k % 10;
ans += Math.min(d1, Math.min(d2, d3)) * k;
k *= 10;
}
return ans;
}
// ---------- 解法二:字符串逐位取 min(对照) ----------
public int generateKeyStr(int num1, int num2, int num3) {
String s1 = String.format("%04d", num1);
String s2 = String.format("%04d", num2);
String s3 = String.format("%04d", num3);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < 4; ++i) {
char c = (char) Math.min(s1.charAt(i), Math.min(s2.charAt(i), s3.charAt(i)));
sb.append(c);
}
return Integer.parseInt(sb.toString());
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] nums = {
{1, 10, 1000},
{987, 879, 798},
{1, 2, 3}
};
int[] expects = {0, 777, 1};
boolean allPass = true;
for (int i = 0; i < nums.length; ++i) {
int a = sol.generateKey(nums[i][0], nums[i][1], nums[i][2]);
int b = sol.generateKeyStr(nums[i][0], nums[i][1], nums[i][2]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int x = 1 + rnd.nextInt(9999);
int y = 1 + rnd.nextInt(9999);
int z = 1 + rnd.nextInt(9999);
int a = sol.generateKey(x, y, z);
int b = sol.generateKeyStr(x, y, z);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH x=" + x + " y=" + y + " z=" + z + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
对每一位取三个数字该位的最小值累加进答案。时间复杂度 O(1),空间复杂度 O(1)。
时间复杂度 O(1),空间复杂度 O(1)。
- 时间复杂度:O(1)
- 空间复杂度:O(1)
3271. Hash Divided String(哈希分割字符串)
题目描述
给你一个长度为 n 的字符串 s 和一个整数 k,n 是 k 的倍数。你的任务是将字符串 s
哈希为一个长度为 n / k 的新字符串 result。
首先,将 s 分割成 n / k 个子字符串,每个子字符串的长度都为 k。然后,将 result
初始化为一个空字符串。我们依次处理每一个子字符串:
- 一个字符的哈希值是它在字母表中的下标('
a' -> 0,'b' -> 1,...,'z' -> 25)。 - 将子字符串中字母的哈希值求和。
- 将和对 26 取余,将结果记为
hashedChar。 - 找到小写字母表中
hashedChar对应的字符,将该字符添加到result的末尾。
返回result。
示例 1
s = "abcd", k = 2 -> "bf"("ab" -> 1 % 26 = 1 -> 'b';"cd" -> 5 % 26 = 5 -> 'f')
示例 2
s = "mxz", k = 3 -> "i"(12 + 23 + 25 = 60,60 % 26 = 8 -> 'i')
解题思路
解法一:按块求和取模,主提交版本
遍历 s,每 k 个字符为一组,累加 char - 'a',对 26 取余后映射回字符追加到结果。
时间复杂度 O(n),空间复杂度 O(n / k)(结果本身)。
解法二:前缀和处理每组和(对照)
先计算前缀和数组 pre(prei+1 = prei + si-'a'),每组和 = prei+k - prei。
时间复杂度 O(n),空间复杂度 O(n)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(n / k)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:按块求和(主提交版本) ----------
public String stringHash(String s, int k) {
StringBuilder ans = new StringBuilder();
int n = s.length();
for (int i = 0; i < n; i += k) {
int t = 0;
for (int j = i; j < i + k; ++j) {
t += s.charAt(j) - 'a';
}
ans.append((char) ('a' + t % 26));
}
return ans.toString();
}
// ---------- 解法二:前缀和(对照) ----------
public String stringHashPre(String s, int k) {
int n = s.length();
int[] pre = new int[n + 1];
for (int i = 0; i < n; ++i) {
pre[i + 1] = pre[i] + (s.charAt(i) - 'a');
}
StringBuilder ans = new StringBuilder();
for (int i = 0; i < n; i += k) {
int t = pre[i + k] - pre[i];
ans.append((char) ('a' + t % 26));
}
return ans.toString();
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] ss = {"abcd", "mxz", "abcdefgh", "zzzz"};
int[] ks = {2, 3, 4, 4};
String[] expects = {"bf", "i", "gw", "w"};
boolean allPass = true;
for (int i = 0; i < ss.length; ++i) {
String a = sol.stringHash(ss[i], ks[i]);
String b = sol.stringHashPre(ss[i], ks[i]);
boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int k = 1 + rnd.nextInt(5);
int groups = 1 + rnd.nextInt(5);
int n = k * groups;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
sb.append((char) ('a' + rnd.nextInt(26)));
}
String s = sb.toString();
String a = sol.stringHash(s, k);
String b = sol.stringHashPre(s, k);
if (!a.equals(b)) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH s=" + s + " k=" + k + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n / k)(结果本身)。
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(n / k)
3272. Find the Count of Good Integers(统计好整数的数目)
题目描述
给你两个正整数 n 和 k。如果一个整数 x 满足以下条件,那么它被称为 k 回文整数:
x是一个回文整数。x能被k整除。
如果一个整数的数位重新排列后能得到一个k回文整数,那么我们称这个整数为好整数。
请你返回n个数位的整数中,有多少个好整数。
注意,任何整数在重新排列数位之前或者之后都不能有前导 0。
示例 1
n = 3, k = 5 -> 27
示例 2
n = 1, k = 4 -> 2(4 和 8)
示例 3
n = 5, k = 6 -> 2468
解题思路
解法一:枚举回文数 + 组合计数去重,主提交版本
n 位回文数由前 ceil(n/2) 位唯一确定,枚举所有前半部分(10^((n-1)/2) 到 10^ceil(n/2)-1),
拼出完整回文串 s,若能被 k 整除,则其"数位多重集"(排序后的数位串)是一种可采用的数字组合。
同一多重集对应的所有好整数个数 = 用这些数字排列出 n 位无前导 0 数的方案数:
总排列数 n! / Π cntd!,减去首位为 0 的排列数 (n-1)! / Π'(少一个 0 后的阶乘)。
用 Set 对多重集去重,累加各多重集的贡献。fx = x! 需预计算到 n。
时间复杂度 O(10^ceil(n/2) * n),空间复杂度 O(n)。
解法二:暴力枚举全部 n 位数(对照,n <= 6)
枚举 10^(n-1) 到 10^n - 1 的所有 n 位整数,检查其数位重排后是否存在一个回文且
被 k 整除的排列:直接检查"最大回文排列"(贪心构造)复杂,这里用排列去重枚举,
或更简单:枚举 x 的全部不同排列(next_permutation 风格),看是否存在回文且 %k==0。
实际实现:生成 n 位数的所有排列会超量,改为对每个 x 统计其数位并判断
"是否存在排列是回文"(数位奇数次个数 <= 1 即可回文)------但这不足以保证被 k 整除。
因此用稳定的做法:对每个 x(n <= 6 时排列数 <= 720)枚举不同排列逐项判 k 回文。
时间复杂度 O(10^n * n!),仅小规模验证。
复杂度:
- 时间复杂度:O(10^ceil(n/2) * n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:枚举回文 + 组合计数(主提交版本) ----------
public long countGoodIntegers(int n, int k) {
long[] fac = new long[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; ++i) {
fac[i] = fac[i - 1] * i;
}
long ans = 0;
Set<String> vis = new HashSet<>();
// 前半部分长度
int half = (n + 1) / 2;
int lo = (int) Math.pow(10, half - 1);
int hi = (int) Math.pow(10, half);
for (int i = lo; i < hi; ++i) {
String s = String.valueOf(i);
StringBuilder sb = new StringBuilder(s).reverse();
StringBuilder full = new StringBuilder(s);
if (n % 2 == 0) {
full.append(sb);
} else {
full.append(sb.substring(1)); // 去掉中间重复位
}
String p = full.toString();
if (Long.parseLong(p) % k != 0) {
continue;
}
char[] arr = p.toCharArray();
Arrays.sort(arr);
String key = new String(arr);
if (vis.contains(key)) {
continue;
}
vis.add(key);
int[] cnt = new int[10];
for (char c : arr) {
cnt[c - '0']++;
}
// 无前导 0 的排列数:总排列 - 首位 0 的排列
long total = fac[n];
for (int c : cnt) {
total /= fac[c];
}
if (cnt[0] > 0) {
long leadZero = fac[n - 1];
leadZero /= fac[cnt[0] - 1];
for (int d = 1; d < 10; ++d) {
leadZero /= fac[cnt[d]];
}
total -= leadZero;
}
ans += total;
}
return ans;
}
// ---------- 解法二:暴力枚举全部排列(对照,n <= 6) ----------
public long countGoodIntegersBrute(int n, int k) {
int lo = (int) Math.pow(10, n - 1);
int hi = (int) Math.pow(10, n);
long ans = 0;
for (int x = lo; x < hi; ++x) {
if (isGood(x, n, k)) {
++ans;
}
}
return ans;
}
// x 是好整数 ⟺ 存在一个 n 位数(首位非 0)的排列,它是回文且被 k 整除
private boolean isGood(int x, int n, int k) {
char[] c = String.valueOf(x).toCharArray();
// 枚举全部不同排列
Arrays.sort(c);
do {
if (c[0] != '0' && isPalin(c) && Long.parseLong(new String(c)) % k == 0) {
return true;
}
} while (nextPerm(c));
return false;
}
private boolean isPalin(char[] c) {
for (int i = 0, j = c.length - 1; i < j; ++i, --j) {
if (c[i] != c[j]) {
return false;
}
}
return true;
}
private boolean nextPerm(char[] c) {
int i = c.length - 2;
while (i >= 0 && c[i] >= c[i + 1]) {
--i;
}
if (i < 0) {
return false;
}
int j = c.length - 1;
while (c[j] <= c[i]) {
--j;
}
char t = c[i];
c[i] = c[j];
c[j] = t;
for (int l = i + 1, r = c.length - 1; l < r; ++l, --r) {
t = c[l];
c[l] = c[r];
c[r] = t;
}
return true;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] cases = {
{3, 5},
{1, 4},
{5, 6},
{2, 1},
{4, 3}
};
long[] expects = {27, 2, 2468, 9, 84};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
long a = sol.countGoodIntegers(cases[i][0], cases[i][1]);
long b = cases[i][0] <= 6 ? sol.countGoodIntegersBrute(cases[i][0], cases[i][1]) : -1;
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " n=" + cases[i][0] + " k=" + cases[i][1]
+ " -> main=" + a + " brute=" + b + " expected=" + expects[i]
+ (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 30; ++t) {
int n = 1 + rnd.nextInt(5);
int k = 1 + rnd.nextInt(9);
long a = sol.countGoodIntegers(n, k);
long b = sol.countGoodIntegersBrute(n, k);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH n=" + n + " k=" + k + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(10^ceil(n/2) * n),空间复杂度 O(n)。
时间复杂度 O(10^n * n!),仅小规模验证。
- 时间复杂度:O(10^ceil(n/2) * n)
- 空间复杂度:O(n)
3273. Minimum Amount of Damage Dealt to Bob(对 Bob 造成的最少伤害)
题目描述
给你一个整数 power 和两个整数数组 damage 和 health,两个数组的长度都为 n。
Bob 有 n 个敌人,如果第 i 个敌人还活着(也就是健康值 health[i] > 0 的时候),
每秒钟会对 Bob 造成 damage[i] 点伤害。
每一秒中,在敌人对 Bob 造成伤害之后,Bob 会选择 一个还活着的敌人进行攻击,
该敌人的健康值减少 power。
请你返回 Bob 将所有 n 个敌人都消灭之前,最少会受到多少伤害。
示例 1
power = 4, damage = [1,2,3,4], health = [4,5,6,8] -> 39
示例 2
power = 1, damage = [1,1,1,1], health = [1,2,3,4] -> 20
示例 3
power = 8, damage = [40], health = [59] -> 320
解题思路
解法一:按"伤害/所需秒数"比值降序贪心(主提交版本)
设敌人 i 需要 ti = ceil(healthi / power) 次攻击才能消灭,即它存活 ti 秒。
若按某个顺序消灭敌人,第 i 个被消灭的敌人存活到时刻 T = 前缀秒数之和,
期间每秒造成 damage 伤害,总伤害为 damage * T。
总伤害 = Σ damagei * (t 的前缀和)。对相邻两个敌人 a、b(时间 t_a/t_b,伤害 d_a/d_b):
a 先杀则贡献 d_at_a + d_b (t_a+t_b),b 先杀则 d_bt_b + d_a (t_b+t_a),
a 先杀更优 ⟺ d_at_b > d_b t_a ⟺ d_a/t_a > d_b/t_b。因此按 d/t 降序击杀最优。
比较用交叉相乘 long 避免浮点。总伤害用 long。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:全排列暴力(对照,n <= 8)
枚举所有消灭顺序,计算每种顺序的总伤害取最小。
时间复杂度 O(n! * n),仅小规模验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:比值贪心(主提交版本) ----------
public long minimumDamage(int power, int[] damage, int[] health) {
int n = damage.length;
Integer[] ord = new Integer[n];
int[] t = new int[n];
for (int i = 0; i < n; ++i) {
ord[i] = i;
t[i] = (health[i] + power - 1) / power; // 消灭所需秒数 = 攻击次数
}
// 按 d/t 降序:d_a * t_b > d_b * t_a 时 a 在前
Arrays.sort(ord, (a, b) -> Long.compare((long) damage[b] * t[a], (long) damage[a] * t[b]));
long cur = 0, ans = 0;
for (int idx : ord) {
cur += t[idx];
ans += (long) damage[idx] * cur;
}
return ans;
}
// ---------- 解法二:全排列暴力(对照,n <= 8) ----------
private long best;
public long minimumDamageBrute(int power, int[] damage, int[] health) {
int n = damage.length;
int[] t = new int[n];
for (int i = 0; i < n; ++i) {
t[i] = (health[i] + power - 1) / power;
}
best = Long.MAX_VALUE;
dfs(t, damage, new boolean[n], 0, 0, 0);
return best;
}
// 已用 sec 秒,已累计 cur 伤害,排列计数 cnt
private void dfs(int[] t, int[] damage, boolean[] used, int cnt, long sec, long cur) {
if (cnt == t.length) {
best = Math.min(best, cur);
return;
}
if (cur >= best) {
return;
}
for (int i = 0; i < t.length; ++i) {
if (!used[i]) {
used[i] = true;
dfs(t, damage, used, cnt + 1, sec + t[i], cur + (long) damage[i] * (sec + t[i]));
used[i] = false;
}
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] damages = {
{1, 2, 3, 4},
{1, 1, 1, 1},
{40},
{3, 1}
};
int[][] healths = {
{4, 5, 6, 8},
{1, 2, 3, 4},
{59},
{1, 1}
};
int[] powers = {4, 1, 8, 2};
long[] expects = {39, 20, 320, 5};
boolean allPass = true;
for (int i = 0; i < damages.length; ++i) {
long a = sol.minimumDamage(powers[i], damages[i], healths[i]);
long b = sol.minimumDamageBrute(powers[i], damages[i], healths[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int n = 1 + rnd.nextInt(8);
int power = 1 + rnd.nextInt(20);
int[] d = new int[n];
int[] h = new int[n];
for (int i = 0; i < n; ++i) {
d[i] = 1 + rnd.nextInt(30);
h[i] = 1 + rnd.nextInt(30);
}
long a = sol.minimumDamage(power, d, h);
long b = sol.minimumDamageBrute(power, d, h);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH power=" + power + " d=" + Arrays.toString(d)
+ " h=" + Arrays.toString(h) + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
时间复杂度 O(n! * n),仅小规模验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3274. Check if Two Chessboard Squares Have the Same Color(检查棋盘方格颜色是否相同)
题目描述
给你两个字符串 coordinate1 和 coordinate2,代表 8 x 8 国际象棋棋盘上的两个方格的坐标。
如果这两个方格颜色相同,返回 true,否则返回 false。
坐标总是表示有效的棋盘方格。坐标的格式总是先字母(表示列),再数字(表示行)。
示例 1
coordinate1 = "a1", coordinate2 = "c3" -> true
示例 2
coordinate1 = "a1", coordinate2 = "h3" -> false
解题思路
解法一:行列奇偶校验,主提交版本
国际象棋盘上,格子的颜色由 (列号 + 行号) 的奇偶性决定:
令 col = c - 'a'(0~7),row = c - '1'(0~7),(col + row) 为偶数的格子同色。
两个格子同色 ⟺ (col1 + row1) 与 (col2 + row2) 奇偶性相同
⟺ ((col1 - col2) + (row1 - row2)) % 2 == 0。
时间复杂度 O(1),空间复杂度 O(1)。
解法二:单独求每格颜色后比较(对照)
分别计算两个格子的颜色((col + row) % 2),比较是否相等。
时间复杂度 O(1),空间复杂度 O(1)。
复杂度:
- 时间复杂度:O(1)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:行列差奇偶校验(主提交版本) ----------
public boolean checkTwoChessboards(String coordinate1, String coordinate2) {
int x = coordinate1.charAt(0) - coordinate2.charAt(0);
int y = coordinate1.charAt(1) - coordinate2.charAt(1);
return (x + y) % 2 == 0;
}
// ---------- 解法二:逐格求色后比较(对照) ----------
public boolean checkTwoChessboardsBrute(String coordinate1, String coordinate2) {
return color(coordinate1) == color(coordinate2);
}
// 0 = 黑,1 = 白(这里只需比较相对值)
private int color(String c) {
return (c.charAt(0) - 'a' + c.charAt(1) - '1') % 2;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[][] cases = {
{"a1", "c3"},
{"a1", "h3"},
{"a1", "a1"},
{"h1", "a8"}
};
boolean[] expects = {true, false, true, true};
boolean allPass = true;
for (int i = 0; i < cases.length; ++i) {
boolean a = sol.checkTwoChessboards(cases[i][0], cases[i][1]);
boolean b = sol.checkTwoChessboardsBrute(cases[i][0], cases[i][1]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
String c1 = "" + (char) ('a' + rnd.nextInt(8)) + (char) ('1' + rnd.nextInt(8));
String c2 = "" + (char) ('a' + rnd.nextInt(8)) + (char) ('1' + rnd.nextInt(8));
boolean a = sol.checkTwoChessboards(c1, c2);
boolean b = sol.checkTwoChessboardsBrute(c1, c2);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH c1=" + c1 + " c2=" + c2 + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(1),空间复杂度 O(1)。
- 时间复杂度:O(1)
- 空间复杂度:O(1)
3275. K-th Nearest Obstacle Queries(第 K 近障碍物查询)
题目描述
有一个无限大的二维平面。给你一个正整数 k,同时给你一个二维数组 queries,包含一系列查询:
queries[i] = `x`, `y`:在平面上坐标 (x, y) 处建一个障碍物,数据保证之前的查询不会在这个坐标处建立任何障碍物。
每次查询后,你需要找到离原点第 k 近障碍物到原点的距离。
请你返回一个整数数组 results,其中 results[i] 表示建立第 i 个障碍物以后,离原地第 k 近障碍物距离原点的距离。
如果少于 k 个障碍物,results[i] == -1。
坐标在 (x, y) 处的点距离原点的距离定义为 |x| + |y|。
示例 1
queries = [[1,2],[3,4],[2,3],[-3,0]], k = 2 -> [-1,7,5,3]
示例 2
queries = [[5,5],[4,4],[3,3]], k = 1 -> [10,8,6]
解题思路
解法一:大小为 k 的最大堆维护第 k 小距离,主提交版本
对每个新障碍物计算曼哈顿距离 |x| + |y|,压入最大堆(堆顶是堆中最大,即当前最大的距离)。
若堆大小超过 k,弹出堆顶(淘汰当前第 k+1 大)。这样堆顶始终保持第 k 小的距离。
不足 k 个时答案为 -1。时间复杂度 O(n log k),空间复杂度 O(k)。
解法二:每次排序取第 k 小(对照)
每插入一个障碍物,把当前所有距离排序,若长度 >= k 取第 k 小。
时间复杂度 O(n^2 log n),仅小规模验证。
复杂度:
- 时间复杂度:O(n log k)
- 空间复杂度:O(k)
代码实现
java
import java.util.Arrays;
import java.util.Collections;
import java.util.PriorityQueue;
import java.util.Random;
public class Solution {
// ---------- 解法一:大小为 k 的最大堆(主提交版本) ----------
public int[] resultsArray(int[][] queries, int k) {
int n = queries.length;
int[] ans = new int[n];
PriorityQueue<Integer> pq = new PriorityQueue<>(Collections.reverseOrder());
for (int i = 0; i < n; ++i) {
int d = Math.abs(queries[i][0]) + Math.abs(queries[i][1]);
pq.offer(d);
if (i >= k) {
pq.poll();
}
ans[i] = i >= k - 1 ? pq.peek() : -1;
}
return ans;
}
// ---------- 解法二:排序取第 k 小(对照) ----------
public int[] resultsArrayBrute(int[][] queries, int k) {
int n = queries.length;
int[] ans = new int[n];
int[] ds = new int[n];
int cnt = 0;
for (int i = 0; i < n; ++i) {
ds[cnt++] = Math.abs(queries[i][0]) + Math.abs(queries[i][1]);
if (cnt < k) {
ans[i] = -1;
} else {
int[] sorted = Arrays.copyOf(ds, cnt);
Arrays.sort(sorted);
ans[i] = sorted[k - 1];
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][][] qs = {
{{1, 2}, {3, 4}, {2, 3}, {-3, 0}},
{{5, 5}, {4, 4}, {3, 3}}
};
int[] ks = {2, 1};
int[][] expects = {
{-1, 7, 5, 3},
{10, 8, 6}
};
boolean allPass = true;
for (int i = 0; i < qs.length; ++i) {
int[] a = sol.resultsArray(qs[i], ks[i]);
int[] b = sol.resultsArrayBrute(qs[i], ks[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> main=" + Arrays.toString(a) + " brute="
+ Arrays.toString(b) + " expected=" + Arrays.toString(expects[i])
+ (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 300; ++t) {
int n = 1 + rnd.nextInt(20);
int k = 1 + rnd.nextInt(6);
int[][] q = new int[n][2];
for (int i = 0; i < n; ++i) {
q[i][0] = rnd.nextInt(21) - 10;
q[i][1] = rnd.nextInt(21) - 10;
}
int[] a = sol.resultsArray(q, k);
int[] b = sol.resultsArrayBrute(q, k);
if (!Arrays.equals(a, b)) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH k=" + k + " q=" + Arrays.deepToString(q)
+ " main=" + Arrays.toString(a) + " brute=" + Arrays.toString(b));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
不足 k 个时答案为 -1。时间复杂度 O(n log k),空间复杂度 O(k)。
时间复杂度 O(n^2 log n),仅小规模验证。
- 时间复杂度:O(n log k)
- 空间复杂度:O(k)
3276. Select Cells in Grid With Maximum Score(选择矩阵中单元格的最大得分)
题目描述
给你一个由正整数构成的二维矩阵 grid。你需要从矩阵中选择一个或多个单元格,选中的单元格应满足以下条件:
- 所选单元格中的任意两个单元格都不会处于矩阵的同一行。
- 所选单元格的值互不相同。
你的得分为所选单元格值的总和。返回你能获得的最大得分。
示例 1
grid = [[1,2,3],[4,3,2],[1,1,1]] -> 8(选 1、3、4)
示例 2
grid = [[8,7,6],[8,3,2]] -> 15(选 7 和 8)
解题思路
解法一:按值从小到大 DP + 行位掩码,主提交版本
值 <= 100,行数 m <= 10。gxi 表示值 x 出现在第 i 行。对值 x 从 1 到 100 做 DP:
fxmask = 使用前 x 个值、已选行集合为 mask 的最大得分(mask 共 1<<m 种)。
转移:不选值 x:fxmask = max(fxmask, fx-1mask);
选值 x 在第 i 行(要求 mask 含 i 位):fxmask = max(fxmask, fx-1mask\^(1\<\ + x)。
答案 = f100(1\<\
时间复杂度 O(100 * 2^m * m),空间 O(100 * 2^m)。
解法二:逐列深度优先枚举(对照,小规模)
按"值"降序直接回溯:遍历每个值,尝试放入还没占用的行,或跳过,枚举所有组合取最大得分。
时间复杂度 O(2^(值数 * 行数)),仅小规模验证。
复杂度:
- 时间复杂度:O(100 * 2^m * m)
- 空间复杂度:O(100 * 2^m)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:按值 DP + 行掩码(主提交版本) ----------
public int maxScore(List<List<Integer>> grid) {
int m = grid.size();
int mx = 0;
boolean[][] g = new boolean[101][m];
for (int i = 0; i < m; ++i) {
for (int x : grid.get(i)) {
g[x][i] = true;
mx = Math.max(mx, x);
}
}
int[][] f = new int[mx + 1][1 << m];
// f[0][*] = 0
for (int x = 1; x <= mx; ++x) {
for (int mask = 0; mask < 1 << m; ++mask) {
f[x][mask] = f[x - 1][mask];
for (int i = 0; i < m; ++i) {
if (g[x][i] && (mask >> i & 1) == 1) {
f[x][mask] = Math.max(f[x][mask], f[x - 1][mask ^ (1 << i)] + x);
}
}
}
}
return f[mx][(1 << m) - 1];
}
// ---------- 解法二:DFS 枚举(对照,小规模) ----------
private int best;
private boolean[] usedVal;
public int maxScoreBrute(List<List<Integer>> grid) {
int m = grid.size();
best = 0;
// 收集所有 (值, 行)
List<int[]> cells = new ArrayList<>();
for (int i = 0; i < m; ++i) {
for (int x : grid.get(i)) {
cells.add(new int[] {x, i});
}
}
// 值降序排序便于剪枝
cells.sort((a, b) -> b[0] - a[0]);
usedVal = new boolean[101];
dfs(cells, 0, 0, 0);
return best;
}
private void dfs(List<int[]> cells, int idx, int rowMask, int score) {
if (idx == cells.size()) {
best = Math.max(best, score);
return;
}
// 剪枝:即使后面全部选上也超不过当前最优
long rem = 0;
for (int i = idx; i < cells.size(); ++i) {
rem += cells.get(i)[0];
}
if (score + rem <= best) {
return;
}
int v = cells.get(idx)[0];
int r = cells.get(idx)[1];
// 不选
dfs(cells, idx + 1, rowMask, score);
// 选(行未占用且值未占用)
if ((rowMask >> r & 1) == 0 && !usedVal[v]) {
usedVal[v] = true;
dfs(cells, idx + 1, rowMask | (1 << r), score + v);
usedVal[v] = false;
}
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][][] grids = {
{{1, 2, 3}, {4, 3, 2}, {1, 1, 1}},
{{8, 7, 6}, {8, 3, 2}},
{{5}},
{{7, 7}, {7, 7}}
};
int[] expects = {8, 15, 5, 7};
boolean allPass = true;
for (int i = 0; i < grids.length; ++i) {
List<List<Integer>> g = new ArrayList<>();
for (int[] row : grids[i]) {
List<Integer> r = new ArrayList<>();
for (int v : row) {
r.add(v);
}
g.add(r);
}
int a = sol.maxScore(g);
int b = sol.maxScoreBrute(g);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
// 小而稠密网格的随机对拍
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 200; ++t) {
int m = 1 + rnd.nextInt(3);
int n = 1 + rnd.nextInt(3);
int[][] gg = new int[m][n];
for (int i = 0; i < m; ++i) {
for (int j = 0; j < n; ++j) {
gg[i][j] = 1 + rnd.nextInt(8);
}
}
List<List<Integer>> g = new ArrayList<>();
for (int[] row : gg) {
List<Integer> r = new ArrayList<>();
for (int v : row) {
r.add(v);
}
g.add(r);
}
int a = sol.maxScore(g);
int b = sol.maxScoreBrute(g);
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH g=" + Arrays.deepToString(gg) + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(100 * 2^m * m),空间 O(100 * 2^m)。
时间复杂度 O(2^(值数 * 行数)),仅小规模验证。
- 时间复杂度:O(100 * 2^m * m)
- 空间复杂度:O(100 * 2^m)
3277. Maximum XOR Score Subarray Queries(查询子数组最大异或分数)
题目描述
给你一个由 n 个整数组成的数组 nums,以及一个大小为 q 的二维整数数组 queries,
其中 queries[i] = `li`, `ri`。对于每一个查询,你需要找出 nums`li`...`ri` 中任意子数组的
最大异或分数。
数组的异或分数需要对数组 a 反复执行以下操作,直到只剩一个元素,剩下的那个元素就是异或分数:
- 对于除最后一个下标以外的所有下标
i,同时将a[i]替换为a[i]XORa[i + 1]。 - 移除数组的最后一个元素。
返回一个大小为q的数组answer,其中answer[i]表示查询i的答案。
示例 1
nums = [2,8,4,32,16,1], queries = [[0,2],[1,4],[0,5]] -> [12,60,60]
示例 2
nums = [0,7,3,2,8,5,1], queries = [[0,3],[1,5],[2,4],[2,6],[5,6]] -> [7,14,11,14,5]
解题思路
解法一:区间 DP,主提交版本
对长度为 L 的数组 a 做"相邻异或然后删尾"的过程,最终结果等于原数组所有元素
按二项式系数奇偶异或:f(l, r) = XOR_{i} ( C(r-l, i-l) % 2 ? numsi : 0 )。
由于 C 的奇偶性满足帕斯卡三角奇偶(Sierpinski 三角),可等价递推:
flr = flr-1 ^ fl+1r,边界 fii = numsi。
子数组的最大异或分数 glr = max(flr, glr-1, gl+1r),
即"整个异或分数"与"左侧更短子数组的最大值""右侧更短子数组的最大值"取最大。
预处理 O(n^2),每个查询 O(1)。
时间复杂度 O(n^2 + q),空间复杂度 O(n^2)。
解法二:直接模拟子数组(对照,小规模)
对每个查询的子数组,枚举全部子区间,每个区间按题意模拟"相邻异或删尾"直至单元素。
时间复杂度 O(q * len^3),仅小规模验证。
复杂度:
- 时间复杂度:O(n^2 + q)
- 空间复杂度:O(n^2)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:区间 DP(主提交版本) ----------
public int[] maximumSubarrayXor(int[] nums, int[][] queries) {
int n = nums.length;
int[][] f = new int[n][n]; // f[l][r] = 区间 [l, r] 的异或分数
int[][] g = new int[n][n]; // g[l][r] = 区间 [l, r] 内子数组的最大异或分数
for (int i = n - 1; i >= 0; --i) {
f[i][i] = nums[i];
g[i][i] = nums[i];
for (int j = i + 1; j < n; ++j) {
f[i][j] = f[i][j - 1] ^ f[i + 1][j];
g[i][j] = Math.max(f[i][j], Math.max(g[i][j - 1], g[i + 1][j]));
}
}
int m = queries.length;
int[] ans = new int[m];
for (int i = 0; i < m; ++i) {
int l = queries[i][0], r = queries[i][1];
ans[i] = g[l][r];
}
return ans;
}
// ---------- 解法二:直接模拟(对照,小规模) ----------
public int[] maximumSubarrayXorBrute(int[] nums, int[][] queries) {
int n = nums.length;
int m = queries.length;
int[] ans = new int[m];
for (int qi = 0; qi < m; ++qi) {
int l = queries[qi][0], r = queries[qi][1];
int best = 0;
for (int a = l; a <= r; ++a) {
for (int b = a; b <= r; ++b) {
best = Math.max(best, score(nums, a, b));
}
}
ans[qi] = best;
}
return ans;
}
// 模拟"相邻异或删尾"求区间 [l, r] 的异或分数(结果 = 二项式系数奇偶异或)
private int score(int[] nums, int l, int r) {
int len = r - l + 1;
int res = 0;
for (int i = 0; i < len; ++i) {
if (((combParity(len - 1, i))) == 1) {
res ^= nums[l + i];
}
}
return res;
}
// 组合数的奇偶性:C(n,k) 为奇数 ⟺ k 是 n 的子集(位运算 n & k == k)
private int combParity(int n, int k) {
return (n & k) == k ? 1 : 0;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[][] numsList = {
{2, 8, 4, 32, 16, 1},
{0, 7, 3, 2, 8, 5, 1}
};
int[][][] qs = {
{{0, 2}, {1, 4}, {0, 5}},
{{0, 3}, {1, 5}, {2, 4}, {2, 6}, {5, 6}}
};
int[][] expects = {
{12, 60, 60},
{7, 14, 11, 14, 5}
};
boolean allPass = true;
for (int i = 0; i < numsList.length; ++i) {
int[] a = sol.maximumSubarrayXor(numsList[i], qs[i]);
int[] b = sol.maximumSubarrayXorBrute(numsList[i], qs[i]);
boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> main=" + Arrays.toString(a) + " brute="
+ Arrays.toString(b) + " expected=" + Arrays.toString(expects[i])
+ (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 200; ++t) {
int n = 1 + rnd.nextInt(8);
int[] nums = new int[n];
for (int i = 0; i < n; ++i) {
nums[i] = rnd.nextInt(100);
}
int q = 1 + rnd.nextInt(8);
int[][] queries = new int[q][2];
for (int i = 0; i < q; ++i) {
int l = rnd.nextInt(n);
int r = l + rnd.nextInt(n - l);
queries[i][0] = l;
queries[i][1] = r;
}
int[] a = sol.maximumSubarrayXor(nums, queries);
int[] b = sol.maximumSubarrayXorBrute(nums, queries);
if (!Arrays.equals(a, b)) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH nums=" + Arrays.toString(nums) + " q="
+ Arrays.deepToString(queries) + " main=" + Arrays.toString(a)
+ " brute=" + Arrays.toString(b));
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n^2 + q),空间复杂度 O(n^2)。
时间复杂度 O(q * len^3),仅小规模验证。
- 时间复杂度:O(n^2 + q)
- 空间复杂度:O(n^2)
3278. Find Candidates for Data Scientist Position II(寻找数据科学家职位的候选人 II)
题目类型:数据库(SQL)
题目描述
表:Candidates
+--------------+---------+
| Column Name | Type |
+--------------+---------+
| candidate_id | int |
| skill | varchar |
| proficiency | int |
+--------------+---------+
(candidate_id, skill) 是这张表的主键。每一行包括 candidate_id 和技能,以及熟练程度(1-5)。
表:Projects
+--------------+---------+
| Column Name | Type |
+--------------+---------+
| project_id | int |
| skill | varchar |
| importance | int |
+--------------+---------+
(project_id, skill) 是这张表的主键。每一行包括 project_id、所需技能,以及项目的重要性(1-5)。
编写一个解决方案来根据以下条件为每一个项目 找到最佳候选人:
- 候选人必须拥有项目所需的所有技能。
- 为每个候选人-项目对计算如下的分数 :从
100分开始;对于每一个技能,当熟练程度 > 重要性加10分;当熟练程度 < 重要性减5分;相等则分数保持不变。
仅包括每个项目的最佳候选人(最高分)。如果相同,选择有更小 candidate_id 的候选人。如果一个项目没有 适合的候选人,不要返回那个项目。返回结果表以 project_id 升序排序。
示例 1:
输入:
Candidates 表:
+--------------+-----------+-------------+
| candidate_id | skill | proficiency |
+--------------+-----------+-------------+
| 101 | Python | 5 |
| 101 | Tableau | 3 |
| 101 | PostgreSQL| 4 |
| 101 | TensorFlow| 2 |
| 102 | Python | 4 |
| 102 | Tableau | 5 |
| 102 | PostgreSQL| 4 |
| 102 | R | 4 |
| 103 | Python | 3 |
| 103 | Tableau | 5 |
| 103 | PostgreSQL| 5 |
| 103 | Spark | 4 |
+--------------+-----------+-------------+
Projects 表:
+-------------+-----------+------------+
| project_id | skill | importance |
+-------------+-----------+------------+
| 501 | Python | 4 |
| 501 | Tableau | 3 |
| 501 | PostgreSQL| 5 |
| 502 | Python | 3 |
| 502 | Tableau | 4 |
| 502 | R | 2 |
+-------------+-----------+------------+
输出:
+-------------+--------------+-------+
| project_id | candidate_id | score |
+-------------+--------------+-------+
| 501 | 101 | 105 |
| 502 | 102 | 130 |
+-------------+--------------+-------+
解释:项目 501(需 Python/Tableau/PostgreSQL):候选人 101/102/103 均具备且同得 105 分,取最小 candidate_id 为 101;项目 502 需要技能 R,仅候选人 102 具备全部技能,得分 100 + 10 + 10 + 10 = 130。
解题思路
候选人必须覆盖项目全部技能,这决定了两张表必须按 skill 连接后,对 (project_id, candidate_id) 分组并核对匹配技能数 == 项目技能总数 (用 HAVING COUNT(*) = (SELECT COUNT(*) FROM Projects p2 WHERE p2.project_id = ...) 或窗口总数判断)。分数用 SUM(CASE WHEN proficiency > importance THEN 10 WHEN proficiency < importance THEN -5 ELSE 0 END) + 100 累计。随后用 ROW_NUMBER() OVER (PARTITION BY project_id ORDER BY score DESC, candidate_id ASC) 选出每项目最高分、同分取最小 id 的候选人,无合适候选人的项目自然为空不出现在结果中。
代码实现
sql
WITH scored AS (
SELECT p.project_id,
c.candidate_id,
100 + SUM(CASE WHEN c.proficiency > p.importance THEN 10
WHEN c.proficiency < p.importance THEN -5
ELSE 0 END) AS score,
COUNT(*) AS covered_skills
FROM Projects p
JOIN Candidates c ON c.skill = p.skill
GROUP BY p.project_id, c.candidate_id
HAVING COUNT(*) = (SELECT COUNT(*) FROM Projects p2 WHERE p2.project_id = p.project_id)
),
ranked AS (
SELECT project_id, candidate_id, score,
ROW_NUMBER() OVER (
PARTITION BY project_id
ORDER BY score DESC, candidate_id ASC
) AS rn
FROM scored
)
SELECT project_id, candidate_id, score
FROM ranked
WHERE rn = 1
ORDER BY project_id;
复杂度分析
本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。
3279. Maximum Total Area Occupied by Pistons(活塞占据的最大总区域)
题目描述
一台旧车的引擎中有一些活塞,我们想要计算活塞下方的最大区域。
给定:
- 一个整数
height,表示活塞最大可到达的高度。 - 一个整数数组
positions,其中positions[i]是活塞i的当前位置,等于其下方的当前区域。 - 一个字符串
directions,其中directions[i]是活塞i的当前移动方向,'U' 表示向上,'D' 表示向下。
每一秒:每个活塞向它的当前方向移动 1 单位;如果一个活塞到达了其中一个终点,
即positions[i]== 0 或positions[i]==height,它的方向将会改变。
返回所有活塞下方的最大可能区域。
示例 1
height = 5, positions = [2,5], directions = "UD" -> 7
示例 2
height = 6, positions = [0,0,6,3], directions = "UUDU" -> 15(3 秒后 [3,3,3,6])
解题思路
解法一:事件扫描 / 差分斜率(主提交版本)
每个活塞在 0, height 之间做匀速折返运动,周期 2height。所有活塞位置之和
total(t) 是时间的分段线性函数,其斜率会发生变化只发生在某些活塞到达端点(0 或 height)
并反转方向的时刻。
对活塞 i(位置 p、方向 U):初始时刻其位置随时间 +1(斜率贡献 +1);
到达顶点的时刻 t = height - p(位置 = height)反转方向,之后斜率贡献变 -1,
即斜率变化量 -2;到达底点的时刻 t = 2 height - p 再反转回 +1,斜率变化量 +2。
方向 D 同理:初始斜率贡献 -1;到达底点 t = p 斜率 +2;到达顶点 t = height + p 斜率 -2。
用 TreeMap 记录"时刻 -> 斜率总变化量",初始 res = Σ p,初始总斜率 diff = (#U) - (#D)。
按事件时刻由小到大扫描:在到达事件时刻 cur 之前,面积以旧斜率 diff 线性变化,
res += diff * (cur - pre);到达 cur 后叠加事件斜率变化 d,取过程中最大值。
只需记录 0, 2*height 内每个活塞首次的两个折点时刻(再往后周期性重复)。
时间复杂度 O(n log n),空间复杂度 O(n)。
解法二:按秒模拟全周期(对照,小规模)
直接模拟 t = 0...2* height 时刻的所有活塞位置(到端点反向),记录总面积最大值。
因为状态周期为 2height,模拟一个完整周期即覆盖所有可能的面积。
时间复杂度 O(2 height * n),仅小规模验证。
复杂度:
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.Arrays;
import java.util.Map;
import java.util.Random;
import java.util.TreeMap;
public class Solution {
// ---------- 解法一:事件扫描 / 差分斜率(主提交版本) ----------
public long maxArea(int height, int[] positions, String directions) {
Map<Integer, Integer> delta = new TreeMap<>();
int diff = 0; // 当前总斜率
long res = 0; // t = 0 时刻总面积
int n = positions.length;
for (int i = 0; i < n; ++i) {
int p = positions[i];
char dir = directions.charAt(i);
res += p;
if (dir == 'U') {
++diff;
// 到顶:height - p 时刻斜率 -2
delta.merge(height - p, -2, Integer::sum);
// 到底:2*height - p 时刻斜率 +2
delta.merge(2 * height - p, 2, Integer::sum);
} else {
--diff;
// 到底:p 时刻斜率 +2
delta.merge(p, 2, Integer::sum);
// 到顶:height + p 时刻斜率 -2
delta.merge(height + p, -2, Integer::sum);
}
}
long ans = res;
int pre = 0;
for (Map.Entry<Integer, Integer> e : delta.entrySet()) {
int cur = e.getKey();
int d = e.getValue();
res += (long) (cur - pre) * diff; // 旧斜率走到 cur 时刻
pre = cur;
diff += d; // 到达 cur 后应用斜率跳变
ans = Math.max(ans, res);
}
return ans;
}
// ---------- 解法二:按秒模拟全周期(对照,小规模) ----------
public long maxAreaBrute(int height, int[] positions, String directions) {
int n = positions.length;
long ans = 0;
int[] cur = positions.clone();
char[] dir = directions.toCharArray();
int period = 2 * height;
for (int t = 0; t < period; ++t) {
long s = 0;
for (int i = 0; i < n; ++i) {
s += cur[i];
}
ans = Math.max(ans, s);
// 推进 1 秒:端点处先按物理反弹(否则会越界),再移动
for (int i = 0; i < n; ++i) {
if (cur[i] == 0) {
dir[i] = 'U';
} else if (cur[i] == height) {
dir[i] = 'D';
}
cur[i] += dir[i] == 'U' ? 1 : -1;
}
}
return ans;
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
int[] hs = {5, 6, 4, 10};
int[][] ps = {
{2, 5},
{0, 0, 6, 3},
{2, 2, 3},
{4, 1, 7, 0, 10}
};
String[] ds = {"UD", "UUDU", "DUU", "UUDDD"};
long[] expects = {7, 15, 8, 29};
boolean allPass = true;
for (int i = 0; i < hs.length; ++i) {
long a = sol.maxArea(hs[i], ps[i], ds[i]);
long b = sol.maxAreaBrute(hs[i], ps[i], ds[i]);
boolean ok = a == expects[i] && b == expects[i];
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 500; ++t) {
int h = 2 + rnd.nextInt(20);
int n = 1 + rnd.nextInt(5);
int[] p = new int[n];
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; ++i) {
p[i] = rnd.nextInt(h + 1);
sb.append(rnd.nextInt(2) == 0 ? 'U' : 'D');
}
long a = sol.maxArea(h, p, sb.toString());
long b = sol.maxAreaBrute(h, p, sb.toString());
if (a != b) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH h=" + h + " p=" + Arrays.toString(p)
+ " d=" + sb + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(n log n),空间复杂度 O(n)。
时间复杂度 O(2*height * n),仅小规模验证。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
3280. Convert Date to Binary(将日期转换为二进制表示)
题目描述
给你一个字符串 date,它的格式为 yyyy-mm-dd,表示一个公历日期。
date 可以重写为二进制表示,只需要将年、月、日分别转换为对应的二进制表示
(不带前导零)并遵循 year-month-day 的格式。返回 date 的二进制表示。
示例 1
date = "2080-02-29" -> "100000100000-10-11101"
示例 2
date = "1900-01-01" -> "11101101100-1-1"
解题思路
解法一:拆分后逐段转二进制,主提交版本
按 '-' 拆分日期串得到年/月/日三个十进制串,各自 parseInt 后用
Integer.toBinaryString 转二进制(自带无前导零),再用 '-' 连接。
时间复杂度 O(|date|),空间复杂度 O(|date|)。
解法二:手写除 2 取余转换(对照)
对每个十进制数 x,循环 x % 2 收集余数再反转,得到二进制串。
时间复杂度 O(|date|),空间复杂度 O(|date|)。
复杂度:
- 时间复杂度:O(|date|)
- 空间复杂度:O(|date|)
代码实现
java
import java.util.ArrayList;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:拆分 + Integer.toBinaryString(主提交版本) ----------
public String convertDateToBinary(String date) {
List<String> ans = new ArrayList<>();
for (String s : date.split("-")) {
int x = Integer.parseInt(s);
ans.add(Integer.toBinaryString(x));
}
return String.join("-", ans);
}
// ---------- 解法二:手写除 2 取余(对照) ----------
public String convertDateToBinaryManual(String date) {
String[] parts = date.split("-");
StringBuilder sb = new StringBuilder();
for (int i = 0; i < parts.length; ++i) {
if (i > 0) {
sb.append('-');
}
sb.append(toBinary(Integer.parseInt(parts[i])));
}
return sb.toString();
}
private String toBinary(int x) {
if (x == 0) {
return "0";
}
StringBuilder sb = new StringBuilder();
while (x > 0) {
sb.append((char) ('0' + (x & 1)));
x >>= 1;
}
return sb.reverse().toString();
}
// ---------- 本地测试 ----------
public static void main(String[] args) {
Solution sol = new Solution();
String[] dates = {"2080-02-29", "1900-01-01", "2024-12-31", "2100-12-31"};
String[] expects = {"100000100000-10-11101", "11101101100-1-1",
"11111101000-1100-11111", "100000110100-1100-11111"};
boolean allPass = true;
for (int i = 0; i < dates.length; ++i) {
String a = sol.convertDateToBinary(dates[i]);
String b = sol.convertDateToBinaryManual(dates[i]);
boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
allPass &= ok;
System.out.println("case " + i + " -> main=" + a + " brute=" + b
+ " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
}
Random rnd = new Random(42);
int fail = 0;
for (int t = 0; t < 300; ++t) {
int y = 1900 + rnd.nextInt(201);
int m = 1 + rnd.nextInt(12);
int d = 1 + rnd.nextInt(28);
String date = String.format("%04d-%02d-%02d", y, m, d);
String a = sol.convertDateToBinary(date);
String b = sol.convertDateToBinaryManual(date);
if (!a.equals(b)) {
++fail;
if (fail <= 3) {
System.out.println("MISMATCH date=" + date + " main=" + a + " brute=" + b);
}
}
}
System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
}
}
复杂度分析
时间复杂度 O(|date|),空间复杂度 O(|date|)。
- 时间复杂度:O(|date|)
- 空间复杂度:O(|date|)