LeetCode2981~3000题目解析

LeetCode 2981-3000. 题解合集

文章目录


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 的前缀个数):

  1. 0,a-1 与 max(b,d)+1, m-1 必须无 mismatch,否则不可行;
  2. d <= b(t 区间被 s 区间包含):只需 a,b 内 sL 与 t 计数相等;
  3. b < c(两区间不相交):中间 b+1,c-1 无 mismatch,且两区间各自计数相等;
  4. 相交: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 <= 50
  • 1 <= 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 <= 1e5
  • 0 <= nums[i] <= 1e6
  • 0 <= 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 <= 1e15
  • 1 <= limit <= 9
  • 1 <= s.length <= floor(log10(finish)) + 1
  • s 每个数位都小于等于 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 <= 100
  • 1 <= 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)
相关推荐
nice_lcj5202 小时前
【从零理解 Spring AI · 13】RAG 要解决什么:把“闭卷考试“变成“开卷“
java·spring·检索增强·rag·spring ai·ai应用开发
学长毕设2 小时前
基于SpringBoot军事纪念馆管理系统设计与实现-附源码
java·spring boot·后端
这个昵称不容易3 小时前
SpringBoot 医疗病历交互系统的设计与实现:192 个 Java 文件、256 个接口、22 张表,附真实运行截图
java·springboot·毕设
驭渊的小故事4 小时前
订单服务如何调用商品服务?一次 RestTemplate 跨服务调用入门
java·开发语言·php
文丑颜不良啊6 小时前
LeetCode3001~3020题目解析
java·leetcode
山楂树の7 小时前
Java 字符串高效处理:StringBuilder、StringBuffer、StringJoiner
java·开发语言
.痞老板.9 小时前
java ee--文件操作和IO
java·java-ee
简 洁 冬冬9 小时前
分页「向上取整」公式 `(total + size - 1) / size` 的完整推导
java·分页
装不满的克莱因瓶11 小时前
【从零搭建】AI大模型之ReactAgent智能体对接MCP实战
java·人工智能·ai·springai·mcp·springaialibaba