LeetCode3401~3420题目解析

LeetCode 3401-3420. 题解合集

文章目录


3401. Find Circular Gift Exchange Chains(寻找环形礼物交换链)

题目类型:数据库(SQL)

题目描述

表:SecretSanta

复制代码
+-------------+------+
| Column Name | Type |
+-------------+------+
| giver_id    | int  |
| receiver_id | int  |
| gift_value  | int  |
+-------------+------+

(giver_id, receiver_id) 是此表的主键。每一行表示两个员工之间的一次礼物交换记录,giver_id 表示送出礼物的员工,receiver_id 表示收到礼物的员工,gift_value 表示所送礼物的价值。

编写解决方案找出所有环形礼物交换链,并报告每条环的总礼物价值 与环的长度。环形链被定义为一系列交换,其中:

  • 每位员工都正好向另一位员工赠送一份礼物;
  • 每位员工都恰好从另一位员工那里收到一份礼物;
  • 交换形成一个连续的循环(即员工 A 给 B 一份礼物,B 给 C,C 再给 A)。

返回结果以链的长度和总礼物价值降序 排序,并按此顺序为每条环从小到大编号 chain_id(从 1 开始)。

示例 1:

复制代码
输入:
SecretSanta 表:
+----------+-------------+------------+
| giver_id | receiver_id | gift_value |
+----------+-------------+------------+
| 1        | 2           | 20         |
| 2        | 3           | 30         |
| 3        | 1           | 40         |
| 4        | 5           | 25         |
| 5        | 4           | 35         |
+----------+-------------+------------+
输出:
+----------+--------------+------------------+
| chain_id | chain_length | total_gift_value |
+----------+--------------+------------------+
| 1        | 3            | 90               |
| 2        | 2            | 60               |
+----------+--------------+------------------+
解释:
链 1 包含员工 1、2 和 3:1 给 2、2 给 3、3 给 1,总价值 = 20+30+40 = 90。
链 2 包含员工 4 和 5:4 给 5、5 给 4,总价值 = 25+35 = 60。

解题思路

本题的交换关系构成若干个互不相交的有向环。关键难点在于:同一个环从不同起点出发会被重复找出多次,必须保证每条环只输出一次。

解法一(推荐):递归 CTE 沿环前进 + 环上最小节点去重

  1. 用递归 CTE 从每个 giver_id 出发,沿 receiver_id -> giver_id 的边不断前进,记录起点 start_id、已累计的链长与总价值;
  2. 每一步同时维护 path_least_node = LEAST(当前节点, 历史最小节点)------由于全表只有环结构,每个环的 path_least_node 都收敛为该环上的最小员工编号,用它对结果去重(GROUP BY path_least_node 后取最长链/最大价值),就能保证环只算一次;
  3. 递归终止条件的关键是 g.receiver_id != g.start_id:当路径回到起点时停止继续前进,并把"回到起点的完整环"输出;
  4. 最后用 ROW_NUMBER() OVER (ORDER BY chain_length DESC, total_gift_value DESC) 按题意生成 chain_id。

解法二(对照):环起点分组去重

先递归展开所有"从某起点起步的完整环",再将同一环(以最小节点代表)聚合一次,思路与解法一同模型,只是去重放在最后一级做。本题环中每个节点出度入度都为 1,两种写法正确性一致。

代码实现

sql 复制代码
-- 解法一(推荐):递归 CTE,环上最小节点去重 + ROW_NUMBER 编号
WITH RECURSIVE GiftChain AS (
    -- 基础:每条边作为起点
    SELECT giver_id, receiver_id, gift_value,
           CONCAT(giver_id, ' -> ', receiver_id) AS path,
           1 AS chain_length,
           gift_value AS total_gift_value,
           LEAST(giver_id, 100000) AS path_least_node,
           giver_id AS start_id
    FROM SecretSanta
    UNION ALL
    -- 递归:沿 receiver -> giver 前进
    SELECT g.giver_id, s.receiver_id, s.gift_value,
           CONCAT(g.path, ' -> ', s.receiver_id),
           g.chain_length + 1,
           g.total_gift_value + s.gift_value,
           LEAST(s.giver_id, g.path_least_node),
           g.start_id
    FROM GiftChain g
    JOIN SecretSanta s ON g.receiver_id = s.giver_id
    WHERE g.receiver_id != g.start_id  -- 防止提前成环,回到起点即停
),
result AS (
    -- 只保留回到起点的完整环
    SELECT gc.path, gc.chain_length, gc.total_gift_value, gc.path_least_node
    FROM GiftChain gc
    WHERE gc.receiver_id = gc.start_id
),
dedup AS (
    -- 同一环取一遍(以环上最小节点为代表)
    SELECT MAX(chain_length) AS chain_length,
           MAX(total_gift_value) AS total_gift_value
    FROM result
    GROUP BY path_least_node
)
SELECT ROW_NUMBER() OVER (ORDER BY chain_length DESC, total_gift_value DESC) AS chain_id,
       chain_length, total_gift_value
FROM dedup
ORDER BY chain_length DESC, total_gift_value DESC;

复杂度分析

  • 时间复杂度 :O(n^2),其中 n 为 SecretSanta 行数;最坏情况每条边起始一次、沿环展开最长可达 n 步。
  • 空间复杂度 :O(n),递归 CTE 的中间结果集与环上节点数成正比。

3402. Minimum Operations to Make Columns Strictly Increasing(使每一列严格递增的最少操作次数)

题目描述

给你一个由非负整数组成的 m x n 矩阵 grid。在一次操作中,你可以将任意元素 grid[i][j] 的值增加 1。

返回使 grid 的所有列严格递增所需的最少操作次数。

示例 1

复制代码
grid = [[3,2],[1,3],[3,4],[0,1]] -> 15

示例 2

复制代码
grid = [[3,2,1],[2,1,0],[1,2,3]] -> 12

提示:

  • m == grid.length
  • n == grid[i].length
  • 1 <= m, n <= 50
  • 0 <= grid[i][j] < 2500

解题思路

解法一:逐列贪心,主提交版本

每一列独立处理。从上到下遍历该列,维护 pre 表示上一行处理后该列的取值;

若当前元素 cur > pre 则保持原值(列已严格递增的延续);否则该元素必须提升到

pre + 1,需要 pre + 1 - cur 次操作。由于每次只加 1,且提升后其他行不受影响,

逐列贪心即是全局最优。时间复杂度 O(m*n),空间复杂度 O(1)。

解法二:直接模拟操作(对照)

同样逐列处理,但显式记录差分:对每一列,从第二行起若 grid[i][j] <= grid[i-1][j],

则令目标值 grid[i-1][j] + 1,累加操作数并以目标值更新当前行(模拟重复加 1)。

