LeetCode3041~3060题目解析

LeetCode 3041-3060. 题解合集

文章目录


3041. Maximize Consecutive Elements in an Array After Modification(修改数组后最大化数组中的连续元素数目)

题目描述

给你一个下标从 0 开始只包含正整数的数组 nums。

一开始,你可以将数组中任意数量元素增加至多 1。

修改后,你可以从最终数组中选择一个或者更多元素,并确保这些元素升序排序后是连续的。

比方说,3, 4, 5 是连续的,但是 3, 4, 6 和 1, 1, 2, 3 不是连续的。

请你返回最多可以选出的元素数目。

示例 1

复制代码
nums = [2,1,5,1,1] -> 3(把两个 1 中一个增到 2,选出 [1,2,3])

示例 2

复制代码
nums = [1,4,7,10] -> 1

提示:

  • 1 <= nums.length <= 10^5
  • 1 <= nums[i] <= 10^6

解题思路

解法一:排序 + HashMap 线性 DP,主提交版本

每个元素最终要么保持原值 num,要么变成 num+1。升序排序后依次处理,关键观察:

选择出的连续序列中,若当前元素不操作(保持 num),它可以接在以 num-1 结尾的序列后

(dpnum = dpnum-1 + 1);若操作(变为 num+1),它可以接在以 num 结尾的序列后

(dpnum+1 = dpnum + 1)。用哈希表 dp 记录"以某个值为结尾的最长连续选出长度"。

每处理一个 numsi 同时更新两个转移,并全局维护最大值。

排序后"小值先处理",保证 dpnum-1 / dpnum 在用到时已就绪;

同值重复元素也能通过两次转移分别接续,天然支持"多个相同元素各占用一个连续位"。

时间复杂度 O(n log n),空间复杂度 O(n)。

解法二:枚举起点的暴力(对照)

小规模场景:枚举所有数字作为连续段起点,统计"每个值 +1 后"能衔接的最长长度,

用每个值在原数组中的出现次数判断是否够用。实现朴素、直观,用于交叉验证。

时间复杂度 O(n^2),空间复杂度 O(n),仅用于小规模验证。

复杂度:

  • 时间复杂度:O(n log n)
  • 空间复杂度:O(n)

代码实现

