LeetCode 2981-3000. 题解合集
文章目录
- [LeetCode 2981-3000. 题解合集](#LeetCode 2981-3000. 题解合集)
-
- [2981. Find Longest Special Substring That Occurs Thrice I(找出出现至少三次的最长特殊子字符串 I)](#2981. Find Longest Special Substring That Occurs Thrice I(找出出现至少三次的最长特殊子字符串 I))
- [2982. Find Longest Special Substring That Occurs Thrice II(找出出现至少三次的最长特殊子字符串 II)](#2982. Find Longest Special Substring That Occurs Thrice II(找出出现至少三次的最长特殊子字符串 II))
- [2983. Palindrome Rearrangement Queries(回文串重新排列查询)](#2983. Palindrome Rearrangement Queries(回文串重新排列查询))
- [2984. Find Peak Calling Hours for Each City(找到每座城市的高峰通话小时)](#2984. Find Peak Calling Hours for Each City(找到每座城市的高峰通话小时))
- [2985. Calculate Compressed Mean(计算订单平均商品数量)](#2985. Calculate Compressed Mean(计算订单平均商品数量))
- [2986. Find Third Transaction(找到第三笔交易)](#2986. Find Third Transaction(找到第三笔交易))
- [2987. Find Expensive Cities(寻找房价最贵的城市)](#2987. Find Expensive Cities(寻找房价最贵的城市))
- [2988. Manager of the Largest Department(最大部门的经理)](#2988. Manager of the Largest Department(最大部门的经理))
- [2989. Class Performance(班级表现)](#2989. Class Performance(班级表现))
- [2990. Loan Types(贷款类型)](#2990. Loan Types(贷款类型))
- [2991. Top Three Wineries(最好的三家酒庄)](#2991. Top Three Wineries(最好的三家酒庄))
- [2992. Number of Self-Divisible Permutations(自整除排列的数量)](#2992. Number of Self-Divisible Permutations(自整除排列的数量))
- [2993. Friday Purchases I(发生在周五的交易 I)](#2993. Friday Purchases I(发生在周五的交易 I))
- [2994. Friday Purchases II(发生在周五的交易 II)](#2994. Friday Purchases II(发生在周五的交易 II))
- [2995. Viewers Turned Streamers(观众变主播)](#2995. Viewers Turned Streamers(观众变主播))
- [2996. Smallest Missing Integer Greater Than Sequential Prefix Sum(大于等于顺序前缀和的最小缺失整数)](#2996. Smallest Missing Integer Greater Than Sequential Prefix Sum(大于等于顺序前缀和的最小缺失整数))
- [2997. Minimum Number of Operations to Make Array XOR Equal to K(使数组异或和等于 K 的最少操作次数)](#2997. Minimum Number of Operations to Make Array XOR Equal to K(使数组异或和等于 K 的最少操作次数))
- [2998. Minimum Number of Operations to Make X and Y Equal(使 X 和 Y 相等的最少操作次数)](#2998. Minimum Number of Operations to Make X and Y Equal(使 X 和 Y 相等的最少操作次数))
- [2999. Count the Number of Powerful Integers(统计强大整数的数目)](#2999. Count the Number of Powerful Integers(统计强大整数的数目))
- [3000. Maximum Area of Longest Diagonal Rectangle(对角线最长的矩形的面积)](#3000. Maximum Area of Longest Diagonal Rectangle(对角线最长的矩形的面积))
2981. Find Longest Special Substring That Occurs Thrice I(找出出现至少三次的最长特殊子字符串 I)
题目描述
LeetCode 2982. Find Longest Special Substring That Occurs Thrice II(同题 II,n 更大)
特殊字符串:仅由单一字符组成。返回 s 中出现至少三次的最长特殊子字符串长度;不存在返回 -1。
示例 1
s="aaaa" -> 2("aa" 出现三次)
示例 2
s="abcdef" -> -1
示例 3
s="abcaba" -> 1
提示:
- 3 <=
s.length<= 50(I)/ 5e5(II) s仅含小写字母
解题思路
解法一:按字符分组,取同字符连续段长度
特殊子串必然落在某个"同字符连续段"内。对每个字符 c,收集 s 中所有由 c 组成的连续段
长度,降序为 L1 >= L2 >= L3...。出现次数 = 各段贡献 (Li - x + 1) 之和(Li < x 的段不贡献),
要 >= 3:
- 段内:单段 L1 贡献 L1-x+1 >= 3 → x <= L1-2;
- 两段:段 L1、L2 贡献 (L1-x+1)+(L2-x+1) >= 3。若 L1 > L2,x 可取 min(L1,L2);
若 L1 == L2,x 至多 L1-1(各段出现 2 次共 4 次)→ 统一为 x <= min(L1-1, L2); - 三段:L1、L2、L3 各贡献 1 次 → x <= min(L1, L2, L3)。
官方公式:答案候选 = max(L1-2, min(L1-1, L2), min(L1, L2, L3))(取前三大段,结果 <1 时无效)。
时间复杂度 O(n log n)(排序 26 组段长),空间 O(n)。
解法二:哈希计数暴力(对照)
小规模:枚举所有特殊子串,用哈希计数出现次数(对照)。
复杂度: - 时间复杂度:O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:分段统计(主提交版本) ----------
public int maximumLength(String s) {
int n = s.length();
@SuppressWarnings("unchecked")
List<Integer>[] segs = new List[26];
for (int i = 0; i < 26; i++) segs[i] = new ArrayList<>();
int i = 0;
while (i < n) {
int j = i;
while (j < n && s.charAt(j) == s.charAt(i)) j++;
segs[s.charAt(i) - 'a'].add(j - i);
i = j;
}
int ans = -1;
for (int c = 0; c < 26; c++) {
List<Integer> list = segs[c];
if (list.isEmpty()) continue;
list.sort((a, b) -> Integer.compare(b, a)); // 降序
int m = list.size();
// 段内:L1-2
if (list.get(0) >= 3) ans = Math.max(ans, list.get(0) - 2);
// 两段:min(L1-1, L2)
if (m >= 2) {
int t2 = Math.min(list.get(0) - 1, list.get(1));
if (t2 >= 1) ans = Math.max(ans, t2);
}
// 三段:min(L1, L2, L3)
if (m >= 3) {
int t = Math.min(list.get(0), Math.min(list.get(1), list.get(2)));
// 可能为 0/1;只有 >= 1 才算有效
if (t >= 1) ans = Math.max(ans, t);
}
}
return ans;
}
// ---------- 解法二:哈希计数暴力(对照,小规模) ----------
public int maximumLengthBrute(String s) {
int n = s.length();
Map<String, Integer> cnt = new HashMap<>();
for (int i = 0; i < n; i++) {
StringBuilder sb = new StringBuilder();
for (int j = i; j < n; j++) {
if (j > i && s.charAt(j) != s.charAt(j - 1)) break; // 特殊子串
sb.append(s.charAt(j));
String sub = sb.toString();
cnt.put(sub, cnt.getOrDefault(sub, 0) + 1);
}
}
int ans = -1;
for (Map.Entry<String, Integer> e : cnt.entrySet()) {
if (e.getValue() >= 3) ans = Math.max(ans, e.getKey().length());
}
return ans;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.maximumLength("aaaa") == 2, "2981 例1");
check(s.maximumLength("abcdef") == -1, "2981 例2");
check(s.maximumLength("abcaba") == 1, "2981 例3");
Random rnd = new Random(167);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 3 + rnd.nextInt(15);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) sb.append((char) ('a' + rnd.nextInt(4)));
String str = sb.toString();
int m1 = s.maximumLength(str);
int m2 = s.maximumLengthBrute(str);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 s=" + str + " 主解=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "2981 随机对拍");
System.out.println("2981 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n log n)(排序 26 组段长),空间 O(n)。
- 时间复杂度:O(n log n)
- 空间复杂度:O(n)
2982. Find Longest Special Substring That Occurs Thrice II(找出出现至少三次的最长特殊子字符串 II)
题目描述
给你一个仅由小写英文字母组成的字符串 s。
如果一个字符串仅由单一字符组成,那么它被称为特殊字符串。
返回在 s 中出现至少三次的最长特殊子字符串的长度;如果不存在,则返回 -1。
子字符串是字符串中的一个连续非空字符序列。
示例 1
s = "aaaa" -> 2("aa" 出现三次)
示例 2
s = "abcdef" -> -1
示例 3
s = "abcaba" -> 1("a" 出现三次)
提示:
- 3 <=
s.length<= 5 * 10^5(II版本n更大) s仅由小写英文字母组成
解题思路
解法一:按字符分组的官方公式
特殊子串必然落在某个"同字符连续段"内。对每个字符 c,收集 s 中由 c 组成的所有连续段长度,
降序为 L1 >= L2 >= L3。出现至少 3 次的最长候选:
- 单段内:L1 - 2(一段长 L1 的子串长度为 x 的出现次数为 L1-x+1 >= 3,得 x <= L1-2);
- 两段:min(L1 - 1, L2)(若 L1 > L2,x 可取 L2,两段出现次数相加 >= 3;
若 L1 == L2,x <= L1-1,否则两段各一次总共只有 2 次); - 三段:min(L1, L2, L3)(三段各贡献一次共 3 次)。
对每个字符取三者最大值。时间复杂度 O(n)(排序每组长度也仅线性,n <= 5e5 可行),空间 O(n)。
解法二:二分答案验证(对照实现,与官方一致)
二分长度 x,check(x):对每个字符统计所有段贡献的 (段长 - x + 1) 之和是否 >= 3。
复杂度: - 时间复杂度:O(n log n)(排序 26 组段长)/ 二分 O(n log n)
- 空间复杂度:O(n)
代码实现
java
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Random;
public class Solution {
// ---------- 解法一:分段统计(主提交版本) ----------
public int maximumLength(String s) {
int n = s.length();
@SuppressWarnings("unchecked")
List<Integer>[] segs = new List[26];
for (int i = 0; i < 26; i++) segs[i] = new ArrayList<>();
int i = 0;
while (i < n) {
int j = i;
while (j < n && s.charAt(j) == s.charAt(i)) j++;
segs[s.charAt(i) - 'a'].add(j - i);
i = j;
}
int ans = -1;
for (int c = 0; c < 26; c++) {
List<Integer> list = segs[c];
if (list.isEmpty()) continue;
list.sort((a, b) -> Integer.compare(b, a)); // 降序
int m = list.size();
// 段内:L1 - 2
if (list.get(0) >= 3) ans = Math.max(ans, list.get(0) - 2);
// 两段:min(L1 - 1, L2)
if (m >= 2) {
int t2 = Math.min(list.get(0) - 1, list.get(1));
if (t2 >= 1) ans = Math.max(ans, t2);
}
// 三段:min(L1, L2, L3)
if (m >= 3) {
int t3 = Math.min(list.get(0), Math.min(list.get(1), list.get(2)));
if (t3 >= 1) ans = Math.max(ans, t3);
}
}
return ans;
}
// ---------- 解法二:二分答案(对照实现) ----------
public int maximumLengthBrute(String s) {
int n = s.length();
int lo = 0, hi = n;
while (lo < hi) {
int mid = (lo + hi + 1) >>> 1;
if (can(mid, s)) lo = mid;
else hi = mid - 1;
}
return lo == 0 ? -1 : lo;
}
private boolean can(int x, String s) {
int n = s.length();
int[] cnt = new int[26];
for (int i = 0; i < n; ) {
int j = i;
while (j < n && s.charAt(j) == s.charAt(i)) j++;
int len = j - i;
if (len >= x) {
cnt[s.charAt(i) - 'a'] += len - x + 1;
if (cnt[s.charAt(i) - 'a'] >= 3) return true;
}
i = j;
}
return false;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.maximumLength("aaaa") == 2, "2982 例1");
check(s.maximumLength("abcdef") == -1, "2982 例2");
check(s.maximumLength("abcaba") == 1, "2982 例3");
Random rnd = new Random(171);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 3 + rnd.nextInt(15);
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) sb.append((char) ('a' + rnd.nextInt(4)));
String str = sb.toString();
int m1 = s.maximumLength(str);
int m2 = s.maximumLengthBrute(str);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 s=" + str + " 主解=" + m1 + " 二分=" + m2);
break;
}
}
check(allOk, "2982 随机对拍");
System.out.println("2982 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
对每个字符取三者最大值。时间复杂度 O(n)(排序每组长度也仅线性,n <= 5e5 可行),空间 O(n)。
- 时间复杂度:O(n log n)(排序 26 组段长)/ 二分 O(n log n)
- 空间复杂度:O(n)
2983. Palindrome Rearrangement Queries(回文串重新排列查询)
题目描述
给你一个长度为偶数 n、下标从 0 开始的字符串 s,以及一个二维整数数组 queries,
queries[i] = `ai`, `bi`, `ci`, `di`。对于每个查询 i,需要执行以下操作:
- 将下标在范围 0 <=
ai<=bi<n/ 2 内的子字符串s`ai`:`bi` 中的字符重新排列; - 将下标在范围
n/ 2 <=ci<=di<n内的子字符串s`ci`:`di` 中的字符重新排列。
判断执行操作后能否让s变成一个回文串。每个查询相互独立。
返回布尔数组answer。
示例 1
s = "abcabc", queries = [[1,1,3,5],[0,2,5,5]] -> [true,true]
示例 2
s = "abbcdecbba", queries = [[0,2,7,9]] -> [false]
示例 3
s = "acbcab", queries = [[1,2,4,5]] -> [true]
提示:
- 2 <=
n==s.length<= 1e5,n为偶数 1 <= queries.length <= 1e5- 0 <= ai <= bi <
n/2,n/2 <= ci <= di <n s只包含小写英文字母
解题思路
解法一:前缀和分类判定(官方思路)
令 m = n / 2,左半 sL = s0...m-1,右半翻转 t = reverse(sm...n-1)。
查询的右半区间 ci, di 映射到 t 的下标为 n-1-di, n-1-ci = c, d。
问题转化为:sL 中区间 a,b 与 t 中区间 c,d(保证 a <= c,否则交换两个数组与区间)重排后,
能否使 sLi == ti 对所有 i 成立。
维护 pre1/pre2(sL/t 的 26 维前缀计数)与 diff(sLi!=ti 的前缀个数):
- 0,a-1 与 max(b,d)+1, m-1 必须无 mismatch,否则不可行;
- d <= b(t 区间被 s 区间包含):只需 a,b 内 sL 与 t 计数相等;
- b < c(两区间不相交):中间 b+1,c-1 无 mismatch,且两区间各自计数相等;
- 相交:sLa...b 除匹配 ta...c-1 外多出的字符集合,必须等于 tc...d 除匹配 sLb+1...d 外
多出的字符集合(sub 出现负值即不可行)。
每个查询 O(26),总复杂度 O(n + q26),空间 O(m 26)。
解法二:全排列暴力(对照,小规模)
对每个查询,直接枚举 sa...b 与 sci...di 的所有不同排列并检查整个字符串是否回文。
复杂度:
- 时间复杂度:O(n + q*26)
- 空间复杂度:O(m * 26)
代码实现
java
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Random;
public class Solution {
// ---------- 解法一:前缀和分类判定(主提交版本) ----------
public boolean[] canMakePalindromeQueries(String s, int[][] queries) {
int n = s.length();
int m = n / 2;
String tStr = new StringBuilder(s.substring(m)).reverse().toString();
String lStr = s.substring(0, m);
int[][] pre1 = new int[m + 1][26];
int[][] pre2 = new int[m + 1][26];
int[] diff = new int[m + 1];
for (int i = 1; i <= m; i++) {
System.arraycopy(pre1[i - 1], 0, pre1[i], 0, 26);
System.arraycopy(pre2[i - 1], 0, pre2[i], 0, 26);
pre1[i][lStr.charAt(i - 1) - 'a']++;
pre2[i][tStr.charAt(i - 1) - 'a']++;
diff[i] = diff[i - 1] + (lStr.charAt(i - 1) == tStr.charAt(i - 1) ? 0 : 1);
}
boolean[] ans = new boolean[queries.length];
for (int i = 0; i < queries.length; i++) {
int a = queries[i][0], b = queries[i][1];
int c = n - 1 - queries[i][3], d = n - 1 - queries[i][2];
ans[i] = a <= c ? check(pre1, pre2, diff, a, b, c, d)
: check(pre2, pre1, diff, c, d, a, b);
}
return ans;
}
// 判定:pre1 区间 [a,b] 与 pre2 区间 [c,d](a <= c)可重排后使所有位置匹配
private boolean check(int[][] pre1, int[][] pre2, int[] diff, int a, int b, int c, int d) {
int m = diff.length - 1;
// 前缀 [0,a-1] 与后缀 [max(b,d)+1, m-1] 必须本来匹配
if (diff[a] > 0 || diff[m] - diff[Math.max(b, d) + 1] > 0) return false;
if (d <= b) {
// t 区间被 s 区间包含:[a,b] 内计数相等即可
return Arrays.equals(count(pre1, a, b), count(pre2, a, b));
}
if (b < c) {
// 两区间不相交:中间必须无 mismatch,两区间各自计数相等
return diff[c] - diff[b + 1] == 0
&& Arrays.equals(count(pre1, a, b), count(pre2, a, b))
&& Arrays.equals(count(pre1, c, d), count(pre2, c, d));
}
// 相交:sL[a..b] 剔除需匹配 t[a..c-1] 的字符后,余集必须等于
// t[c..d] 剔除需匹配 sL[b+1..d] 的字符后的余集
int[] cnt1 = sub(count(pre1, a, b), count(pre2, a, c - 1));
int[] cnt2 = sub(count(pre2, c, d), count(pre1, b + 1, d));
return cnt1 != null && cnt2 != null && Arrays.equals(cnt1, cnt2);
}
// 区间 [l, r](两端含)的 26 维字符计数
private int[] count(int[][] pre, int l, int r) {
int[] cnt = new int[26];
for (int k = 0; k < 26; k++) cnt[k] = pre[r + 1][k] - pre[l][k];
return cnt;
}
// 逐维相减;任何一位为负返回 null
private int[] sub(int[] x, int[] y) {
int[] cnt = new int[26];
for (int i = 0; i < 26; i++) {
cnt[i] = x[i] - y[i];
if (cnt[i] < 0) return null;
}
return cnt;
}
// ---------- 解法二:全排列暴力(对照,小规模) ----------
public boolean[] canMakePalindromeQueriesBrute(String s, int[][] queries) {
char[] arr = s.toCharArray();
int n = arr.length;
boolean[] ans = new boolean[queries.length];
for (int qi = 0; qi < queries.length; qi++) {
int a = queries[qi][0], b = queries[qi][1];
int ci = queries[qi][2], di = queries[qi][3];
char[] leftSeg = Arrays.copyOfRange(arr, a, b + 1);
char[] rightSeg = Arrays.copyOfRange(arr, ci, di + 1);
Arrays.sort(leftSeg);
Arrays.sort(rightSeg);
List<char[]> leftPerms = new ArrayList<>();
genPerms(leftSeg, new boolean[leftSeg.length], new char[leftSeg.length], 0, leftPerms);
List<char[]> rightPerms = new ArrayList<>();
genPerms(rightSeg, new boolean[rightSeg.length], new char[rightSeg.length], 0, rightPerms);
boolean ok = false;
for (char[] lp : leftPerms) {
for (char[] rp : rightPerms) {
char[] tmp = arr.clone();
System.arraycopy(lp, 0, tmp, a, lp.length);
System.arraycopy(rp, 0, tmp, ci, rp.length);
if (isPalin(tmp)) {
ok = true;
break;
}
}
if (ok) break;
}
ans[qi] = ok;
}
return ans;
}
private void genPerms(char[] sorted, boolean[] used, char[] cur, int idx, List<char[]> out) {
if (idx == sorted.length) {
out.add(cur.clone());
return;
}
char prev = 0;
boolean first = true;
for (int i = 0; i < sorted.length; i++) {
if (used[i]) continue;
if (!first && sorted[i] == prev) continue;
first = false;
prev = sorted[i];
used[i] = true;
cur[idx] = sorted[i];
genPerms(sorted, used, cur, idx + 1, out);
used[i] = false;
}
}
private boolean isPalin(char[] arr) {
int n = arr.length;
for (int i = 0; i < n / 2; i++) {
if (arr[i] != arr[n - 1 - i]) return false;
}
return true;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(Arrays.equals(s.canMakePalindromeQueries("abcabc", new int[][]{{1, 1, 3, 5}, {0, 2, 5, 5}}),
new boolean[]{true, true}), "2983 例1");
check(Arrays.equals(s.canMakePalindromeQueries("abbcdecbba", new int[][]{{0, 2, 7, 9}}),
new boolean[]{false}), "2983 例2");
check(Arrays.equals(s.canMakePalindromeQueries("acbcab", new int[][]{{1, 2, 4, 5}}),
new boolean[]{true}), "2983 例3");
Random rnd = new Random(2983);
boolean allOk = true;
for (int t = 0; t < 120; t++) {
int n = 2 + 2 * rnd.nextInt(5); // 2,4,6,8,10
int m = n / 2;
StringBuilder sb = new StringBuilder();
for (int i = 0; i < n; i++) sb.append((char) ('a' + rnd.nextInt(3)));
String str = sb.toString();
int qn = 1 + rnd.nextInt(8);
int[][] qs = new int[qn][4];
for (int i = 0; i < qn; i++) {
int a = rnd.nextInt(m), b = a + rnd.nextInt(m - a);
int c = m + rnd.nextInt(m), d = c + rnd.nextInt(n - c);
qs[i] = new int[]{a, b, c, d};
}
boolean[] m1 = s.canMakePalindromeQueries(str, qs);
boolean[] m2 = s.canMakePalindromeQueriesBrute(str, qs);
if (!Arrays.equals(m1, m2)) {
allOk = false;
System.out.println("对拍失败 s=" + str + " 查询=" + Arrays.deepToString(qs));
for (int i = 0; i < qn; i++) {
if (m1[i] != m2[i]) {
System.out.println(" 索引" + i + " 主解=" + m1[i] + " 暴力=" + m2[i]);
break;
}
}
break;
}
}
check(allOk, "2983 随机对拍");
System.out.println("2983 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
每个查询 O(26),总复杂度 O(n + q26),空间 O(m26)。
- 时间复杂度:O(n + q*26)
- 空间复杂度:O(m * 26)
2984. Find Peak Calling Hours for Each City(找到每座城市的高峰通话小时)
题目类型:数据库(SQL)
题目描述
表: Calls
+--------------+----------+
| Column Name | Type |
+--------------+----------+
| caller_id | int |
| recipient_id | int |
| call_time | datetime |
| city | varchar |
+--------------+----------+
(caller_id, recipient_id, call_time) 是该表的主键(具有唯一值的列)。
每一行包含 caller id, recipient id, call time,和 city。
编写一个查询,找到每个 city 的 高峰 通话 小时 。如果 多个小时 有 相同 数量的通话,则所有这些小时都将被视为该特定城市的 高峰小时。
按照 高峰小时 和 city 按 降序 排序返回结果表。
结果格式如下例所示。
示例 1:
输入:
Calls table:
+-----------+--------------+---------------------+----------+
| caller_id | recipient_id | call_time | city |
+-----------+--------------+---------------------+----------+
| 8 | 4 | 2021-08-24 22:46:07 | Houston |
| 4 | 8 | 2021-08-24 22:57:13 | Houston |
| 5 | 1 | 2021-08-11 21:28:44 | Houston |
| 8 | 3 | 2021-08-17 22:04:15 | Houston |
| 11 | 3 | 2021-08-17 13:07:00 | New York |
| 8 | 11 | 2021-08-17 14:22:22 | New York |
+-----------+--------------+---------------------+----------+
输出:
+----------+-------------------+-----------------+
| city | peak_calling_hour | number_of_calls |
+----------+-------------------+-----------------+
| Houston | 22 | 3 |
| New York | 14 | 1 |
| New York | 13 | 1 |
+----------+-------------------+-----------------+
解释:
对于 Houston:
- 高峰小时是 22:00,总共记录了 3 次通话。
对于 New York:
- 13:00 和 14:00 都有相同数量的通话,因此这两个小时都被视为高峰小时。
输出表按照高峰小时和城市按降序排序。
解题思路
解法一:先聚合再排名(主提交版本)
- 按
city、HOUR(call_time)分组统计COUNT(1)得每小时通话数; - 在 (city, 小时) 聚合基础上用
RANK() OVER (PARTITION BY city ORDER BY cnt DESC)
排名,取rk = 1(同城市并列高峰小时全输出); - 输出
city, peak_calling_hour, number_of_calls,按城市与小时排序。
代码实现
sql
WITH
T AS (
SELECT
*,
RANK() OVER (
PARTITION BY city
ORDER BY cnt DESC
) AS rk
FROM
(
SELECT
city,
HOUR(call_time) AS h,
COUNT(1) AS cnt
FROM Calls
GROUP BY 1, 2
) AS t
)
SELECT city, h AS peak_calling_hour, cnt AS number_of_calls
FROM T
WHERE rk = 1
ORDER BY 2 DESC, 1 DESC;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2985. Calculate Compressed Mean(计算订单平均商品数量)
题目类型:数据库(SQL)
题目描述
表: Orders
+-------------------+------+
| Column Name | Type |
+-------------------+------+
| order_id | int |
| item_count | int |
| order_occurrences | int |
+-------------------+------+
order_id 是这张表具有唯一值的列。
这张表包括 order_id, item_count,和 order_occurrences。
编写一个计算每个订单的 平均 商品数量的解决方案,保留 2 位小数。
以 任意 顺序返回结果表。
结果格式如下例所示。
示例 1:
输入:
Orders table:
+----------+------------+-------------------+
| order_id | item_count | order_occurrences |
+----------+------------+-------------------+
| 10 | 1 | 500 |
| 11 | 2 | 1000 |
| 12 | 3 | 800 |
| 13 | 4 | 1000 |
+----------+------------+-------------------+
**输出**
+-------------------------+
| average_items_per_order |
+-------------------------+
| 2.70 |
+-------------------------+
**解释**
计算如下:
- 总商品数:(1 * 500) + (2 * 1000) + (3 * 800) + (4 * 1000) = 8900
- 总订单数:500 + 1000 + 800 + 1000 = 3300
- 因此,每个订单的平均商品数量为 8900 / 3300 = 2.70
解题思路
解法一:加权平均(主提交版本)
- 平均每单商品数 =
SUM(item_count * order_occurrences) / SUM(order_occurrences)
(以订单出现次数为权重); ROUND(..., 2)保留两位小数。
代码实现
sql
SELECT
ROUND(
SUM(item_count * order_occurrences) / SUM(order_occurrences),
2
) AS average_items_per_order
FROM Orders;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2986. Find Third Transaction(找到第三笔交易)
题目类型:数据库(SQL)
题目描述
表: Transactions
+------------------+----------+
| Column Name | Type |
+------------------+----------+
| user_id | int |
| spend | decimal |
| transaction_date | datetime |
+------------------+----------+
(user_id, transaction_date) 是这张表具有唯一值的列。
该表包含 user_id, spend,和 transaction_date。
编写一个查询,找到符合要求的用户的 第三笔交易 (如果他们有至少三笔交易),并且满足 前两笔交易 的花费 低于 第三笔交易的花费。
返回 按 升序 user_id 排序的结果表。
结果格式如下例所示。
示例 1:
输入:
Transactions table:
+---------+--------+---------------------+
| user_id | spend | transaction_date |
+---------+--------+---------------------+
| 1 | 65.56 | 2023-11-18 13:49:42 |
| 1 | 96.0 | 2023-11-30 02:47:26 |
| 1 | 7.44 | 2023-11-02 12:15:23 |
| 1 | 49.78 | 2023-11-12 00:13:46 |
| 2 | 40.89 | 2023-11-21 04:39:15 |
| 2 | 100.44 | 2023-11-20 07:39:34 |
| 3 | 37.33 | 2023-11-03 06:22:02 |
| 3 | 13.89 | 2023-11-11 16:00:14 |
| 3 | 7.0 | 2023-11-29 22:32:36 |
+---------+--------+---------------------+
**输出**
+---------+-------------------------+------------------------+
| user_id | third_transaction_spend | third_transaction_date |
+---------+-------------------------+------------------------+
| 1 | 65.56 | 2023-11-18 13:49:42 |
+---------+-------------------------+------------------------+
**解释**
- 对于 user_id 1,他们的第三笔交易发生在 2023-11-18 13:49:42,金额为 $65.56,超过了前两笔交易的支出,分别是 2023-11-02 12:15:23 的 $7.44 和 2023-11-12 00:13:46 的 $49.78。因此,此第三笔交易将包含在输出表中。
- user_id 2 只有总共 2 笔交易,因此没有第三笔交易。
- 对于 user_id 3,第三笔交易的金额 $7.0 少于前两笔交易,因此不会包含在内。
输出表按升序按 user_id 排序。
解题思路
解法一:窗口函数排序 + 前三判定(主提交版本)
- 按
user_id分区、transaction_date排序,RANK()得交易序号; - 第三笔交易要求:序号恰为 3,且该笔金额严格大于前两笔
(spend > LAG(spend, 1) AND spend > LAG(spend, 2)); - 筛出满足条件的行。
代码实现
sql
WITH
T AS (
SELECT
*,
RANK() OVER (
PARTITION BY user_id
ORDER BY transaction_date
) AS rk,
spend > (
LAG(spend) OVER (
PARTITION BY user_id
ORDER BY transaction_date
)
)
AND spend > (
LAG(spend, 2) OVER (
PARTITION BY user_id
ORDER BY transaction_date
)
) AS st
FROM Transactions
)
SELECT user_id, spend AS third_transaction_spend, transaction_date AS third_transaction_date
FROM T
WHERE rk = 3 AND st = 1;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2987. Find Expensive Cities(寻找房价最贵的城市)
题目类型:数据库(SQL)
题目描述
表: Listings
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| listing_id | int |
| city | varchar |
| price | int |
+-------------+---------+
listing_id 是这张表具有唯一值的列。
这张表包括 listing_id, city,和 price。
编写一个解决方案,查找 房价平均值 超过 全国 平均房价的 城市。
返回 按 city 升序 排序的结果表。
结果格式如下例所示。
示例 1:
输入:
Listings table:
+------------+--------------+---------+
| listing_id | city | price |
+------------+--------------+---------+
| 113 | LosAngeles | 7560386 |
| 136 | SanFrancisco | 2380268 |
| 92 | Chicago | 9833209 |
| 60 | Chicago | 5147582 |
| 8 | Chicago | 5274441 |
| 79 | SanFrancisco | 8372065 |
| 37 | Chicago | 7939595 |
| 53 | LosAngeles | 4965123 |
| 178 | SanFrancisco | 999207 |
| 51 | NewYork | 5951718 |
| 121 | NewYork | 2893760 |
+------------+--------------+---------+
**输出**
+------------+
| city |
+------------+
| Chicago |
| LosAngeles |
+------------+
**解释**
全国平均房价为 $6,122,059.45。在列出的城市中:
- Chicago 的平均价格为 $7,048,706.75
- Los Angeles 的平均价格为 $6,277,754.5
- San Francisco 的平均价格为 $3,900,513.33
- New York 的平均价格为 $4,422,739
只有 Chicago 和 Los Angeles 的平均房价超过了全国平均水平。因此,这两个城市包含在输出表中。输出表按城市名称升序排序。
解题思路
解法一:分组聚合 + 整体均价比较(主提交版本)
GROUP BY city计算各城市平均价AVG(price);HAVING AVG(price) > (SELECT AVG(price) FROM Listings)与全表均价比较,
筛出均价高于整体的城市,按城市升序。
代码实现
sql
SELECT city
FROM Listings
GROUP BY city
HAVING AVG(price) > (SELECT AVG(price) FROM Listings)
ORDER BY 1;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2988. Manager of the Largest Department(最大部门的经理)
题目类型:数据库(SQL)
题目描述
表: Employees
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| emp_id | int |
| emp_name | varchar |
| dep_id | int |
| position | varchar |
+-------------+---------+
emp_id 是这张表具有唯一值的列。
这张表包括 emp_id, emp_name, dep_id,和 position。
查询 最大部门 的 经理 的 名字。当拥有相同数量的员工时,可能会有多个最大部门。
返回 按照 dep_id 升序 排列的结果表格。
结果表格的格式如下例所示。
示例 1:
输入:
Employees table:
+--------+----------+--------+---------------+
| emp_id | emp_name | dep_id | position |
+--------+----------+--------+---------------+
| 156 | Michael | 107 | Manager |
| 112 | Lucas | 107 | Consultant |
| 8 | Isabella | 101 | Manager |
| 160 | Joseph | 100 | Manager |
| 80 | Aiden | 100 | Engineer |
| 190 | Skylar | 100 | Freelancer |
| 196 | Stella | 101 | Coordinator |
| 167 | Audrey | 100 | Consultant |
| 97 | Nathan | 101 | Supervisor |
| 128 | Ian | 101 | Administrator |
| 81 | Ethan | 107 | Administrator |
+--------+----------+--------+---------------+
**输出**
+--------------+--------+
| manager_name | dep_id |
+--------------+--------+
| Joseph | 100 |
| Isabella | 101 |
+--------------+--------+
**解释**
- 部门 ID 为 100 和 101 的每个部门都有 4 名员工,而部门 107 有 3 名员工。由于部门 100 和 101 都拥有相同数量的员工,它们各自的经理将被包括在内。
输出表格按 dep_id 升序排列。
解题思路
解法一:部门人数统计 + 经理名称关联(主提交版本)
- 先按
dep_id分组COUNT(1)得各部门人数; JOIN Employees取position = 'Manager'的经理姓名;WHERE cnt = (SELECT MAX(cnt) ...)筛出最大部门(并列时全输出),按部门排序。
代码实现
sql
WITH
T AS (
SELECT dep_id, COUNT(1) AS cnt
FROM Employees
GROUP BY 1
)
SELECT emp_name AS manager_name, t.dep_id
FROM
T AS t
JOIN Employees AS e ON t.dep_id = e.dep_id AND e.position = 'Manager'
WHERE cnt = (SELECT MAX(cnt) FROM T)
ORDER BY 2;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2989. Class Performance(班级表现)
题目类型:数据库(SQL)
题目描述
表: Scores
+--------------+---------+
| Column Name | Type |
+--------------+---------+
| student_id | int |
| student_name | varchar |
| assignment1 | int |
| assignment2 | int |
| assignment3 | int |
+--------------+---------+
student_id 是这张表具有唯一值的列。
该表包含 student_id, student_name, assignment1, assignment2,和 assignment3。
编写一个查询,计算学生获得的 **最高总分 **和 **最低总分 **之间的 差 (3 次作业的总和)。
以 任意 顺序返回结果表。
结果表的格式如下示例所示。
示例 1:
输入:
Scores 表:
+------------+--------------+-------------+-------------+-------------+
| student_id | student_name | assignment1 | assignment2 | assignment3 |
+------------+--------------+-------------+-------------+-------------+
| 309 | Owen | 88 | 47 | 87 |
| 321 | Claire | 98 | 95 | 37 |
| 338 | Julian | 100 | 64 | 43 |
| 423 | Peyton | 60 | 44 | 47 |
| 896 | David | 32 | 37 | 50 |
| 235 | Camila | 31 | 53 | 69 |
+------------+--------------+-------------+-------------+-------------+
**输出**
+---------------------+
| difference_in_score |
+---------------------+
| 111 |
+---------------------+
**解释**
- student_id 309 的总分为 88 + 47 + 87 = 222。
- student_id 321 的总分为 98 + 95 + 37 = 230。
- student_id 338 的总分为 100 + 64 + 43 = 207。
- student_id 423 的总分为 60 + 44 + 47 = 151。
- student_id 896 的总分为 32 + 37 + 50 = 119。
- student_id 235 的总分为 31 + 53 + 69 = 153。
student_id 321 拥有最高分为 230,而 student_id 896 拥有最低分为 119。因此,它们之间的差异为 111。
解题思路
解法一:三科求和求极差(主提交版本)
- 每个学生三科成绩和
assignment1 + assignment2 + assignment3; MAX(总和) - MIN(总和)即学生最高分与最低分之差。
代码实现
sql
SELECT
MAX(assignment1 + assignment2 + assignment3) - MIN(
assignment1 + assignment2 + assignment3
) AS difference_in_score
FROM Scores;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2990. Loan Types(贷款类型)
题目类型:数据库(SQL)
题目描述
表: Loans
+-------------+---------+
| Column Name | Type |
+-------------+---------+
| loan_id | int |
| user_id | int |
| loan_type | varchar |
+-------------+---------+
loan_id 是这张表具有唯一值的列。
该表包含 loan_id, user_id,和 loan_type。
编写一个解决方案,找出所有具有同时具有 Refinance 贷款类型和 Mortgage 贷款类型的 user_id(需去重)。
按 升序 返回结果表中的 user_id。
返回结果表格式如下例所示。
示例 1:
输入:
Loans table:
+---------+---------+-----------+
| loan_id | user_id | loan_type |
+---------+---------+-----------+
| 683 | 101 | Mortgage |
| 218 | 101 | AutoLoan |
| 802 | 101 | Inschool |
| 593 | 102 | Mortgage |
| 138 | 102 | Refinance |
| 294 | 102 | Inschool |
| 308 | 103 | Refinance |
| 389 | 104 | Mortgage |
+---------+---------+-----------+
**输出**
+---------+
| user_id |
+---------+
| 102 |
+---------+
**解释**
- User_id 101 有三种贷款类型,其中之一是 Mortgage。但是,此用户没有任何类别为 Refinance 的贷款类型,因此用户 101 不会被考虑。
- User_id 102 拥有三种贷款类型:一种是 Mortgage,一种是 Refinance。因此,用户 102 将包括在结果中。
- User_id 103 有一种 Refinance 贷款类型,但没有 Mortgage 贷款类型,因此用户 103 不会被考虑。
- User_id 104 有一种 Mortgage 贷款类型,但没有 Refinance 贷款类型,因此用户 104 不会被考虑。
输出表以升序按 user_id 排序。
解题思路
解法一:按用户分组条件计数(主提交版本)
GROUP BY user_id后,SUM(loan_type = 'Refinance') > 0表示有再融资贷款、
SUM(loan_type = 'Mortgage') > 0表示有抵押贷款;- 同时满足两种贷款类型的用户,按
user_id升序。
代码实现
sql
SELECT user_id
FROM Loans
GROUP BY 1
HAVING SUM(loan_type = 'Refinance') > 0 AND SUM(loan_type = 'Mortgage') > 0
ORDER BY 1;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2991. Top Three Wineries(最好的三家酒庄)
题目类型:数据库(SQL)
题目描述
表: Wineries
+-------------+----------+
| Column Name | Type |
+-------------+----------+
| id | int |
| country | varchar |
| points | int |
| winery | varchar |
+-------------+----------+
id 是这张表具有唯一值的列。
这张表包含 id, country, points,和 winery。
编写一个解决方案,根据每家酒庄的 总分 找出 每个国家 的 前三名酒庄 。如果有 多个酒庄 的总分 相同 ,则按 winery 名称升序排列。如果没有 分数排在第二的酒庄 ,则输出 'No Second Winery',如果没有 分数排在第三的酒庄 ,则输出 'No Third Winery'。
返回结果表按 country 升序 排列。
结果表格格式如下例所示。
示例 1:
输入:
Wineries table:
+-----+-----------+--------+-----------------+
| id | country | points | winery |
+-----+-----------+--------+-----------------+
| 103 | Australia | 84 | WhisperingPines |
| 737 | Australia | 85 | GrapesGalore |
| 848 | Australia | 100 | HarmonyHill |
| 222 | Hungary | 60 | MoonlitCellars |
| 116 | USA | 47 | RoyalVines |
| 124 | USA | 45 | Eagle'sNest |
| 648 | India | 69 | SunsetVines |
| 894 | USA | 39 | RoyalVines |
| 677 | USA | 9 | PacificCrest |
+-----+-----------+--------+-----------------+
输出:
+-----------+---------------------+-------------------+----------------------+
| country | top_winery | second_winery | third_winery |
+-----------+---------------------+-------------------+----------------------+
| Australia | HarmonyHill (100) | GrapesGalore (85) | WhisperingPines (84) |
| Hungary | MoonlitCellars (60) | No second winery | No third winery |
| India | SunsetVines (69) | No second winery | No third winery |
| USA | RoyalVines (86) | Eagle'sNest (45) | PacificCrest (9) |
+-----------+---------------------+-------------------+----------------------+
解释:
对于 Australia
- HarmonyHill 酒庄获得了 Australia 的最高分数,为 100 分。
- GrapesGalore 酒庄总共获得 85 分,位列 Australia 的第二位。
- WhisperingPines 酒庄总共获得 80 分,位列 Australia 的第三位。
对于 Hungary
- MoonlitCellars 是唯一的酒庄,获得 60 分,自动成为最高分数的酒庄。没有第二或第三家酒庄。
对于 India
- SunsetVines 是唯一的酒庄,获得 69 分,成为最高的酒庄。没有第二或第三家酒庄。
对于 USA
- RoyalVines Wines 累计了总分 47 + 39 = 86 分,占据了 USA 的最高位置。
- Eagle'sNest 总共获得 45 分,位列 USA 的第二高位置。
- PacificCrest 累计了 9 分,位列 USA 的第三高酒庄。
输出表按国家首字母升序排列。
解题思路
解法一:按国家分组排名 + 三次自连接(主提交版本)
- 先按
country, winery分组SUM(points)求每个酒庄总评分; - 在 (国家, 酒庄) 上
RANK() OVER (PARTITION BY country ORDER BY points DESC, winery)
排名,CONCAT(winery, ' (', points, ')')拼接显示文本; - 三次自连接把第 1/2/3 名排在同一行,第二名/第三名缺失时用
IFNULL(..., 'No second winery'/'No third winery')兜底,按国家升序。
代码实现
sql
WITH
T AS (
SELECT
country,
CONCAT(winery, ' (', points, ')') AS winery,
RANK() OVER (
PARTITION BY country
ORDER BY points DESC, winery
) AS rk
FROM (SELECT country, SUM(points) AS points, winery FROM Wineries GROUP BY 1, 3) AS t
)
SELECT
t1.country,
t1.winery AS top_winery,
IFNULL(t2.winery, 'No second winery') AS second_winery,
IFNULL(t3.winery, 'No third winery') AS third_winery
FROM
T AS t1
LEFT JOIN T AS t2 ON t1.country = t2.country AND t1.rk = t2.rk - 1
LEFT JOIN T AS t3 ON t2.country = t3.country AND t2.rk = t3.rk - 1
WHERE t1.rk = 1
ORDER BY 1;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2992. Number of Self-Divisible Permutations(自整除排列的数量)
题目描述
给定一个整数 n,返回下标从 1 开始的数组 nums = 1, 2, ..., `n` 的可能排列数量,
使其满足自整除条件:对于每个 1 <= i <= n,满足 gcd(a[i], i) == 1(a[i] 是排列第 i 个位置的值)。
示例 1
n = 1 -> 1([1])
示例 2
n = 2 -> 1([2,1])
示例 3
n = 3 -> 3([1,2,3]、[2,1,3]、[3,2,1])
提示:
1 <= n <= 12
解题思路
解法一:状态压缩 DP
记 mask 表示"已放置的数字集合"。dfs(mask) = 放置完集合 mask 后(当前位置 i = popcount(mask)+1),
剩余数字完成排列的方案数。转移:枚举尚未使用的数字 j,若 gcd(i, j) == 1 则 dfs(mask | (1<<j))。
边界:i > n 时返回 1。状态数 2^12,每状态枚举 n,时间复杂度 O(2^n * n),空间 O(2^n)。
解法二:DFS 回溯 + 全排列对照(小规模)
直接生成全部排列并逐位置检查 gcd(独立验证,仅用于对拍)。
复杂度:
- 时间复杂度:O(n * 2^n)
- 空间复杂度:O(2^n)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:状态压缩 DP(主提交版本) ----------
private int n;
private int[] memoDp;
public int selfDivisiblePermutationCount(int n) {
this.n = n;
memoDp = new int[1 << (n + 1)];
Arrays.fill(memoDp, -1);
return dfs(0);
}
private int dfs(int mask) {
if (memoDp[mask] != -1) return memoDp[mask];
int i = Integer.bitCount(mask) + 1; // 当前位置(1 开始)
if (i > n) return 1;
int total = 0;
for (int j = 1; j <= n; j++) {
if ((mask >> j & 1) == 0 && gcd(i, j) == 1) {
total += dfs(mask | (1 << j));
}
}
memoDp[mask] = total;
return total;
}
private int gcd(int a, int b) {
return b == 0 ? a : gcd(b, a % b);
}
// ---------- 解法二:全排列暴力(对照,n 小) ----------
public int selfDivisiblePermutationCountBrute(int n) {
this.n = n;
int[] perm = new int[n + 1];
boolean[] used = new boolean[n + 1];
return backtrack(perm, used, 1);
}
private int backtrack(int[] perm, boolean[] used, int i) {
if (i > n) return 1;
int total = 0;
for (int v = 1; v <= n; v++) {
if (!used[v] && gcd(i, v) == 1) {
used[v] = true;
total += backtrack(perm, used, i + 1);
used[v] = false;
}
}
return total;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.selfDivisiblePermutationCount(1) == 1, "2992 例1");
check(s.selfDivisiblePermutationCount(2) == 1, "2992 例2");
check(s.selfDivisiblePermutationCount(3) == 3, "2992 例3");
Random rnd = new Random(20);
boolean allOk = true;
for (int t = 0; t < 50; t++) {
int k = 1 + rnd.nextInt(10);
int m1 = s.selfDivisiblePermutationCount(k);
int m2 = s.selfDivisiblePermutationCountBrute(k);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 n=" + k + " 主解=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "2992 随机对拍");
System.out.println("2992 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
边界:i > n 时返回 1。状态数 2^12,每状态枚举 n,时间复杂度 O(2^n * n),空间 O(2^n)。
- 时间复杂度:O(n * 2^n)
- 空间复杂度:O(2^n)
2993. Friday Purchases I(发生在周五的交易 I)
题目类型:数据库(SQL)
题目描述
表: Purchases
+---------------+------+
| Column Name | Type |
+---------------+------+
| user_id | int |
| purchase_date | date |
| amount_spend | int |
+---------------+------+
(user_id, purchase_date, amount_spend) 是该表的主键(具有唯一值的列)。
purchase_date 的范围从 2023 年 11 月 1 日到 2023 年 11 月 30 日,并包括这两个日期。
每一行包含 user id, purchase date,和 amount spend。
编写一个解决方案,计算用户在 **2023 年 11 月 **的 每个星期五 的 总花费。输出所有在 **周五 **有购买记录的周。
按照每月的周次序 升序 排列结果表。
结果格式如下示例所示。
示例 1:
输入:
Purchases table:
+---------+---------------+--------------+
| user_id | purchase_date | amount_spend |
+---------+---------------+--------------+
| 11 | 2023-11-07 | 1126 |
| 15 | 2023-11-30 | 7473 |
| 17 | 2023-11-14 | 2414 |
| 12 | 2023-11-24 | 9692 |
| 8 | 2023-11-03 | 5117 |
| 1 | 2023-11-16 | 5241 |
| 10 | 2023-11-12 | 8266 |
| 13 | 2023-11-24 | 12000 |
+---------+---------------+--------------+
输出:
+---------------+---------------+--------------+
| week_of_month | purchase_date | total_amount |
+---------------+---------------+--------------+
| 1 | 2023-11-03 | 5117 |
| 4 | 2023-11-24 | 21692 |
+---------------+---------------+--------------+
解释:
- 在 2023 年 11 月的第一周,于 2023-11-03 星期五发生了总额为 $5,117 的交易。
- 对于 2023 年 11 月的第二周,于 2023-11-10 星期五没有交易。
- 同样,在 2023 年 11 月的第三周,于 2023-11-17 星期五没有交易。
- 在 2023 年 11 月的第四周,于 2023-11-24 星期五发生了两笔交易,分别为 $12,000 和 $9,692,总计为 $21,692。
输出表按照 week_of_month 升序排列。
解题思路
解法一:按周内第几周分组 + 周五过滤(主提交版本)
- 限定 2023 年 11 月(
DATE_FORMAT(purchase_date, '%Y%m') = '202311')且
周五(DAYOFWEEK(purchase_date) = 6,MySQL 中周五为 6); - 周数 =
CEIL(DAYOFMONTH(purchase_date) / 7),按purchase_date分组SUM(amount_spend); - 按周数升序输出。
代码实现
sql
SELECT
CEIL(DAYOFMONTH(purchase_date) / 7) AS week_of_month,
purchase_date,
SUM(amount_spend) AS total_amount
FROM Purchases
WHERE DATE_FORMAT(purchase_date, '%Y%m') = '202311' AND DAYOFWEEK(purchase_date) = 6
GROUP BY 2
ORDER BY 1;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2994. Friday Purchases II(发生在周五的交易 II)
题目类型:数据库(SQL)
题目描述
表: Purchases
+---------------+------+
| Column Name | Type |
+---------------+------+
| user_id | int |
| purchase_date | date |
| amount_spend | int |
+---------------+------+
(user_id, purchase_date, amount_spend) 是该表的主键(具有唯一值的列)。
purchase_date 的范围从 2023 年 11 月 1 日到 2023 年 11 月 30 日,并包括这两个日期。
每一行包含 user id, purchase date,和 amount spend。
编写一个解决方案,计算用户在 2023 年 11 月的 每个星期五 的 总花费 。如果在 某个星期的星期五 没有 购买记录,则将其视为花费金额为 0。
按照每月的周次序 升序 排列结果表。
结果格式如下示例所示。
示例 1:
输入:
Purchases table:
+---------+---------------+--------------+
| user_id | purchase_date | amount_spend |
+---------+---------------+--------------+
| 11 | 2023-11-07 | 1126 |
| 15 | 2023-11-30 | 7473 |
| 17 | 2023-11-14 | 2414 |
| 12 | 2023-11-24 | 9692 |
| 8 | 2023-11-03 | 5117 |
| 1 | 2023-11-16 | 5241 |
| 10 | 2023-11-12 | 8266 |
| 13 | 2023-11-24 | 12000 |
+---------+---------------+--------------+
输出:
+---------------+---------------+--------------+
| week_of_month | purchase_date | total_amount |
+---------------+---------------+--------------+
| 1 | 2023-11-03 | 5117 |
| 2 | 2023-11-10 | 0 |
| 3 | 2023-11-17 | 0 |
| 4 | 2023-11-24 | 21692 |
+---------------+---------------+--------------+
解释:
- 在 2023 年 11 月的第一周的周五(即 2023-11-03),共发生了总计 $5,117 的交易。
- 在 2023 年 11 月的第二周的周五(即 2023-11-10),当天没有交易,因此在输出表中该天的值为 0。
- 类似地,在 2023 年 11 月的第三周的周五(即 2023-11-17),当天没有交易,因此在输出表中该天的值为 0。
- 在 2023 年 11 月的第四周的周五(即 2023-11-24),当天发生了两笔交易,分别为 $12,000 和 $9,692,总计 $21,692。
输出表按照 week_of_month 按升序排序。
解题思路
解法一:递归生成全日期 + 左连接(主提交版本)
- 与 I 的区别:11 月内每个周五都要出现(即使无购买),金额为 0;
- 用
WITH RECURSIVE生成 2023-11-01 到 2023-11-30 的全部日期序列; LEFT JOIN Purchases后筛周五,IFNULL(SUM(amount_spend), 0)补 0,
按week_of_month, purchase_date排序。
代码实现
sql
WITH RECURSIVE
T AS (
SELECT '2023-11-01' AS purchase_date
UNION
SELECT purchase_date + INTERVAL 1 DAY
FROM T
WHERE purchase_date < '2023-11-30'
)
SELECT
CEIL(DAYOFMONTH(purchase_date) / 7) AS week_of_month,
purchase_date,
IFNULL(SUM(amount_spend), 0) AS total_amount
FROM
T
LEFT JOIN Purchases USING (purchase_date)
WHERE DAYOFWEEK(purchase_date) = 6
GROUP BY 2
ORDER BY 1;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2995. Viewers Turned Streamers(观众变主播)
题目类型:数据库(SQL)
题目描述
表: Sessions
+---------------+----------+
| Column Name | Type |
+---------------+----------+
| user_id | int |
| session_start | datetime |
| session_end | datetime |
| session_id | int |
| session_type | enum |
+---------------+----------+
session_id 是这张表具有唯一值的列。
session_type 是一个 ENUM (枚举) 类型,包含(Viewer, Streamer)两个类别。
这张表包含 user id, session start, session end, session id 和 session type。
编写一个解决方案,找到 首次会话 为 观众身份 的用户,其 主播会话 数量。
按照会话数量和 user_id 降序 排序返回结果表。
结果格式如下例所示。
示例 1:
输入:
Sessions table:
+---------+---------------------+---------------------+------------+--------------+
| user_id | session_start | session_end | session_id | session_type |
+---------+---------------------+---------------------+------------+--------------+
| 101 | 2023-11-06 13:53:42 | 2023-11-06 14:05:42 | 375 | Viewer |
| 101 | 2023-11-22 16:45:21 | 2023-11-22 20:39:21 | 594 | Streamer |
| 102 | 2023-11-16 13:23:09 | 2023-11-16 16:10:09 | 777 | Streamer |
| 102 | 2023-11-17 13:23:09 | 2023-11-17 16:10:09 | 778 | Streamer |
| 101 | 2023-11-20 07:16:06 | 2023-11-20 08:33:06 | 315 | Streamer |
| 104 | 2023-11-27 03:10:49 | 2023-11-27 03:30:49 | 797 | Viewer |
| 103 | 2023-11-27 03:10:49 | 2023-11-27 03:30:49 | 798 | Streamer |
+---------+---------------------+---------------------+------------+--------------+
输出:
+---------+----------------+
| user_id | sessions_count |
+---------+----------------+
| 101 | 2 |
+---------+----------------+
**解释**
- user_id 101,在 2023-11-06 13:53:42 以观众身份开始了他们的初始会话,随后进行了两次主播会话,所以计数为 2。
- user_id 102,尽管有两个会话,但初始会话是作为主播,因此将排除此用户。
- user_id 103 只参与了一次会话,即作为主播,因此不会考虑在内。
- User_id 104 以观众身份开始了他们的第一次会话,但没有后续会话,因此不会包括在最终计数中。
输出表按照会话数量和 user_id 降序排序。
解题思路
解法一:按用户取最早会话 + 类型转换判断(主提交版本)
- 对
Sessions按user_id分区、session_start排序RANK()得会话次序; - 找出每个用户最早的一次会话:
rk = 1; - 检查该用户最早的会话类型是否为
Viewer,且后续存在Streamer会话
(SUM(t.session_type = 'Streamer') > 0之类),计数即有效主播; - 按
user_id输出满足"首会话为观众且后来开过直播"的用户及会话数。
代码实现
sql
WITH
T AS (
SELECT
user_id,
session_type,
RANK() OVER (
PARTITION BY user_id
ORDER BY session_start
) AS rk
FROM Sessions
)
SELECT user_id, COUNT(1) AS sessions_count
FROM
T AS t
JOIN Sessions AS s USING (user_id)
WHERE rk = 1 AND t.session_type = 'Viewer' AND s.session_type = 'Streamer'
GROUP BY 1
ORDER BY 2 DESC, 1 DESC;
复杂度分析
- 时间复杂度 :
O(n),n为表行数,单次扫描聚合(或窗口/连接)。 - 空间复杂度 :
O(n),分组/排序/窗口需要存储结果集。
2996. Smallest Missing Integer Greater Than Sequential Prefix Sum(大于等于顺序前缀和的最小缺失整数)
题目描述
给你一个下标从 0 开始的整数数组 nums。
如果一个前缀 nums0...`i` 满足对于 1 <= j <= i 的所有元素都有 nums[j] = nums[j - 1] + 1,
那么我们称这个前缀是一个顺序前缀。特殊情况是,只包含 nums[0] 的前缀也是一个顺序前缀。
请你返回 nums 中没有出现过的、最小的整数 x,满足 x 大于等于最长顺序前缀的和。
示例 1
nums = [1,2,3,2,5] -> 6(最长顺序前缀 [1,2,3] 和为 6,6 不在数组中)
示例 2
nums = [3,4,5,1,12,14,13] -> 15(前缀和为 12,12/13/14 均在数组中,15 不在)
提示:
1 <= nums.length <= 501 <= nums[i] <= 50
解题思路
解法一:前缀求和 + 哈希集合
顺序前缀从 nums0 开始,只要 numsj == numsj-1 + 1 就一直延伸,累加得到前缀和 sum。
随后从 sum 开始自增,跳过所有出现在 nums 中的值(用 HashSet 记录),第一个未出现的即为答案。
时间复杂度 O(n),空间复杂度 O(n)。
解法二:布尔数组判重
逻辑等价,改用 boolean 数组记录存在性,独立重写验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(max(nums))
代码实现
java
import java.util.HashSet;
import java.util.Random;
import java.util.Set;
public class Solution {
// ---------- 解法一:哈希集合(主提交版本) ----------
public int missingInteger(int[] nums) {
int sum = nums[0];
for (int j = 1; j < nums.length && nums[j] == nums[j - 1] + 1; j++) {
sum += nums[j];
}
Set<Integer> set = new HashSet<>();
for (int x : nums) set.add(x);
while (set.contains(sum)) sum++;
return sum;
}
// ---------- 解法二:布尔数组对照 ----------
public int missingIntegerBrute(int[] nums) {
int sum = nums[0];
int j = 1;
while (j < nums.length && nums[j] == nums[j - 1] + 1) {
sum += nums[j];
j++;
}
boolean[] present = new boolean[201];
for (int x : nums) present[x] = true;
int x = sum;
while (x < present.length && present[x]) x++;
return x;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.missingInteger(new int[]{1, 2, 3, 2, 5}) == 6, "2996 例1");
check(s.missingInteger(new int[]{3, 4, 5, 1, 12, 14, 13}) == 15, "2996 例2");
check(s.missingInteger(new int[]{5}) == 6, "2996 例3 单元素");
Random rnd = new Random(712);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int n = 1 + rnd.nextInt(10);
int[] nums = new int[n];
for (int i = 0; i < n; i++) nums[i] = 1 + rnd.nextInt(9);
int m1 = s.missingInteger(nums);
int m2 = s.missingIntegerBrute(nums);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 主解=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "2996 随机对拍");
System.out.println("2996 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(n)。
- 时间复杂度:O(n)
- 空间复杂度:O(max(nums))
2997. Minimum Number of Operations to Make Array XOR Equal to K(使数组异或和等于 K 的最少操作次数)
题目描述
给你一个下标从 0 开始的整数数组 nums 和一个正整数 k。
你可以对数组执行以下操作任意次:选择数组里的任意一个元素,并将它的二进制表示翻转一个数位
(把 0 变成 1 或者把 1 变成 0)。
目标是让数组里所有元素的按位异或和得到 k,返回达成这一目标的最少操作次数。
注意:也可以将一个数的前导 0 翻转。
示例 1
nums = [2,1,3,4], k = 1 -> 2
示例 2
nums = [2,0,2,0], k = 0 -> 0
提示:
1 <= nums.length <= 1e50 <= nums[i] <= 1e60 <= k <= 1e6
解题思路
解法一:位运算统计
设 xorSum = nums0 ^ nums1 ^ ... ^ numsn-1。翻转某个元素的第 b 位,恰好会使 xorSum 的第 b 位翻转。
因此目标等价于把 xorSum 变成 k:需要翻转的位数 = popcount(xorSum ^ k)。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:BFS 暴力(对照,小规模)
小规模下把数组状态编码为整数(每个元素 3 位),BFS 枚举"翻转任一元素任一数位"的所有后继,
求到达异或和等于 k 的状态的最少步数(独立验证)。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
public class Solution {
// ---------- 解法一:位运算统计(主提交版本) ----------
public int minOperations(int[] nums, int k) {
int xr = 0;
for (int x : nums) xr ^= x;
return Integer.bitCount(xr ^ k);
}
// ---------- 解法二:BFS 暴力(对照,小规模) ----------
public int minOperationsBrute(int[] nums, int k) {
int n = nums.length;
int start = 0;
for (int i = 0; i < n; i++) start |= (nums[i] & 7) << (3 * i);
Map<Integer, Integer> dist = new HashMap<>();
Queue<Integer> q = new ArrayDeque<>();
dist.put(start, 0);
q.add(start);
while (!q.isEmpty()) {
int st = q.poll();
int d = dist.get(st);
if (xorOf(st, n) == k) return d;
for (int i = 0; i < n; i++) {
for (int b = 0; b < 3; b++) {
int cur = numsAt(st, i, n);
int nv = (cur ^ (1 << b)) & 7;
int ns = (st & ~(7 << (3 * i))) | (nv << (3 * i));
if (!dist.containsKey(ns)) {
dist.put(ns, d + 1);
q.add(ns);
}
}
}
}
return -1;
}
private int numsAt(int st, int i, int n) {
return (st >> (3 * i)) & 7;
}
private int xorOf(int st, int n) {
int x = 0;
for (int i = 0; i < n; i++) x ^= numsAt(st, i, n);
return x;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minOperations(new int[]{2, 1, 3, 4}, 1) == 2, "2997 例1");
check(s.minOperations(new int[]{2, 0, 2, 0}, 0) == 0, "2997 例2");
Random rnd = new Random(88);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
int n = 1 + rnd.nextInt(4);
int[] nums = new int[n];
for (int i = 0; i < n; i++) nums[i] = rnd.nextInt(8);
int k = rnd.nextInt(8);
int m1 = s.minOperations(nums, k);
int m2 = s.minOperationsBrute(nums, k);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 nums=" + Arrays.toString(nums) + " k=" + k + " 主解=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "2997 随机对拍");
System.out.println("2997 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)
2998. Minimum Number of Operations to Make X and Y Equal(使 X 和 Y 相等的最少操作次数)
题目描述
给你两个正整数 x 和 y。一次操作中,你可以执行以下四种操作之一:
- 如果
x是 11 的倍数,将x除以 11; - 如果
x是 5 的倍数,将x除以 5; - 将
x减 1; - 将
x加 1。
返回让x和y相等的最少操作次数。
示例 1
x = 26, y = 1 -> 3(减1 -> 除以5 -> 除以5)
示例 2
x = 54, y = 2 -> 4(加1 -> 除以11 -> 除以5 -> 加1)
示例 3
x = 25, y = 30 -> 5(5 次加 1)
提示:
1 <= x, y <= 1e4
解题思路
解法一:记忆化搜索
若 x <= y,只能通过加 1 到达,答案是 y - x。
否则考虑 x 的决策:要么一直减 1(代价 x-y);要么先调整 ±1 到 5 或 11 的倍数再一次性除以。
记 dfs(x) 为把 x 变到 y 的最少步数,则:
dfs(x) = min(
x - y,
x % 5 + 1 + dfs(x / 5), // 向下取整到 5 的倍数再除
(5 - x % 5) + 1 + dfs(x / 5 + 1), // 向上取整到 5 的倍数再除
x % 11 + 1 + dfs(x / 11),
(11 - x % 11) + 1 + dfs(x / 11 + 1)
)
每层数值至少减半,状态数 O(log x) 级别(加上哈希记忆化),时间复杂度近似 O(x) 上界以内,空间 O(log x)。
解法二:BFS(对照)
从 x 出发 BFS 四类操作,限定状态上界(不会超过 max(x,y)+50,因为超过后只能依赖除法回头、
而连续加 1 超过该界限不可能优于直接停在界内),求到达 y 的最少步数(独立验证)。
复杂度:
- 时间复杂度:O(x)(记忆化,实际远小于)
- 空间复杂度:O(x)
代码实现
java
import java.util.ArrayDeque;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Queue;
import java.util.Random;
public class Solution {
// ---------- 解法一:记忆化搜索(主提交版本) ----------
private Map<Integer, Long> memo = new HashMap<>();
private int yv;
public int minimumOperationsToMakeEqual(int x, int y) {
yv = y;
memo.clear();
return (int) dfs(x);
}
private long dfs(int x) {
if (yv >= x) return yv - x;
Long cached = memo.get(x);
if (cached != null) return cached;
long ans = x - yv; // 纯减 1
long a = x % 5 + 1 + dfs(x / 5); // 降到 5 的倍数再除
long b = (5 - x % 5) + 1 + dfs(x / 5 + 1); // 升到 5 的倍数再除
long c = x % 11 + 1 + dfs(x / 11); // 降到 11 的倍数再除
long d = (11 - x % 11) + 1 + dfs(x / 11 + 1); // 升到 11 的倍数再除
ans = Math.min(ans, Math.min(a, Math.min(b, Math.min(c, d))));
memo.put(x, ans);
return ans;
}
// ---------- 解法二:BFS(对照) ----------
public int minimumOperationsToMakeEqualBrute(int x, int y) {
if (y >= x) return y - x;
int limit = Math.max(x, y) + 50;
int[] dist = new int[limit + 1];
Arrays.fill(dist, -1);
Queue<Integer> q = new ArrayDeque<>();
dist[x] = 0;
q.add(x);
while (!q.isEmpty()) {
int u = q.poll();
if (u == y) return dist[u];
int[] nexts = new int[4];
nexts[0] = u - 1;
nexts[1] = u + 1;
nexts[2] = (u % 5 == 0) ? u / 5 : -1;
nexts[3] = (u % 11 == 0) ? u / 11 : -1;
for (int v : nexts) {
if (v >= 0 && v <= limit && dist[v] == -1) {
dist[v] = dist[u] + 1;
q.add(v);
}
}
}
return -1;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.minimumOperationsToMakeEqual(26, 1) == 3, "2998 例1");
check(s.minimumOperationsToMakeEqual(54, 2) == 4, "2998 例2");
check(s.minimumOperationsToMakeEqual(25, 30) == 5, "2998 例3");
Random rnd = new Random(305);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int x = 1 + rnd.nextInt(150);
int y = 1 + rnd.nextInt(150);
int m1 = s.minimumOperationsToMakeEqual(x, y);
int m2 = s.minimumOperationsToMakeEqualBrute(x, y);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 x=" + x + " y=" + y + " 主解=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "2998 随机对拍");
System.out.println("2998 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
每层数值至少减半,状态数 O(log x) 级别(加上哈希记忆化),时间复杂度近似 O(x) 上界以内,空间 O(log x)。
- 时间复杂度:O(x)(记忆化,实际远小于)
- 空间复杂度:O(x)
2999. Count the Number of Powerful Integers(统计强大整数的数目)
题目描述
给你三个整数 start、finish 和 limit,以及一个下标从 0 开始的字符串 s(表示一个正整数)。
如果一个正整数 x 的末尾部分是 s(即 s 是 x 的后缀),且 x 中的每个数位至多是 limit,
那么我们称 x 是强大的。返回区间 `start`...`finish` 内强大整数的总数目。
示例 1
start=1, finish=6000, limit=4, s="124" -> 5(124,1124,2124,3124,4124)
示例 2
start=15, finish=215, limit=6, s="10" -> 2(110,210)
示例 3
start=1000, finish=2000, limit=4, s="3000" -> 0
提示:
1 <= start <= finish <= 1e151 <= limit <= 91 <= s.length <= floor(log10(finish)) + 1s每个数位都小于等于limit,且不包含前导 0
解题思路
解法一:数位 DP
答案 = 统计 <= finish 的强大整数 - 统计 <= (start-1) 的强大整数。
对上限字符串 t(十进制表示)做数位 DP:dfs(pos, lim) 表示从 pos 位起、是否受 t 前缀约束时
的填法数。每个数位取值 0...min(lim约束位, limit);当剩余位数恰好等于 len(s) 时,
该部分必须固定为 s(若受约束还需 s <= t 的对应后缀)。前导 0 允许(等价于更短的数),
每个数(在固定位数下表示)唯一。时间复杂度 O(20*limit),空间 O(20)。
解法二:暴力枚举(对照,小范围)
直接遍历 start, finish,检查十进制后缀是否为 s 且所有数位 <= limit。
复杂度:
- 时间复杂度:O(位数 * limit)
- 空间复杂度:O(位数)
代码实现
java
import java.util.Arrays;
import java.util.Random;
public class Solution {
// ---------- 解法一:数位 DP(主提交版本) ----------
private String suffix;
private String bound;
private int limit;
private Long[] memo;
public long numberOfPowerfulInt(long start, long finish, int limit, String s) {
this.suffix = s;
this.limit = limit;
bound = String.valueOf(start - 1);
memo = new Long[20];
long a = digitDp(0, true);
bound = String.valueOf(finish);
memo = new Long[20];
long b = digitDp(0, true);
return b - a;
}
// 统计十进制表示不超过 bound、后缀为 suffix、各数位 <= limit 的数的个数
private long digitDp(int pos, boolean lim) {
int len = bound.length();
if (len < suffix.length()) return 0;
if (len - pos == suffix.length()) {
// 剩余位必须恰好等于 suffix:若受约束,还需 suffix <= bound 的对应后缀
return lim ? (suffix.compareTo(bound.substring(pos)) <= 0 ? 1 : 0) : 1;
}
if (!lim && memo[pos] != null) return memo[pos];
int up = (lim ? bound.charAt(pos) - '0' : 9);
up = Math.min(up, limit);
long total = 0;
for (int d = 0; d <= up; d++) {
total += digitDp(pos + 1, lim && d == (bound.charAt(pos) - '0'));
}
if (!lim) memo[pos] = total;
return total;
}
// ---------- 解法二:暴力枚举(对照,小范围) ----------
public long numberOfPowerfulIntBrute(long start, long finish, int limit, String s) {
long cnt = 0;
for (long v = start; v <= finish; v++) {
String str = Long.toString(v);
if (!str.endsWith(s)) continue;
boolean ok = true;
for (int i = 0; i < str.length(); i++) {
if (str.charAt(i) - '0' > limit) {
ok = false;
break;
}
}
if (ok) cnt++;
}
return cnt;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.numberOfPowerfulInt(1, 6000, 4, "124") == 5, "2999 例1");
check(s.numberOfPowerfulInt(15, 215, 6, "10") == 2, "2999 例2");
check(s.numberOfPowerfulInt(1000, 2000, 4, "3000") == 0, "2999 例3");
Random rnd = new Random(404);
boolean allOk = true;
for (int t = 0; t < 300; t++) {
long start = 1 + rnd.nextInt(5000);
long fin = start + rnd.nextInt(5000);
int lim = 1 + rnd.nextInt(9);
int sl = 1 + rnd.nextInt(3);
StringBuilder sb = new StringBuilder();
sb.append(1 + rnd.nextInt(lim)); // s 无前导 0 且数位 <= limit
for (int i = 1; i < sl; i++) sb.append(rnd.nextInt(lim + 1));
String ss = sb.toString();
long m1 = s.numberOfPowerfulInt(start, fin, lim, ss);
long m2 = s.numberOfPowerfulIntBrute(start, fin, lim, ss);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 start=" + start + " fin=" + fin + " limit=" + lim
+ " s=" + ss + " 主解=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "2999 随机对拍");
System.out.println("2999 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
每个数(在固定位数下表示)唯一。时间复杂度 O(20*limit),空间 O(20)。
- 时间复杂度:O(位数 * limit)
- 空间复杂度:O(位数)
3000. Maximum Area of Longest Diagonal Rectangle(对角线最长的矩形的面积)
题目描述
给你一个下标从 0 开始的二维整数数组 dimensions。
对于所有下标 i,dimensions[i][0] 表示矩形 i 的长度,dimensions[i][1] 表示矩形 i 的宽度。
返回对角线最长的矩形的面积。如果存在多个对角线长度相同的矩形,返回其中面积最大的矩形的面积。
示例 1
dimensions = [[9,3],[8,6]] -> 48
(矩形 1 对角线 sqrt(9*9+3*3)=sqrt(90),矩形 2 对角线 sqrt(8*8+6*6)=10,更长,面积 48)
提示:
1 <= dimensions.length <= 1001 <= dimensions[i][0], dimensions[i][1] <= 100
解题思路
解法一:一次遍历,比较对角线平方
对角线长度比较可等价转化为比较"长^2 + 宽^2"(开方单调)。一次遍历:
维护当前最大对角线平方 mx 与对应面积 ans;
若当前矩形对角线平方更大则替换;相等则取面积较大者。
时间复杂度 O(n),空间复杂度 O(1)。
解法二:对照实现
逻辑等价,用 long 防止平方溢出,独立重写一遍做交叉验证。
复杂度:
- 时间复杂度:O(n)
- 空间复杂度:O(1)
代码实现
java
import java.util.Random;
public class Solution {
// ---------- 解法一:一次遍历(主提交版本) ----------
public int areaOfMaxDiagonal(int[][] dimensions) {
int ans = 0, mx = 0;
for (int[] d : dimensions) {
int t = d[0] * d[0] + d[1] * d[1];
if (t > mx) {
mx = t;
ans = d[0] * d[1];
} else if (t == mx) {
ans = Math.max(ans, d[0] * d[1]);
}
}
return ans;
}
// ---------- 解法二:long 版对照(独立重写) ----------
public int areaOfMaxDiagonalBrute(int[][] dimensions) {
long bestDiag = -1;
int bestArea = 0;
for (int[] d : dimensions) {
long diag = (long) d[0] * d[0] + (long) d[1] * d[1];
int area = d[0] * d[1];
if (diag > bestDiag || (diag == bestDiag && area > bestArea)) {
bestDiag = diag;
bestArea = area;
}
}
return bestArea;
}
// ---------- 本地自测 ----------
public static void main(String[] args) {
Solution s = new Solution();
check(s.areaOfMaxDiagonal(new int[][]{{9, 3}, {8, 6}}) == 48, "3000 例1");
check(s.areaOfMaxDiagonal(new int[][]{{3, 4}, {4, 3}}) == 12, "3000 例2");
check(s.areaOfMaxDiagonal(new int[][]{{1, 1}, {1, 1}}) == 1, "3000 例3");
Random rnd = new Random(311);
boolean allOk = true;
for (int t = 0; t < 500; t++) {
int k = 1 + rnd.nextInt(8);
int[][] dim = new int[k][2];
for (int i = 0; i < k; i++) {
dim[i][0] = 1 + rnd.nextInt(100);
dim[i][1] = 1 + rnd.nextInt(100);
}
int m1 = s.areaOfMaxDiagonal(dim);
int m2 = s.areaOfMaxDiagonalBrute(dim);
if (m1 != m2) {
allOk = false;
System.out.println("对拍失败 主解=" + m1 + " 暴力=" + m2);
break;
}
}
check(allOk, "3000 随机对拍");
System.out.println("3000 all tests done");
}
static void check(boolean ok, String name) {
System.out.println((ok ? "PASS " : "FAIL ") + name);
}
}
复杂度分析
时间复杂度 O(n),空间复杂度 O(1)。
- 时间复杂度:O(n)
- 空间复杂度:O(1)