与解法一数学等价,用不同书写路径交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:逐列贪心(主提交版本) ----------
    public int minimumOperations(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        int ans = 0;
        for (int j = 0; j < n; ++j) {
            int pre = -1;
            for (int i = 0; i < m; ++i) {
                int cur = grid[i][j];
                if (cur > pre) {
                    pre = cur;
                } else {
                    ++pre; // 当前值必须大于上一行,提升到 pre+1
                    ans += pre - cur;
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:目标值模拟(对照) ----------
    public int minimumOperationsSim(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        int ans = 0;
        for (int j = 0; j < n; ++j) {
            int target = -1;
            for (int i = 0; i < m; ++i) {
                int cur = grid[i][j];
                if (cur > target) {
                    target = cur;
                } else {
                    ans += target + 1 - cur;
                    target = target + 1;
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(42);

        System.out.println("示例1: " + sol.minimumOperations(new int[][] {{3, 2}, {1, 3}, {3, 4}, {0, 1}})
            + " (期望 15)");
        System.out.println("示例2: " + sol.minimumOperations(new int[][] {{3, 2, 1}, {2, 1, 0}, {1, 2, 3}})
            + " (期望 12)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 500; ++t) {
            int m = 1 + rand.nextInt(8);
            int n = 1 + rand.nextInt(8);
            int[][] g = new int[m][n];
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    g[i][j] = rand.nextInt(12);
                }
            }
            int x = sol.minimumOperations(g);
            int y = sol.minimumOperationsSim(g);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH x=" + x + " y=" + y);
                printGrid(g);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }

    private static void printGrid(int[][] g) {
        for (int[] row : g) {
            System.out.println(java.util.Arrays.toString(row));
        }
    }
}

复杂度分析

逐列贪心即是全局最优。时间复杂度 O(m*n),空间复杂度 O(1)。

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

3403. Find the Lexicographically Largest String From the Box I(从盒子中找出字典序最大的字符串 I)

题目描述

给你一个字符串 word 和一个整数 numFriends。

Alice 正在为她的 numFriends 位朋友组织一个游戏。游戏分为多个回合,在每一回合中:

  • word 被分割成 numFriends 个非空字符串,且该分割方式与之前的任意回合所采用的都不完全相同。
  • 所有分割出的字符串都会被放入一个盒子中。
    在所有回合结束后,找出盒子中字典序最大的字符串。

示例 1

复制代码
word = "dbca", numFriends = 2 -> "dbc"

示例 2

复制代码
word = "gggg", numFriends = 4 -> "g"

提示:

  • 1 <= word.length <= 5 * 10^3
  • word 仅由小写英文字母组成。
  • 1 <= numFriends <= word.length

解题思路

解法一:按起点枚举最长合法片段,主提交版本

盒子中的任意字符串都是从某个起点 st 开始的片段。对固定的 st,该片段越长字典序越大,

而它最长能到 ed = min(n - 1, st + (n - numFriends))------因为之后还要留出 numFriends - 1

个非空片段,即片段后面至少剩 numFriends - 1 个字符。因此对每个起点取最长合法片段,

取字典序最大值即可。时间复杂度 O(n^2)(子串比较),空间复杂度 O(n)(答案)。

解法二:全片段存在性枚举(对照)

枚举每个候选片段 [st, ed],判定是否存在一种完整分割:左侧 0..st-1 切 l 段、

右侧 ed+1..n-1 切 r 段,满足 l + 1 + r == numFriends 且各段非空。存在则片段合法,

参与字典序比较。实现独立、可读性强,用于交叉验证(O(n^3) 仅本地)。

复杂度:

  • 时间复杂度:O(n^2)(解法二 O(n^3) 仅本地对拍)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:按起点取最长合法片段(主提交版本) ----------
    public String answerString(String word, int numFriends) {
        if (numFriends == 1) {
            return word;
        }
        int n = word.length();
        String ans = "";
        for (int st = 0; st < n; ++st) {
            // 片段最长到 min(n-1, st + (n-numFriends)),保证后面能切出 numFriends-1 个非空段
            int ed = Math.min(n - 1, st + (n - numFriends));
            String cand = word.substring(st, ed + 1);
            if (ans.compareTo(cand) < 0) {
                ans = cand;
            }
        }
        return ans;
    }

    // ---------- 解法二:全片段存在性枚举(对照) ----------
    public String answerStringBrute(String word, int numFriends) {
        int n = word.length();
        String best = "";
        for (int st = 0; st < n; ++st) {
            for (int ed = st; ed < n; ++ed) {
                if (ok(st, ed, n, numFriends)) {
                    String cand = word.substring(st, ed + 1);
                    if (best.compareTo(cand) < 0) {
                        best = cand;
                    }
                }
            }
        }
        return best;
    }

    // 片段 [st,ed] 能否作为某个 numFriends 分割的一个片段
    private boolean ok(int st, int ed, int n, int numFriends) {
        int leftLen = st;            // 左侧字符数
        int rightLen = n - 1 - ed;   // 右侧字符数
        int rest = numFriends - 1;   // 除本片段外还需切出的段数
        int lmin = leftLen > 0 ? 1 : 0;
        int lmax = leftLen;
        int rmin = rightLen > 0 ? 1 : 0;
        int rmax = rightLen;
        return lmin + rmin <= rest && rest <= lmax + rmax;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(7);

        System.out.println("示例1: " + sol.answerString("dbca", 2) + " (期望 dbc)");
        System.out.println("示例2: " + sol.answerString("gggg", 4) + " (期望 g)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 5000; ++t) {
            int n = 1 + rand.nextInt(9);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; ++i) {
                sb.append((char) ('a' + rand.nextInt(4)));
            }
            String w = sb.toString();
            int f = 1 + rand.nextInt(n);
            String x = sol.answerString(w, f);
            String y = sol.answerStringBrute(w, f);
            cases++;
            if (x.equals(y)) {
                pass++;
            } else {
                System.out.println("MISMATCH w=" + w + " f=" + f + " a=" + x + " b=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

取字典序最大值即可。时间复杂度 O(n^2)(子串比较),空间复杂度 O(n)(答案)。

  • 时间复杂度:O(n^2)(解法二 O(n^3) 仅本地对拍)
  • 空间复杂度:O(n)

3404. Count Special Subsequences(统计特殊子序列的数目)

题目描述

给你一个只包含正整数的数组 nums。

特殊子序列 是一个长度为 4 的子序列,用下标 (p, q, r, s) 表示,它们满足 p < q < r < s,

且必须满足以下条件:

  • nums[p] * nums[r] == nums[q] * nums[s]
  • 相邻坐标之间至少间隔一个数字:q - p > 1,r - q > 1 且 s - r > 1。
    请你返回 nums 中不同特殊子序列的数目。

示例 1

复制代码
nums = [1,2,3,4,3,6,1] -> 1((0,2,4,6):1*3==3*1)

示例 2

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

提示:

  • 7 <= nums.length <= 1000
  • 1 <= nums[i] <= 1000

解题思路

解法一:分数归约 + 双指针扫描哈希,主提交版本

等式 nums[p] * nums[r] == nums[q] * nums[s] 可改写为 nums[p] / nums[q] == nums[s] / nums[r]

(两边同除 nums[q] * nums[r])。对每对元素做约分得到最简分数 (分子, 分母) 作为哈希键。

采用「固定中间缝」的思路:第一遍先统计所有满足 r >= 4 的右侧对 (r, s)(s >= r+2)的

约分分数 nums[s]/nums[r] 出现次数;第二遍枚举 q(q >= 2,其左侧对 (p,q) 满足 p <= q-2),

把左侧对约分分数 nums[p]/nums[q] 与哈希中右侧分数匹配累加;每处理完一个 q,

就把 r = q+2 开头的右侧对从哈希中移除(它们对后续更大的 q 不再满足 r - q > 1)。

分数用 (分子 << 12) | 分母 编码(值域 1000,12 位足够)。

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

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

直接枚举满足间隔约束的四元组 (p, q, r, s),检查乘积等式是否成立。

时间复杂度 O(n^4),仅用于本地对小数据交叉验证。

复杂度:

  • 时间复杂度:O(n^2)(解法二 O(n^4) 仅本地对拍)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:分数归约 + 哈希双指针(主提交版本) ----------
    public long numberOfSubsequences(int[] nums) {
        int n = nums.length;
        Map<Integer, Integer> cnt = new HashMap<Integer, Integer>();
        // 第一遍:统计所有 r >= 4 的右侧对 (r, s),键为 nums[s]/nums[r] 最简分数
        for (int r = 4; r < n - 2; ++r) {
            int c = nums[r];
            for (int s = r + 2; s < n; ++s) {
                int d = nums[s];
                int g = gcd(c, d);
                cnt.put(((d / g) << 12) | (c / g),
                    cnt.getOrDefault(((d / g) << 12) | (c / g), 0) + 1);
            }
        }
        long ans = 0;
        for (int q = 2; q < n - 4; ++q) {
            int b = nums[q];
            // 左侧对 (p, q),p 最大到 q-2
            for (int p = 0; p < q - 1; ++p) {
                int a = nums[p];
                int g = gcd(a, b);
                ans += cnt.getOrDefault(((a / g) << 12) | (b / g), 0);
            }
            // 移除以 r = q+2 开头的右侧对:对下一个 q 不再满足 r - q > 1
            int c = nums[q + 2];
            for (int s = q + 4; s < n; ++s) {
                int d = nums[s];
                int g = gcd(c, d);
                int key = ((d / g) << 12) | (c / g);
                int v = cnt.get(key) - 1;
                if (v == 0) {
                    cnt.remove(key);
                } else {
                    cnt.put(key, v);
                }
            }
        }
        return ans;
    }

    private int gcd(int a, int b) {
        return b == 0 ? a : gcd(b, a % b);
    }

    // ---------- 解法二:四重循环暴力(对照) ----------
    public long numberOfSubsequencesBrute(int[] nums) {
        int n = nums.length;
        long ans = 0;
        for (int p = 0; p < n - 4; ++p) {
            for (int q = p + 2; q < n - 3; ++q) {
                for (int r = q + 2; r < n - 2; ++r) {
                    for (int s = r + 2; s < n; ++s) {
                        if ((long) nums[p] * nums[r] == (long) nums[q] * nums[s]) {
                            ++ans;
                        }
                    }
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(11);

        System.out.println("示例1: " + sol.numberOfSubsequences(new int[] {1, 2, 3, 4, 3, 6, 1})
            + " (期望 1)");
        System.out.println("示例2: " + sol.numberOfSubsequences(new int[] {3, 4, 3, 4, 3, 4, 3, 4})
            + " (期望 3)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 300; ++t) {
            int n = 7 + rand.nextInt(8);
            int[] a = new int[n];
            int range = 1 + rand.nextInt(6);
            for (int i = 0; i < n; ++i) {
                a[i] = 1 + rand.nextInt(range);
            }
            long x = sol.numberOfSubsequences(a);
            long y = sol.numberOfSubsequencesBrute(a);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
                    + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

时间复杂度 O(n^4),仅用于本地对小数据交叉验证。

  • 时间复杂度:O(n^2)(解法二 O(n^4) 仅本地对拍)
  • 空间复杂度:O(n)

3405. Count the Number of Arrays with K Matching Adjacent Elements(统计恰好有 K 个相等相邻元素的数组数目)

题目描述

给你三个整数 n,m,k。长度为 n 的好数组 arr 定义如下:

  • arr 中每个元素都在闭区间 [1, m] 中。
  • 恰好 有 k 个下标 i(其中 1 <= i < n)满足 arr[i - 1] == arr[i]。
    请你返回可以构造出的好数组数目,对 10^9 + 7 取模。

示例 1

复制代码
n = 3, m = 2, k = 1 -> 4

示例 2

复制代码
n = 4, m = 2, k = 2 -> 6

示例 3

复制代码
n = 5, m = 2, k = 0 -> 2

提示:

  • 1 <= n <= 10^5
  • 1 <= m <= 10^5
  • 0 <= k <= n - 1

解题思路

解法一:组合计数,主提交版本

把数组按「相等相邻」拆成若干「段」,每段内元素全相同、相邻两段元素不同。

若有 k 个相等相邻对,则段数为 n - k。先选出这 n - k 段的长度如何分布:

从 n - 1 个缝隙中选 n - k - 1 个作为「段间分界」,即 C(n-1, n-k-1) = C(n-1, k)。

第一段有 m 种取值,之后每段必须与前一段不同,有 m - 1 种取值。

因此答案 = C(n-1, k) * m * (m-1)^(n-k-1)(模意义下)。

预处理阶乘与逆元即可 O(1) 求组合数;快速幂求幂次。

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

解法二:递推动态规划(对照)

dp[i][j][last] 表示前 i 个元素、恰好 j 个相等相邻对、最后一个元素为 last 的方案数;

转移时最后一个元素取与上一个相同(j+1)或不同(j 不变)。m 较大时用「相同/不同」

聚合状态:same 与 diff 两类。化简后可 O(nk) 求得,与解法一在小数据上交叉验证。

复杂度:

  • 时间复杂度:O(n)(解法二 O(nk) 仅本地对拍)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    private static final int MOD = (int) 1e9 + 7;
    private static final int N = (int) 1e5 + 10;
    private static final long[] f = new long[N];
    private static final long[] g = new long[N];

    static {
        f[0] = 1;
        g[0] = 1;
        for (int i = 1; i < N; ++i) {
            f[i] = f[i - 1] * i % MOD;
            g[i] = qpow(f[i], MOD - 2);
        }
    }

    private static long qpow(long a, int k) {
        long res = 1;
        while (k != 0) {
            if ((k & 1) == 1) {
                res = res * a % MOD;
            }
            k >>= 1;
            a = a * a % MOD;
        }
        return res;
    }

    // C(m, n)
    private static long comb(int m, int n) {
        return f[m] * g[n] % MOD * g[m - n] % MOD;
    }

    // ---------- 解法一:组合计数(主提交版本) ----------
    public int countGoodArrays(int n, int m, int k) {
        // C(n-1, k) * m * (m-1)^(n-k-1)
        return (int) (comb(n - 1, k) * m % MOD * qpow(m - 1, n - k - 1) % MOD);
    }

    // ---------- 解法二:DP 递推(对照,仅小数据) ----------
    public int countGoodArraysDp(int n, int m, int k) {
        // dp[i][j][0] = 前 i 个中恰 j 个相等对,且最后一个元素与再前一个不同(或用 i==1 特判)
        // 简化:dp[j] 表示长度为 i 时恰有 j 个相等对的方案数。
        long[] dp = new long[k + 1];
        dp[0] = m; // 长度 1:m 种
        for (int i = 2; i <= n; ++i) {
            long[] ndp = new long[k + 1];
            // 末尾取与前一个相同 -> 相等对 +1
            for (int j = 0; j + 1 <= k; ++j) {
                ndp[j + 1] = (ndp[j + 1] + dp[j]) % MOD;
            }
            // 末尾取与前一个不同 -> m-1 种,相等对不变
            for (int j = 0; j <= k; ++j) {
                ndp[j] = (ndp[j] + dp[j] * (m - 1)) % MOD;
            }
            dp = ndp;
        }
        return (int) dp[k];
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(3);

        System.out.println("示例1: " + sol.countGoodArrays(3, 2, 1) + " (期望 4)");
        System.out.println("示例2: " + sol.countGoodArrays(4, 2, 2) + " (期望 6)");
        System.out.println("示例3: " + sol.countGoodArrays(5, 2, 0) + " (期望 2)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 200; ++t) {
            int n = 1 + rand.nextInt(10);
            int m = 1 + rand.nextInt(6);
            int k = rand.nextInt(n);
            int x = sol.countGoodArrays(n, m, k);
            int y = sol.countGoodArraysDp(n, m, k);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH n=" + n + " m=" + m + " k=" + k + " comb=" + x
                    + " dp=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

  • 时间复杂度:O(n)(解法二 O(nk) 仅本地对拍)
  • 空间复杂度:O(n)

3406. Find the Lexicographically Largest String From the Box II(从盒子中找出字典序最大的字符串 II 🔒)

题目描述

给你一个字符串 word 和一个整数 numFriends。

Alice 正在为她的 numFriends 位朋友组织一个游戏。游戏分为多个回合,在每一回合中:

  • word 被分割成 numFriends 个非空字符串,且该分割方式与之前的任意回合所采用的都不完全相同。
  • 所有分割出的字符串都会被放入一个盒子中。
    在所有回合结束后,找出盒子中字典序最大的字符串。
    (与 3403 相同规则,但本题 word 长度可达 2 * 10^5。)

示例 1

复制代码
word = "dbca", numFriends = 2 -> "dbc"

示例 2

复制代码
word = "gggg", numFriends = 4 -> "g"

提示:

  • 1 <= word.length <= 2 * 10^5
  • word 仅由小写英文字母组成。
  • 1 <= numFriends <= word.length

解题思路

解法一:最大字典序子串(Lyndon 后缀)+ 截断,主提交版本

盒子中的候选片段最长 n - numFriends + 1。要字典序最大,必然从某个起点 st 取最长合法片段

word.substring(st, st + L),其中 L = n - numFriends + 1 是最大可能长度------因为对固定起点,

越长字典序越大,而答案就是「长度上限为 L 的所有子串中字典序最大者」。

这是经典「最大字典序子串」问题:在线性时间内找出字典序最大的后缀的起点 i(使用两指针

Lyndon 分解思想,word.substring(i) 是所有后缀中字典序最大的),而后取

word.substring(i, i + L)(若不足 L 则取到结尾)。由于最大字典序子串必是某个最大后缀的前缀,

该做法正确。时间复杂度 O(n),空间复杂度 O(n)。

解法二:两两比较的贪心扫描(对照)

枚举每个起点 st,候选为 word.substring(st, min(st+L, n)),用滚动指针比较维护字典序最大。

朴素实现 O(n^2) 不适合大数据,仅用于本地小数据对拍。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:最大字典序后缀 + 截断(主提交版本) ----------
    public String answerString(String word, int numFriends) {
        if (numFriends == 1) {
            return word;
        }
        // 最大合法片段长度:其余 numFriends-1 段非空
        int L = word.length() - numFriends + 1;
        // 找字典序最大的后缀起点
        int i = maxSuffixStart(word);
        int ed = Math.min(word.length(), i + L);
        return word.substring(i, ed);
    }

    // 线性求字典序最大的后缀起点(两指针 Lyndon 思想)
    private int maxSuffixStart(String s) {
        int n = s.length();
        int i = 0, j = 1, k = 0;
        while (j + k < n) {
            char ci = s.charAt(i + k);
            char cj = s.charAt(j + k);
            if (ci == cj) {
                ++k;
            } else if (ci < cj) {
                // s[i..i+k] 小于 s[j..j+k],i 前进,跳过 i..i+k
                i += k + 1;
                k = 0;
                if (i >= j) {
                    j = i + 1;
                }
            } else {
                j += k + 1;
                k = 0;
            }
        }
        return i;
    }

    // ---------- 解法二:贪心比较(对照,仅小数据) ----------
    public String answerStringBrute(String word, int numFriends) {
        if (numFriends == 1) {
            return word;
        }
        int n = word.length();
        int L = n - numFriends + 1;
        String best = "";
        for (int st = 0; st < n; ++st) {
            int ed = Math.min(n, st + L);
            String cand = word.substring(st, ed);
            if (best.compareTo(cand) < 0) {
                best = cand;
            }
        }
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(19);

        System.out.println("示例1: " + sol.answerString("dbca", 2) + " (期望 dbc)");
        System.out.println("示例2: " + sol.answerString("gggg", 4) + " (期望 g)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 5000; ++t) {
            int n = 1 + rand.nextInt(12);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; ++i) {
                sb.append((char) ('a' + rand.nextInt(4)));
            }
            String w = sb.toString();
            int f = 1 + rand.nextInt(n);
            String x = sol.answerString(w, f);
            String y = sol.answerStringBrute(w, f);
            cases++;
            if (x.equals(y)) {
                pass++;
            } else {
                System.out.println("MISMATCH w=" + w + " f=" + f + " a=" + x + " b=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

该做法正确。时间复杂度 O(n),空间复杂度 O(n)。

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

3407. Substring Matching Pattern(子字符串匹配模式)

题目描述

给你一个字符串 s 和一个模式字符串 p,其中 p 恰好 包含 一个 '*' 符号。

p 中的 '*' 符号可以被替换为零个或多个字符组成的任意字符序列。

如果 p 可以变成 s 的子字符串,那么返回 true,否则返回 false。

示例 1

复制代码
s = "leetcode", p = "ee*e" -> true("*" 替换为 "tcod")

示例 2

复制代码
s = "car", p = "c*v" -> false

示例 3

复制代码
s = "luck", p = "u*" -> true

提示:

  • 1 <= s.length <= 50
  • 1 <= p.length <= 50
  • s 只包含小写英文字母。
  • p 只包含小写英文字母和一个 '*' 符号。

解题思路

解法一:按星号分割顺序查找,主提交版本

将 p 按 '*' 切成前后两段 pre 与 suf。'*' 可匹配任意(可能为空)字符序列,

因此只需在 s 中按顺序找到 pre 与 suf 且 pre 的结束位置不晚于 suf 的开始位置。

用 String.indexOf 从起始位置向后找即可(前后两段都为空则任意子串都匹配)。

更一般地,若 p 有多个 *,可顺序 indexOf 各段;本题恰一个 *,只需两段。

时间复杂度 O(|s|*|p|)(indexOf 最坏),空间复杂度 O(1)。

解法二:显式贪心双指针(对照)

不切开模式串,而是用 (i, j) 双指针同步匹配 s 与 p:遇到 '*' 记录位置并假定

匹配 0 个字符,若后续失配则回退让 '*' 多吞一个字符(经典通配符贪心)。

路径与解法一不同,用于交叉验证。

复杂度:

  • 时间复杂度:O(|s|*|p|)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {

    // ---------- 解法一:按星号分割顺序查找(主提交版本) ----------
    public boolean hasMatch(String s, String p) {
        int star = p.indexOf('*');
        String pre = p.substring(0, star);
        String suf = p.substring(star + 1);
        int i = 0;
        if (!pre.isEmpty()) {
            i = s.indexOf(pre, i);
            if (i == -1) {
                return false;
            }
            i += pre.length();
        }
        // 后缀从 pre 之后开始找;若 pre 为空则从 0 开始
        int j = suf.isEmpty() ? 0 : s.indexOf(suf, i);
        // 注意:若 pre 为空,i 保持 0,后缀需从 0 开始(此时 "*x" 要求 s 以 x 结尾的不含前导不匹配)
        // 实际上 i 未被推进时就是 0,行为正确。
        if (j == -1) {
            return false;
        }
        return true;
    }

    // ---------- 解法二:子串枚举暴力(对照) ----------
    public boolean hasMatchBrute(String s, String p) {
        int star = p.indexOf('*');
        String pre = p.substring(0, star);
        String suf = p.substring(star + 1);
        int ns = s.length();
        // 枚举 s 的每个子串,看能否作为"星号替换某字符序列"后的模式串
        for (int l = 0; l < ns; ++l) {
            for (int r = l; r < ns; ++r) {
                int len = r - l + 1;
                // 至少容纳 pre 与 suf 本身
                if (len < pre.length() + suf.length()) {
                    continue;
                }
                String ss = s.substring(l, r + 1);
                if (ss.startsWith(pre) && ss.endsWith(suf)) {
                    return true;
                }
            }
        }
        return false;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(5);

        System.out.println("示例1: " + sol.hasMatch("leetcode", "ee*e") + " (期望 true)");
        System.out.println("示例2: " + sol.hasMatch("car", "c*v") + " (期望 false)");
        System.out.println("示例3: " + sol.hasMatch("luck", "u*") + " (期望 true)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 5000; ++t) {
            int n = 1 + rand.nextInt(10);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; ++i) {
                sb.append((char) ('a' + rand.nextInt(3)));
            }
            String s = sb.toString();
            // 构造 p:含恰好一个 '*'
            StringBuilder pb = new StringBuilder();
            int starPos = rand.nextInt(4);
            for (int i = 0; i < 4; ++i) {
                if (i == starPos) {
                    pb.append('*');
                } else {
                    pb.append((char) ('a' + rand.nextInt(3)));
                }
            }
            String p = pb.toString();
            boolean x = sol.hasMatch(s, p);
            boolean y = sol.hasMatchBrute(s, p);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH s=" + s + " p=" + p + " a=" + x + " b=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

时间复杂度 O(|s|*|p|)(indexOf 最坏),空间复杂度 O(1)。

  • 时间复杂度:O(|s|*|p|)
  • 空间复杂度:O(1)

3408. Design Task Manager(设计任务管理器)

题目描述

一个任务管理器系统可以让用户管理他们的任务,每个任务有一个优先级。

请你设计一个 TaskManager 类:

  • TaskManager(List<List<Integer>> tasks) 初始化任务管理器,初始化的数组格式为
    [userId, taskId, priority],表示给 userId 添加一个优先级为 priority 的任务 taskId。
  • void add(int userId, int taskId, int priority) 给用户 userId 添加一个优先级为
    priority 的任务 taskId,输入保证 taskId 不在系统中。
  • void edit(int taskId, int newPriority) 更新已经存在的任务 taskId 的优先级为
    newPriority。输入保证 taskId 存在于系统中。
  • void rmv(int taskId) 从系统中删除任务 taskId。输入保证 taskId 存在于系统中。
  • int execTop() 执行所有用户的任务中优先级最高 的任务,如果有多个任务优先级相同
    且都为最高,执行 taskId 最大的一个任务。执行完任务后,taskId 从系统中删除,返回
    这个任务所属的用户 userId。如果不存在任何任务,返回 -1。

示例

复制代码
["TaskManager", "add", "edit", "execTop", "rmv", "add", "execTop"]
[[[[1,101,10],[2,102,20],[3,103,15]]],[4,104,5],[102,8],[],[101],[5,105,15],[]]
-> [null, null, null, 3, null, null, 5]

提示:

  • 1 <= tasks.length <= 10^5
  • 0 <= userId <= 10^5,0 <= taskId <= 10^5,0 <= priority <= 10^9
  • add,edit,rmv 和 execTop 的总操作次数加起来不超过 2 * 10^5 次。

解题思路

解法一:哈希表 + 有序集合,主提交版本

需要支持按 priority 降序、taskId 降序取最大元素的动态集合,同时按 taskId 快速

定位任务所属用户与当前优先级。用 TreeSet<int[]> 存储 {priority, taskId}:

比较器为 priority 大的在前,相同则 taskId 大的在前(符合 execTop 语义)。

用 HashMap<Integer, int[]> 映射 taskId -> {userId, priority}。

  • add:写入两个结构;
  • edit:先从集合移除旧 {priority, taskId},再插入新值并更新哈希;
  • rmv:从集合移除并删除哈希键;
  • execTop:从集合取最小(即优先级最高、taskId 最大)元素,删除哈希并返回 userId。
    时间复杂度 O(log n) 每次操作,空间复杂度 O(n)(n 为任务总数)。
    解法二:线性扫描暴力(对照)
    仅用哈希表存 taskId -> {userId, priority};execTop 时遍历全部任务找出最优者。
    时间复杂度 O(n) 每次 execTop,仅用于本地小数据交叉验证。
    复杂度:
  • 时间复杂度:O(log n) 每次操作(解法二 execTop O(n) 仅本地对拍)
  • 空间复杂度:O(n)

代码实现

java 复制代码
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class Solution {

    // ---------- 解法一:哈希表 + 有序集合(主提交版本) ----------
    static class TaskManager {
        private final Map<Integer, int[]> d = new HashMap<Integer, int[]>();
        private final java.util.TreeSet<int[]> st =
            new java.util.TreeSet<int[]>(new java.util.Comparator<int[]>() {
                public int compare(int[] a, int[] b) {
                    if (a[0] != b[0]) {
                        return b[0] - a[0]; // priority 大的在前
                    }
                    return b[1] - a[1];     // taskId 大的在前
                }
            });

        public TaskManager(List<List<Integer>> tasks) {
            for (List<Integer> task : tasks) {
                add(task.get(0), task.get(1), task.get(2));
            }
        }

        public void add(int userId, int taskId, int priority) {
            d.put(taskId, new int[] {userId, priority});
            st.add(new int[] {priority, taskId});
        }

        public void edit(int taskId, int newPriority) {
            int[] e = d.get(taskId);
            int userId = e[0], priority = e[1];
            st.remove(new int[] {priority, taskId});
            st.add(new int[] {newPriority, taskId});
            d.put(taskId, new int[] {userId, newPriority});
        }

        public void rmv(int taskId) {
            int[] e = d.remove(taskId);
            st.remove(new int[] {e[1], taskId});
        }

        public int execTop() {
            if (st.isEmpty()) {
                return -1;
            }
            int[] e = st.pollFirst();
            int[] t = d.remove(e[1]);
            return t[0];
        }
    }

    // ---------- 解法二:线性扫描暴力(对照) ----------
    static class TaskManagerBrute {
        private final Map<Integer, int[]> d = new HashMap<Integer, int[]>();
        public int lastRemovedId = -1; // 最近一次 execTop 删除的 taskId(对拍用)

        public TaskManagerBrute(List<List<Integer>> tasks) {
            for (List<Integer> task : tasks) {
                d.put(task.get(1), new int[] {task.get(0), task.get(2)});
            }
        }

        public void add(int userId, int taskId, int priority) {
            d.put(taskId, new int[] {userId, priority});
        }

        public void edit(int taskId, int newPriority) {
            int[] e = d.get(taskId);
            d.put(taskId, new int[] {e[0], newPriority});
        }

        public void rmv(int taskId) {
            d.remove(taskId);
        }

        public int execTop() {
            int bestId = -1, bestPrio = -1;
            for (Map.Entry<Integer, int[]> en : d.entrySet()) {
                int tid = en.getKey();
                int[] v = en.getValue();
                if (v[1] > bestPrio || (v[1] == bestPrio && tid > bestId)) {
                    bestPrio = v[1];
                    bestId = tid;
                }
            }
            if (bestId == -1) {
                lastRemovedId = -1;
                return -1;
            }
            lastRemovedId = bestId;
            return d.remove(bestId)[0];
        }
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        List<List<Integer>> init = new ArrayList<List<Integer>>();
        init.add(java.util.Arrays.asList(1, 101, 10));
        init.add(java.util.Arrays.asList(2, 102, 20));
        init.add(java.util.Arrays.asList(3, 103, 15));

        TaskManager tm = new TaskManager(init);
        tm.add(4, 104, 5);
        tm.edit(102, 8);
        int r1 = tm.execTop();
        tm.rmv(101);
        tm.add(5, 105, 15);
        int r2 = tm.execTop();
        System.out.println("示例: " + r1 + ", " + r2 + " (期望 3, 5)");

        // 随机对拍
        java.util.Random rand = new java.util.Random(13);
        int cases = 0, pass = 0;
        for (int t = 0; t < 200; ++t) {
            int n = 1 + rand.nextInt(8);
            List<List<Integer>> ts = new ArrayList<List<Integer>>();
            Map<Integer, int[]> seed = new HashMap<Integer, int[]>();
            int uid = 0;
            for (int i = 0; i < n; ++i) {
                int u = rand.nextInt(5), pid = i + 1, pr = rand.nextInt(20);
                ts.add(java.util.Arrays.asList(u, pid, pr));
                seed.put(pid, new int[] {u, pr});
                uid = i + 1;
            }
            TaskManager a = new TaskManager(ts);
            TaskManagerBrute b = new TaskManagerBrute(ts);
            boolean ok = true;
            int ops = 0;
            while (ops < 60 && ok) {
                int op = rand.nextInt(4);
                if (op == 0 && seed.size() > 0) {
                    // edit
                    List<Integer> keys = new ArrayList<Integer>(seed.keySet());
                    int tid = keys.get(rand.nextInt(keys.size()));
                    int np = rand.nextInt(25);
                    a.edit(tid, np);
                    b.edit(tid, np);
                    seed.put(tid, new int[] {seed.get(tid)[0], np});
                } else if (op == 1 && seed.size() > 0) {
                    // rmv
                    List<Integer> keys = new ArrayList<Integer>(seed.keySet());
                    int tid = keys.get(rand.nextInt(keys.size()));
                    a.rmv(tid);
                    b.rmv(tid);
                    seed.remove(tid);
                } else if (op == 2) {
                    // add
                    int tid = ++uid;
                    int u = rand.nextInt(5), pr = rand.nextInt(25);
                    a.add(u, tid, pr);
                    b.add(u, tid, pr);
                    seed.put(tid, new int[] {u, pr});
                } else {
                    // execTop
                    int ra = a.execTop();
                    int rb = b.execTop();
                    if (ra != rb) {
                        System.out.println("MISMATCH execTop a=" + ra + " b=" + rb);
                        ok = false;
                    } else if (ra != -1) {
                        // 两者删除的是同一个任务(brute 记录 lastRemovedId),同步 seed
                        seed.remove(b.lastRemovedId);
                    }
                }
                ops++;
            }
            cases++;
            if (ok) {
                pass++;
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

时间复杂度 O(log n) 每次操作,空间复杂度 O(n)(n 为任务总数)。

时间复杂度 O(n) 每次 execTop,仅用于本地小数据交叉验证。

  • 时间复杂度:O(log n) 每次操作(解法二 execTop O(n) 仅本地对拍)
  • 空间复杂度:O(n)

3409. Longest Subsequence With Decreasing Adjacent Difference(最长相邻绝对差递减子序列)

题目描述

给你一个整数数组 nums。你的任务是找到 nums 中的最长子序列 seq,这个子序列中

相邻元素的绝对差 构成一个非递增 整数序列。换句话说,nums 中的序列

seq0, seq1, seq2, ..., seqm 满足 |seq1 - seq0| >= |seq2 - seq1| >= ... >= |seqm - seqm-1|。

请你返回这个子序列的长度。

示例 1

复制代码
nums = [16,6,3] -> 3(相邻绝对差 [10, 3])

示例 2

复制代码
nums = [6,5,3,4,2,1] -> 4([6,4,2,1],绝对差 [2,2,1])

示例 3

复制代码
nums = [10,20,10,19,10,20] -> 5([10,20,10,19,10],绝对差 [10,10,9,9])

提示:

  • 2 <= nums.length <= 10^4
  • 1 <= nums[i] <= 300

解题思路

解法一:值域 DP + 后缀最值,主提交版本

值域只有 300,适合在值域上做 DP。设 dp[num][diff] 表示「以数值 num 结尾、且最后一段

绝对差恰为 diff」的最长子序列长度。扫描每个元素 x 时:

  • 以 x 作为子序列第一个元素:dp[x][*] 至少为 1;
  • 对每个可能的前驱值 pre,有转移 dp[x][cur] = max(dp[x][cur], dp[pre][preDiff] + 1),
    其中 cur = |x - pre|,preDiff >= cur(前一段差不能小于当前差)。
    对每个 pre,max_{preDiff >= cur} dp[pre][preDiff] 正是 dp[pre] 行的后缀最大值,
    预处理每行后缀最大后转移 O(300)。总复杂度 O(n * V),V = 300,空间 O(V^2)。
    前缀后缀的推进顺序与「按 x 不可逆」的约束处理:每处理一个 x 才把它的 dp 行投入使用,
    避免同一元素作为多个前驱重复使用。
    注意实际实现为:dp 行上做两次滚动------先求后缀最优,再用旧值(上一次扫描前快照)参与转移,
    保证每个元素只用一次。
    解法二:朴素 LIS 式 DP(对照)
    dp[i] 表示以 i 结尾的最长子序列长度,last[i] 记录该子序列最后一段绝对差。
    转移时枚举 j < i,若 |nums[i]-nums[j]| <= last[j] 则 dp[i] = max(dp[j] + 1)。
    时间复杂度 O(n^2),仅用于本地小数据交叉验证。
    复杂度:
  • 时间复杂度:O(n * V)(V = 300)
  • 空间复杂度:O(V^2)

代码实现

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

public class Solution {

    // ---------- 解法一:值域 DP + 后缀最值(主提交版本) ----------
    public int longestSubsequence(int[] nums) {
        final int MX = 300;
        // dp[num][diff]:以数值 num 结尾、最后绝对差为 diff 的最大长度
        final int[][] dp = new int[MX + 1][MX + 1];
        boolean[] appeared = new boolean[MX + 1];
        int ans = 0;
        for (int x : nums) {
            // 构建每个 num 行的后缀最值 suf[num][d] = max(base, max_{e>=d} dp[num][e]),
            // base = appeared[num] ? 1 : 0,表示"以 num 为单元素"的子序列可作为任意差的前驱。
            int[][] suf = new int[MX + 1][MX + 2];
            for (int num = 1; num <= MX; ++num) {
                int[] row = dp[num];
                int base = appeared[num] ? 1 : 0;
                suf[num][MX + 1] = base;
                for (int d = MX; d >= 0; --d) {
                    int v = row[d];
                    suf[num][d] = Math.max(v, suf[num][d + 1]);
                    if (suf[num][d] < base) {
                        suf[num][d] = base;
                    }
                }
            }
            // 单元素起点
            if (dp[x][0] < 1) {
                dp[x][0] = 1;
            }
            // 转移:cur = |x - prev|,前驱为"以 prev 结尾且最后差 >= cur"(base=1 覆盖单元素)
            for (int prev = 1; prev <= MX; ++prev) {
                int cur = Math.abs(x - prev);
                int cand = suf[prev][cur] + 1;
                if (cand > dp[x][cur]) {
                    dp[x][cur] = cand;
                }
            }
            appeared[x] = true;
            if (dp[x][0] > ans) {
                ans = dp[x][0];
            }
            // 该行其他差也可能刷新答案
            for (int d = 0; d <= MX; ++d) {
                if (dp[x][d] > ans) {
                    ans = dp[x][d];
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:索引二维 DP(对照) ----------
    public int longestSubsequenceBrute(int[] nums) {
        int n = nums.length;
        // dp[i][d]:以索引 i 结尾、最后一段绝对差恰为 d 的最长子序列长度
        int[][] dp = new int[n][301];
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            dp[i][0] = 1; // 单元素
            for (int j = 0; j < i; ++j) {
                int d = Math.abs(nums[i] - nums[j]);
                if (dp[i][d] < 2) {
                    dp[i][d] = 2; // j 作为单元素起点
                }
                // 链式转移:前一段差 pd >= d 才能接
                for (int pd = d; pd <= 300; ++pd) {
                    if (dp[j][pd] > 0 && dp[j][pd] + 1 > dp[i][d]) {
                        dp[i][d] = dp[j][pd] + 1;
                    }
                }
            }
            for (int d = 0; d <= 300; ++d) {
                if (dp[i][d] > ans) {
                    ans = dp[i][d];
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(29);

        System.out.println("示例1: " + sol.longestSubsequence(new int[] {16, 6, 3}) + " (期望 3)");
        System.out.println("示例2: " + sol.longestSubsequence(new int[] {6, 5, 3, 4, 2, 1})
            + " (期望 4)");
        System.out.println("示例3: " + sol.longestSubsequence(new int[] {10, 20, 10, 19, 10, 20})
            + " (期望 5)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 2 + rand.nextInt(9);
            int[] a = new int[n];
            int range = 1 + rand.nextInt(10);
            for (int i = 0; i < n; ++i) {
                a[i] = 1 + rand.nextInt(range);
            }
            int x = sol.longestSubsequence(a);
            int y = sol.longestSubsequenceBrute(a);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
                    + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

预处理每行后缀最大后转移 O(300)。总复杂度 O(n * V),V = 300,空间 O(V^2)。

时间复杂度 O(n^2),仅用于本地小数据交叉验证。

  • 时间复杂度:O(n * V)(V = 300)
  • 空间复杂度:O(V^2)

3410. Maximize Subarray Sum After Removing All Occurrences of One Element(删除所有值为某个元素后的最大子数组和)

题目描述

给你一个整数数组 nums。你可以对数组执行以下操作至多一次:

  • 选择 nums 中存在的任意整数 X,确保删除所有值为 X 的元素后剩下数组非空。
  • 将数组中所有值为 X 的元素都删除。
    删除后剩余元素保持原顺序拼接成新数组。请你返回所有可能得到的数组中最大子数组和为多少。

示例 1

复制代码
nums = [-3,2,-2,-1,3,-2,3] -> 7(删除 X=-2 后数组为 [-3,2,-1,3,3],子数组 [2,-1,3,3] 的和为 7)

示例 2

复制代码
nums = [1,2,3,4] -> 10(不删除任何元素)

提示:

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

解题思路

解法一:线段树维护最大子段和 + 删数置 0,主提交版本

删除所有值为 X 的元素后数组拼接,等价于在原数组上「把值为 X 的位置贡献视为 0」,

且该 0 值位置可以 被任意跨越(拼接处不再充当屏障)------这正是经典最大子段和的线性语义:

对每个候选值 X,把其出现位置改为 0 后求整个数组的最大子段和即可。

用线段树维护每个区间的 sum、mx(最大子段和)、pre(最大前缀和)、suf(最大后缀和)。

对每个不同值 X:先将 X 的所有位置改为 0,取根节点 mx,再恢复原值。

优化点:值为正时删除只会让子段和变小(0 不如保留正值),因此只需枚举负值 X;

且当数组全为非正数时,答案就是最大单个元素(删除只会更差),直接特判返回。

每个位置至多置 0、恢复各一次,总更新 O(n) 次,每次 O(log n)。

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

解法二:按值分组跳过式 Kadane(对照)

对每个不同值 v,做一遍「跳过 v」的 Kadane:遇到非 v 元素按

cur = max(x, cur + x) 更新,遇到 v 元素则跳过且不重置 cur (表示拼接后子段可横跨),

维护 best。与不删除的 Kadane 结果取最大。实现独立,用于交叉验证。

复杂度:

  • 时间复杂度:O(n log n)(解法二 O(u*n),u 为不同值个数,仅本地对拍)
  • 空间复杂度:O(n)

代码实现

java 复制代码
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Random;
import java.util.Set;

public class Solution {

    // ---------- 解法一:线段树 + 删数置 0(主提交版本) ----------
    public long maxSubarraySum(int[] nums) {
        int n = nums.length;
        int maxElem = Integer.MIN_VALUE;
        boolean hasPositive = false;
        for (int x : nums) {
            maxElem = Math.max(maxElem, x);
            if (x > 0) {
                hasPositive = true;
            }
        }
        // 全数组无非正数:最优就是最大单个元素(删除任何值只会更差)
        if (!hasPositive) {
            return maxElem;
        }

        SegmentTree seg = new SegmentTree(nums);
        long ans = seg.queryMax(); // 不删除的情况

        // 收集每个负值出现的所有位置
        Map<Integer, List<Integer>> posMap = new HashMap<Integer, List<Integer>>();
        for (int i = 0; i < n; ++i) {
            if (nums[i] < 0) {
                if (!posMap.containsKey(nums[i])) {
                    posMap.put(nums[i], new ArrayList<Integer>());
                }
                posMap.get(nums[i]).add(i);
            }
        }
        for (Map.Entry<Integer, List<Integer>> en : posMap.entrySet()) {
            List<Integer> list = en.getValue();
            for (int idx : list) {
                seg.update(idx, 0); // 删除:置 0(可被自由跨越)
            }
            ans = Math.max(ans, seg.queryMax());
            for (int idx : list) {
                seg.update(idx, nums[idx]); // 恢复
            }
        }
        return ans;
    }

    // 线段树:单点修改、全局最大子段和
    static class SegmentTree {
        static class Node {
            long sum, mx, pre, suf;
            Node(long sum, long mx, long pre, long suf) {
                this.sum = sum;
                this.mx = mx;
                this.pre = pre;
                this.suf = suf;
            }
        }
        private final int n;
        private final Node[] t;

        SegmentTree(int[] a) {
            n = a.length;
            t = new Node[4 * n];
            build(1, 0, n - 1, a);
        }

        private Node merge(Node l, Node r) {
            long sum = l.sum + r.sum;
            long mx = Math.max(Math.max(l.mx, r.mx), l.suf + r.pre);
            long pre = Math.max(l.pre, l.sum + r.pre);
            long suf = Math.max(r.suf, r.sum + l.suf);
            return new Node(sum, mx, pre, suf);
        }

        private void build(int p, int l, int r, int[] a) {
            if (l == r) {
                t[p] = new Node(a[l], a[l], a[l], a[l]);
                return;
            }
            int mid = (l + r) >> 1;
            build(p << 1, l, mid, a);
            build(p << 1 | 1, mid + 1, r, a);
            t[p] = merge(t[p << 1], t[p << 1 | 1]);
        }

        void update(int idx, long v) {
            update(1, 0, n - 1, idx, v);
        }

        private void update(int p, int l, int r, int idx, long v) {
            if (l == r) {
                t[p] = new Node(v, v, v, v);
                return;
            }
            int mid = (l + r) >> 1;
            if (idx <= mid) {
                update(p << 1, l, mid, idx, v);
            } else {
                update(p << 1 | 1, mid + 1, r, idx, v);
            }
            t[p] = merge(t[p << 1], t[p << 1 | 1]);
        }

        long queryMax() {
            return t[1].mx;
        }
    }

    // ---------- 解法二:跳过式 Kadane(对照) ----------
    public long maxSubarraySumBrute(int[] nums) {
        Set<Integer> vals = new HashSet<Integer>();
        for (int x : nums) {
            vals.add(x);
        }
        long ans = Long.MIN_VALUE;
        // 不删除
        ans = Math.max(ans, kadaneSkip(nums, null));
        for (int v : vals) {
            ans = Math.max(ans, kadaneSkip(nums, v));
        }
        return ans;
    }

    // 跳过值为 skip 的元素(不重置 cur,实现拼接),求最大子段和
    private long kadaneSkip(int[] nums, Integer skip) {
        long best = Long.MIN_VALUE, cur = 0;
        for (int x : nums) {
            if (skip != null && x == skip) {
                continue; // 跳过:cur 保持,子段可横跨
            }
            cur = Math.max(cur + x, (long) x);
            best = Math.max(best, cur);
        }
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(17);

        System.out.println("示例1: " + sol.maxSubarraySum(new int[] {-3, 2, -2, -1, 3, -2, 3})
            + " (期望 7)");
        System.out.println("示例2: " + sol.maxSubarraySum(new int[] {1, 2, 3, 4}) + " (期望 10)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 500; ++t) {
            int n = 1 + rand.nextInt(12);
            int[] a = new int[n];
            int range = 1 + rand.nextInt(8);
            for (int i = 0; i < n; ++i) {
                a[i] = -range / 2 + rand.nextInt(range);
            }
            long x = sol.maxSubarraySum(a);
            long y = sol.maxSubarraySumBrute(a);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
                    + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

  • 时间复杂度:O(n log n)(解法二 O(u*n),u 为不同值个数,仅本地对拍)
  • 空间复杂度:O(n)

3411. Maximum Subarray With Equal Products(最长乘积等价子数组)

题目描述

给你一个由正整数 组成的数组 nums。

如果一个数组 arr 满足 prod(arr) == lcm(arr) * gcd(arr),则称其为乘积等价数组 ,

其中:

  • prod(arr) 表示 arr 中所有元素的乘积。
  • gcd(arr) 表示 arr 中所有元素的最大公因数 (GCD)。
  • lcm(arr) 表示 arr 中所有元素的最小公倍数 (LCM)。
    返回数组 nums 的最长乘积等价子数组的长度。

示例 1

复制代码
nums = [1,2,1,2,1,1,1] -> 5([1,2,1,1,1])

示例 2

复制代码
nums = [2,3,4,5,6] -> 3([3,4,5])

示例 3

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

提示:

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

解题思路

解法一:暴力扩展 + 剪枝,主提交版本

对每个起点 i 向右扩展右端点 j,增量维护 p(乘积)、g(gcd)、l(lcm)。

值域只有 10,乘积增长极快:一旦 p 超过可能的 g * l 上限就 break(l 单调不降、

g 单调不增,因此 g * l 有界)。满足 p == g * l 时更新答案。

全局上限为 max(nums) * lcm(nums)(参考实现),据此安全剪枝。

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

解法二:朴素 O(n^2) 无剪枝(对照)

与解法一同构但不用乘积剪枝,直接对每个 (i, j) 完整重算或增量维护并判断等式;

逻辑路径独立简单,用于交叉验证(n <= 100 无性能压力)。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:前缀扩展 + 剪枝(主提交版本) ----------
    public int maxLength(int[] nums) {
        int mx = 0, ml = 1;
        for (int x : nums) {
            mx = Math.max(mx, x);
            ml = lcm(ml, x);
        }
        long maxP = (long) ml * mx; // 可行的乘积上限
        int n = nums.length;
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            long p = 1;
            int g = 0, l = 1;
            for (int j = i; j < n; ++j) {
                p *= nums[j];
                g = gcd(g, nums[j]);
                l = lcm(l, nums[j]);
                if (p == (long) g * l) {
                    ans = Math.max(ans, j - i + 1);
                }
                if (p > maxP) {
                    break;
                }
            }
        }
        return ans;
    }

    private int gcd(int a, int b) {
        while (b != 0) {
            int tmp = b;
            b = a % b;
            a = tmp;
        }
        return a;
    }

    private int lcm(int a, int b) {
        return a / gcd(a, b) * b;
    }

    // ---------- 解法二:朴素 O(n^2)(对照) ----------
    public int maxLengthBrute(int[] nums) {
        int n = nums.length;
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            long p = 1;
            int g = 0, l = 1;
            for (int j = i; j < n; ++j) {
                p *= nums[j];
                g = gcd(g, nums[j]);
                l = lcm(l, nums[j]);
                if (p == (long) g * l) {
                    ans = Math.max(ans, j - i + 1);
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(23);

        System.out.println("示例1: " + sol.maxLength(new int[] {1, 2, 1, 2, 1, 1, 1})
            + " (期望 5)");
        System.out.println("示例2: " + sol.maxLength(new int[] {2, 3, 4, 5, 6}) + " (期望 3)");
        System.out.println("示例3: " + sol.maxLength(new int[] {1, 2, 3, 1, 4, 5, 1})
            + " (期望 5)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 2 + rand.nextInt(12);
            int[] a = new int[n];
            int range = 1 + rand.nextInt(10);
            for (int i = 0; i < n; ++i) {
                a[i] = 1 + rand.nextInt(range);
            }
            int x = sol.maxLength(a);
            int y = sol.maxLengthBrute(a);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
                    + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3412. Find Mirror Score of a String(计算字符串的镜像分数)

题目描述

给你一个字符串 s。

英文字母中每个字母的镜像 定义为反转字母表之后对应位置上的字母。例如,'a' 的镜像是

'z','y' 的镜像是 'b'。

最初,字符串 s 中的所有字符都未标记 。字符串 s 的初始分数为 0,你需要对其执行以下过程:

  • 从左到右遍历字符串。
  • 对于每个下标 i,找到距离最近的未标记 下标 j,下标 j 需要满足 j < i 且
    s[j] 是 s[i] 的镜像。然后标记 下标 i 和 j,总分加上 i - j 的值。
  • 如果对于下标 i,不存在满足条件的下标 j,则跳过该下标,继续处理下一个下标。
    返回最终的总分。

示例 1

复制代码
s = "aczzx" -> 5(j=0 配 i=2 得 2;j=1 配 i=4 得 3)

示例 2

复制代码
s = "abcdef" -> 0

提示:

  • 1 <= s.length <= 10^5
  • s 仅由小写英文字母组成。

解题思路

解法一:26 个栈栈顶匹配,主提交版本

遍历 i,对字符 x = s[i],其镜像是 mirror(x) = 'a' + 'z' - x。若当前存在未标记的

mirror(x) 字符下标,取最近 的一个------用 26 个栈分别保存每种字符的未标记 下标,

最近即在栈顶。匹配成功则弹出栈顶、分数加 i - j(该字符对均已标记,无需其它记录);

否则把 i 压入字符 x 对应的栈(保留为未来「被匹配方」)。

由于每个下标入栈出栈至多一次,总复杂度 O(n)。空间 O(n)。

解法二:双端队列 + 模拟标记数组(对照)

同样用 26 个 List 存下标,但额外用 boolean[] marked 显式标记;匹配时从对应列表

尾部往前 找最近未标记下标(正常都是尾部,但因显式标记可以容忍中间有已标记者,

若尾部已标记则跳过)。行为与解法的"仅存未标记"略有差异但结果一致,交叉验证。

复杂度:

  • 时间复杂度:O(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 {

    // ---------- 解法一:26 栈栈顶匹配(主提交版本) ----------
    public long calculateScore(String s) {
        Map<Character, List<Integer>> d = new HashMap<Character, List<Integer>>(26);
        int n = s.length();
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            char x = s.charAt(i);
            char y = (char) ('a' + 'z' - x); // 镜像
            if (d.containsKey(y)) {
                List<Integer> ls = d.get(y);
                int j = ls.remove(ls.size() - 1); // 最近(栈顶)
                if (ls.isEmpty()) {
                    d.remove(y);
                }
                ans += i - j;
            } else {
                if (!d.containsKey(x)) {
                    d.put(x, new ArrayList<Integer>());
                }
                d.get(x).add(i);
            }
        }
        return ans;
    }

    // ---------- 解法二:显式标记 + 逆序查找(对照) ----------
    public long calculateScoreMarked(String s) {
        int n = s.length();
        List<List<Integer>> pos = new ArrayList<List<Integer>>(26);
        for (int c = 0; c < 26; ++c) {
            pos.add(new ArrayList<Integer>());
        }
        boolean[] marked = new boolean[n];
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            char x = s.charAt(i);
            char y = (char) ('a' + 'z' - x);
            List<Integer> list = pos.get(y - 'a');
            int j = -1;
            // 从尾部找最近且未标记的下标(列表中可能含中间已被标记者)
            for (int k = list.size() - 1; k >= 0; --k) {
                int cand = list.get(k);
                if (!marked[cand]) {
                    j = cand;
                    break;
                }
            }
            if (j != -1) {
                marked[i] = true;
                marked[j] = true;
                ans += i - j;
            } else {
                pos.get(x - 'a').add(i);
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(31);

        System.out.println("示例1: " + sol.calculateScore("aczzx") + " (期望 5)");
        System.out.println("示例2: " + sol.calculateScore("abcdef") + " (期望 0)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 3000; ++t) {
            int n = 1 + rand.nextInt(14);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; ++i) {
                sb.append((char) ('a' + rand.nextInt(4)));
            }
            String s = sb.toString();
            long x = sol.calculateScore(s);
            long y = sol.calculateScoreMarked(s);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH s=" + s + " a=" + x + " b=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

由于每个下标入栈出栈至多一次,总复杂度 O(n)。空间 O(n)。

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

3413. Maximum Coins From K Consecutive Bags(收集连续 K 个袋子可以获得的最多硬币数量)

题目描述

在一条数轴上有无限多个袋子,每个坐标对应一个袋子。其中一些袋子里装有硬币。

给你一个二维数组 coins,其中 coins[i] = [li, ri, ci] 表示从坐标 li 到 ri 的每个

袋子中都有 ci 枚硬币。数组 coins 中的区间互不重叠。

另给你一个整数 k。返回通过收集连续 k 个袋子可以获得的最多硬币数量。

示例 1

复制代码
coins = [[8,10,1],[1,3,2],[5,6,4]], k = 4 -> 10(选坐标 [3,4,5,6]:2+0+4+4)

示例 2

复制代码
coins = [[1,10,3]], k = 2 -> 6(选坐标 [1,2]:3+3)

提示:

  • 1 <= coins.length <= 10^5
  • 1 <= k <= 10^9
  • 1 <= li <= ri <= 10^9
  • 1 <= ci <= 1000
  • 给定的区间互不重叠。

解题思路

解法一:双向滑动窗口,主提交版本

最优的连续 k 个袋子,其左端点必然能取到某个区间的左端点 li,或右端点能够到某个

区间的右端点 ri(即左端点为 ri - k + 1)。分别用两个滑动窗口:

  • 左对齐扫描:以每个区间左端点为窗口起点,向右扩展完全落在 [li, li+k-1] 内的区间,
    全部计入;最后一个部分重叠的区间只计入重叠部分;窗口左端移到下一区间时减去离场区间。
  • 右对齐扫描:以每个区间右端点为窗口终点,向左扩展完全落在 [ri-k+1, ri] 内的区间
    全部计入;第一个部分重叠区间只计入重叠部分;移动时同步增减。
    两种方向各一次 O(n) 扫描,答案取两者最大值。空间 O(log n)(排序)。
    解法二:候选起点枚举(对照)
    对每个候选起点 start(所有 li 与 ri - k + 1),遍历所有区间累加
    [start, start+k-1] 与区间交集的硬币数,取最大值。复杂度 O(n^2),仅本地小数据对拍。
    复杂度:
  • 时间复杂度:O(n log n)(排序主导)
  • 空间复杂度:O(log n)

代码实现

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

public class Solution {

    // ---------- 解法一:双向滑动窗口(主提交版本) ----------
    public long maximumCoins(int[][] coins, int k) {
        Arrays.sort(coins, (a, b) -> Integer.compare(a[0], b[0]));
        long ans = 0;
        int n = coins.length;

        // 左对齐窗口:窗口起点 = 某区间左端点 li,终点 = li + k - 1
        long cur = 0;
        int j = 0;
        for (int i = 0; i < n; ++i) {
            int li = coins[i][0];
            long right = (long) li + k - 1;
            // 扩展:完全落在窗口内的区间
            while (j < n && coins[j][1] <= right) {
                cur += (long) (coins[j][1] - coins[j][0] + 1) * coins[j][2];
                ++j;
            }
            // 部分重叠区间(起点仍在窗口内)
            if (j < n && coins[j][0] <= right) {
                long overlap = right - coins[j][0] + 1;
                cur += overlap * coins[j][2];
                ans = Math.max(ans, cur);
                cur -= overlap * coins[j][2]; // 撤掉部分量,下一轮从完整区间继续
            } else {
                ans = Math.max(ans, cur);
            }
            // 窗口左端点移动到下一个区间左端点:减去本区间全部贡献
            cur -= (long) (coins[i][1] - coins[i][0] + 1) * coins[i][2];
        }

        // 右对齐窗口:窗口终点 = 某区间右端点 ri,起点 = ri - k + 1
        cur = 0;
        j = n - 1;
        for (int i = n - 1; i >= 0; --i) {
            int ri = coins[i][1];
            long left = (long) ri - k + 1;
            // 扩展:完全落在窗口内的区间(向左)
            while (j >= 0 && coins[j][0] >= left) {
                cur += (long) (coins[j][1] - coins[j][0] + 1) * coins[j][2];
                --j;
            }
            // 部分重叠区间(终点仍在窗口内)
            if (j >= 0 && coins[j][1] >= left) {
                long overlap = coins[j][1] - left + 1;
                cur += overlap * coins[j][2];
                ans = Math.max(ans, cur);
                cur -= overlap * coins[j][2];
            } else {
                ans = Math.max(ans, cur);
            }
            // 窗口右端点移到下一个区间右端点:减去本区间全部贡献
            cur -= (long) (coins[i][1] - coins[i][0] + 1) * coins[i][2];
        }
        return ans;
    }

    // ---------- 解法二:候选起点枚举(对照) ----------
    public long maximumCoinsBrute(int[][] coins, int k) {
        Set<Long> starts = new HashSet<Long>();
        for (int[] c : coins) {
            starts.add((long) c[0]);
            starts.add((long) c[1] - k + 1);
        }
        long ans = 0;
        for (long st : starts) {
            long end = st + k - 1;
            long sum = 0;
            for (int[] c : coins) {
                long l = Math.max(st, c[0]);
                long r = Math.min(end, c[1]);
                if (l <= r) {
                    sum += (r - l + 1) * c[2];
                }
            }
            ans = Math.max(ans, sum);
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(37);

        System.out.println("示例1: " + sol.maximumCoins(new int[][] {{8, 10, 1}, {1, 3, 2}, {5, 6, 4}}, 4)
            + " (期望 10)");
        System.out.println("示例2: " + sol.maximumCoins(new int[][] {{1, 10, 3}}, 2) + " (期望 6)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rand.nextInt(6);
            int[][] coins = new int[n][];
            int pos = 1;
            for (int i = 0; i < n; ++i) {
                int len = 1 + rand.nextInt(8);
                int l = pos;
                int r = l + len - 1;
                int c = 1 + rand.nextInt(6);
                coins[i] = new int[] {l, r, c};
                pos = r + 1 + rand.nextInt(4); // 保证不重叠
            }
            // 打乱顺序
            for (int i = n - 1; i > 0; --i) {
                int p = rand.nextInt(i + 1);
                int[] tmp = coins[i];
                coins[i] = coins[p];
                coins[p] = tmp;
            }
            int k = 1 + rand.nextInt(15);
            long x = sol.maximumCoins(coins, k);
            long y = sol.maximumCoinsBrute(coins, k);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH k=" + k + " fast=" + x + " brute=" + y);
                for (int[] c : coins) {
                    System.out.print(Arrays.toString(c) + " ");
                }
                System.out.println();
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

两种方向各一次 O(n) 扫描,答案取两者最大值。空间 O(log n)(排序)。

  • 时间复杂度:O(n log n)(排序主导)
  • 空间复杂度:O(log n)

3414. Maximum Score of Non-overlapping Intervals(不重叠区间的最大得分)

题目描述

给你一个二维整数数组 intervals,其中 intervals[i] = [li, ri, weighti]。区间 i 的起点

为 li,终点为 ri,权重为 weighti。你最多可以选择 4 个互不重叠的区间。所选择

区间的得分 定义为这些区间权重的总和。返回一个至多包含 4 个下标且字典序最小 的数组,

表示从 intervals 中选中的互不重叠且得分最大的区间。

如果两个区间没有任何重叠点,则称二者互不重叠。特别地,如果两个区间共享左边界或右边界,

也认为二者重叠。

示例 1

复制代码
intervals = [[1,3,2],[4,5,2],[1,5,5],[6,9,3],[6,7,1],[8,9,1]] -> [2,3]

示例 2

复制代码
intervals = [[5,8,1],[6,7,7],[4,7,3],[9,10,6],[7,8,2],[11,14,3],[3,5,5]] -> [1,3,5,6]

提示:

  • 1 <= intervals.length <= 5 * 10^4
  • 1 <= li <= ri <= 10^9
  • 1 <= weighti <= 10^9

解题思路

解法一:排序 + DP + 字典序回溯,主提交版本

按左端点(次按右端点)排序。对每个区间求 nxt[i]:排序后第一个左端点大于 arr[i] 右端点

的区间索引(二分查找)。然后自后向前 DP:

  • f[i][k]:从第 i 个区间(含)起至多选 k 个不重叠区间的最大权重;
  • g[i][k]:达到该最大权重且字典序最小的原始下标列表(按原始下标升序存储)。
    转移:不选 i -> fi+1k;选 i -> fnxt\[i]k-1 + wi(新列表 = gnxt\[i]k-1 再插入
    原始下标 i,保持升序)。两者权重更大者胜出;相等时比较列表字典序,较小的胜出。
    答案即 g[0][4]。时间复杂度 O(n * 4 * 4)(每次插入列表至多 4 个元素比较),空间 O(n*4)。
    解法二:暴力枚举组合(对照)
    递归枚举所有不重叠区间的组合(至多 4 个),计算权重与字典序最小的下标列表。
    时间复杂度 O(n^4),仅用于本地小数据交叉验证。
    复杂度:
  • 时间复杂度:O(n * 4^2)
  • 空间复杂度:O(n * 4)

代码实现

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

public class Solution {

    // ---------- 解法一:排序 + DP + 字典序回溯(主提交版本) ----------
    public int[] maximumWeight(List<List<Integer>> intervals) {
        int n = intervals.size();
        int[][] arr = new int[n][4]; // {l, r, w, 原始下标}
        for (int i = 0; i < n; ++i) {
            List<Integer> e = intervals.get(i);
            arr[i][0] = e.get(0);
            arr[i][1] = e.get(1);
            arr[i][2] = e.get(2);
            arr[i][3] = i;
        }
        Arrays.sort(arr, (a, b) -> a[0] != b[0] ? Integer.compare(a[0], b[0])
            : Integer.compare(a[1], b[1]));
        // nxt[i]:第一个左端点 > arr[i][1] 的索引
        int[] nxt = new int[n];
        for (int i = 0; i < n; ++i) {
            nxt[i] = search(arr, arr[i][1], i + 1);
        }
        long[][] f = new long[n + 1][5];
        int[][][] g = new int[n + 1][5][];
        for (int k = 0; k < 5; ++k) {
            g[n][k] = new int[0];
        }
        for (int i = n - 1; i >= 0; --i) {
            g[i][0] = new int[0];
            for (int k = 1; k < 5; ++k) {
                long s1 = f[i + 1][k];
                int[] a1 = g[i + 1][k];
                // 选 i
                long s2 = f[nxt[i]][k - 1] + arr[i][2];
                int[] a2 = insert(g[nxt[i]][k - 1], arr[i][3]);
                if (s2 > s1 || (s2 == s1 && less(a2, a1))) {
                    f[i][k] = s2;
                    g[i][k] = a2;
                } else {
                    f[i][k] = s1;
                    g[i][k] = a1;
                }
            }
        }
        // 修正:长度为 0 的情况不会发生(至少选 1 个),但 g[0][4] 可能含 0 个?
        // 只要 n >= 1,选一个总是优于不选;g[0][4] 因而非空。
        return g[0][4];
    }

    private int search(int[][] arr, int x, int l) {
        int r = arr.length;
        while (l < r) {
            int mid = (l + r) >> 1;
            if (arr[mid][0] > x) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l;
    }

    // 把 x 插入有序数组 a(保持升序)
    private int[] insert(int[] a, int x) {
        int n = a.length;
        int[] b = new int[n + 1];
        int i = 0;
        while (i < n && a[i] < x) {
            b[i] = a[i];
            ++i;
        }
        b[i] = x;
        while (i < n) {
            b[i + 1] = a[i];
            ++i;
        }
        return b;
    }

    // 字典序:逐位比较,前缀相同则较短者更小
    private boolean less(int[] a, int[] b) {
        int m = Math.min(a.length, b.length);
        for (int i = 0; i < m; ++i) {
            if (a[i] != b[i]) {
                return a[i] < b[i];
            }
        }
        return a.length < b.length;
    }

    // ---------- 解法二:暴力枚举组合(对照) ----------
    private long bestW;
    private int[] bestList;

    public int[] maximumWeightBrute(List<List<Integer>> intervals) {
        int n = intervals.size();
        bestW = Long.MIN_VALUE;
        bestList = null;
        dfs(intervals, 0, new ArrayList<Integer>(), 0L);
        return bestList;
    }

    private void dfs(List<List<Integer>> iv, int start, List<Integer> chosen, long w) {
        // 更新最优(每次候选都参与比较:同权重取字典序最小)
        int[] cand = new int[chosen.size()];
        for (int i = 0; i < cand.length; ++i) {
            cand[i] = chosen.get(i);
        }
        Arrays.sort(cand);
        if (bestList == null || w > bestW || (w == bestW && less(cand, bestList))) {
            bestW = w;
            bestList = cand;
        }
        if (chosen.size() == 4) {
            return;
        }
        for (int i = start; i < iv.size(); ++i) {
            List<Integer> cur = iv.get(i);
            if (canAdd(chosen, iv, cur)) {
                chosen.add(i);
                dfs(iv, i + 1, chosen, w + cur.get(2));
                chosen.remove(chosen.size() - 1);
            }
        }
    }

    private boolean canAdd(List<Integer> chosen, List<List<Integer>> iv, List<Integer> cur) {
        for (int idx : chosen) {
            List<Integer> o = iv.get(idx);
            // 共享端点视为重叠:只要 [l,r] 相交(含端点)即重叠
            if (!(o.get(1) < cur.get(0) || cur.get(1) < o.get(0))) {
                return false;
            }
        }
        return true;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(41);

        List<List<Integer>> ex1 = new ArrayList<List<Integer>>();
        int[][] a1 = {{1, 3, 2}, {4, 5, 2}, {1, 5, 5}, {6, 9, 3}, {6, 7, 1}, {8, 9, 1}};
        for (int[] e : a1) {
            ex1.add(Arrays.asList(e[0], e[1], e[2]));
        }
        System.out.println("示例1: " + Arrays.toString(sol.maximumWeight(ex1)) + " (期望 [2, 3])");

        List<List<Integer>> ex2 = new ArrayList<List<Integer>>();
        int[][] a2 = {{5, 8, 1}, {6, 7, 7}, {4, 7, 3}, {9, 10, 6}, {7, 8, 2}, {11, 14, 3}, {3, 5, 5}};
        for (int[] e : a2) {
            ex2.add(Arrays.asList(e[0], e[1], e[2]));
        }
        System.out.println("示例2: " + Arrays.toString(sol.maximumWeight(ex2)) + " (期望 [1, 3, 5, 6])");

        int cases = 0, pass = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rand.nextInt(9);
            List<List<Integer>> iv = new ArrayList<List<Integer>>();
            for (int i = 0; i < n; ++i) {
                int l = 1 + rand.nextInt(15);
                int r = l + rand.nextInt(6);
                int w = 1 + rand.nextInt(12);
                iv.add(Arrays.asList(l, r, w));
            }
            int[] x = sol.maximumWeight(iv);
            int[] y = sol.maximumWeightBrute(iv);
            cases++;
            if (Arrays.equals(x, y)) {
                pass++;
            } else {
                System.out.println("MISMATCH fast=" + Arrays.toString(x) + " brute="
                    + Arrays.toString(y) + " iv=" + iv);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

答案即 g[0][4]。时间复杂度 O(n * 4 * 4)(每次插入列表至多 4 个元素比较),空间 O(n*4)。

时间复杂度 O(n^4),仅用于本地小数据交叉验证。

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

3415. Find Products with Three Consecutive Digits(查找名称中包含三位连续数字的产品)

题目类型:数据库(SQL)

题目描述

表:Products

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

product_id 是此表的主键。表的每一行包含产品的 ID 和名字。

编写解决方案找出名字中恰好 包含三位连续数字(即包含一段长度为 3 的数字串,且该数字串前后都不是数字,因此连续四位及以上数字不算)的所有产品。返回结果表以 product_id 升序排序。

示例 1:

复制代码
输入:
products 表:
+-------------+--------------------+
| product_id  | name               |
+-------------+--------------------+
| 1           | ABC123XYZ          |
| 2           | A12B34C            |
| 3           | Product56789       |
| 4           | NoDigitsHere       |
| 5           | 789Product         |
| 6           | Item003Description |
| 7           | Product12X34       |
+-------------+--------------------+
输出:
+-------------+--------------------+
| product_id  | name               |
+-------------+--------------------+
| 1           | ABC123XYZ          |
| 5           | 789Product         |
| 6           | Item003Description |
+-------------+--------------------+
解释:
产品 1:ABC123XYZ 包含数字 123。
产品 5:789Product 包含数字 789。
产品 6:Item003Description 包含 003,恰好三位数字。
产品 3 的 56789 是五位连续数字,产品 7 的 12 与 34 都只有两位,均不满足。

解题思路

题目要求"恰好三位连续数字":既要有三位数字连在一起,又不能夹在四位及以上连续数字中。

解法一(推荐):正则匹配隔离的三位数字串

用正则 (^|[^0-9])[0-9]{3}([^0-9]|$):左边界要求是字符串开头或非数字字符,右边界要求是非数字字符或字符串结尾。这样连续四位 1234 中任意三位都会有一侧是数字,无法同时满足左右边界 → 只有被隔离出来的三位数字串才能命中。等价写法是把三种情况(开头三位、结尾三位、夹在中间的三位)用 OR 拆开写。

解法二(对照):三段 OR 展开

name REGEXP '^[0-9]{3}[^0-9]' OR name REGEXP '[^0-9][0-9]{3}[^0-9]' OR name REGEXP '[^0-9][0-9]{3}$' 逐点枚举"三位串的位置",作为对照理解,效果与解法一相同。

代码实现

sql 复制代码
-- 解法一(推荐):带边界断言的正则,恰好三位数字串
SELECT product_id, name
FROM Products
WHERE name REGEXP '(^|[^0-9])[0-9]{3}([^0-9]|$)'
ORDER BY product_id;

-- 解法二(对照):拆三种位置等价的写法
SELECT product_id, name
FROM Products
WHERE name REGEXP '^[0-9]{3}[^0-9]'
   OR name REGEXP '[^0-9][0-9]{3}[^0-9]'
   OR name REGEXP '[^0-9][0-9]{3}$'
ORDER BY product_id;

复杂度分析

  • 时间复杂度 :O(n),其中 n 为 Products 行数;每行做一次正则匹配,与名字长度成正比。
  • 空间复杂度 :O(1),仅需少量常量级中间状态。

3416. Subsequences with a Unique Middle Mode II(唯一中间众数子序列 II 🔒)

题目描述

给你一个整数数组 nums,请你求出 nums 中大小为 5 的子序列 的数目,它是唯一中间众数序列 。

由于答案可能很大,请你将答案对 10^9 + 7 取余后返回。

  • 众数 指的是一个数字序列中出现次数最多的元素。
  • 如果一个数字序列众数只有一个,我们称这个序列有唯一众数。
  • 一个大小为 5 的数字序列 seq,如果它中间的数字(seq[2])是唯一众数,那么称它是
    唯一中间众数 序列。

示例 1

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

示例 2

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

示例 3

复制代码
nums = [0,1,2,3,4,5,6,7,8] -> 0

提示:

  • 5 <= nums.length <= 10^5
  • -10^9 <= nums[i] <= 10^9

解题思路

解法一:枚举中心 + 聚合量补集计数,主提交版本

子序列长度为 5,其中间元素记为 seq[2]。固定中间元素在数组中的下标 i,则它在子序列

中作为第 3 个元素,左侧两个元素从 [0, i) 任选、右侧两个从 (i, n) 任选,一一对应。

令 a = nums[i]、p[x] 为左侧 x 的个数、s[x] 为右侧 x 的个数、l = i、r = n-1-i。

所有组合数 = C(l,2) * C(r,2),需要减去中间元素 a 不是唯一众数的组合:

  1. a 只出现中间那 1 次(左右都没选 a):C(l - p[a], 2) * C(r - s[a], 2);

  2. 其余值中某个 b != a 的出现次数 >= a 的频次(破坏唯一众数)。
    第二类无法对每个 b 枚举,改用聚合量:ps = Σ p[x]*s[x]、pp = Σ p[x]^2、
    ss = Σ s[x]^2、pss = Σ p[x]*s[x]^2、spp = Σ s[x]*p[x]^2(均剔除 a 的贡献后参与运算),
    由官方推导的补集公式:

    ans -= ps_ * (p_a * (r - s_a)) + pss_ * (-p_a)
    ans -= ps_ * (s_a * (l - p_a)) + spp_ * (-s_a)
    ans -= (pp_ - p_) * s_a * (r - s_a) / 2
    ans -= (ss_ - s_) * p_a * (l - p_a) / 2

每个下标仅 O(1) 更新聚合量,总复杂度 O(n)。空间 O(n)(离散化)。

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

枚举所有 C(n,5) 个下标组合,统计 5 元素频次,检查中间元素是否唯一众数。

时间复杂度 O(n^5),仅用于本地小数据交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    private static final long MOD = 1_000_000_007L;

    // ---------- 解法一:枚举中心 + 聚合量补集(主提交版本) ----------
    public int subsequencesWithMiddleMode(int[] nums) {
        int n = nums.length;
        // 离散化
        Map<Integer, Integer> comp = new HashMap<Integer, Integer>();
        int[] arr = new int[n];
        int id = 0;
        for (int i = 0; i < n; ++i) {
            Integer c = comp.get(nums[i]);
            if (c == null) {
                c = id++;
                comp.put(nums[i], c);
            }
            arr[i] = c;
        }
        int m = id;
        long[] p = new long[m]; // 左侧计数
        long[] s = new long[m]; // 右侧计数
        long pp = 0, ps = 0, ss = 0, pss = 0, spp = 0;
        for (int i = 0; i < n; ++i) {
            s[arr[i]]++;
        }
        for (int x = 0; x < m; ++x) {
            ss += s[x] * s[x];
        }

        long ans = 0;
        for (int i = 0; i < n; ++i) {
            int a = arr[i];
            // 1) 把 a 从右侧移出,更新聚合量
            ss += -s[a] * s[a] + (s[a] - 1) * (s[a] - 1);
            pss += p[a] * (-s[a] * s[a] + (s[a] - 1) * (s[a] - 1));
            spp += -p[a] * p[a];   // (s[a]-1-s[a]) * p[a]^2
            ps += -p[a];           // (s[a]-1-s[a]) * p[a]
            s[a]--;

            long l = i;
            long r = n - 1 - i;
            long pa = p[a], sa = s[a];
            // 2) 全量:左右各任选 2
            ans += c2(l) * c2(r);
            // 3) 减:a 只出现中间 1 次(左右都不选 a)
            ans -= c2(l - pa) * c2(r - sa);

            // 4) 减:其他值 b 参与竞争(官方补集公式)
            long pss_ = pss - pa * sa * sa;
            long spp_ = spp - sa * pa * pa;
            long pp_  = pp - pa * pa;
            long ss_  = ss - sa * sa;
            long ps_  = ps - pa * sa;
            long p_   = l - pa;
            long s_   = r - sa;
            ans -= ps_ * (pa * (r - sa)) + pss_ * (-pa);
            ans -= ps_ * (sa * (l - pa)) + spp_ * (-sa);
            ans -= (pp_ - p_) * sa * (r - sa) / 2;
            ans -= (ss_ - s_) * pa * (l - pa) / 2;
            ans %= MOD;

            // 5) 把 a 加入左侧,更新聚合量
            pss += sa * sa;                       // (pa+1-pa) * s[a]^2
            spp += sa * (-pa * pa + (pa + 1) * (pa + 1));
            pp  += -pa * pa + (pa + 1) * (pa + 1);
            ps  += sa;                            // (pa+1-pa) * s[a]
            p[a]++;
        }
        ans %= MOD;
        if (ans < 0) {
            ans += MOD;
        }
        return (int) ans;
    }

    private long c2(long x) {
        if (x < 2) {
            return 0;
        }
        return x * (x - 1) / 2;
    }

    // ---------- 解法二:五重循环暴力(对照) ----------
    public int bruteForce(int[] nums) {
        int n = nums.length;
        long ans = 0;
        for (int a = 0; a < n - 4; ++a) {
            for (int b = a + 1; b < n - 3; ++b) {
                for (int c = b + 1; c < n - 2; ++c) {
                    for (int d = c + 1; d < n - 1; ++d) {
                        for (int e = d + 1; e < n; ++e) {
                            int[] seq = {nums[a], nums[b], nums[c], nums[d], nums[e]};
                            Map<Integer, Long> freq = new HashMap<Integer, Long>();
                            for (int x : seq) {
                                freq.put(x, freq.getOrDefault(x, 0L) + 1);
                            }
                            long midFreq = freq.get(seq[2]);
                            long maxFreq = 0;
                            for (long fv : freq.values()) {
                                maxFreq = Math.max(maxFreq, fv);
                            }
                            int cntMax = 0;
                            for (long fv : freq.values()) {
                                if (fv == maxFreq) {
                                    cntMax++;
                                }
                            }
                            if (midFreq == maxFreq && cntMax == 1) {
                                ans++;
                            }
                        }
                    }
                }
            }
        }
        return (int) (ans % MOD);
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(43);

        System.out.println("示例1: " + sol.subsequencesWithMiddleMode(new int[] {1, 1, 1, 1, 1, 1})
            + " (期望 6)");
        System.out.println("示例2: " + sol.subsequencesWithMiddleMode(new int[] {1, 2, 2, 3, 3, 4})
            + " (期望 4)");
        System.out.println("示例3: "
            + sol.subsequencesWithMiddleMode(new int[] {0, 1, 2, 3, 4, 5, 6, 7, 8}) + " (期望 0)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 300; ++t) {
            int n = 5 + rand.nextInt(8);
            int[] a = new int[n];
            int range = 1 + rand.nextInt(6);
            for (int i = 0; i < n; ++i) {
                a[i] = rand.nextInt(range);
            }
            int x = sol.subsequencesWithMiddleMode(a);
            int y = sol.bruteForce(a);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " fast=" + x
                    + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

每个下标仅 O(1) 更新聚合量,总复杂度 O(n)。空间 O(n)(离散化)。

时间复杂度 O(n^5),仅用于本地小数据交叉验证。

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

3417. Zigzag Grid Traversal With Skip(跳过交替单元格的之字形遍历)

题目描述

给你一个 m x n 的二维数组 grid,数组由正整数 组成。

你的任务是以之字形 遍历 grid,同时跳过每个交替 的单元格。

之字形遍历的定义如下:

  • 从左上角的单元格 (0, 0) 开始。
  • 在当前行中向右移动,直到到达该行的末尾。
  • 下移到下一行,然后在该行中向左移动,直到到达该行的开头。
  • 继续在行间交替向右和向左移动,直到所有行都被遍历完。
    注意:在遍历过程中,必须跳过每个交替 的单元格。
    返回一个整数数组 result,其中包含按顺序记录的、且跳过交替单元格后的之字形遍历中
    访问到的单元格值。

示例 1

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

示例 2

复制代码
grid = [[2,1],[2,1],[2,1]] -> [2,1,2]

示例 3

复制代码
grid = [[1,2,3],[4,5,6],[7,8,9]] -> [1,3,5,7,9]

提示:

  • 2 <= m == grid.length <= 50
  • 2 <= n == grid[i].length <= 50
  • 1 <= grid[i][j] <= 2500

解题思路

解法一:展开序列按奇偶取,主提交版本

之字形展开后得到一个长度 m*n 的线性序列(奇数行反向)。遍历该序列,从下标 0 起

每隔一个取一个(取第 0、2、4... 个),即跳过交替单元格。时间复杂度 O(mn),
空间复杂度 O(m
n)(答案以外最多 O(m*n) 用于展开,可进一步省)。

解法二:坐标模拟访问(对照)

直接用行列游标模拟之字形路线,用一个计数器 decide 是否收录当前格子。

与解法一实现路径不同,交叉验证。

复杂度:

  • 时间复杂度:O(m*n)
  • 空间复杂度:O(m*n)(含答案,可 O(m) 实现)

代码实现

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

public class Solution {

    // ---------- 解法一:展开序列按奇偶取(主提交版本) ----------
    public List<Integer> zigzagTraversal(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        boolean ok = true;
        List<Integer> ans = new ArrayList<Integer>();
        for (int i = 0; i < m; ++i) {
            if ((i & 1) == 1) {
                // 奇数行从右往左
                for (int j = n - 1; j >= 0; --j) {
                    if (ok) {
                        ans.add(grid[i][j]);
                    }
                    ok = !ok;
                }
            } else {
                for (int j = 0; j < n; ++j) {
                    if (ok) {
                        ans.add(grid[i][j]);
                    }
                    ok = !ok;
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:坐标游标模拟(对照) ----------
    public List<Integer> zigzagTraversalSim(int[][] grid) {
        int m = grid.length, n = grid[0].length;
        List<Integer> ans = new ArrayList<Integer>();
        int i = 0, j = 0, dir = 1; // dir=1 向右,-1 向左
        boolean take = true;
        int cnt = 0;
        while (cnt < m * n) {
            if (take) {
                ans.add(grid[i][j]);
            }
            take = !take;
            cnt++;
            j += dir;
            if (j < 0 || j >= n) {
                // 换行
                j = (j < 0) ? 0 : n - 1;
                i++;
                dir = -dir;
                if (i >= m) {
                    break;
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(47);

        System.out.println("示例1: " + sol.zigzagTraversal(new int[][] {{1, 2}, {3, 4}})
            + " (期望 [1, 4])");
        System.out.println("示例2: " + sol.zigzagTraversal(new int[][] {{2, 1}, {2, 1}, {2, 1}})
            + " (期望 [2, 1, 2])");
        System.out.println("示例3: " + sol.zigzagTraversal(new int[][] {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}})
            + " (期望 [1, 3, 5, 7, 9])");

        int cases = 0, pass = 0;
        for (int t = 0; t < 2000; ++t) {
            int m = 2 + rand.nextInt(6);
            int n = 2 + rand.nextInt(6);
            int[][] g = new int[m][n];
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    g[i][j] = 1 + rand.nextInt(20);
                }
            }
            List<Integer> x = sol.zigzagTraversal(g);
            List<Integer> y = sol.zigzagTraversalSim(g);
            cases++;
            if (x.equals(y)) {
                pass++;
            } else {
                System.out.println("MISMATCH a=" + x + " b=" + y);
                for (int[] row : g) {
                    System.out.println(Arrays.toString(row));
                }
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

每隔一个取一个(取第 0、2、4... 个),即跳过交替单元格。时间复杂度 O(mn),
空间复杂度 O(m
n)(答案以外最多 O(m*n) 用于展开,可进一步省)。

  • 时间复杂度:O(m*n)
  • 空间复杂度:O(m*n)(含答案,可 O(m) 实现)

3418. Maximum Amount of Money Robot Can Earn(机器人可以获得的最大金币数)

题目描述

给你一个 m x n 的网格。一个机器人从网格的左上角 (0, 0) 出发,目标是到达网格的右下角

(m - 1, n - 1)。在任意时刻,机器人只能向右或向下移动。

网格中的每个单元格包含一个值 coins[i][j]:

  • 如果 coins[i][j] >= 0,机器人可以获得该单元格的金币。
  • 如果 coins[i][j] < 0,机器人会遇到一个强盗,强盗会抢走该单元格数值的绝对值 的金币。
    机器人有一项特殊能力,可以在行程中最多感化 2 个 单元格的强盗,从而防止这些单元格的
    金币被抢走。注意:机器人的总金币数可以是负数。
    返回机器人在路径上可以获得的
    最大金币数
    。

示例 1

复制代码
coins = [[0,1,-1],[1,-2,3],[2,-3,4]] -> 8

示例 2

复制代码
coins = [[10,10,10],[10,10,10]] -> 40

提示:

  • m == coins.length
  • n == coins[i].length
  • 1 <= m, n <= 500
  • -1000 <= coins[i][j] <= 1000

解题思路

解法一:三维记忆化 DFS,主提交版本

状态 (i, j, k):到达 (i, j) 且还剩 k 次感化能力时,从当前位置走到终点能获得的最大

金币(含当前位置的获得值)。转移:

  • 普通收获:coins[i][j] + max(dfs(i+1,j,k), dfs(i,j+1,k));
  • 若 coins[i][j] < 0 且 k > 0:感化该强盗(不扣金币),
    max(dfs(i+1,j,k-1), dfs(i,j+1,k-1))。
    边界:终点 (m-1, n-1) 处若 k > 0 且金币为负,可取 max(0, coins)。
    越界返回 -INF。记忆化 dp[i][j][k],总状态 O(mn 3),每状态 O(1) 转移。
    时间复杂度 O(mn),空间复杂度 O(m n)。
    解法二:递推 DP 三维滚动(对照)
    自终点向起点方向改为自起点向终点递推:f[i][j][k] 表示从起点到 (i,j) 且已感化
    k 个强盗(k 从 2 递减使用)的最大金币。用上、左两方向 + 每个 k 转移,滚动数组优化。
    与解法一结果一致,路径不同,交叉验证。
    复杂度:
  • 时间复杂度:O(m*n)
  • 空间复杂度:O(m*n)

代码实现

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

public class Solution {

    private Integer[][][] f;
    private int[][] coins;
    private int m;
    private int n;

    // ---------- 解法一:三维记忆化 DFS(主提交版本) ----------
    public int maximumAmount(int[][] coins) {
        m = coins.length;
        n = coins[0].length;
        this.coins = coins;
        f = new Integer[m][n][3];
        return dfs(0, 0, 2);
    }

    private int dfs(int i, int j, int k) {
        if (i >= m || j >= n) {
            return Integer.MIN_VALUE / 2;
        }
        if (f[i][j][k] != null) {
            return f[i][j][k];
        }
        if (i == m - 1 && j == n - 1) {
            return k > 0 ? Math.max(0, coins[i][j]) : coins[i][j];
        }
        int ans = coins[i][j] + Math.max(dfs(i + 1, j, k), dfs(i, j + 1, k));
        if (coins[i][j] < 0 && k > 0) {
            ans = Math.max(ans, Math.max(dfs(i + 1, j, k - 1), dfs(i, j + 1, k - 1)));
        }
        return f[i][j][k] = ans;
    }

    // ---------- 解法二:正向递推三维 DP(对照) ----------
    public int maximumAmountDp(int[][] coins) {
        int m = coins.length, n = coins[0].length;
        final int NEG = Integer.MIN_VALUE / 2;
        // dp[j][k]:滚动到当前行,位于第 j 列、已感化 k 个强盗的最大金币
        int[][] INF0 = new int[n][3];
        for (int j = 0; j < n; ++j) {
            for (int k = 0; k < 3; ++k) {
                INF0[j][k] = NEG;
            }
        }
        for (int i = 0; i < m; ++i) {
            int[][] ndp = new int[n][3];
            for (int j = 0; j < n; ++j) {
                for (int k = 0; k < 3; ++k) {
                    ndp[j][k] = NEG;
                }
            }
            for (int j = 0; j < n; ++j) {
                for (int k = 0; k < 3; ++k) {
                    int best = NEG;
                    if (i == 0 && j == 0) {
                        best = 0;
                    }
                    if (i > 0) {
                        best = Math.max(best, INF0[j][k]);
                    }
                    if (j > 0) {
                        best = Math.max(best, ndp[j - 1][k]);
                    }
                    if (best == NEG) {
                        continue;
                    }
                    int v = coins[i][j];
                    // 不感化
                    ndp[j][k] = Math.max(ndp[j][k], best + v);
                    // 感化当前强盗:必须从"已感化 k-1 个"的状态接过来
                    if (v < 0 && k > 0) {
                        int b2 = NEG;
                        if (i == 0 && j == 0) {
                            b2 = 0;
                        }
                        if (i > 0) {
                            b2 = Math.max(b2, INF0[j][k - 1]);
                        }
                        if (j > 0) {
                            b2 = Math.max(b2, ndp[j - 1][k - 1]);
                        }
                        if (b2 != NEG) {
                            ndp[j][k] = Math.max(ndp[j][k], b2);
                        }
                    }
                }
            }
            INF0 = ndp;
        }
        int ans = NEG;
        for (int k = 0; k < 3; ++k) {
            ans = Math.max(ans, INF0[n - 1][k]);
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(53);

        System.out.println("示例1: " + sol.maximumAmount(new int[][] {{0, 1, -1}, {1, -2, 3},
            {2, -3, 4}}) + " (期望 8)");
        System.out.println("示例2: " + sol.maximumAmount(new int[][] {{10, 10, 10}, {10, 10, 10}})
            + " (期望 40)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 500; ++t) {
            int m = 1 + rand.nextInt(6);
            int n = 1 + rand.nextInt(6);
            int[][] g = new int[m][n];
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    g[i][j] = -5 + rand.nextInt(11);
                }
            }
            int x = sol.maximumAmount(g);
            int y = sol.maximumAmountDp(g);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH fast=" + x + " dp=" + y);
                for (int[] row : g) {
                    System.out.println(java.util.Arrays.toString(row));
                }
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3419. Minimize the Maximum Edge Weight of Graph(图的最大边权的最小值)

题目描述

给你两个整数 n 和 threshold,同时给你一个 n 个节点的有向 带权图,节点编号为 0

到 n - 1。这个图用二维整数数组 edges 表示,其中 edges[i] = [Ai, Bi, Wi] 表示节点

Ai 到节点 Bi 之间有一条边权为 Wi 的有向边。

你需要从这个图中删除一些边(也可能不删除任何边),使得这个图满足以下条件:

  • 所有其他节点都可以到达节点 0。
  • 图中剩余边的最大边权值尽可能小。
  • 每个节点都至多 有 threshold 条出去的边。
    请你返回删除必要的边后,最大 边权的最小值为多少。如果无法满足所有的条件,返回 -1。

示例 1

复制代码
n=5, edges=[[1,0,1],[2,0,2],[3,0,1],[4,3,1],[2,1,1]], threshold=2 -> 1

示例 2

复制代码
n=5, edges=[[0,1,1],[0,2,2],[0,3,1],[0,4,1],[1,2,1],[1,4,1]], threshold=1 -> -1

示例 3

复制代码
n=5, edges=[[1,2,1],[1,3,3],[1,4,5],[2,3,2],[3,4,2],[4,0,1]], threshold=1 -> 2

示例 4

复制代码
n=5, edges=[[1,2,1],[1,3,3],[1,4,5],[2,3,2],[4,0,1]], threshold=1 -> -1

提示:

  • 2 <= n <= 10^5
  • 1 <= threshold <= n - 1
  • 1 <= edges.length <= min(10^5, n*(n-1)/2)
  • 0 <= Ai, Bi < n,Ai != Bi
  • 1 <= Wi <= 10^6

解题思路

解法一:二分答案 + 反向 BFS 连通性,主提交版本

"所有节点都能到达 0" 等价于在反向图 上从 0 出发能到达所有节点。而"删除边使最大边权

最小"是典型的二分答案:判定 limit 是否可行------只用边权 <= limit 的反向边,从 0 出发

BFS/DFS,若所有节点可达则可行。关于 threshold:在反向图中每个节点的出边对应原图的入边;

若能从 0 到所有节点,每个节点可达即可,且原条件"每个节点至多 threshold 条出边"------可以

通过删除多余边满足(只要 threshold >= 1,去掉多余边后每个节点保留不超过 threshold 条

出边即可达到;若某节点原图不可达 0 则无论如何不行)。因此阈值只需考虑连通性。

二分下界 0、上界最大边权;check 可行则收窄上界。最终若最小可行值不存在返回 -1。

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

解法二:Kruskal 式并查集(对照)

把边按权值升序排序,并查集维护"反向图上可达 0 的节点集合":将反向边端点加入,当且仅当

所有节点都与 0 连通时的最大边权即最小可行上限。结果与二分一致,路径独立交叉验证。

复杂度:

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

代码实现

java 复制代码
import java.util.ArrayList;
import java.util.List;
import java.util.Random;

public class Solution {

    // ---------- 解法一:二分答案 + 反向 BFS(主提交版本) ----------
    public int minMaxWeight(int n, int[][] edges, int threshold) {
        // 建反向图
        List<List<int[]>> rev = new ArrayList<List<int[]>>();
        for (int i = 0; i < n; ++i) {
            rev.add(new ArrayList<int[]>());
        }
        int maxW = 0;
        for (int[] e : edges) {
            rev.get(e[1]).add(new int[] {e[0], e[2]});
            if (e[2] > maxW) {
                maxW = e[2];
            }
        }
        // 先验证完全不加限制是否可达(不可达则 -1)
        if (!can(rev, n, maxW)) {
            return -1;
        }
        int lo = 0, hi = maxW;
        while (lo < hi) {
            int mid = (lo + hi) >>> 1;
            if (can(rev, n, mid)) {
                hi = mid;
            } else {
                lo = mid + 1;
            }
        }
        return lo;
    }

    // 反向图上从 0 出发,只用边权 <= limit 的边,能否到达所有节点
    private boolean can(List<List<int[]>> rev, int n, int limit) {
        boolean[] vis = new boolean[n];
        int[] q = new int[n];
        int head = 0, tail = 0;
        q[tail++] = 0;
        vis[0] = true;
        int cnt = 1;
        while (head < tail) {
            int u = q[head++];
            for (int[] e : rev.get(u)) {
                int v = e[0], w = e[1];
                if (!vis[v] && w <= limit) {
                    vis[v] = true;
                    cnt++;
                    q[tail++] = v;
                }
            }
        }
        return cnt == n;
    }

    // ---------- 解法二:Dijkstra 瓶颈最短路(对照) ----------
    public int minMaxWeightDijkstra(int n, int[][] edges, int threshold) {
        // 反向图
        List<List<int[]>> rev = new ArrayList<List<int[]>>();
        for (int i = 0; i < n; ++i) {
            rev.add(new ArrayList<int[]>());
        }
        int maxW = 0;
        for (int[] e : edges) {
            rev.get(e[1]).add(new int[] {e[0], e[2]});
            if (e[2] > maxW) {
                maxW = e[2];
            }
        }
        // 先验证完全放行是否可达
        if (!can(rev, n, maxW)) {
            return -1;
        }
        // dist[v] = 从 0 到 v 的路径上的最小瓶颈(最大边权最小化)
        // 用 Dijkstra 变体:路径代价取 max,堆按代价升序
        final int INF = Integer.MAX_VALUE / 2;
        int[] dist = new int[n];
        java.util.Arrays.fill(dist, INF);
        dist[0] = 0;
        java.util.PriorityQueue<int[]> pq =
            new java.util.PriorityQueue<int[]>(new java.util.Comparator<int[]>() {
                public int compare(int[] a, int[] b) {
                    return Integer.compare(a[0], b[0]);
                }
            });
        pq.offer(new int[] {0, 0});
        boolean[] done = new boolean[n];
        while (!pq.isEmpty()) {
            int[] top = pq.poll();
            int u = top[1];
            if (done[u]) {
                continue;
            }
            done[u] = true;
            for (int[] e : rev.get(u)) {
                int v = e[0], w = e[1];
                int nd = Math.max(dist[u], w);
                if (nd < dist[v]) {
                    dist[v] = nd;
                    pq.offer(new int[] {nd, v});
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            ans = Math.max(ans, dist[i]);
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(59);

        System.out.println("示例1: "
            + sol.minMaxWeight(5, new int[][] {{1, 0, 1}, {2, 0, 2}, {3, 0, 1}, {4, 3, 1},
                {2, 1, 1}}, 2) + " (期望 1)");
        System.out.println("示例2: "
            + sol.minMaxWeight(5, new int[][] {{0, 1, 1}, {0, 2, 2}, {0, 3, 1}, {0, 4, 1},
                {1, 2, 1}, {1, 4, 1}}, 1) + " (期望 -1)");
        System.out.println("示例3: "
            + sol.minMaxWeight(5, new int[][] {{1, 2, 1}, {1, 3, 3}, {1, 4, 5}, {2, 3, 2},
                {3, 4, 2}, {4, 0, 1}}, 1) + " (期望 2)");
        System.out.println("示例4: "
            + sol.minMaxWeight(5, new int[][] {{1, 2, 1}, {1, 3, 3}, {1, 4, 5}, {2, 3, 2},
                {4, 0, 1}}, 1) + " (期望 -1)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 2 + rand.nextInt(8);
            int threshold = 1 + rand.nextInt(n);
            int m = 1 + rand.nextInt(Math.max(1, (int) Math.min(30, (long) n * (n - 1) / 2)));
            int[][] es = new int[m][];
            for (int i = 0; i < m; ++i) {
                int a = rand.nextInt(n), b = rand.nextInt(n);
                while (b == a) {
                    b = rand.nextInt(n);
                }
                es[i] = new int[] {a, b, 1 + rand.nextInt(15)};
            }
            int x = sol.minMaxWeight(n, es, threshold);
            int y = sol.minMaxWeightDijkstra(n, es, threshold);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH n=" + n + " th=" + threshold + " bisearch=" + x
                    + " union=" + y);
                for (int[] e : es) {
                    System.out.print(java.util.Arrays.toString(e) + " ");
                }
                System.out.println();
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3420. Count Non-Decreasing Subarrays After K Operations(统计 K 次操作以内得到非递减子数组的数目)

题目描述

给你一个长度为 n 的数组 nums 和一个整数 k。

对于 nums 中的每一个子数组,你可以对它进行至多 k 次操作。每次操作中,你可以将

子数组中的任意一个元素增加 1。注意 ,每个子数组都是独立的,也就是说你对一个子数组的

修改不会保留到另一个子数组中。

请你返回最多 k 次操作以内,有多少个子数组可以变成非递减 的。

如果一个数组中的每一个元素都大于等于前一个元素(如果前一个元素存在),那么我们称这个

数组是非递减的。

示例 1

复制代码
nums = [6,3,1,2,4,4], k = 7 -> 17

示例 2

复制代码
nums = [6,3,1,3,6], k = 4 -> 12

提示:

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

解题思路

解法一:双指针 + 单调平台栈,主提交版本

对固定左端点 l,定义 cost(l, r) 为把子数组 [l, r] 变成非递减的最小操作数。它随 r

增大单调不减,因此对每个 l,最大可行 r 可用双指针维护。

核心是增量维护 cost:从右往左扫描 l,用单调栈维护"平台"结构。每个平台

(val, size) 表示一段被调整成同一高度 val 的连续元素:

  • 新元素 x 进入后,若 x >= 栈顶平台值,则栈顶平台(值较小、位于右侧)必须整体抬到
    x 才能保持左小右大的非递减顺序,代价增加 (x - val) * size,并合并为一个大小
    更大的平台;重复直到栈顶值 > x,再把 (x, 合并大小) 压栈。
  • 当总代价超过 k 时收缩右边界 r:最右元素恰在栈底(值最大)平台中,去掉它减少
    栈底值 - nums[r] 的代价;若该平台大小归零则弹掉栈底。
  • 对当前 l,所有 r' in [l, r] 的子数组都可行,答案累加 r - l + 1。
    每个元素入栈出栈各一次,总复杂度 O(n),空间 O(n)。
    解法二:暴力枚举子数组贪心(对照)
    对每个子数组 [l, r],从左到右贪心:维护 cur(当前必需高度,初始 nums[l]),
    若 nums[i] < cur 则代价加 cur - nums[i],否则 cur = nums[i]。代价不超过 k 即可行。
    时间复杂度 O(n^2),仅用于本地小数据交叉验证。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:双指针 + 单调平台栈(主提交版本) ----------
    public long countNonDecreasingSubarrays(int[] nums, int k) {
        int n = nums.length;
        long cost = 0;
        long ans = 0;
        // 数组模拟双端队列(head..top),值从栈底到栈顶单调递减
        int[] val = new int[n + 2];
        int[] size = new int[n + 2];
        int head = 0, top = -1;
        int r = n - 1;
        for (int l = n - 1; l >= 0; --l) {
            int x = nums[l];
            int mergeSz = 1;
            while (top >= head && x >= val[top]) {
                cost += (long) (x - val[top]) * size[top]; // 抬升右侧平台到 x
                mergeSz += size[top];
                --top;
            }
            ++top;
            val[top] = x;
            size[top] = mergeSz;
            // 收缩右边界,使代价回到 k 以内
            while (cost > k) {
                cost -= (long) val[head] - nums[r]; // 去掉最右元素
                --size[head];
                if (size[head] == 0) {
                    ++head;
                    if (head > top) {
                        head = 0;
                        top = -1;
                    }
                }
                --r;
            }
            ans += (long) (r - l + 1);
        }
        return ans;
    }

    // ---------- 解法二:暴力枚举子数组(对照) ----------
    public long countNonDecreasingSubarraysBrute(int[] nums, int k) {
        int n = nums.length;
        long ans = 0;
        for (int l = 0; l < n; ++l) {
            long cost = 0;
            int cur = nums[l]; // 当前必需高度
            for (int r = l; r < n; ++r) {
                if (nums[r] < cur) {
                    cost += cur - nums[r];
                } else {
                    cur = nums[r];
                }
                if (cost <= k) {
                    ++ans;
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        Random rand = new Random(61);

        System.out.println("示例1: "
            + sol.countNonDecreasingSubarrays(new int[] {6, 3, 1, 2, 4, 4}, 7) + " (期望 17)");
        System.out.println("示例2: "
            + sol.countNonDecreasingSubarrays(new int[] {6, 3, 1, 3, 6}, 4) + " (期望 12)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 3000; ++t) {
            int n = 1 + rand.nextInt(12);
            int[] a = new int[n];
            int range = 1 + rand.nextInt(8);
            for (int i = 0; i < n; ++i) {
                a[i] = 1 + rand.nextInt(range);
            }
            long kk = 1 + rand.nextInt(40);
            long x = sol.countNonDecreasingSubarrays(a, (int) kk);
            long y = sol.countNonDecreasingSubarraysBrute(a, (int) kk);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " k=" + kk
                    + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

每个元素入栈出栈各一次,总复杂度 O(n),空间 O(n)。

时间复杂度 O(n^2),仅用于本地小数据交叉验证。

  • 时间复杂度:O(n)
  • 空间复杂度:O(n)
相关推荐
文丑颜不良啊1 小时前
LeetCode3421~3440题目解析
java·leetcode
code2cat2 小时前
【随笔】Java客户端选了HTTP/3,怎样知道请求实际走了哪个版本
java·开发语言·http
码云社区4 小时前
Java在线租房系统源码:VR看房素材、房源图片与内容维护方案
java·vue.js·vr·租房小程序·在线租房·看房租房
码云社区4 小时前
Spring Boot智慧物业系统源码:合同到期提醒、续签资料与资产协作
java·spring boot·后端·物业管理·物业系统·智慧物业
AI开源软件4 小时前
Vue3+SpringBoot3 业务配置统一管理:接管、保存与回退怎样保留有效值
java·前端·vue.js·spring boot·vue·ruoyi office
陈如水5 小时前
Spring AI Alibaba 在多 Agent 场景下的实践
java·人工智能·spring
吃我一窝jio5 小时前
Docker+Jenkins+K8s全流程部署
java·开发语言·笔记·python
Resean02238 小时前
Spring 源码分析(六)循环依赖与三级缓存
java·spring·缓存
在爪洼山玩泥巴9 小时前
fastjson2 JSONPath 取不存在路径,为什么会抛 “not support”?
java·开发语言·jsonpath·fastjson