java 复制代码
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class Solution {

    // ---------- 解法一:排序 + HashMap 线性 DP(主提交版本) ----------
    public int maxSelectedElements(int[] nums) {
        Arrays.sort(nums);
        Map<Integer, Integer> dp = new HashMap<>(); // 值 -> 以该值结尾的最长连续选出长度
        int ans = 0;
        for (int num : nums) {
            // 关键顺序:先更新 dp[num+1](引用 dp[num] 的旧值),再更新 dp[num](引用 dp[num-1])。
            // 若反过来,同一个元素会同时被两条链(作 num 与作 num+1)各"使用一次",导致长度虚增。
            int inc = dp.getOrDefault(num, 0) + 1;      // 操作:num -> num+1,接在以 num 结尾的序列后
            dp.put(num + 1, inc);
            int keep = dp.getOrDefault(num - 1, 0) + 1; // 不操作:num 接在以 num-1 结尾的序列后
            dp.put(num, keep);
            ans = Math.max(ans, Math.max(inc, keep));
        }
        return ans;
    }

    // ---------- 解法二:暴力枚举最终连续段(对照) ----------
    public int maxSelectedElementsBrute(int[] nums) {
        int n = nums.length;
        // 每个元素可选 num 或 num+1,枚举所有最终值集合(二进制枚举)
        // 对每个组合,统计能构成的最长连续段
        int best = 0;
        for (int mask = 0; mask < (1 << n); ++mask) {
            // 求该组合的去重排序后最大连续长度
            int[] finals = new int[n];
            for (int i = 0; i < n; ++i) {
                finals[i] = nums[i] + ((mask >> i) & 1);
            }
            Arrays.sort(finals);
            int cur = 1;
            best = Math.max(best, 1);
            for (int i = 1; i < n; ++i) {
                if (finals[i] == finals[i - 1] + 1) {
                    cur++;
                } else if (finals[i] == finals[i - 1]) {
                    // 相同值不能计入同一连续段(连续要求严格递增),跳过
                } else {
                    cur = 1;
                }
                best = Math.max(best, cur);
            }
        }
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {2, 1, 5, 1, 1},
            {1, 4, 7, 10},
            {1, 1, 1, 1},
            {1, 2, 3},
            {4, 1, 1, 1, 3},
            {1, 2, 2, 3},
            {5, 6, 7, 8, 9},
        };
        int[] expects = {3, 1, 2, 3, 4, 4, 5};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.maxSelectedElements(cases[i]);
            int b = sol.maxSelectedElementsBrute(cases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + a
                    + " / brute=" + b + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(103);
        int trials = 3000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(9);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(8);
            int a = sol.maxSelectedElements(nums);
            int b = sol.maxSelectedElementsBrute(nums);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH " + Arrays.toString(nums) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(n log n),空间复杂度 O(n)。

时间复杂度 O(n^2),空间复杂度 O(n),仅用于小规模验证。

  • 时间复杂度:O(n log n)
  • 空间复杂度:O(n)

3042. Count Prefix and Suffix Pairs I(统计前后缀下标对 I)

题目描述

给你一个下标从 0 开始的字符串数组 words。

定义一个布尔函数 isPrefixAndSuffix,它接受两个字符串参数 str1 和 str2:

  • 当 str1 同时是 str2 的前缀(prefix)和后缀(suffix)时返回 true,否则返回 false。
    例如,isPrefixAndSuffix("aba", "ababa") 返回 true,而 isPrefixAndSuffix("abc", "abcd") 返回 false。
    以整数形式,返回满足 i < j 且 isPrefixAndSuffix(words[i], words[j]) 为 true 的下标对的数目。

示例 1

复制代码
words = ["a","aba","ababa","aa"] -> 4

提示:

  • 1 <= words.length <= 50(3042 为 I 版本,规模较小;3045 为 II 版本)
  • 1 <= words[i].length <= 10

解题思路

解法一:双重遍历 + API 判断,主提交版本

枚举每个有序对 (i, j)(i < j),直接用 startsWith 与 endsWith 判断 wordsi

是否同时是 wordsj 的前缀和后缀。n <= 50,双重循环足够。

时间复杂度 O(n^2 * L),空间复杂度 O(1)。

解法二:双重遍历手工比较(对照)

不依赖 startsWith/endsWith,手工实现 isPrefixAndSuffix:检查 str1 长度不超过

str2,且 str2 的前 len 个字符与后 len 个字符都等于 str1。与解法一互相校验。

时间复杂度 O(n^2 * L),空间复杂度 O(1)。

复杂度:

  • 时间复杂度:O(n^2 * L)
  • 空间复杂度:O(1)

代码实现

java 复制代码
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class Solution {

    // ---------- 解法一:API 判断(主提交版本) ----------
    public int countPrefixSuffixPairs(String[] words) {
        int ans = 0;
        int n = words.length;
        for (int i = 0; i < n; ++i) {
            String s = words[i];
            for (int j = i + 1; j < n; ++j) {
                String t = words[j];
                if (t.startsWith(s) && t.endsWith(s)) {
                    ++ans;
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:手工比较(对照) ----------
    public int countPrefixSuffixPairsBrute(String[] words) {
        int ans = 0;
        int n = words.length;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (isPS(words[i], words[j])) {
                    ++ans;
                }
            }
        }
        return ans;
    }

    private boolean isPS(String a, String b) {
        if (a.length() > b.length()) return false;
        int len = a.length();
        for (int k = 0; k < len; ++k) {
            if (b.charAt(k) != a.charAt(k)) return false;          // 前缀
            if (b.charAt(b.length() - len + k) != a.charAt(k)) return false; // 后缀
        }
        return true;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[][] cases = {
            {"a", "aba", "ababa", "aa"},
            {"pa", "papa", "ma", "mama"},
            {"abab", "ab"},
            {"a", "aa", "aaa", "aaaa"},
            {"ab", "ba"},
        };
        int[] expects = {4, 2, 0, 6, 0};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.countPrefixSuffixPairs(cases[i]);
            int b = sol.countPrefixSuffixPairsBrute(cases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + a
                    + " / brute=" + b + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(107);
        int trials = 3000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 2 + rnd.nextInt(8);
            String[] words = new String[n];
            for (int i = 0; i < n; ++i) {
                int len = 1 + rnd.nextInt(5);
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < len; ++j) {
                    sb.append((char) ('a' + rnd.nextInt(3)));
                }
                words[i] = sb.toString();
            }
            int a = sol.countPrefixSuffixPairs(words);
            int b = sol.countPrefixSuffixPairsBrute(words);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH " + Arrays.toString(words) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(n^2 * L),空间复杂度 O(1)。

  • 时间复杂度:O(n^2 * L)
  • 空间复杂度:O(1)

3043. Find the Length of the Longest Common Prefix(最长公共前缀的长度)

题目描述

给你两个正整数数组 arr1 和 arr2。

正整数的前缀是其最左边的一位或多位数字组成的整数。例如,123 是整数 12345 的前缀。

设若整数 c 是整数 a 和 b 的公共前缀,那么 c 需要同时是 a 和 b 的前缀。

你需要找出属于 arr1 的整数 x 和属于 arr2 的整数 y 组成的所有数对 (x, y) 之中

最长的公共前缀的长度。如果它们之间不存在公共前缀,则返回 0。

示例 1

复制代码
arr1 = [1,10,100], arr2 = [1000] -> 3

示例 2

复制代码
arr1 = [1,2,3], arr2 = [4,4,4] -> 0

提示:

  • 1 <= arr1.length, arr2.length <= 5 * 10^4
  • 1 <= arr1[i], arr2[i] <= 10^8

解题思路

解法一:前缀集合 + 逐段比较,主提交版本

数字前缀 c(如 12345 的前缀有 1、12、123、1234、12345)可以通过不断除以 10 枚举。

把 arr1 中所有数的所有前缀存进 HashSet;再遍历 arr2 中的每个数的前缀(同样不断

除以 10),若某个前缀出现在集合中,则它必是一个公共前缀。取所有公共前缀中

数值最大的(前缀越长数值越大),答案为它的十进制位数。

时间复杂度 O((len1 + len2) * d)(d 为最大位数,<= 9),空间复杂度 O(len1 * d)。

解法二:字符串前缀暴力(对照)

把每个数转成字符串,对每个 (x, y) 对逐位比较公共前缀长度。复杂度 O(n1 * n2 * d),

仅用于小规模交叉验证。

复杂度:

  • 时间复杂度:O((len1 + len2) * d)
  • 空间复杂度:O(len1 * d)

代码实现

java 复制代码
import java.util.HashSet;
import java.util.Random;
import java.util.Set;

public class Solution {

    // ---------- 解法一:前缀集合(主提交版本) ----------
    public int longestCommonPrefix(int[] arr1, int[] arr2) {
        Set<Integer> set = new HashSet<>();
        for (int x : arr1) {
            while (x > 0) {
                set.add(x);
                x /= 10;
            }
        }
        int best = 0;
        for (int x : arr2) {
            while (x > 0) {
                if (set.contains(x)) {
                    best = Math.max(best, x);
                    break; // 该数更大的前缀不存在(递归前缀更短),只需取最长的一段
                }
                x /= 10;
            }
        }
        return best == 0 ? 0 : String.valueOf(best).length();
    }

    // ---------- 解法二:字符串暴力(对照) ----------
    public int longestCommonPrefixBrute(int[] arr1, int[] arr2) {
        int best = 0;
        for (int a : arr1) {
            String sa = String.valueOf(a);
            for (int b : arr2) {
                String sb = String.valueOf(b);
                int l = 0;
                while (l < sa.length() && l < sb.length() && sa.charAt(l) == sb.charAt(l)) {
                    l++;
                }
                best = Math.max(best, l);
            }
        }
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] arr1s = {{1, 10, 100}, {1, 2, 3}, {123, 456}, {9999, 888}, {5}};
        int[][] arr2s = {{1000}, {4, 4, 4}, {1234, 458}, {999, 8877}, {50}};
        int[] expects = {3, 0, 3, 3, 1};
        boolean allPass = true;
        for (int i = 0; i < arr1s.length; ++i) {
            int a = sol.longestCommonPrefix(arr1s[i], arr2s[i]);
            int b = sol.longestCommonPrefixBrute(arr1s[i], arr2s[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(java.util.Arrays.toString(arr1s[i]) + " vs "
                    + java.util.Arrays.toString(arr2s[i]) + " -> " + a
                    + " / brute=" + b + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(109);
        int trials = 2000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n1 = 1 + rnd.nextInt(6);
            int n2 = 1 + rnd.nextInt(6);
            int[] a1 = new int[n1];
            int[] a2 = new int[n2];
            for (int i = 0; i < n1; ++i) a1[i] = 1 + rnd.nextInt(99999);
            for (int i = 0; i < n2; ++i) a2[i] = 1 + rnd.nextInt(99999);
            int a = sol.longestCommonPrefix(a1, a2);
            int b = sol.longestCommonPrefixBrute(a1, a2);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH " + java.util.Arrays.toString(a1)
                            + " vs " + java.util.Arrays.toString(a2) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O((len1 + len2) * d)(d 为最大位数,<= 9),空间复杂度 O(len1 * d)。

  • 时间复杂度:O((len1 + len2) * d)
  • 空间复杂度:O(len1 * d)

3044. Most Frequent Prime(出现频率最高的质数)

题目描述

给你一个大小为 m x n、下标从 0 开始的二维矩阵 mat。在每个单元格,你可以按以下方式生成数字:

  • 最多有 8 条路径可以选择:东,东南,南,西南,西,西北,北,东北。
  • 选择其中一条路径,沿着这个方向移动,并且将路径上的数字添加到正在形成的数字后面。
  • 注意,每一步都会生成数字,例如,如果路径上的数字是 1, 9, 1,那么在这个方向上
    会生成三个数字:1, 19, 191。
    返回在遍历矩阵所创建的所有数字中,出现频率最高的、大于 10 的质数;如果不存在这样的质数,
    则返回 -1。如果存在多个出现频率最高的质数,那么返回其中最大的那个。
    注意:移动过程中不允许改变方向。

示例 1

复制代码
mat = [[1,1],[9,9],[1,1]] -> 19

示例 2

复制代码
mat = [[7]] -> -1

示例 3

复制代码
mat = [[9,7,8],[4,6,5],[2,8,6]] -> 97

提示:

  • m == mat.length
  • n == mat[i].length
  • 1 <= m, n <= 6
  • 1 <= mat[i][j] <= 9

解题思路

解法一:8 方向扩展 + 计数,主提交版本

从每个单元格出发,沿 8 个方向(除 (0,0) 外的 8 个 (dx, dy))逐步前进,每走一步

就把新到达的格子数字追加到当前数字末尾(v = v * 10 + digit),步进过程中持续生成

新数字。对每个生成的大于 10 的数字判断质数,用哈希表统计出现次数。

最后遍历计数表:次数最多者中取数值最大。因为质数判定是针对 <= 9 位数字的

简单试除即可(最大数字 999999999 < 1e9)。

时间复杂度 O(m * n * 8 * max(m, n) * sqrt(v)),空间复杂度 O(生成数字数)。

解法二:朴素枚举所有线段(对照)

对每个起点与方向,直接用一个循环沿方向收集数字序列,把序列的每个前缀转成整数

并统计质数。实现上把所有"前缀数字"都交给同一个 isPrime 判断与计数表,

与解法一完全等价,仅写法不同,用于交叉验证。

复杂度:

  • 时间复杂度:O(m * n * 8 * L * sqrt(V))
  • 空间复杂度:O(生成数字数)

代码实现

java 复制代码
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class Solution {

    private static final int[] DX = {-1, -1, -1, 0, 0, 1, 1, 1};
    private static final int[] DY = {-1, 0, 1, -1, 1, -1, 0, 1};

    // ---------- 解法一:8 方向扩展 + 计数(主提交版本) ----------
    public int mostFrequentPrime(int[][] mat) {
        int m = mat.length;
        int n = mat[0].length;
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                for (int d = 0; d < 8; ++d) {
                    int x = i, y = j;
                    int v = mat[i][j];
                    // 至少再走一步才能生成 >10 的数
                    x += DX[d];
                    y += DY[d];
                    while (x >= 0 && x < m && y >= 0 && y < n) {
                        v = v * 10 + mat[x][y];
                        if (isPrime(v)) {
                            cnt.merge(v, 1, Integer::sum);
                        }
                        x += DX[d];
                        y += DY[d];
                    }
                }
            }
        }
        int ans = -1;
        int mx = 0;
        for (Map.Entry<Integer, Integer> e : cnt.entrySet()) {
            int v = e.getKey();
            int c = e.getValue();
            if (c > mx || (c == mx && v > ans)) {
                mx = c;
                ans = v;
            }
        }
        return ans;
    }

    // ---------- 解法二:前缀收集(对照) ----------
    public int mostFrequentPrimeBrute(int[][] mat) {
        int m = mat.length;
        int n = mat[0].length;
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                for (int d = 0; d < 8; ++d) {
                    long v = mat[i][j];
                    int x = i + DX[d], y = j + DY[d];
                    while (x >= 0 && x < m && y >= 0 && y < n) {
                        v = v * 10 + mat[x][y];
                        if (v > 10 && isPrime((int) v)) {
                            cnt.merge((int) v, 1, Integer::sum);
                        }
                        x += DX[d];
                        y += DY[d];
                    }
                }
            }
        }
        int ans = -1;
        int mx = 0;
        for (Map.Entry<Integer, Integer> e : cnt.entrySet()) {
            int v = e.getKey();
            int c = e.getValue();
            if (c > mx || (c == mx && v > ans)) {
                mx = c;
                ans = v;
            }
        }
        return ans;
    }

    private boolean isPrime(int x) {
        if (x <= 10) return false;
        for (int i = 2; i <= x / i; ++i) {
            if (x % i == 0) {
                return false;
            }
        }
        return true;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][][] mats = {
            {{1, 1}, {9, 9}, {1, 1}},
            {{7}},
            {{9, 7, 8}, {4, 6, 5}, {2, 8, 6}},
            {{2, 5}, {3, 7}},
        };
        int[] expects = {19, -1, 97, 73};
        boolean allPass = true;
        for (int t = 0; t < mats.length; ++t) {
            int a = sol.mostFrequentPrime(mats[t]);
            int b = sol.mostFrequentPrimeBrute(mats[t]);
            boolean ok = a == expects[t] && b == expects[t];
            allPass &= ok;
            System.out.println(java.util.Arrays.deepToString(mats[t]) + " -> " + a
                    + " / brute=" + b + " expected=" + expects[t] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(113);
        int trials = 1000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int m = 1 + rnd.nextInt(4);
            int n = 1 + rnd.nextInt(4);
            int[][] mat = new int[m][n];
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    mat[i][j] = 1 + rnd.nextInt(9);
                }
            }
            int a = sol.mostFrequentPrime(mat);
            int b = sol.mostFrequentPrimeBrute(mat);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH " + java.util.Arrays.deepToString(mat)
                            + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(m * n * 8 * max(m, n) * sqrt(v)),空间复杂度 O(生成数字数)。

  • 时间复杂度:O(m * n * 8 * L * sqrt(V))
  • 空间复杂度:O(生成数字数)

3045. Count Prefix and Suffix Pairs II(统计前后缀下标对 II)

题目描述

给你一个下标从 0 开始的字符串数组 words。

定义一个布尔函数 isPrefixAndSuffix,它接受两个字符串参数 str1 和 str2:

  • 当 str1 同时是 str2 的前缀(prefix)和后缀(suffix)时返回 true,否则返回 false。
    例如,isPrefixAndSuffix("aba", "ababa") 返回 true,而 isPrefixAndSuffix("abc", "abcd") 返回 false。
    以整数形式,返回满足 i < j 且 isPrefixAndSuffix(words[i], words[j]) 为 true 的下标对的数目。

示例 1

复制代码
words = ["a","aba","ababa","aa"] -> 4

示例 2

复制代码
words = ["pa","papa","ma","mama"] -> 2

示例 3

复制代码
words = ["abab","ab"] -> 0

提示:

  • 1 <= words.length <= 10^5
  • 1 <= words[i].length <= 10^5
  • words[i] 仅由小写英文字母组成
  • 所有 words[i] 的长度之和不超过 5 * 10^5

解题思路

解法一:成对字符 Trie,主提交版本

设 wordsi 是 wordsj 的前缀且后缀,则 wordsi 的长度 <= wordsj 的长度,

且 wordsj 的首尾对应位置两两相等并构成"成对字符"序列:

(w0, wlen-1), (w1, wlen-2), ... 而 wordsi 对应的成对字符序列正是

(s0, sm-1), (s1, sm-2), ...。因此把每个字符串的成对字符序列插入一棵 Trie,

在插入过程中,路径上每个节点记录的"已完整插入的字符串个数"正是以该序列为前缀的

之前字符串的数量------它们都与当前字符串构成合法下标对(每个前面插入的串都是

当前串的公共前后缀)。插入时每经过一个节点就把 cnt 累加进答案,最后给末端节点 cnt+1。

成对字符用 si * 26 + sm-1-i 编号(不超过 26*26 上限,虽用 int 实际只到 675 也安全)。

时间复杂度 O(totalLen),空间复杂度 O(totalLen)。

解法二:暴力双循环(对照)

直接枚举 (i, j),用 startsWith + endsWith 判定。复杂度 O(n^2 * L),

仅用于小规模交叉验证。

复杂度:

  • 时间复杂度:O(totalLen)
  • 空间复杂度:O(totalLen)

代码实现

java 复制代码
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class Solution {

    static class Node {
        Map<Integer, Node> children = new HashMap<>();
        int cnt;
    }

    // ---------- 解法一:成对字符 Trie(主提交版本) ----------
    public long countPrefixSuffixPairs(String[] words) {
        long ans = 0;
        Node root = new Node();
        for (String s : words) {
            Node node = root;
            int m = s.length();
            for (int i = 0; i < m; ++i) {
                int key = s.charAt(i) * 26 + s.charAt(m - 1 - i);
                Node child = node.children.get(key);
                if (child == null) {
                    child = new Node();
                    node.children.put(key, child);
                }
                node = child;
                ans += node.cnt; // 路径上每个节点完整串都是当前串的公共前后缀
            }
            node.cnt++; // 当前串本身完整插入
        }
        return ans;
    }

    // ---------- 解法二:暴力双循环(对照) ----------
    public long countPrefixSuffixPairsBrute(String[] words) {
        long ans = 0;
        int n = words.length;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (words[j].startsWith(words[i]) && words[j].endsWith(words[i])) {
                    ++ans;
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[][] cases = {
            {"a", "aba", "ababa", "aa"},
            {"pa", "papa", "ma", "mama"},
            {"abab", "ab"},
            {"a", "aa", "aaa", "aaaa"},
            {"ab", "ba", "aba", "bab"},
        };
        long[] expects = {4, 2, 0, 6, 0};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            long a = sol.countPrefixSuffixPairs(cases[i]);
            long b = sol.countPrefixSuffixPairsBrute(cases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + a
                    + " / brute=" + b + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(127);
        int trials = 2000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 2 + rnd.nextInt(8);
            String[] words = new String[n];
            for (int i = 0; i < n; ++i) {
                int len = 1 + rnd.nextInt(6);
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < len; ++j) {
                    sb.append((char) ('a' + rnd.nextInt(3)));
                }
                words[i] = sb.toString();
            }
            long a = sol.countPrefixSuffixPairs(words);
            long b = sol.countPrefixSuffixPairsBrute(words);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH " + Arrays.toString(words) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(totalLen),空间复杂度 O(totalLen)。

  • 时间复杂度:O(totalLen)
  • 空间复杂度:O(totalLen)

3046. Split the Array(分割数组)

题目描述

给你一个长度为偶数的整数数组 nums。你需要将这个数组分割成 nums1 和 nums2 两部分,要求:

  • nums1.length == nums2.length == nums.length / 2
  • nums1 应包含互不相同的元素
  • nums2 也应包含互不相同的元素
    如果能够分割数组就返回 true,否则返回 false。

示例 1

复制代码
nums = [1,1,2,2,3,4] -> true

示例 2

复制代码
nums = [1,1,1,1] -> false

提示:

  • 1 <= nums.length <= 100
  • nums.length % 2 == 0
  • 1 <= nums[i] <= 100

解题思路

解法一:频次统计,主提交版本

两个数组大小相等(各 n/2),且每个数组内元素互不相同,等价于每个值最多出现 2 次

(出现 2 次时可各放一个到两个数组;出现 3 次及以上则必然导致某个数组内重复)。

只要所有数的出现次数都不超过 2 即可分割(每个出现 2 次的数两边各放一份,

出现 1 次的数任意分配,两边数量恰好相等)。

时间复杂度 O(n),空间复杂度 O(1)。

解法二:模拟分配(对照)

维护两个集合 s1、s2,遍历 nums 时按"尽可能不重复"的原则分配:优先放进

不含该数的集合,两边数量差控制后同步放;若某数在两边都已存在(出现 >= 3 次)

则无法分割。小规模时结果与解法一完全一致,用于交叉验证。

时间复杂度 O(n),空间复杂度 O(n)。

复杂度:

  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

代码实现

java 复制代码
import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.Random;

public class Solution {

    // ---------- 解法一:频次统计(主提交版本) ----------
    public boolean isPossibleToSplit(int[] nums) {
        int[] cnt = new int[101];
        for (int x : nums) {
            if (++cnt[x] > 2) {
                return false;
            }
        }
        return true;
    }

    // ---------- 解法二:模拟分配(对照) ----------
    public boolean isPossibleToSplitBrute(int[] nums) {
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int x : nums) {
            cnt.merge(x, 1, Integer::sum);
            if (cnt.get(x) > 2) {
                return false;
            }
        }
        // 出现 2 次的必须两边各 1 个;出现 1 次的可以任选一边,总数量必为偶数即可
        int half = nums.length / 2;
        int dbl = 0;
        for (int c : cnt.values()) {
            if (c == 2) dbl++;
        }
        // 单次数 = 总个数 - 2*双次数;单次项放进同一边的数量 = (单次数 可任意),
        // 只需 dbl <= half 即可(每个半边至少需要 1 个位置放双次项,其余由单次项补齐)
        return dbl <= half && dbl + (nums.length - 2 * dbl) >= half
                && (dbl + (nums.length - 2 * dbl) - half) >= 0;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {1, 1, 2, 2, 3, 4},
            {1, 1, 1, 1},
            {1, 2, 3, 4},
            {1, 1, 2, 3},
            {5, 5, 6, 6, 7, 7, 8, 8},
            {1, 1, 1, 2, 2, 3},
        };
        boolean[] expects = {true, false, true, true, true, false};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            boolean a = sol.isPossibleToSplit(cases[i]);
            boolean b = sol.isPossibleToSplitBrute(cases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + a
                    + " / brute=" + b + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(131);
        int trials = 3000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 2 * (1 + rnd.nextInt(6));
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(5);
            boolean a = sol.isPossibleToSplit(nums);
            boolean b = sol.isPossibleToSplitBrute(nums);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH " + Arrays.toString(nums) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(n),空间复杂度 O(1)。

时间复杂度 O(n),空间复杂度 O(n)。

  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

3047. Find the Largest Area of Square Inside Two Rectangles(求交集区域内的最大正方形面积)

题目描述

在二维平面上存在 n 个矩形。给你两个下标从 0 开始的二维整数数组 bottomLeft 和 topRight,

两个数组的大小都是 n x 2,其中 bottomLeft[i] 和 topRight[i] 分别代表第 i 个矩形的左下角

和右上角坐标。我们定义向右的方向为 x 轴正半轴,向上的方向为 y 轴正半轴。

你可以选择一个区域,该区域由两个矩形的交集形成。你需要找出能够放入该区域内的最大正方形面积,

并选择最优解。返回能够放入交集区域的正方形的最大可能面积,如果矩形之间不存在任何交集区域,

则返回 0。注意,区域可以由多于两个矩形的交集构成(但题意简化后等价于取任两矩形交集)。

示例 1

复制代码
bottomLeft = [[1,1],[2,2],[3,1]], topRight = [[3,3],[4,4],[6,6]] -> 1

示例 2

复制代码
bottomLeft = [[1,1],[2,2],[1,2]], topRight = [[3,3],[4,4],[3,4]] -> 1

示例 3

复制代码
bottomLeft = [[1,1],[3,3],[3,1]], topRight = [[2,2],[4,4],[4,2]] -> 0

提示:

  • n == bottomLeft.length == topRight.length
  • 2 <= n <= 10^3
  • bottomLeft[i].length == topRight[i].length == 2
  • 1 <= bottomLeft[i][0], bottomLeft[i][1] <= 10^7

解题思路

解法一:两两枚举交集宽度高度,主提交版本

两个轴对齐矩形的交集若存在,其 x 方向宽度 = min(x2, x4) - max(x1, x3),

y 方向高度 = min(y2, y4) - max(y1, y3);交集非空当且仅当 w > 0 且 h > 0。

能放入交集内的最大正方形边长 = min(w, h),面积 = 边长^2。

枚举所有矩形对 (i, j)(i < j),取它们交集内正方形面积的最大值。

注意:题目示例说明"区域可由多于两个矩形的交集构成",但多个矩形的交集是

所有两两交集各自的交集,其内正方形面积不会超过某个两两交集内的正方形面积,

因此仅枚举所有对即可覆盖最优解。

时间复杂度 O(n^2),空间复杂度 O(1)。

解法二:三重子集枚举(对照)

小规模场景:枚举所有矩形子集(至少 2 个),求它们的公共交集(逐矩形收缩),

交集非空时计算 min(w, h)^2 并取最大。用于交叉验证"多于两个矩形"情形。

时间复杂度 O(2^n * n),仅用于小规模验证。

复杂度:

  • 时间复杂度:O(n^2)
  • 空间复杂度:O(1)

代码实现

java 复制代码
import java.util.Arrays;
import java.util.Random;

public class Solution {

    // ---------- 解法一:两两枚举交集(主提交版本) ----------
    public long largestSquareArea(int[][] bottomLeft, int[][] topRight) {
        int n = bottomLeft.length;
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            int x1 = bottomLeft[i][0], y1 = bottomLeft[i][1];
            int x2 = topRight[i][0], y2 = topRight[i][1];
            for (int j = i + 1; j < n; ++j) {
                int x3 = bottomLeft[j][0], y3 = bottomLeft[j][1];
                int x4 = topRight[j][0], y4 = topRight[j][1];
                int w = Math.min(x2, x4) - Math.max(x1, x3);
                int h = Math.min(y2, y4) - Math.max(y1, y3);
                if (w > 0 && h > 0) {
                    int side = Math.min(w, h);
                    ans = Math.max(ans, (long) side * side);
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:三重子集枚举(对照) ----------
    public long largestSquareAreaBrute(int[][] bottomLeft, int[][] topRight) {
        int n = bottomLeft.length;
        long ans = 0;
        for (int mask = 0; mask < (1 << n); ++mask) {
            // 至少两个矩形
            if (Integer.bitCount(mask) < 2) continue;
            int minX = Integer.MAX_VALUE, minY = Integer.MAX_VALUE;
            int maxX = Integer.MIN_VALUE, maxY = Integer.MIN_VALUE;
            for (int i = 0; i < n; ++i) {
                if ((mask & (1 << i)) != 0) {
                    minX = Math.min(minX, topRight[i][0]);
                    minY = Math.min(minY, topRight[i][1]);
                    maxX = Math.max(maxX, bottomLeft[i][0]);
                    maxY = Math.max(maxY, bottomLeft[i][1]);
                }
            }
            // 交集为 [maxX, minX] x [maxY, minY]
            int w = minX - maxX;
            int h = minY - maxY;
            if (w > 0 && h > 0) {
                int side = Math.min(w, h);
                ans = Math.max(ans, (long) side * side);
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][][] bLs = {
            {{1, 1}, {2, 2}, {3, 1}},
            {{1, 1}, {2, 2}, {1, 2}},
            {{1, 1}, {3, 3}, {3, 1}},
            {{0, 0}, {2, 2}},
            {{1, 1}, {3, 3}, {2, 2}},
        };
        int[][][] tRs = {
            {{3, 3}, {4, 4}, {6, 6}},
            {{3, 3}, {4, 4}, {3, 4}},
            {{2, 2}, {4, 4}, {4, 2}},
            {{3, 3}, {5, 5}},
            {{2, 2}, {4, 4}, {4, 4}},
        };
        long[] expects = {1, 1, 0, 1, 1};
        boolean allPass = true;
        for (int i = 0; i < bLs.length; ++i) {
            long a = sol.largestSquareArea(bLs[i], tRs[i]);
            long b = sol.largestSquareAreaBrute(bLs[i], tRs[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println("case " + (i + 1) + " -> " + a + " / brute=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(137);
        int trials = 1000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 2 + rnd.nextInt(4); // 子集枚举限制 n 小
            int[][] bl = new int[n][2];
            int[][] tr = new int[n][2];
            for (int i = 0; i < n; ++i) {
                int x1 = rnd.nextInt(8);
                int y1 = rnd.nextInt(8);
                int x2 = x1 + 1 + rnd.nextInt(4);
                int y2 = y1 + 1 + rnd.nextInt(4);
                bl[i][0] = x1; bl[i][1] = y1;
                tr[i][0] = x2; tr[i][1] = y2;
            }
            long a = sol.largestSquareArea(bl, tr);
            long b = sol.largestSquareAreaBrute(bl, tr);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH bl=" + Arrays.deepToString(bl)
                            + " tr=" + Arrays.deepToString(tr) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(n^2),空间复杂度 O(1)。

时间复杂度 O(2^n * n),仅用于小规模验证。

  • 时间复杂度:O(n^2)
  • 空间复杂度:O(1)

3048. Earliest Second to Mark Indices I(标记所有下标的最早秒数 I)

题目描述

给你两个下标从 1 开始的整数数组 nums 和 changeIndices,数组的长度分别为 n 和 m。

一开始,nums 中所有下标都是未标记的,你的任务是标记 nums 中所有下标。

从第 1 秒到第 m 秒(包括第 m 秒),对于每一秒 s,你可以执行以下操作之一:

  • 选择范围 1, `n` 中的一个下标 i,并且将 nums[i] 减少 1。
  • 如果 nums`changeIndices[s]` 等于 0,标记下标 changeIndices[s]。
  • 什么也不做。
    返回范围 1, `m` 中的一个整数,表示最优操作下,标记 nums 中所有下标的最早秒数,
    如果无法标记所有下标,返回 -1。

示例 1

复制代码
nums = [2,2,0], changeIndices = [2,2,2,2,3,2,2,1] -> 8

示例 2

复制代码
nums = [1,3], changeIndices = [1,1,1,2,1,1,1] -> 6

示例 3

复制代码
nums = [0,1], changeIndices = [2,2,2] -> -1

提示:

  • 1 <= n == nums.length <= 2000
  • 0 <= nums[i] <= 10^9
  • 1 <= m == changeIndices.length <= 2000
  • 1 <= changeIndices[i] <= n

解题思路

解法一:二分答案 + 贪心判定,主提交版本

标记操作只能发生在 changeIndicess 恰好等于某个下标且该下标 numsi 已减到 0 时。

对每个下标 i,最晚可行的标记时刻应是 changeIndices 中 i 最后一次出现的位置(越晚越有利,

可以有更多时间把 numsi 减到 0);而"减少 1"的操作可以在任意秒进行。

判定给定前缀长度 t 内能否完成:先算出每个下标在 1...t 内的最后出现位置 lasti;

然后顺序扫描 1...t 这 t 秒:若某秒 s 是某下标 i 的最后一次出现,则必须在这一秒标记它,

此时要求此前已积累了至少 numsi 次"减少"机会(decrement >= numsi),并消耗掉;

其余秒都视为一次"减少"机会(decrement++,但标记秒不再增加机会,因为该秒被占用)。

若最终所有下标都被标记则 t 可行。二分答案找最小可行 t。

时间复杂度 O(m log m),空间复杂度 O(n)。

解法二:暴力模拟(对照)

小规模场景:直接对每个候选 t(1...m)做一遍"最后出现位置贪心"判定(与解法一同逻辑),

取第一个可行 t,用于交叉验证二分结果的正确性。该实现与二分等价,仅去掉二分外层。

时间复杂度 O(m^2),空间复杂度 O(n)。

复杂度:

  • 时间复杂度:O(m log m)
  • 空间复杂度:O(n)

代码实现

java 复制代码
import java.util.Arrays;
import java.util.Random;

public class Solution {

    private int[] nums;
    private int[] changeIndices;

    // ---------- 解法一:二分答案 + 贪心判定(主提交版本) ----------
    public int earliestSecondToMarkIndices(int[] nums, int[] changeIndices) {
        this.nums = nums;
        this.changeIndices = changeIndices;
        int m = changeIndices.length;
        int l = 1, r = m + 1;
        while (l < r) {
            int mid = (l + r) >>> 1;
            if (check(mid)) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l > m ? -1 : l;
    }

    private boolean check(int t) {
        int n = nums.length;
        int[] last = new int[n];
        Arrays.fill(last, -1);
        for (int s = 0; s < t; ++s) {
            last[changeIndices[s] - 1] = s;
        }
        int decrement = 0;
        int marked = 0;
        for (int s = 0; s < t; ++s) {
            int idx = changeIndices[s] - 1;
            if (last[idx] == s) {
                // 这一秒必须标记 idx,需要此前积累 nums[idx] 次减少机会
                if (decrement < nums[idx]) {
                    return false;
                }
                decrement -= nums[idx];
                marked++;
            } else {
                decrement++;
            }
        }
        return marked == n;
    }

    // ---------- 解法二:顺序扫描判定(对照) ----------
    public int earliestSecondToMarkIndicesBrute(int[] nums, int[] changeIndices) {
        int m = changeIndices.length;
        this.nums = nums;
        this.changeIndices = changeIndices;
        for (int t = 1; t <= m; ++t) {
            if (check(t)) {
                return t;
            }
        }
        return -1;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] numss = {
            {2, 2, 0},
            {1, 3},
            {0, 1},
            {0, 0, 0},
            {1, 1, 1},
            {3, 0},
        };
        int[][] cIs = {
            {2, 2, 2, 2, 3, 2, 2, 1},
            {1, 1, 1, 2, 1, 1, 1},
            {2, 2, 2},
            {1, 1, 1, 2, 2, 2, 3, 3},
            {1, 2, 1, 2, 1, 2, 3, 3, 3},
            {2, 2, 1, 1},
        };
        int[] expects = {8, 6, -1, 7, 7, -1};
        // 手工核对:
        // nums=[0,0,0], ci 含 1,2,3 各至少一次且可标记:t=3 时 last(1)=2,last(2)=4,last(3)=6 均 >3?
        // 实际 t=3 时只有秒 1..3, ci[0..2]=1,1,1 只含下标 1 -> 无法标记 2、3 -> 需更久
        // t=6 时 ci[0..5]=1,1,1,2,2,2, last(1)=2, last(2)=5; 下标 3 的 last 在 t 内找不到 -> 更久
        // t=8 时 last(1)=2,last(2)=5,last(3)=7; 秒顺序 1,1,1,2,2,2,3,3:
        //   s=0 idx1 non-last -> d=1; s=1 idx1 non-last -> d=2; s=2 idx1 last -> 需 nums[0]=0, mark, d=2
        //   s=3 idx2 non -> d=3; s=4 idx2 non -> d=4; s=5 idx2 last -> nums[1]=0, mark, d=4
        //   s=6 idx3 non -> d=5; s=7 idx3 last -> nums[2]=0, mark。全部标记,t=8 可行;t=7? d=4 at s=6(非last) d=5, s=7 不在 → 无法标记 3。
        //   → 答案 8 ✓
        boolean allPass = true;
        for (int i = 0; i < numss.length; ++i) {
            int a = sol.earliestSecondToMarkIndices(numss[i], cIs[i]);
            int b = sol.earliestSecondToMarkIndicesBrute(numss[i], cIs[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(numss[i]) + " ci="
                    + Arrays.toString(cIs[i]) + " -> " + a + " / brute=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍(小规模,暴力验证二分判定)
        Random rnd = new Random(149);
        int trials = 2000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(4);
            int m = n + rnd.nextInt(5);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = rnd.nextInt(4);
            int[] ci = new int[m];
            for (int i = 0; i < m; ++i) ci[i] = 1 + rnd.nextInt(n);
            int a = sol.earliestSecondToMarkIndices(nums, ci);
            int b = sol.earliestSecondToMarkIndicesBrute(nums, ci);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                            + " ci=" + Arrays.toString(ci) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(m log m),空间复杂度 O(n)。

时间复杂度 O(m^2),空间复杂度 O(n)。

  • 时间复杂度:O(m log m)
  • 空间复杂度:O(n)

3049. Earliest Second to Mark Indices II(标记所有下标的最早秒数 II)

题目描述

给你两个下标从 1 开始的整数数组 nums 和 changeIndices,数组的长度分别为 n 和 m。

一开始,nums 中所有下标都是未标记的,你的任务是标记 nums 中所有下标。

从第 1 秒到第 m 秒(包括第 m 秒),对于每一秒 s,你可以执行以下操作之一:

  • 选择范围 1, `n` 中的一个下标 i,并且将 nums[i] 减少 1;
  • 将 nums`changeIndices[s]` 设置成任意的非负整数(最优即设为 0);
  • 选择范围 1, `n` 中的一个下标 i,满足 nums[i] 等于 0,并标记下标 i;
  • 什么也不做。
    返回范围 1, `m` 中的一个整数,表示最优操作下标记所有下标的最早秒数,
    如果无法标记所有下标,返回 -1。
    与 3048 的关键区别:标记下标可以在任意秒执行,不要求该秒 changeIndices[s] 等于它。

示例 1

复制代码
nums = [3,2,3], changeIndices = [1,3,2,2,2,2,3] -> 6

示例 2

复制代码
nums = [0,0,1,2], changeIndices = [1,2,1,2,1,2,1,2] -> 7

示例 3

复制代码
nums = [1,2,3], changeIndices = [1,2,3] -> -1

提示:

  • 1 <= n == nums.length <= 5000
  • 0 <= nums[i] <= 10^9
  • 1 <= m == changeIndices.length <= 5000
  • 1 <= changeIndices[i] <= n

解题思路

解法一:二分答案 + 倒序扫描 + 小根堆反悔贪心,主提交版本

对时间 t 二分。判定 t 秒内能否全部标记:

  1. 标记每个下标恰好需要 1 秒(任意秒均可),n 个下标共需 n 个"标记秒";
  2. 其余秒用于把 numsi 清零。清空一个下标有两种方式:
  • "减 1":消耗 numsi 个自由秒,不占 changeIndices;
  • "设置 0":消耗 1 个自由秒,但必须在该下标出现在 changeIndices0...t-1 的某一秒执行。
    每个下标最多只有一次"首次出现"机会可用,且 numsi 越大用"设置 0"越划算(省下 numsi-1 秒)。
  1. 倒序扫描前 t 秒:设 cnt 为当前可自由支配的秒数(既没被安排标记也没被安排置零),
    用一个小根堆维护选择"设置 0"的下标集合 S(堆内存 nums 值,表示它们不再需要减 1 秒)。
    遇到某非零下标的首次出现秒时,若 cnt > 0 直接入堆(cnt--);否则与堆顶比较:
    仅当堆顶 < numsidx(新候选清空收益更大)才弹出堆顶改回减一、把新下标入堆,否则放弃。
    非首次出现秒只会使 cnt++(可以留着做标记或减一)。
  2. 结束时:堆外下标仍需 sum(nums) - sum(S) 个减一秒,堆外下标仍需 n - |S| 个标记秒,
    可行当且仅当 减一秒总数 + 标记秒总数 <= cnt。
    时间复杂度 O(m log m log m),空间复杂度 O(n + m)。
    解法二:全操作模拟搜索(对照)
    小规模场景:对每个 t(1...m),用 DFS 逐秒枚举所有可执行操作(减 1 任意下标 /
    设置 changeIndicess 为 0 / 标记任意为 0 的下标 / 无事),看是否存在一个长度 t
    的操作序列使所有下标都被标记。完全模拟规则,用于交叉验证主解的贪心判定。
    (经独立 BFS 逐状态穷举仲裁,二者真值一致)
    时间复杂度指数级,仅用于小规模验证。
    复杂度:
  • 时间复杂度:O(m log m log m)
  • 空间复杂度:O(n + m)

代码实现

java 复制代码
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.Random;

public class Solution {

    private int[] nums;
    private int[] changeIndices;
    private int n;

    // ---------- 解法一:二分答案 + 倒序扫描 + 小根堆反悔贪心(主提交版本) ----------
    public int earliestSecondToMarkIndices(int[] nums, int[] changeIndices) {
        this.nums = nums;
        this.changeIndices = changeIndices;
        this.n = nums.length;
        int m = changeIndices.length;
        int l = 1, r = m + 1;
        while (l < r) {
            int mid = (l + r) >>> 1;
            if (check(mid)) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l > m ? -1 : l;
    }

    private boolean check(int t) {
        // 每个下标在前 t 秒内的首次出现秒(0 基);没出现记为 -1
        int[] first = new int[n];
        Arrays.fill(first, -1);
        for (int s = 0; s < t; ++s) {
            int idx = changeIndices[s] - 1;
            if (first[idx] < 0) {
                first[idx] = s;
            }
        }
        long total = 0;
        for (int v : nums) {
            total += v;
        }
        PriorityQueue<Integer> pq = new PriorityQueue<>(); // 小根堆:选择"设置 0"的下标的 nums 值
        long total2 = 0; // 堆内下标因"设置 0"省下的减 1 秒总量
        int cnt = 0;     // 当前可自由支配的秒数
        for (int s = t - 1; s >= 0; --s) {
            int idx = changeIndices[s] - 1;
            if (nums[idx] > 0 && first[idx] == s) { // 该秒是下标 idx 的首次出现,可执行"设置 0"
                if (cnt > 0) {
                    cnt--;
                    total2 += nums[idx];
                    pq.offer(nums[idx]);
                } else if (!pq.isEmpty() && pq.peek() < nums[idx]) {
                    // 反悔:把收益最小的旧下标改为"减 1",换成收益更大的新下标
                    int j = pq.poll();
                    total2 += nums[idx] - j;
                    pq.offer(nums[idx]);
                } else {
                    cnt++; // 放弃本次置零机会
                }
            } else {
                cnt++; // 非首次出现秒:自由支配
            }
        }
        long need = total - total2;     // 堆外下标所需的减 1 秒
        long markLeft = n - pq.size();  // 堆外下标所需的标记秒
        return need + markLeft <= cnt;
    }

    // ---------- 解法二:全操作模拟(对照) ----------
    public int earliestSecondToMarkIndicesBrute(int[] nums, int[] changeIndices) {
        this.nums = nums;
        this.changeIndices = changeIndices;
        this.n = nums.length;
        for (int t = 1; t <= changeIndices.length; ++t) {
            if (dfs(0, t, nums.clone(), 0)) {
                return t;
            }
        }
        return -1;
    }

    // 在 t 秒内从第 s 秒(0 基)开始搜索;vals 当前值,mask 已标记
    private boolean dfs(int s, int t, int[] vals, int mask) {
        if (mask == (1 << n) - 1) {
            return true;
        }
        if (s >= t) {
            return false;
        }
        // 操作1:减 1 任意下标
        for (int i = 0; i < n; ++i) {
            if (vals[i] > 0) {
                vals[i]--;
                if (dfs(s + 1, t, vals, mask)) {
                    vals[i]++;
                    return true;
                }
                vals[i]++;
            }
        }
        // 操作2:设置 changeIndices[s] 为 0
        int ci = changeIndices[s] - 1;
        if (vals[ci] != 0) {
            int old = vals[ci];
            vals[ci] = 0;
            if (dfs(s + 1, t, vals, mask)) {
                vals[ci] = old;
                return true;
            }
            vals[ci] = old;
        }
        // 操作3:标记任意为 0 的下标
        for (int i = 0; i < n; ++i) {
            if (vals[i] == 0 && (mask & (1 << i)) == 0) {
                if (dfs(s + 1, t, vals, mask | (1 << i))) {
                    return true;
                }
            }
        }
        // 操作4:什么也不做
        return dfs(s + 1, t, vals, mask);
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] numss = {
            {3, 2, 3},
            {0, 0, 1, 2},
            {1, 2, 3},
            {0, 0, 0},
            {1},
            {2, 2, 0},
            {3, 0, 3},
            {1, 1, 3},
            {1, 1, 0},
            {3, 0, 1},
            {0, 2, 1},
        };
        int[][] cIs = {
            {1, 3, 2, 2, 2, 2, 3},
            {1, 2, 1, 2, 1, 2, 1, 2},
            {1, 2, 3},
            {1, 1, 1, 2, 2, 2, 3, 3},
            {1, 1, 1, 1, 1},
            {2, 2, 2, 2, 3, 2, 2, 1},
            {3, 2, 2, 3, 1, 3},
            {2, 2, 1, 2, 2, 3},
            {1, 2, 1},
            {2, 2, 3, 1, 1, 3, 3},
            {1, 1, 3, 2, 1},
        };
        // 真值经独立 Python BFS 逐状态穷举仲裁
        int[] expects = {6, 7, -1, 3, 2, 6, 6, -1, -1, 5, 5};
        boolean allPass = true;
        for (int i = 0; i < numss.length; ++i) {
            int a = sol.earliestSecondToMarkIndices(numss[i], cIs[i]);
            int b = sol.earliestSecondToMarkIndicesBrute(numss[i], cIs[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(numss[i]) + " ci="
                    + Arrays.toString(cIs[i]) + " -> " + a + " / brute=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍
        Random rnd = new Random(151);
        int trials = 400;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(3);
            int m = n + rnd.nextInt(4);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = rnd.nextInt(4);
            int[] ci = new int[m];
            for (int i = 0; i < m; ++i) ci[i] = 1 + rnd.nextInt(n);
            int a = sol.earliestSecondToMarkIndices(nums, ci);
            int b = sol.earliestSecondToMarkIndicesBrute(nums, ci);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                            + " ci=" + Arrays.toString(ci) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(m log m log m),空间复杂度 O(n + m)。

时间复杂度指数级,仅用于小规模验证。

  • 时间复杂度:O(m log m log m)
  • 空间复杂度:O(n + m)

3050. Pizza Toppings Cost Analysis(披萨配料成本分析)

题目类型:数据库(SQL)

题目描述

表:Toppings

复制代码
+--------------+---------+
| Column Name  | Type    |
+--------------+---------+
| topping_name | varchar |
| cost         | decimal |
+--------------+---------+

topping_name 是这张表的主键。该表的每一行包含配料名和配料的单份花费。

编写一个解决方案,根据给定的配料表计算所有可能的 3 种配料 披萨组合的总花费 。总花费必须四舍五入 到 2 位小数。

注意:

  • 不要 包含重复配料的披萨(如 'Pepperoni, Pepperoni, Onion Pizza')。
  • 配料必须 以字母顺序排序(如 'Chicken, Onions, Sausage';'Onion, Sausage, Chicken' 不会被通过)。

返回结果表,以总花费降序 排序,配料组合名升序排序。

示例 1:

复制代码
输入:
Toppings 表:
+--------------+------+
| topping_name | cost |
+--------------+------+
| Pepperoni    | 0.50 |
| Sausage      | 0.70 |
| Chicken      | 0.55 |
| Extra Cheese | 0.40 |
+--------------+------+
输出:
+--------------------------------+------------+
| pizza                          | total_cost |
+--------------------------------+------------+
| Chicken,Pepperoni,Sausage      | 1.75       |
| Chicken,Extra Cheese,Sausage   | 1.65       |
| Extra Cheese,Pepperoni,Sausage | 1.60       |
| Chicken,Extra Cheese,Pepperoni | 1.45       |
+--------------------------------+------------+

解释:四种三配料组合,总花费分别为 1.75 / 1.65 / 1.60 / 1.45,按总花费降序输出。

解题思路

三个 JOIN 自连接同一张 Toppings 表,用 t1.topping_name < t2.topping_name、t2.topping_name < t3.topping_name 保证组合无重复且字母升序;每行的总花费为三者之和并 ROUND(, 2),最后按 total_cost DESC、pizza ASC 排序。

代码实现

sql 复制代码
SELECT CONCAT(t1.topping_name, ',', t2.topping_name, ',', t3.topping_name) AS pizza,
       ROUND(t1.cost + t2.cost + t3.cost, 2) AS total_cost
FROM Toppings t1
JOIN Toppings t2 ON t1.topping_name < t2.topping_name
JOIN Toppings t3 ON t2.topping_name < t3.topping_name
ORDER BY total_cost DESC, pizza ASC;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3051. Find Candidates for Data Scientist Position(寻找数据科学家职位的候选人)

题目类型:数据库(SQL)

题目描述

表:Candidates

复制代码
+--------------+---------+
| Column Name  | Type    |
+--------------+---------+
| candidate_id | int     |
| skill        | varchar |
+--------------+---------+

(candidate_id, skill) 是这张表的主键。每一行包含候选人的 ID 和其掌握的技能。

编写一个查询,找到最适合数据科学家职位的候选人 。应聘者必须精通 Python 、Tableau 和 PostgreSQL 三项技能。

返回结果表,以 candidate_id 升序排序。

示例 1:

复制代码
输入:
Candidates 表:
+---------------+--------------+
| candidate_id  | skill        |
+---------------+--------------+
| 123           | Python       |
| 234           | R            |
| 123           | Tableau      |
| 123           | PostgreSQL   |
| 234           | PowerBI      |
| 234           | SQL Server   |
| 147           | Python       |
| 147           | Tableau      |
| 147           | Java         |
| 147           | PostgreSQL   |
| 256           | Tableau      |
| 102           | DataAnalysis |
+---------------+--------------+
输出:
+--------------+
| candidate_id |
+--------------+
| 123          |
| 147          |
+--------------+

解释:候选人 123 和 147 同时具备 Python、Tableau、PostgreSQL 三项技能。

解题思路

先按 skill IN ('Python','Tableau','PostgreSQL') 过滤,再按 candidate_id 分组,用 HAVING COUNT(DISTINCT skill) = 3 保证三项技能全部具备,最后按 candidate_id 升序输出。

代码实现

sql 复制代码
SELECT candidate_id
FROM Candidates
WHERE skill IN ('Python', 'Tableau', 'PostgreSQL')
GROUP BY candidate_id
HAVING COUNT(DISTINCT skill) = 3
ORDER BY candidate_id;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3052. Maximize Items(最大化商品)

题目类型:数据库(SQL)

题目描述

表:Inventory

复制代码
+----------------+---------+
| Column Name    | Type    |
+----------------+---------+
| item_id        | int     |
| item_type      | varchar |
| item_category  | varchar |
| square_footage | decimal |
+----------------+---------+

item_id 是这张表中值互不相同的列。每一行包含商品 ID、商品类型、商品类别和商品占地面积(平方英尺)。

仓库总面积为 500,000 平方英尺。优先存储尽量多的主要 商品(prime_eligible),用剩下 的空间存储最大数量的非主要 商品(not_prime)。

编写解决方案,输出两种商品类型各能存储的最大商品数量。

注意:

  • 商品数量必须是整数(按"每组商品整套存放"计算:同类型商品各 1 件为一整套,整套面积 = 该类型所有商品面积之和)。
  • 若 not_prime 类型的数量为 0,也应当输出 0 行。

返回结果表,以商品数量降序排序。

示例 1:

复制代码
输入:
Inventory 表(共 10 行,prime_eligible 6 件总面积 555.20,not_prime 4 件总面积 128.50)
输出:
+----------------+-------------+
| item_type      | item_count  |
+----------------+-------------+
| prime_eligible | 5400        |
| not_prime      | 8           |
+----------------+-------------+

解释:500000 / 555.20 = 900.57...,可放 900 整套 = 5400 件,占 499,680 平方英尺,剩 320 平方英尺;320 / 128.50 = 2.49...,可再放 2 整套 not_prime = 8 件。

解题思路

分两步:① 对 prime_eligible 类型求总面积 total_footage 与单套件数 item_count,可放 FLOOR(500000 / total_footage) 套,件数 = 套数 × 单套件数,并算出剩余空间 MOD(500000, total_footage)(样例为 320);② 对 not_prime 类型同样求总面积与件数,用剩余空间计算可放套数 FLOOR(remain / total_footage),件数 = 套数 × 单套件数。最后用 UNION ALL 拼两行并按件数降序输出。用 CTE 让逻辑清晰、避免重复计算。

代码实现

sql 复制代码
WITH pt AS (
    SELECT SUM(square_footage) AS total_footage, COUNT(*) AS item_count
    FROM Inventory WHERE item_type = 'prime_eligible'
),
pp AS (
    SELECT FLOOR(500000 / total_footage) * item_count AS item_count,
           MOD(500000, total_footage) AS remain
    FROM pt
),
nt AS (
    SELECT SUM(square_footage) AS total_footage, COUNT(*) AS item_count
    FROM Inventory WHERE item_type = 'not_prime'
)
SELECT 'prime_eligible' AS item_type, item_count FROM pp
UNION ALL
SELECT 'not_prime', FLOOR(remain / nt.total_footage) * nt.item_count
FROM pp, nt
ORDER BY item_count DESC;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3053. Classifying Triangles by Lengths(根据长度分类三角形)

题目类型:数据库(SQL)

题目描述

表:Triangles

复制代码
+-------------+------+
| Column Name | Type |
+-------------+------+
| A           | int  |
| B           | int  |
| C           | int  |
+-------------+------+

(A, B, C) 是这张表的主键。每一行包含三角形三边的长度。

编写一个查询,对于每一行输出三角形的类型:

  • Equilateral:3 边长度相同;
  • Isosceles:恰有 2 边长度相同;
  • Scalene:3 边长度互不相同;
  • Not A Triangle:给定三边不能构成三角形(两边之和 <= 第三边)。

以任何顺序返回结果表。

示例 1:

复制代码
输入:
Triangles 表:
+----+----+----+
| A  | B  | C  |
+----+----+----+
| 20 | 20 | 23 |
| 20 | 20 | 20 |
| 20 | 21 | 22 |
| 13 | 14 | 30 |
+----+----+----+
输出:
+----------------+
| triangle_type  |
+----------------+
| Isosceles      |
| Equilateral    |
| Scalene        |
| Not A Triangle |
+----------------+

解题思路

先用三角形不等式判定 Not A Triangle(任两边之和不大于第三边,即 A + B <= C 或 A + C <= B 或 B + C <= A);再按边是否全等、恰两等、全不等依次判定 Equilateral / Isosceles / Scalene。优先判定不构成三角形的情况。

代码实现

sql 复制代码
SELECT CASE
    WHEN A + B <= C OR A + C <= B OR B + C <= A THEN 'Not A Triangle'
    WHEN A = B AND B = C THEN 'Equilateral'
    WHEN A = B OR B = C OR A = C THEN 'Isosceles'
    ELSE 'Scalene'
END AS triangle_type
FROM Triangles;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3054. Binary Tree Nodes(二叉树节点)

题目类型:数据库(SQL)

题目描述

表:Tree

复制代码
+-------------+------+
| Column Name | Type |
+-------------+------+
| N           | int  |
| P           | int  |
+-------------+------+

N 是这张表中值互不相同的列。每一行表示节点 N 的值为二叉树中一个节点值,P 是 N 的父节点值(根节点的 P 为 NULL)。

编写解决方案,对每个节点输出类型:

  • Root:根节点(无父节点);
  • Leaf:叶子节点(没有任何子节点);
  • Inner:内部节点(既不是根也不是叶)。

返回结果表,根据节点值升序排序。

示例 1:

复制代码
输入:
Tree 表:
+---+------+
| N | P    |
+---+------+
| 1 | 2    |
| 3 | 2    |
| 6 | 8    |
| 9 | 8    |
| 2 | 5    |
| 8 | 5    |
| 5 | null |
+---+------+
输出:
+---+-------+
| N | Type  |
+---+-------+
| 1 | Leaf  |
| 2 | Inner |
| 3 | Leaf  |
| 5 | Root  |
| 6 | Leaf  |
| 8 | Inner |
| 9 | Leaf  |
+---+-------+

解题思路

用 CASE 分类:P IS NULL 为 Root;N 出现在 P 列(被其他节点引用为父节点)为 Inner;否则为 Leaf。判断是否有子节点用子查询 N IN (SELECT P FROM Tree WHERE P IS NOT NULL)。最后按 N 升序输出。

代码实现

sql 复制代码
SELECT N,
       CASE
           WHEN P IS NULL THEN 'Root'
           WHEN N IN (SELECT P FROM Tree WHERE P IS NOT NULL) THEN 'Inner'
           ELSE 'Leaf'
       END AS Type
FROM Tree
ORDER BY N;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3055. Top Percentile Fraud(最高欺诈百分位数)

题目类型:数据库(SQL)

题目描述

表:Fraud

复制代码
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| policy_id   | int     |
| state       | varchar |
| fraud_score | int     |
+-------------+---------+

policy_id 是这张表中值互不相同的列。该表包含保单 ID、保单所在州和欺诈得分。

公司把经验最丰富的理赔员分配给每个州前 5% 的被标记索赔(即每个州欺诈得分最高的前 5% 分位的保单)。

编写解决方案,找出每个州 前 5 百分位的索赔。

返回结果表,以 state 升序 、fraud_score 降序 、policy_id 升序排序。

示例 1:

复制代码
输入:
Fraud 表(California 3 行、New York 3 行、Texas 3 行、Florida 5 行)
输出:
+-----------+------------+-------------+
| policy_id | state      | fraud_score |
+-----------+------------+-------------+
| 1         | California | 0.92        |
| 11        | Florida    | 0.98        |
| 4         | New York   | 0.94        |
| 7         | Texas      | 0.98        |
+-----------+------------+-------------+

解释:每个州仅 1 张保单落在前 5% 分位(如 Florida 5 行中仅最高分 0.98 的保单入选)。

解题思路

用窗口函数 PERCENT_RANK() 按 state 分区、fraud_score 降序计算每个保单在州内的百分位排名((rank-1)/(n-1)),外层过滤 pct < 0.05 即前 5% 分位;最后按要求排序。PERCENT_RANK 保证同州内分数最高的行值最小(0),从 0 开始累计,前 5% 即 pct < 0.05。

代码实现

sql 复制代码
SELECT policy_id, state, fraud_score
FROM (
    SELECT policy_id, state, fraud_score,
           PERCENT_RANK() OVER (
               PARTITION BY state ORDER BY fraud_score DESC
           ) AS pct
    FROM Fraud
) t
WHERE pct < 0.05
ORDER BY state ASC, fraud_score DESC, policy_id ASC;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3056. Snaps Analysis(快照分析)

题目类型:数据库(SQL)

题目描述

表:Activities

复制代码
+---------------+---------+
| Column Name   | Type    |
+---------------+---------+
| activity_id   | int     |
| user_id       | int     |
| activity_type | enum    |
| time_spent    | decimal |
+---------------+---------+

activity_id 是这张表中值互不相同的列。activity_type 是 ('send', 'open') 的枚举。该表记录每个用户发送/打开快照所花费的时间。

表:Age

复制代码
+-------------+------+
| Column Name | Type |
+-------------+------+
| user_id     | int  |
| age_bucket  | enum |
+-------------+------+

user_id 是这张表中值互不相同的列。age_bucket 是 ('21-25', '26-30', '31-35') 的枚举。该表记录每个用户所属的年龄组。

编写解决方案,计算每个年龄组 发送和打开快照所花费的总时间百分比 。百分比应四舍五入 至小数点后 2 位,send_perc 与 open_perc 之和应为 100。

以任何顺序返回结果表。

示例 1:

复制代码
输入:
Activities 与 Age 表(3 个年龄组各 1 个用户)
输出:
+------------+-----------+-----------+
| age_bucket | send_perc | open_perc |
+------------+-----------+-----------+
| 31-35      | 37.84     | 62.16     |
| 26-30      | 82.26     | 17.74     |
| 21-25      | 54.31     | 45.69     |
+------------+-----------+-----------+

解释:如 31-35 组用户总用时 9.25,发送 3.50 => (3.50/9.25)*100 = 37.84,打开 5.75 => 62.16。

解题思路

Activities 与 Age 按 user_id JOIN 后按 age_bucket 分组:send_perc = SUM(activity_type='send' 的 time_spent) / SUM(全部 time_spent) * 100,open_perc 同理(用 CASE WHEN 条件聚合),最后 ROUND(, 2)。

代码实现

sql 复制代码
SELECT a.age_bucket,
       ROUND(SUM(CASE WHEN act.activity_type = 'send' THEN act.time_spent ELSE 0 END)
             / SUM(act.time_spent) * 100, 2) AS send_perc,
       ROUND(SUM(CASE WHEN act.activity_type = 'open' THEN act.time_spent ELSE 0 END)
             / SUM(act.time_spent) * 100, 2) AS open_perc
FROM Age a
JOIN Activities act ON a.user_id = act.user_id
GROUP BY a.age_bucket;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3057. Employees Project Allocation(员工项目分配)

题目类型:数据库(SQL)

题目描述

表:Project

复制代码
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| project_id  | int     |
| employee_id | int     |
| workload    | int     |
+-------------+---------+

该表的每一行表示员工 employee_id 在项目 project_id 上的工作量 workload。

表:Employees

复制代码
+------------------+---------+
| Column Name      | Type    |
+------------------+---------+
| employee_id      | int     |
| name             | varchar |
| team             | varchar |
+------------------+---------+

employee_id 是该表的主键。该表包含员工 ID、姓名与所属团队。

编写解决方案,找出在项目上分配的工作量超过各自团队 所有员工平均工作量的员工。

返回结果表,以 employee_id、project_id 升序排序,输出员工姓名与工作量。

示例 1:

复制代码
输入:
Project 表 4 行(工作量 45/90/12/68),Employees 表 4 行(Team A 平均 56.50,Team B 平均 51.00)
输出:
+-------------+------------+---------------+------------------+
| employee_id | project_id | employee_name | project_workload |
+-------------+------------+---------------+------------------+
| 2           | 1          | Ali           | 90               |
| 4           | 2          | Doe           | 68               |
+-------------+------------+---------------+------------------+

解释:员工 2 工作量 90 > Team B 平均 51.00,员工 4 工作量 68 > Team A 平均 56.50,均入选。

解题思路

先按团队 GROUP BY 求各团队平均工作量(子查询/CTE),再把 Project 与 Employees 以及团队平均值表 JOIN 起来,WHERE p.workload > t.avg_workload 过滤出超过团队平均的员工,最后按 employee_id, project_id 升序输出。

代码实现

sql 复制代码
SELECT p.employee_id, p.project_id,
       e.name AS employee_name,
       p.workload AS project_workload
FROM Project p
JOIN Employees e ON p.employee_id = e.employee_id
JOIN (
    SELECT e2.team, AVG(p2.workload) AS avg_workload
    FROM Project p2
    JOIN Employees e2 ON p2.employee_id = e2.employee_id
    GROUP BY e2.team
) t ON e.team = t.team
WHERE p.workload > t.avg_workload
ORDER BY p.employee_id, p.project_id;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3058. Friends With No Mutual Friends(没有共同朋友的朋友)

题目类型:数据库(SQL)

题目描述

表:Friends

复制代码
+-------------+------+
| Column Name | Type |
+-------------+------+
| user_id1    | int  |
| user_id2    | int  |
+-------------+------+

(user_id1, user_id2) 是这张表的主键。每一行表示 user_id1 与 user_id2 互为朋友。

编写解决方案,找到彼此是朋友但没有共同朋友的所有用户对。

以 user_id1、user_id2 升序返回结果表。

示例 1:

复制代码
输入:
Friends 表((1,2),(2,3),(2,4),(1,5),(6,7),(3,4),(2,5),(8,9))
输出:
+----------+----------+
| user_id1 | user_id2 |
+----------+----------+
| 6        | 7        |
| 8        | 9        |
+----------+----------+

解释:(1,2) 有共同好友 5(1-5、2-5 都是朋友);(3,4) 有共同好友 2(2-3、2-4);(2,3) 有共同好友 4;(2,4) 有共同好友 3;(1,5) 有共同好友 2;(2,5) 有共同好友 1;均被排除。只有 (6,7)、(8,9) 无共同好友。

解题思路

把朋友关系当作无向图(用 UNION 将每条边补成双向,便于查任一方向的共同好友)。对每个朋友对 (u1, u2),若存在一个 x(x 不是 u1 / u2)使得 (u1, x) 与 (x, u2) 都是朋友(通过边表自连接 e1.v = e2.u 实现路径 u1 -> x -> u2),则该对存在共同好友,用 NOT EXISTS 排除掉这样的对,剩下的即是"没有共同好友"的朋友对,最后升序输出。

代码实现

sql 复制代码
WITH edges AS (
    SELECT user_id1 AS u, user_id2 AS v FROM Friends
    UNION
    SELECT user_id2 AS u, user_id1 AS v FROM Friends
)
SELECT DISTINCT f.user_id1, f.user_id2
FROM Friends f
WHERE NOT EXISTS (
    SELECT 1
    FROM edges e1
    JOIN edges e2 ON e1.v = e2.u
    WHERE e1.u = f.user_id1
      AND e2.v = f.user_id2
      AND e1.v NOT IN (f.user_id1, f.user_id2)
)
ORDER BY f.user_id1, f.user_id2;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3059. Find All Unique Email Domains(找到所有不同的邮件域名)

题目类型:数据库(SQL)

题目描述

表:Emails

复制代码
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| id          | int     |
| email       | varchar |
+-------------+---------+

id 是这张表的主键。该表包含若干条邮件地址,且邮件地址不含大写字母。

编写解决方案,找出所有不同的电子邮件域名 ,并统计每个域名关联的记录数 。只考虑 以 .com 结尾的域名。

返回结果表以 email_domain 升序排列。

示例 1:

复制代码
输入:
Emails 表(6 条,含 test.edu、outlook.com、yahoo.com、example.org 等域名)
输出:
+--------------+-------+
| email_domain | count |
+--------------+-------+
| outlook.com  | 2     |
| yahoo.com    | 1     |
+--------------+-------+

解释:只有以 .com 结尾的域名被统计,outlook.com 2 条、yahoo.com 1 条。

解题思路

用 SUBSTRING_INDEX(email, '@', -1) 取出 @ 之后的域名部分,WHERE email LIKE '%.com' 只保留以 .com 结尾的记录,按域名 GROUP BY 后 COUNT(*) 统计,最后按域名升序输出。

代码实现

sql 复制代码
SELECT SUBSTRING_INDEX(email, '@', -1) AS email_domain,
       COUNT(*) AS count
FROM Emails
WHERE email LIKE '%.com'
GROUP BY SUBSTRING_INDEX(email, '@', -1)
ORDER BY email_domain;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。


3060. User Activities within Time Bounds(时间范围内的用户活动)

题目类型:数据库(SQL)

题目描述

表:Sessions

复制代码
+---------------+----------+
| Column Name   | Type     |
+---------------+----------+
| user_id       | int      |
| session_start | datetime |
| session_end   | datetime |
| session_id    | int      |
| session_type  | enum     |
+---------------+----------+

session_id 是这张表中值互不相同的列。session_type 是 (Viewer, Streamer) 的枚举。该表记录用户的会话开始/结束时间、会话 ID 与会话类型。

编写解决方案,找出至少有一对相同类型 (同为 Viewer 或同为 Streamer)连续会话 的用户,且这两个会话之间 的时间间隔不超过 12 小时(间隔 = 前一会话结束时刻到后一会话开始时刻)。

返回结果表,以 user_id 升序排序。

示例 1:

复制代码
输入:
Sessions 表(101 有 Viewer/Streamer/Viewer/Streamer 交错会话;102 有 2 个间隔 1 小时的 Viewer 会话和 2 个间隔 4 小时的 Streamer 会话;103 有 3 个 Viewer 会话其中 10->11 间隔 10 小时)
输出:
+---------+
| user_id |
+---------+
| 102     |
| 103     |
+---------+

解释:101 没有相邻同类型会话;102 的 Viewer 会话 3(14:00 结束) 与会话 4(15:00 开始) 间隔 1 小时 <= 12;103 的 Viewer 会话 10(23:00 结束) 与会话 11(次日 09:00 开始) 间隔 10 小时 <= 12,均入选。

解题思路

按 (user_id, session_type) 分区、session_start 升序,用 LAG(session_end) 取上一场同类型会话的结束时间,TIMESTAMPDIFF(MINUTE, prev_end, cur_start) 求两场会话的间隔;过滤出间隔 <= 720 分钟(12 小时)的用户,去重后升序输出。注意间隔要用"上场的结束时刻"而非开始时刻。

代码实现

sql 复制代码
SELECT DISTINCT user_id
FROM (
    SELECT user_id, session_type,
           TIMESTAMPDIFF(MINUTE,
               LAG(session_end) OVER (
                   PARTITION BY user_id, session_type ORDER BY session_start
               ),
               session_start) AS gap_minutes
    FROM Sessions
) t
WHERE gap_minutes IS NOT NULL AND gap_minutes <= 720
ORDER BY user_id;

复杂度分析

本题为数据库查询题,不涉及传统算法的时间/空间复杂度;考察重点为 JOIN / 窗口函数 / 自连接 / 聚合过滤等 SQL 语法与查询逻辑的正确性,执行效率由数据库优化器决定。

相关推荐
文丑颜不良啊2 小时前
LeetCode3101~3120题目解析
java·leetcode
Resean02232 小时前
SpringMVC 6+源码分析(十一)视图渲染与异步请求(收尾篇)
java·spring·springmvc
靠沿2 小时前
MySQL数据库进阶——存储过程和触发器
java·数据库·mysql
码少女3 小时前
MySQL--库与表的增删改查基础
java·数据库·mysql
Flynt5 小时前
掘金热文说 Spring Boot 4.1 默认开虚拟线程,我实测后发现了更狠的坑
java·spring boot·性能优化
Resean02236 小时前
Spring 源码分析(一)IOC 容器总览与 refresh() 全景
java·后端·spring
保利威视频SaaS小张6 小时前
企业直播接入笔记 12|企业内训直播怎么做签到和学时统计,防挂机这件事比想象中难
java·前端·数据库·笔记·视频云·polvy·polyv
顧棟8 小时前
【ES实战】 索引模板「可追溯、可校验」:一种模板治理的工程化思路
java·数据库·elasticsearch
玄昌盛不会编程9 小时前
LeetCode——2243. 计算字符串的数字和
java·算法·leetcode