LeetCode3001~3020题目解析

LeetCode 3001-3020. 题解合集

文章目录


3001. Minimum Moves to Capture The Queen(捕获黑皇后需要的最少移动次数)

题目描述

现有一个下标从 1 开始的 8 x 8 棋盘,上面有 3 枚棋子。

给你 6 个整数 a、b、c、d、e、f,其中 (a, b) 表示白色车的位置,(c, d) 表示白色象的位置,(e, f) 表示黑皇后的位置。

假定你只能移动白色棋子,返回捕获黑皇后所需的最少移动次数。

车可以向垂直或水平方向移动任意数量的格子,但不能跳过其他棋子;

象可以沿对角线方向移动任意数量的格子,但不能跳过其他棋子;

如果车或象能移向皇后所在的格子,则认为它们可以捕获皇后;皇后不能移动。

示例 1

复制代码
a=1,b=1,c=8,d=8,e=2,f=3 -> 2(车先移动到 (1,3) 再移动到 (2,3))

示例 2

复制代码
a=5,b=3,c=3,d=4,e=5,f=2 -> 1(车或象移动 1 次即可)

提示:

  • 1 <= a, b, c, d, e, f <= 8
  • 两枚棋子不会同时出现在同一个格子上。

解题思路

解法一:几何判断,主提交版本

最少移动次数只可能是 1 或 2:任何情况下 2 步内必能捕获(先把车挪到与皇后同行/同列的位置)。

只需判断 1 步是否能捕获:

  1. 车与皇后同行(a == e):中间没有其他棋子阻挡(象不在 (a, b) 与 (e, f) 之间),1 步捕获;
  2. 车与皇后同列(b == f):类似判断;
  3. 象与皇后在同一对角线上(|c-e| == |d-f|):中间没有其他棋子阻挡(车不在两者之间),1 步捕获。
    否则返回 2。
    时间复杂度 O(1),空间复杂度 O(1)。
    解法二:BFS 暴力,对照
    以皇后位置为观察点,直接枚举车/象在 1 步内可达的位置,若任一可达皇后所在格(中途无阻挡)则 1 步;
    否则必为 2 步。由于 2 步一定可行(车先平移不与象冲突的位置),BFS 最多只会走到 2 层。
    复杂度:
  • 时间复杂度:O(1)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {
    // ---------- 解法一:几何判断(主提交版本) ----------
    public int minMovesToCaptureTheQueen(int a, int b, int c, int d, int e, int f) {
        // 车与皇后同行:象不能在中间(c == a && d 在 b 与 f 之间)
        if (a == e) {
            if (!(c == a && between(d, b, f))) {
                return 1;
            }
        }
        // 车与皇后同列
        if (b == f) {
            if (!(d == b && between(c, a, e))) {
                return 1;
            }
        }
        // 象与皇后同一条对角线:车不能在中间(沿对角线方向判断)
        if (Math.abs(c - e) == Math.abs(d - f)) {
            if (!(Math.abs(a - e) == Math.abs(b - f) && betweenOnDiag(c, d, a, b, e, f))) {
                return 1;
            }
        }
        return 2;
    }

    private boolean between(int x, int lo, int hi) {
        return x > Math.min(lo, hi) && x < Math.max(lo, hi);
    }

    // 车 (a,b) 是否在象 (c,d) 与皇后 (e,f) 之间的对角线上
    private boolean betweenOnDiag(int c, int d, int a, int b, int e, int f) {
        if (!(Math.abs(a - e) == Math.abs(b - f))) {
            return false;
        }
        int dx = a - c, dy = b - d;
        return dx * (e - c) > 0 && Math.abs(dx) < Math.abs(e - c) && dx * dy > 0;
    }

    // ---------- 解法二:BFS 可达性枚举(对照) ----------
    public int minMovesToCaptureTheQueenBrute(int a, int b, int c, int d, int e, int f) {
        // 车两步转移路径:先沿某方向走一格(避开象的位置),再看是否 1 步可达即返回
        // 等价判断:枚举车与象各自 1 步可达位置,命中皇后即可
        if (rookOneStep(a, b, c, d, e, f) || bishopOneStep(a, b, c, d, e, f)) {
            return 1;
        }
        return 2;
    }

    // 车 1 步内能否吃到皇后(保持 a==e 或 b==f 且中间无象)
    private boolean rookOneStep(int a, int b, int c, int d, int e, int f) {
        if (a == e && b != f) {
            // 中间格必须无象
            return !(c == a && d > Math.min(b, f) && d < Math.max(b, f));
        }
        if (b == f && a != e) {
            return !(d == b && c > Math.min(a, e) && c < Math.max(a, e));
        }
        return false;
    }

    // 象 1 步内能否吃到皇后(同一对角线且中间无车)
    private boolean bishopOneStep(int a, int b, int c, int d, int e, int f) {
        if (Math.abs(c - e) != Math.abs(d - f)) {
            return false;
        }
        // 车是否在象到皇后的对角线上
        if (Math.abs(a - e) == Math.abs(b - f)) {
            int dx = a - c, dy = b - d;
            if (dx == 0 && dy == 0) {
                return false; // 象的位置就是车
            }
            // 车在两者之间则阻挡
            if (Math.abs(a - e) < Math.abs(c - e) && (a - c) * (e - c) > 0) {
                return false;
            }
        }
        return true;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.minMovesToCaptureTheQueen(1, 1, 8, 8, 2, 3) == 2, "3001 例1");
        check(s.minMovesToCaptureTheQueen(5, 3, 3, 4, 5, 2) == 1, "3001 例2");
        check(s.minMovesToCaptureTheQueen(1, 1, 8, 8, 1, 8) == 1, "3001 车同列");
        check(s.minMovesToCaptureTheQueen(1, 1, 1, 3, 1, 8) == 2, "3001 象阻挡");
        check(s.minMovesToCaptureTheQueen(4, 4, 2, 2, 3, 3) == 1, "3001 象路径被车挡需2步? 验证");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 200; t++) {
            int[] p = new int[6];
            for (int i = 0; i < 6; i++) {
                p[i] = 1 + rnd.nextInt(8);
            }
            // 去掉重合的棋子(简化:不构造三子重合)
            if (allDistinct(p)) {
                int m1 = s.minMovesToCaptureTheQueen(p[0], p[1], p[2], p[3], p[4], p[5]);
                int m2 = s.minMovesToCaptureTheQueenBrute(p[0], p[1], p[2], p[3], p[4], p[5]);
                if (m1 != m2 || m1 < 1 || m1 > 2) {
                    allOk = false;
                    System.out.println("对拍失败 (" + p[0] + "," + p[1] + "," + p[2] + "," + p[3] + "," + p[4] + "," + p[5] + ") 主=" + m1 + " 对照=" + m2);
                    break;
                }
            }
        }
        check(allOk, "3001 随机对拍");
        System.out.println("3001 all tests done");
    }

    private static boolean allDistinct(int[] p) {
        for (int i = 0; i < 6; i += 2) {
            for (int j = i + 2; j < 6; j += 2) {
                if (p[i] == p[j] && p[i + 1] == p[j + 1]) {
                    return false;
                }
            }
        }
        return true;
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3002. Maximum Size of a Set After Removals(移除后集合的最多元素数)

题目描述

给你两个下标从 0 开始的整数数组 nums1 和 nums2,它们的长度都是偶数 n。

你必须从 nums1 中移除 n/2 个元素,同时从 nums2 中也移除 n/2 个元素。

移除之后,你将 nums1 和 nums2 中剩下的元素插入到集合 s 中。

返回集合 s 可能的最多包含多少元素。

示例 1

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

示例 2

复制代码
nums1 = [1,2,3,4,5,6], nums2 = [2,3,2,3,2,3] -> 5

示例 3

复制代码
nums1 = [1,1,2,2,3,3], nums2 = [4,4,5,5,6,6] -> 6

提示:

  • n == nums1.length == nums2.length
  • 1 <= n <= 2 * 10^4,n 是偶数
  • 1 <= nums1[i], nums2[i] <= 10^9

解题思路

解法一:按重叠分组计数,主提交版本

设每个数组保留 n/2 个。理想情况是两个数组各贡献自己独有的那部分元素。

记 only1 = nums1 独有元素数(不在 nums2 中),only2 = nums2 独有元素数,common = 两数组共有元素数。

答案 = min(only1, n/2) + min(only2, n/2) + common 中还能补上的部分。

更稳健的模型:把元素分成「仅 1」「仅 2」「共有」三类:

  • 仅 1 的元素最多能贡献 min(only1, n/2) 个;
  • 仅 2 的元素最多能贡献 min(only2, n/2) 个;
  • 共有的元素每个最多贡献 1 个,把前两类没填满的槽位(n/2 - 已用)填上。
    时间复杂度 O(n),空间复杂度 O(n)。
    解法二:枚举保留子集模拟,对照
    对 n 较小的情况,直接枚举两个数组各保留 n/2 个的所有组合(用组合数剪枝),
    逐组合计算并集大小取最大,作为对照验证。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {
    // ---------- 解法一:分类计数(主提交版本) ----------
    public int maximumSetSize(int[] nums1, int[] nums2) {
        Set<Integer> s1 = new HashSet<>();
        Set<Integer> s2 = new HashSet<>();
        for (int x : nums1) s1.add(x);
        for (int x : nums2) s2.add(x);
        // 只存在于 s1 / 只存在于 s2 / 两边共有
        int only1 = 0, only2 = 0, common = 0;
        for (int x : s1) {
            if (s2.contains(x)) common++;
            else only1++;
        }
        for (int x : s2) {
            if (!s1.contains(x)) only2++;
        }
        int half = nums1.length / 2;
        int take1 = Math.min(only1, half);   // 从仅 1 中取
        int take2 = Math.min(only2, half);   // 从仅 2 中取
        int ans = take1 + take2;
        // 剩余槽位用共有元素填补(每个共有元素最多贡献 1 个)
        int slot = (half - take1) + (half - take2);
        ans += Math.min(common, slot);
        return ans;
    }

    // ---------- 解法二:枚举子集模拟(对照) ----------
    public int maximumSetSizeBrute(int[] nums1, int[] nums2) {
        int n = nums1.length;
        int half = n / 2;
        if (n > 14) {
            // 太大退化为只算一次近似(用于对拍小数据即可)
            return maximumSetSize(nums1, nums2);
        }
        int best = 0;
        // 枚举保留的 n/2 个下标
        int[] keep = new int[half];
        for (int m1 = (1 << n) - 1; m1 >= 0; m1--) {
            if (Integer.bitCount(m1) != half) continue;
            for (int m2 = (1 << n) - 1; m2 >= 0; m2--) {
                if (Integer.bitCount(m2) != half) continue;
                Set<Integer> s = new HashSet<>();
                for (int i = 0; i < n; i++) {
                    if ((m1 & (1 << i)) != 0) s.add(nums1[i]);
                    if ((m2 & (1 << i)) != 0) s.add(nums2[i]);
                }
                best = Math.max(best, s.size());
            }
        }
        return best;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.maximumSetSize(new int[]{1, 2, 1, 2}, new int[]{1, 1, 1, 1}) == 2, "3002 例1");
        check(s.maximumSetSize(new int[]{1, 2, 3, 4, 5, 6}, new int[]{2, 3, 2, 3, 2, 3}) == 5, "3002 例2");
        check(s.maximumSetSize(new int[]{1, 1, 2, 2, 3, 3}, new int[]{4, 4, 5, 5, 6, 6}) == 6, "3002 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            int n = 2 * (1 + rnd.nextInt(4)); // 2,4,6,8
            int[] a = new int[n], b = new int[n];
            for (int i = 0; i < n; i++) {
                a[i] = 1 + rnd.nextInt(6);
                b[i] = 1 + rnd.nextInt(6);
            }
            int m1 = s.maximumSetSize(a, b);
            int m2 = s.maximumSetSizeBrute(a, b);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 " + Arrays.toString(a) + " " + Arrays.toString(b) + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3002 随机对拍");
        System.out.println("3002 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3003. Maximize the Number of Partitions After Operations(执行操作后的最大分割数量)

题目描述

给定一个字符串 s 和一个整数 k。首先,你最多可以更改 s 中的一处下标对应字符为另一个小写英文字母。

之后,执行以下分割操作,直到 s 变为空串:

  • 选择 s 的最长前缀,该前缀最多包含 k 个不同字符;
  • 从 s 中删除这个前缀,并将分割数量加一。
    返回在最多改变一处下标对应字符的情况下,经过操作后得到的最大分割数。

示例 1

复制代码
s = "accca", k = 2 -> 3(把 s[2] 改为 b 得 "acbca",分成 "ac"|"bc"|"a")

示例 2

复制代码
s = "aabaab", k = 3 -> 1

示例 3

复制代码
s = "xxyz", k = 1 -> 4(把 s[0] 改为 w 得 "wxyz",分成 4 段)

提示:

  • 1 <= s.length <= 10^4
  • s 只包含小写英文字母
  • 1 <= k <= 26

解题思路

解法一:记忆化搜索 DFS,主提交版本

状态 (i, cur, t):i 为当前处理到的下标,cur 为当前段已包含字符的位掩码(26 位),t 为是否已用掉一次修改机会。

对每个位置,先把 si 加入当前段:

  • 若加入后不同字符数 > k,则必须重新开段(分割数 +1),从 si 单独开始一段;
  • 否则继续留在当前段。
    若 t == 1(还有修改机会),枚举把 si 改成任意一个字符(26 种)的情况取最大值。
    用 HashMap 记忆化 (i, cur, t)。
    时间复杂度 O(n * 2^26 的最坏情况被剪枝,实际远小于),空间复杂度 O(n * 状态数)。
    解法二:递推 DP + 集合可达状态,对照
    正向维护第 i 步所有可达状态 (cur, t),反向再从末尾算最大段数,取最优值。
    与解法一逻辑等价,相互对拍验证。
    复杂度:
  • 时间复杂度:O(n * 26 * 状态数)(状态数受不同前缀段限制,实际运行很快)
  • 空间复杂度:O(n * 状态数)

代码实现

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

public class Solution {
    private Map<Long, Integer> memo;
    private String s;
    private int k;

    // ---------- 解法一:DFS 记忆化(主提交版本) ----------
    public int maxPartitionsAfterOperations(String s, int k) {
        this.s = s;
        this.k = k;
        this.memo = new HashMap<>();
        return dfs(0, 0, 1);
    }

    private int dfs(int i, int cur, int t) {
        if (i >= s.length()) {
            return 1;
        }
        long key = ((long) i << 32) | ((long) cur << 1) | t;
        Integer cached = memo.get(key);
        if (cached != null) {
            return cached;
        }
        int v = 1 << (s.charAt(i) - 'a');
        int nxt = cur | v;
        // 不修改 s[i]
        int ans = Integer.bitCount(nxt) > k
                ? dfs(i + 1, v, t) + 1
                : dfs(i + 1, nxt, t);
        // 修改 s[i](t == 1 表示还有一次机会)
        if (t > 0) {
            for (int j = 0; j < 26; j++) {
                if (j == (s.charAt(i) - 'a')) {
                    continue;
                }
                nxt = cur | (1 << j);
                if (Integer.bitCount(nxt) > k) {
                    ans = Math.max(ans, dfs(i + 1, 1 << j, 0) + 1);
                } else {
                    ans = Math.max(ans, dfs(i + 1, nxt, 0));
                }
            }
        }
        memo.put(key, ans);
        return ans;
    }

    // ---------- 解法二:暴力枚举修改 + 贪心模拟(对照) ----------
    public int maxPartitionsAfterOperationsBrute(String s, int k) {
        int n = s.length();
        int best = 0;
        // 情况 1:不修改任何字符
        best = Math.max(best, simulate(s, k));
        // 情况 2:修改位置 i 为任意字符(与原来不同才有意义,但枚举 26 种全试)
        for (int i = 0; i < n; i++) {
            char orig = s.charAt(i);
            for (char ch = 'a'; ch <= 'z'; ch++) {
                if (ch == orig) {
                    continue;
                }
                char[] arr = s.toCharArray();
                arr[i] = ch;
                best = Math.max(best, simulate(new String(arr), k));
                if (best == n) {
                    return best; // 上限
                }
            }
        }
        return best;
    }

    // 模拟贪心分割:每次取最长前缀,使其不同字符数 <= k
    private int simulate(String t, int k) {
        int parts = 0;
        int i = 0;
        int n = t.length();
        while (i < n) {
            int mask = 0;
            int j = i;
            while (j < n) {
                int bit = 1 << (t.charAt(j) - 'a');
                if (Integer.bitCount(mask | bit) > k) {
                    break;
                }
                mask |= bit;
                j++;
            }
            parts++;
            if (j == i) {
                // 单个字符超过 k(k>=1 不会发生)
                return parts + n - i - 1;
            }
            i = j;
        }
        return parts;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.maxPartitionsAfterOperations("accca", 2) == 3, "3003 例1");
        check(s.maxPartitionsAfterOperations("aabaab", 3) == 1, "3003 例2");
        check(s.maxPartitionsAfterOperations("xxyz", 1) == 4, "3003 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 200; t++) {
            int len = 1 + rnd.nextInt(10);
            StringBuilder sb = new StringBuilder();
            int alpha = 1 + rnd.nextInt(4);
            for (int i = 0; i < len; i++) {
                sb.append((char) ('a' + rnd.nextInt(alpha)));
            }
            int kk = 1 + rnd.nextInt(4);
            int m1 = s.maxPartitionsAfterOperations(sb.toString(), kk);
            int m2 = s.maxPartitionsAfterOperationsBrute(sb.toString(), kk);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 s=" + sb + " k=" + kk + " 主=" + m1 + " 对照=" + m2);
                break;
            }
        }
        check(allOk, "3003 随机对拍");
        System.out.println("3003 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

时间复杂度 O(n * 2^26 的最坏情况被剪枝,实际远小于),空间复杂度 O(n * 状态数)。

  • 时间复杂度:O(n * 26 * 状态数)(状态数受不同前缀段限制,实际运行很快)
  • 空间复杂度:O(n * 状态数)

3004. Maximum Subtree of the Same Color(相同颜色的最大子树)

题目描述

给定一个二维整数数组 edges,表示一个有 n 个节点的树,节点编号从 0 到 n - 1,以节点 0 为根,

其中 edges[i] = `ui`, `vi` 表示节点 ui 和 vi 之间存在一条边。

还给定一个下标从 0 开始、大小为 n 的整数数组 colors,其中 colors[i] 表示节点 i 分配的颜色。

我们希望找到一个节点 v,使得 v 的子树中的每个节点具有相同的颜色。

返回具有尽可能多节点且符合上述要求的子树大小。

示例 1

复制代码
edges = [[0,1],[0,2],[0,3]], colors = [1,1,2,3] -> 1

示例 2

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

示例 3

复制代码
edges = [[0,1],[0,2],[2,3],[2,4]], colors = [1,2,3,3,3] -> 3(以节点 2 为根的子树)

提示:

  • n == edges.length + 1
  • 1 <= n <= 5 * 10^4
  • colors.length == n,1 <= colors[i] <= 10^5
  • 输入保证 edges 构成一棵树

解题思路

解法一:DFS 统计子树信息,主提交版本

建邻接表后从根 0 做后序遍历。对每个节点 u 统计其子树:

  • sizeu:子树大小;
  • allSameu:子树中所有节点颜色是否全等于 colorsu。
    若 u 的所有孩子节点都 allSame 且这些颜色的值都等于 colorsu,则 u 的整棵子树同色,用 sizeu 更新答案。
    否则 u 的子树不同色(置 allSame=false),答案由子树中的同色块大小决定(递归中已统计)。
    时间复杂度 O(n),空间复杂度 O(n)。
    解法二:换根/全局统计,对照
    先用一次 DFS 收集每个"同色连通块"的大小(颜色相同的相邻节点连成块),
    再考虑"子树限制":只有当整块恰好是以某节点为根的子树时才能计入。
    对拍时直接枚举每个节点 v,独立递归计算 v 子树是否同色并取最大,复杂度 O(n^2)(仅用于小数据校验)。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {
    private List<Integer>[] g;
    private int[] colors;
    private int ans;

    // ---------- 解法一:DFS(主提交版本) ----------
    public int maximumSubtreeSize(int[][] edges, int[] colors) {
        int n = colors.length;
        this.colors = colors;
        this.ans = 0;
        g = new List[n];
        for (int i = 0; i < n; i++) {
            g[i] = new ArrayList<>();
        }
        for (int[] e : edges) {
            g[e[0]].add(e[1]);
            g[e[1]].add(e[0]);
        }
        dfs(0, -1);
        return ans;
    }

    // 返回子树大小;若子树全色为 colors[u],返回大小,否则返回 -size(标记不同色)
    private int dfs(int u, int parent) {
        int size = 1;
        boolean same = true;
        for (int v : g[u]) {
            if (v == parent) {
                continue;
            }
            int sub = dfs(v, u);
            size += Math.abs(sub);
            if (sub < 0 || colors[v] != colors[u]) {
                same = false;
            }
        }
        if (same) {
            ans = Math.max(ans, size);
            return size;
        }
        return -size;
    }

    // ---------- 解法二:枚举根暴力(对照,O(n^2) 仅小数据) ----------
    public int maximumSubtreeSizeBrute(int[][] edges, int[] colors) {
        int n = colors.length;
        this.colors = colors;
        this.ans = 0;
        g = new List[n];
        for (int i = 0; i < n; i++) {
            g[i] = new ArrayList<>();
        }
        for (int[] e : edges) {
            g[e[0]].add(e[1]);
            g[e[1]].add(e[0]);
        }
        // 枚举每个节点作为根,独立验证其子树是否同色(以 0 为根树中的父节点为边界)
        int[] parent = new int[n];
        Arrays.fill(parent, -1);
        dfsParent(0, -1, parent);
        for (int root = 0; root < n; root++) {
            int[] cnt = countSubtree(root, parent[root], colors[root]);
            if (cnt[0] == cnt[1]) {
                ans = Math.max(ans, cnt[0]);
            }
        }
        return ans;
    }

    private void dfsParent(int u, int p, int[] parent) {
        for (int v : g[u]) {
            if (v != p) {
                parent[v] = u;
                dfsParent(v, u, parent);
            }
        }
    }

    private void dfsOrder(int u, int p, List<Integer> order) {
        order.add(u);
        for (int v : g[u]) {
            if (v != p) {
                dfsOrder(v, u, order);
            }
        }
    }

    // 返回 [子树大小, 子树中颜色==color 的个数]
    private int[] countSubtree(int u, int p, int color) {
        int size = 1, same = (colors[u] == color) ? 1 : 0;
        for (int v : g[u]) {
            if (v != p) {
                int[] sub = countSubtree(v, u, color);
                size += sub[0];
                same += sub[1];
            }
        }
        return new int[]{size, same};
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.maximumSubtreeSize(new int[][]{{0, 1}, {0, 2}, {0, 3}}, new int[]{1, 1, 2, 3}) == 1, "3004 例1");
        check(s.maximumSubtreeSize(new int[][]{{0, 1}, {0, 2}, {0, 3}}, new int[]{1, 1, 1, 1}) == 4, "3004 例2");
        check(s.maximumSubtreeSize(new int[][]{{0, 1}, {0, 2}, {2, 3}, {2, 4}}, new int[]{1, 2, 3, 3, 3}) == 3, "3004 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            int n = 1 + rnd.nextInt(8);
            int[][] edges = new int[n - 1][2];
            int[] colors = new int[n];
            for (int i = 1; i < n; i++) {
                int p = rnd.nextInt(i);
                edges[i - 1][0] = p;
                edges[i - 1][1] = i;
            }
            for (int i = 0; i < n; i++) {
                colors[i] = 1 + rnd.nextInt(3);
            }
            int m1 = s.maximumSubtreeSize(edges, colors);
            int m2 = s.maximumSubtreeSizeBrute(edges, colors);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 edges=" + Arrays.deepToString(edges) + " colors=" + Arrays.toString(colors) + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3004 随机对拍");
        System.out.println("3004 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3005. Count Elements With Maximum Frequency(最大频率元素计数)

题目描述

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

返回数组 nums 中所有具有最大频率的元素的 总频率。

元素的频率是指该元素在数组中出现的次数。

示例 1

复制代码
nums = [1,2,2,3,1,4] -> 4(元素 1 和 2 频率为 2,均为最大频率,总频率 2+2=4)

示例 2

复制代码
nums = [1,2,3,4,5] -> 5(所有元素频率都为 1)

提示:

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

解题思路

解法一:单次遍历统计最大值频率,主提交版本

用 HashMap 统计每个数频率,同时维护当前最大频率 mx:

若某数频率超过 mx,则更新 mx 并把累积和重置为该频率;

若相等则累加。最终返回累积和。

注意:当有多个元素达到最大频率时累积的是频率而非个数。

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

解法二:两遍统计,对照

第一遍统计完所有频率并求出最大频率,第二遍累加所有频率等于最大值元素的总频率。

逻辑等价,独立实现交叉验证。

复杂度:

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

代码实现

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

public class Solution {
    // ---------- 解法一:单次遍历(主提交版本) ----------
    public int maxFrequencyElements(int[] nums) {
        int[] cnt = new int[101];
        int mx = 0, ans = 0;
        for (int x : nums) {
            cnt[x]++;
            if (cnt[x] > mx) {
                mx = cnt[x];
                ans = cnt[x];
            } else if (cnt[x] == mx) {
                ans += cnt[x];
            }
        }
        return ans;
    }

    // ---------- 解法二:两遍统计(对照) ----------
    public int maxFrequencyElementsTwo(int[] nums) {
        Map<Integer, Integer> cnt = new HashMap<>();
        for (int x : nums) {
            cnt.put(x, cnt.getOrDefault(x, 0) + 1);
        }
        int mx = 0;
        for (int v : cnt.values()) {
            mx = Math.max(mx, v);
        }
        int ans = 0;
        for (int v : cnt.values()) {
            if (v == mx) {
                ans += v;
            }
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.maxFrequencyElements(new int[]{1, 2, 2, 3, 1, 4}) == 4, "3005 例1");
        check(s.maxFrequencyElements(new int[]{1, 2, 3, 4, 5}) == 5, "3005 例2");
        check(s.maxFrequencyElements(new int[]{1}) == 1, "3005 单元素");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 500; t++) {
            int n = 1 + rnd.nextInt(20);
            int[] nums = new int[n];
            for (int i = 0; i < n; i++) {
                nums[i] = 1 + rnd.nextInt(10);
            }
            int m1 = s.maxFrequencyElements(nums);
            int m2 = s.maxFrequencyElementsTwo(nums);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 主=" + m1 + " 对照=" + m2);
                break;
            }
        }
        check(allOk, "3005 随机对拍");
        System.out.println("3005 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3006. Find Beautiful Indices in the Given Array I(找出数组中的美丽下标 I)

题目描述

给你一个下标从 0 开始的字符串 s、字符串 a、字符串 b 和一个整数 k。

如果下标 i 满足以下条件,则认为它是一个美丽下标:

  • 0 <= i <= s.length - a.length
  • s[i..(i + a.length - 1)] == a
  • 存在下标 j 使得 0 <= j <= s.length - b.length,s`j`...(`j` + `b.length` - 1) == b,且 |j - i| <= k
    以数组形式按从小到大排序返回美丽下标。

示例 1

复制代码
s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15 -> [16,33]

示例 2

复制代码
s = "abcd", a = "a", b = "a", k = 4 -> [0]

提示:

  • 1 <= k <= s.length <= 10^5
  • 1 <= a.length, b.length <= 10
  • s、a、b 只包含小写英文字母

解题思路

解法一:KMP 求出现位置 + 二分判定,主提交版本

  1. 用 KMP 求出 a 在 s 中的全部起始下标列表 pa,b 的起始下标列表 pb;
  2. 对每个 pai,在 pb 中二分查找最接近 pai 的位置,若存在与 pai 距离 <= k 的 pbj,则 pai 是美丽下标。
    时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。
    解法二:双重循环朴素匹配,对照
    直接枚举每个位置用 startsWith 判断 a/b 是否出现(数据量小时可行),
    再对每个 a 出现位置遍历 b 出现位置判定距离,作为对照验证。
    复杂度:
  • 时间复杂度:O(|s| + |pa| * log|pb|)
  • 空间复杂度:O(|s|)

代码实现

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

public class Solution {
    // ---------- 解法一:KMP + 二分(主提交版本) ----------
    public List<Integer> beautifulIndices(String s, String a, String b, int k) {
        List<Integer> pa = kmp(s, a);
        List<Integer> pb = kmp(s, b);
        List<Integer> ans = new ArrayList<>();
        for (int i : pa) {
            // 二分找 pb 中最接近 i 的位置
            int idx = lowerBound(pb, i);
            boolean ok = false;
            if (idx < pb.size() && Math.abs(pb.get(idx) - i) <= k) {
                ok = true;
            }
            if (idx > 0 && Math.abs(pb.get(idx - 1) - i) <= k) {
                ok = true;
            }
            if (ok) {
                ans.add(i);
            }
        }
        return ans;
    }

    private List<Integer> kmp(String s, String p) {
        List<Integer> res = new ArrayList<>();
        int m = p.length();
        int[] pi = new int[m];
        for (int i = 1; i < m; i++) {
            int j = pi[i - 1];
            while (j > 0 && p.charAt(i) != p.charAt(j)) {
                j = pi[j - 1];
            }
            if (p.charAt(i) == p.charAt(j)) {
                j++;
            }
            pi[i] = j;
        }
        int j = 0;
        for (int i = 0; i < s.length(); i++) {
            while (j > 0 && s.charAt(i) != p.charAt(j)) {
                j = pi[j - 1];
            }
            if (s.charAt(i) == p.charAt(j)) {
                j++;
            }
            if (j == m) {
                res.add(i - m + 1);
                j = pi[j - 1];
            }
        }
        return res;
    }

    private int lowerBound(List<Integer> list, int target) {
        int lo = 0, hi = list.size();
        while (lo < hi) {
            int mid = (lo + hi) >>> 1;
            if (list.get(mid) < target) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        return lo;
    }

    // ---------- 解法二:朴素双重循环(对照) ----------
    public List<Integer> beautifulIndicesBrute(String s, String a, String b, int k) {
        List<Integer> pa = new ArrayList<>();
        List<Integer> pb = new ArrayList<>();
        for (int i = 0; i + a.length() <= s.length(); i++) {
            if (s.startsWith(a, i)) {
                pa.add(i);
            }
        }
        for (int i = 0; i + b.length() <= s.length(); i++) {
            if (s.startsWith(b, i)) {
                pb.add(i);
            }
        }
        List<Integer> ans = new ArrayList<>();
        for (int i : pa) {
            for (int j : pb) {
                if (Math.abs(j - i) <= k) {
                    ans.add(i);
                    break;
                }
            }
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.beautifulIndices("isawsquirrelnearmysquirrelhouseohmy", "my", "squirrel", 15).equals(Arrays.asList(16, 33)), "3006 例1");
        check(s.beautifulIndices("abcd", "a", "a", 4).equals(Arrays.asList(0)), "3006 例2");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            int len = 1 + rnd.nextInt(30);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < len; i++) {
                sb.append((char) ('a' + rnd.nextInt(3)));
            }
            int al = 1 + rnd.nextInt(3);
            int bl = 1 + rnd.nextInt(3);
            StringBuilder sa = new StringBuilder();
            StringBuilder sb2 = new StringBuilder();
            for (int i = 0; i < al; i++) sa.append((char) ('a' + rnd.nextInt(3)));
            for (int i = 0; i < bl; i++) sb2.append((char) ('a' + rnd.nextInt(3)));
            int kk = 1 + rnd.nextInt(10);
            List<Integer> m1 = s.beautifulIndices(sb.toString(), sa.toString(), sb2.toString(), kk);
            List<Integer> m2 = s.beautifulIndicesBrute(sb.toString(), sa.toString(), sb2.toString(), kk);
            if (!m1.equals(m2)) {
                allOk = false;
                System.out.println("对拍失败 s=" + sb + " a=" + sa + " b=" + sb2 + " k=" + kk + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3006 随机对拍");
        System.out.println("3006 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。

  • 时间复杂度:O(|s| + |pa| * log|pb|)
  • 空间复杂度:O(|s|)

3007. Maximum Number That Sum of the Prices Is Less Than or Equal to K(价值和小于等于 K 的最大数字)

题目描述

给你一个整数 k 和一个整数 x。整数 num 的价值是它的二进制表示中在 x,2x,3x 等位置处设置位的数目

(第 1 位是最低有效位)。num 的累加价值是从 1 到 num 的数字的总价值。

如果 num 的累加价值小于或等于 k,则 num 是廉价的。返回最大的廉价数字。

示例 1

复制代码
k = 9, x = 1 -> 6(1 到 6 的累加价值是 9,7 到 12 超了)

示例 2

复制代码
k = 7, x = 2 -> 9

提示:

  • 1 <= k <= 10^15
  • 1 <= x <= 8

解题思路

解法一:二分答案 + 按位统计,主提交版本

对候选 num,计算 1...num 的总价值(每个数字在 x, 2x, 3x... 这些位上 1 的个数累加)。

第 bit 位(从 1 开始计)在 1, n 中出现 1 的次数可用周期公式 O(1) 求出:

cycle = 2^bit,每个完整周期贡献 cycle 个 1,余数部分贡献 max(0, rem - cycle)。

总价值随 num 单调不减,因此二分最大的 num 使总价值 <= k。

上界从 1 倍增到总价值超过 k 即可,最多约 60 轮。

时间复杂度 O(log k * log k)(约 60 个位 × 60 轮二分),空间复杂度 O(1)。

解法二:暴力累加模拟,对照

对每个数字 n 直接数它二进制中 x, 2x, ... 位上的 1 的个数并累加,

找到使累加价值首次超过 k 的前一个数字(小数据可用),作为对照验证。

复杂度:

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

代码实现

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

public class Solution {
    private int x;

    // ---------- 解法一:二分 + 按位统计(主提交版本) ----------
    public long findMaximumNumber(long k, int x) {
        this.x = x;
        long lo = 1, hi = 1;
        // 倍增找上界:总价值 > k
        while (totalValue(hi) <= k) {
            hi <<= 1;
            if (hi > (1L << 62)) {
                break;
            }
        }
        // 二分最大 num 使 totalValue(num) <= k
        while (lo < hi) {
            long mid = lo + (hi - lo + 1) / 2;
            if (totalValue(mid) <= k) {
                lo = mid;
            } else {
                hi = mid - 1;
            }
        }
        return lo;
    }

    // 1..n 中 x, 2x, 3x, ... 位为 1 的总个数
    private long totalValue(long n) {
        long ans = 0;
        for (int bit = x; bit <= 62; bit += x) {
            ans += countOnes(n, bit);
            if (ans > Long.MAX_VALUE / 2) {
                break;
            }
        }
        return ans;
    }

    // [1, n] 中第 bit 位(从 1 开始,最低位为第 1 位)为 1 的数字个数
    private long countOnes(long n, int bit) {
        long step = 1L << (bit - 1);   // 一个半周期长度 2^(bit-1)
        long cycle = 1L << bit;        // 完整周期 2^bit
        long total = n + 1;            // 统计 0..n
        long full = total / cycle;
        long rem = total % cycle;
        long cnt = full * step;
        if (rem > step) {
            cnt += rem - step;
        }
        return cnt;
    }

    // ---------- 解法二:暴力逐数统计(对照,小数据) ----------
    public long findMaximumNumberBrute(long k, int x) {
        long acc = 0;
        long num = 1;
        while (true) {
            acc += valueOf(num, x);
            if (acc > k) {
                return num - 1;
            }
            num++;
        }
    }

    private long valueOf(long num, int x) {
        long cnt = 0;
        for (int bit = x; bit <= 62; bit += x) {
            if ((num & (1L << (bit - 1))) != 0) {
                cnt++;
            }
        }
        return cnt;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.findMaximumNumber(9, 1) == 6, "3007 例1");
        check(s.findMaximumNumber(7, 2) == 9, "3007 例2");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            long k = 1 + rnd.nextInt(2000);
            int x = 1 + rnd.nextInt(4);
            long m1 = s.findMaximumNumber(k, x);
            long m2 = s.findMaximumNumberBrute(k, x);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 k=" + k + " x=" + x + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3007 随机对拍");
        System.out.println("3007 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

时间复杂度 O(log k * log k)(约 60 个位 × 60 轮二分),空间复杂度 O(1)。

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

3008. Find Beautiful Indices in the Given Array II(找出数组中的美丽下标 II)

题目描述

给你一个下标从 0 开始的字符串 s、字符串 a、字符串 b 和一个整数 k。

如果下标 i 满足以下条件,则认为它是一个美丽下标:

  • 0 <= i <= s.length - a.length
  • s[i..(i + a.length - 1)] == a
  • 存在下标 j 使得 0 <= j <= s.length - b.length,s`j`...(`j` + `b.length` - 1) == b,且 |j - i| <= k
    以数组形式按从小到大排序返回美丽下标。

示例 1

复制代码
s = "isawsquirrelnearmysquirrelhouseohmy", a = "my", b = "squirrel", k = 15 -> [16,33]

示例 2

复制代码
s = "abcd", a = "a", b = "a", k = 4 -> [0]

提示:

  • 1 <= k <= s.length <= 5 * 10^5
  • 1 <= a.length, b.length <= 5 * 10^5
  • s、a、b 只包含小写英文字母

解题思路

解法一:KMP 求出现位置 + 二分判定,主提交版本

  1. 用 KMP 求出 a 在 s 中的全部起始下标列表 pa,b 的起始下标列表 pb;
  2. 对每个 pai,在 pb 中二分查找最接近 pai 的位置,若存在与 pai 距离 <= k 的 pbj,则 pai 是美丽下标。
    时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。
    解法二:双重循环朴素匹配,对照
    直接枚举每个位置用 startsWith 判断 a/b 是否出现(数据量小时可行),
    再对每个 a 出现位置遍历 b 出现位置判定距离,作为对照验证。
    复杂度:
  • 时间复杂度:O(|s| + |pa| * log|pb|)
  • 空间复杂度:O(|s|)

代码实现

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

public class Solution {
    // ---------- 解法一:KMP + 二分(主提交版本) ----------
    public List<Integer> beautifulIndices(String s, String a, String b, int k) {
        List<Integer> pa = kmp(s, a);
        List<Integer> pb = kmp(s, b);
        List<Integer> ans = new ArrayList<>();
        for (int i : pa) {
            // 二分找 pb 中最接近 i 的位置
            int idx = lowerBound(pb, i);
            boolean ok = false;
            if (idx < pb.size() && Math.abs(pb.get(idx) - i) <= k) {
                ok = true;
            }
            if (idx > 0 && Math.abs(pb.get(idx - 1) - i) <= k) {
                ok = true;
            }
            if (ok) {
                ans.add(i);
            }
        }
        return ans;
    }

    private List<Integer> kmp(String s, String p) {
        List<Integer> res = new ArrayList<>();
        int m = p.length();
        int[] pi = new int[m];
        for (int i = 1; i < m; i++) {
            int j = pi[i - 1];
            while (j > 0 && p.charAt(i) != p.charAt(j)) {
                j = pi[j - 1];
            }
            if (p.charAt(i) == p.charAt(j)) {
                j++;
            }
            pi[i] = j;
        }
        int j = 0;
        for (int i = 0; i < s.length(); i++) {
            while (j > 0 && s.charAt(i) != p.charAt(j)) {
                j = pi[j - 1];
            }
            if (s.charAt(i) == p.charAt(j)) {
                j++;
            }
            if (j == m) {
                res.add(i - m + 1);
                j = pi[j - 1];
            }
        }
        return res;
    }

    private int lowerBound(List<Integer> list, int target) {
        int lo = 0, hi = list.size();
        while (lo < hi) {
            int mid = (lo + hi) >>> 1;
            if (list.get(mid) < target) {
                lo = mid + 1;
            } else {
                hi = mid;
            }
        }
        return lo;
    }

    // ---------- 解法二:朴素双重循环(对照) ----------
    public List<Integer> beautifulIndicesBrute(String s, String a, String b, int k) {
        List<Integer> pa = new ArrayList<>();
        List<Integer> pb = new ArrayList<>();
        for (int i = 0; i + a.length() <= s.length(); i++) {
            if (s.startsWith(a, i)) {
                pa.add(i);
            }
        }
        for (int i = 0; i + b.length() <= s.length(); i++) {
            if (s.startsWith(b, i)) {
                pb.add(i);
            }
        }
        List<Integer> ans = new ArrayList<>();
        for (int i : pa) {
            for (int j : pb) {
                if (Math.abs(j - i) <= k) {
                    ans.add(i);
                    break;
                }
            }
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.beautifulIndices("isawsquirrelnearmysquirrelhouseohmy", "my", "squirrel", 15).equals(Arrays.asList(16, 33)), "3008 例1");
        check(s.beautifulIndices("abcd", "a", "a", 4).equals(Arrays.asList(0)), "3008 例2");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            int len = 1 + rnd.nextInt(30);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < len; i++) {
                sb.append((char) ('a' + rnd.nextInt(3)));
            }
            int al = 1 + rnd.nextInt(3);
            int bl = 1 + rnd.nextInt(3);
            StringBuilder sa = new StringBuilder();
            StringBuilder sb2 = new StringBuilder();
            for (int i = 0; i < al; i++) sa.append((char) ('a' + rnd.nextInt(3)));
            for (int i = 0; i < bl; i++) sb2.append((char) ('a' + rnd.nextInt(3)));
            int kk = 1 + rnd.nextInt(10);
            List<Integer> m1 = s.beautifulIndices(sb.toString(), sa.toString(), sb2.toString(), kk);
            List<Integer> m2 = s.beautifulIndicesBrute(sb.toString(), sa.toString(), sb2.toString(), kk);
            if (!m1.equals(m2)) {
                allOk = false;
                System.out.println("对拍失败 s=" + sb + " a=" + sa + " b=" + sb2 + " k=" + kk + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3008 随机对拍");
        System.out.println("3008 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

时间复杂度 O(|s| + |pa| log |pb|),空间复杂度 O(|s|)。

  • 时间复杂度:O(|s| + |pa| * log|pb|)
  • 空间复杂度:O(|s|)

3009. Maximum Number of Intersections on the Chart(折线图上的最大交点数量)

题目描述

有一条由 n 个点连接而成的折线图。给定一个下标从 1 开始的整数数组 y,第 k 个点的坐标是 (k, y[k])。

图中没有水平线,即没有两个相邻的点有相同的 y 坐标。

假设在图中任意画一条无限长的水平线。请返回这条水平线与折线相交的最多交点数。

示例 1

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

示例 2

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

提示:

  • 2 <= y.length <= 10^5
  • 1 <= y[i] <= 10^9
  • 对于范围 1, `n` - 1 内的所有 i,都有 y[i] != y[i+1]

解题思路

解法一:差分数组按半整数刻度离散化,主提交版本

把每个线段 (yi-1, yi) 看成一个区间,水平线 y = h 与之相交当且仅当 h 严格落在该区间

两个端点之间(开区间)。为了处理半整数(如 y = 1.5),把所有 y 值乘以 2 映射到整数刻度:

线段 (a, b) 对应整数区间 (2min(a,b), 2 max(a,b)),水平线 y = h 对应刻度 2h;

若 2h 严格落在区间内则相交。

用差分数组对每个线段的整数区间 +1,最后前缀和求最大值。

注意端点重合(折线拐点)不能重复计数------用开区间 (l, r) 处理(r 端不 +1 或 l 端 +1、r 端 -1)。

由于 y 值范围大,用 TreeMap 做离散化差分(只在端点处修改)。

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

解法二:枚举半整数值逐段判定,对照

折线最多有 n 个转折点,交点数变化只可能发生在经过某个端点或半整数点时。

枚举所有候选 y 值(每个 yi、yi-0.5、yi+0.5),对每个值逐段判断是否相交取最大作对照。

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

复杂度:

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

代码实现

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

public class Solution {
    // ---------- 解法一:离散化差分(主提交版本) ----------
    public int maxIntersectionCount(int[] y) {
        int n = y.length;
        // 线段 i(连接 y[i-1] 和 y[i])在 2 倍刻度下的开区间 (2*min, 2*max)
        // 水平线高度 h 的刻度是 2h,落在开区间内即相交
        TreeMap<Long, Integer> diff = new TreeMap<>();
        for (int i = 1; i < n; i++) {
            long lo = 2L * Math.min(y[i - 1], y[i]);
            long hi = 2L * Math.max(y[i - 1], y[i]);
            diff.merge(lo + 1, 1, Integer::sum);   // 开区间左端点 +1
            diff.merge(hi, -1, Integer::sum);       // 开区间右端点(不含)-1
        }
        int cur = 0, ans = 0;
        for (int v : diff.values()) {
            cur += v;
            ans = Math.max(ans, cur);
        }
        return ans;
    }

    // ---------- 解法二:枚举候选高度逐段判定(对照) ----------
    public int maxIntersectionCountBrute(int[] y) {
        // 候选高度集合:每个端点的 y,以及 y±0.5(用 2 倍整数表示)
        java.util.Set<Long> cand = new java.util.TreeSet<>();
        for (int v : y) {
            cand.add(2L * v);
            cand.add(2L * v - 1);
            cand.add(2L * v + 1);
        }
        int n = y.length;
        int best = 0;
        for (long h2 : cand) {
            int cnt = 0;
            for (int i = 1; i < n; i++) {
                long lo = 2L * Math.min(y[i - 1], y[i]);
                long hi = 2L * Math.max(y[i - 1], y[i]);
                if (h2 > lo && h2 < hi) {
                    cnt++;
                }
            }
            best = Math.max(best, cnt);
        }
        return best;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.maxIntersectionCount(new int[]{1, 2, 1, 2, 1, 3, 2}) == 5, "3009 例1");
        check(s.maxIntersectionCount(new int[]{2, 1, 3, 4, 5}) == 2, "3009 例2");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 500; t++) {
            int n = 2 + rnd.nextInt(7);
            int[] y = new int[n];
            y[0] = 1 + rnd.nextInt(6);
            for (int i = 1; i < n; i++) {
                do {
                    y[i] = 1 + rnd.nextInt(6);
                } while (y[i] == y[i - 1]);
            }
            int m1 = s.maxIntersectionCount(y);
            int m2 = s.maxIntersectionCountBrute(y);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 y=" + java.util.Arrays.toString(y) + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3009 随机对拍");
        System.out.println("3009 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

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

3010. Divide an Array Into Subarrays With Minimum Cost I(将数组分成最小总代价的子数组 I)

题目描述

给你一个长度为 n 的整数数组 nums。一个数组的代价是它的第一个元素。

你需要将 nums 分成 3 个连续且没有交集的子数组。

请你返回这些子数组的最小代价总和。

示例 1

复制代码
nums = [1,2,3,12] -> 6([1]、[2]、[3,12] 代价 1+2+3)

示例 2

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

示例 3

复制代码
nums = [10,3,1,1] -> 12([10,3]、[1]、[1])

提示:

  • 3 <= n <= 50
  • 1 <= nums[i] <= 50

解题思路

解法一:首元素 + 剩余最小两数,主提交版本

第一个子数组必须以 nums0 开头(且第一个元素必为第一个子数组的代价)。

为使总代价最小,让第一个子数组尽量短。

实际上最优方案一定是:nums\[0] 单独一段,再在 nums1...n-1 中选最小的两个数各开一段。

因为代价就是每段首元素,想让后两段代价最小,就挑剩余最小的两个数。

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

解法二:枚举分割点暴力,对照

枚举两个分割点 i、j(1 <= i < j <= n-1),计算 nums0 + numsi + numsj 取最小。

时间复杂度 O(n^2),用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {
    // ---------- 解法一:首元素 + 剩余最小两数(主提交版本) ----------
    public int minimumCost(int[] nums) {
        int a = nums[0];
        int b = Integer.MAX_VALUE, c = Integer.MAX_VALUE;
        for (int i = 1; i < nums.length; i++) {
            if (nums[i] < b) {
                c = b;
                b = nums[i];
            } else if (nums[i] < c) {
                c = nums[i];
            }
        }
        return a + b + c;
    }

    // ---------- 解法二:枚举分割点(对照) ----------
    public int minimumCostBrute(int[] nums) {
        int n = nums.length;
        int ans = Integer.MAX_VALUE;
        for (int i = 1; i <= n - 2; i++) {
            for (int j = i + 1; j <= n - 1; j++) {
                ans = Math.min(ans, nums[0] + nums[i] + nums[j]);
            }
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.minimumCost(new int[]{1, 2, 3, 12}) == 6, "3010 例1");
        check(s.minimumCost(new int[]{5, 4, 3}) == 12, "3010 例2");
        check(s.minimumCost(new int[]{10, 3, 1, 1}) == 12, "3010 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 500; t++) {
            int n = 3 + rnd.nextInt(8);
            int[] nums = new int[n];
            for (int i = 0; i < n; i++) {
                nums[i] = 1 + rnd.nextInt(50);
            }
            int m1 = s.minimumCost(nums);
            int m2 = s.minimumCostBrute(nums);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 " + Arrays.toString(nums) + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3010 随机对拍");
        System.out.println("3010 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

时间复杂度 O(n^2),用于交叉验证。

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

3011. Find if Array Can Be Sorted(判断一个数组是否可以变为有序)

题目描述

给你一个下标从 0 开始的整数数组 nums。在一步操作中,你可以交换数组中两个相邻元素,

前提是这两个元素二进制表示中 1 的个数相同(set bits 数量相同)。

请你返回能否通过若干次操作将数组变为有序(非递减)。

示例 1

复制代码
nums = [8,4,2,30,15] -> true

示例 2

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

示例 3

复制代码
nums = [3,16,8,4,2] -> false

提示:

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

解题思路

解法一:按 set bit 分组,主提交版本

能交换的只有 set bit 数量相同的元素。把数组按连续的相同 set bit 划成若干"块",

块内元素可以任意重排;但不同块之间不能交换。

因此只需检查:前一块的最大值 <= 后一块的最小值(模拟每块内排序后的衔接)。

若存在前块最大值 > 后块最小值,则无法整体有序。

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

解法二:暴力模拟冒泡,对照

直接用冒泡排序逻辑:只要相邻且 set bit 相同且前者 > 后者就交换,

反复扫描直到不能再交换,最后检查是否整体非递减。

时间复杂度 O(n^2),用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {
    // ---------- 解法一:按 set bit 分组(主提交版本) ----------
    public boolean canSortArray(int[] nums) {
        int n = nums.length;
        int preMax = 0;
        int i = 0;
        while (i < n) {
            int bits = Integer.bitCount(nums[i]);
            int j = i;
            int mi = nums[i], mx = nums[i];
            while (j + 1 < n && Integer.bitCount(nums[j + 1]) == bits) {
                j++;
                mi = Math.min(mi, nums[j]);
                mx = Math.max(mx, nums[j]);
            }
            if (preMax > mi) {
                return false;
            }
            preMax = mx;
            i = j + 1;
        }
        return true;
    }

    // ---------- 解法二:冒泡模拟(对照) ----------
    public boolean canSortArrayBrute(int[] nums) {
        int[] a = nums.clone();
        int n = a.length;
        boolean changed = true;
        while (changed) {
            changed = false;
            for (int i = 0; i + 1 < n; i++) {
                if (a[i] > a[i + 1] && Integer.bitCount(a[i]) == Integer.bitCount(a[i + 1])) {
                    int t = a[i];
                    a[i] = a[i + 1];
                    a[i + 1] = t;
                    changed = true;
                }
            }
        }
        for (int i = 0; i + 1 < n; i++) {
            if (a[i] > a[i + 1]) {
                return false;
            }
        }
        return true;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.canSortArray(new int[]{8, 4, 2, 30, 15}), "3011 例1");
        check(s.canSortArray(new int[]{1, 2, 3, 4, 5}), "3011 例2");
        check(!s.canSortArray(new int[]{3, 16, 8, 4, 2}), "3011 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 500; t++) {
            int n = 1 + rnd.nextInt(10);
            int[] nums = new int[n];
            for (int i = 0; i < n; i++) {
                nums[i] = 1 + rnd.nextInt(255);
            }
            boolean m1 = s.canSortArray(nums);
            boolean m2 = s.canSortArrayBrute(nums);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 " + Arrays.toString(nums) + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3011 随机对拍");
        System.out.println("3011 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

时间复杂度 O(n^2),用于交叉验证。

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

3012. Minimize Length of Array Using Operations(通过操作使数组长度最小)

题目描述

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

你的任务是通过进行以下操作任意次(可以是 0 次)最小化 nums 的长度:

  • 在 nums 中选择两个不同下标 i 和 j,满足 nums[i] > 0 且 nums[j] > 0;
  • 将结果 nums[i] % nums[j] 插入 nums 的结尾;
  • 将 nums 中下标为 i 和 j 的元素删除。
    返回进行任意次操作以后 nums 的最小长度。

示例 1

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

示例 2

复制代码
nums = [5,5,5,10,5] -> 2

示例 3

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

提示:

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

解题思路

解法一:最小值分类,主提交版本

设数组最小值为 mi。

  • 若存在某个 numsi % mi != 0:该数 x 满足 x % mi != 0,则 gcd(x, mi) 也可能不为 1,
    但更本质的结论是:只要存在 x % mi != 0,就有办法通过 x % mi 生成一个更小的正数(< mi),
    使新的最小值更小......官方结论:若存在 x % mi != 0,则答案恒为 1;
  • 否则(所有数都能被 mi 整除):每次操作消耗两个数,生成 0,而 0 不能再参与取模产生更小的正数,
    所以只有 mi 们两两配对删除,答案为 (cnt_mi + 1) / 2。
    原理:所有数都能被 mi 整除时,任意取模结果要么是 0 要么是 mi 的倍数,
    若选出的两个数不同(比如 mi 和 2mi),mi % 2mi = mi(不变)、2mi % mi = 0。
    最优策略是每次用两个 mi 配对产生 0,最终只剩 ceil(cnt/2) 个 mi。
    时间复杂度 O(n),空间复杂度 O(1)。
    解法二:贪心模拟对拍,对照
    小数据下直接模拟:不断寻找可配对(gcd > 1)的一对数删除,优先删除能导致最短长度的方案,
    用 DFS/回溯穷举(数据量限制 <= 8),取最短最终长度作为对照。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {
    // ---------- 解法一:最小值分类(主提交版本) ----------
    public int minimumArrayLength(int[] nums) {
        int mi = Integer.MAX_VALUE;
        for (int x : nums) {
            mi = Math.min(mi, x);
        }
        for (int x : nums) {
            if (x % mi != 0) {
                return 1;
            }
        }
        int cnt = 0;
        for (int x : nums) {
            if (x == mi) {
                cnt++;
            }
        }
        return (cnt + 1) / 2;
    }

    // ---------- 解法二:回溯模拟(对照,小型数据) ----------
    public int minimumArrayLengthBrute(int[] nums) {
        java.util.List<Integer> arr = new java.util.ArrayList<>();
        for (int x : nums) {
            arr.add(x);
        }
        return dfs(arr);
    }

    private int dfs(java.util.List<Integer> arr) {
        // 收集可选的正数下标
        java.util.List<Integer> pos = new java.util.ArrayList<>();
        for (int i = 0; i < arr.size(); i++) {
            if (arr.get(i) > 0) {
                pos.add(i);
            }
        }
        if (pos.size() < 2) {
            return arr.size();
        }
        int best = arr.size();
        for (int a = 0; a < pos.size(); a++) {
            for (int b = a + 1; b < pos.size(); b++) {
                int i = pos.get(a), j = pos.get(b);
                // i、j 有序:两种顺序都试(nums[i]%nums[j] 与 nums[j]%nums[i])
                for (int k = 0; k < 2; k++) {
                    int vi = k == 0 ? i : j;
                    int vj = k == 0 ? j : i;
                    int val = arr.get(vi) % arr.get(vj);
                    java.util.List<Integer> next = new java.util.ArrayList<>(arr);
                    int hi = Math.max(i, j), lo = Math.min(i, j);
                    next.remove(hi);
                    next.remove(lo);
                    next.add(val);
                    best = Math.min(best, dfs(next));
                }
            }
        }
        return best;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.minimumArrayLength(new int[]{1, 4, 3, 1}) == 1, "3012 例1");
        check(s.minimumArrayLength(new int[]{5, 5, 5, 10, 5}) == 2, "3012 例2");
        check(s.minimumArrayLength(new int[]{2, 3, 4}) == 1, "3012 例3");
        check(s.minimumArrayLength(new int[]{1}) == 1, "3012 单元素");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            int n = 1 + rnd.nextInt(7);
            int[] nums = new int[n];
            for (int i = 0; i < n; i++) {
                nums[i] = 1 + rnd.nextInt(20);
            }
            int m1 = s.minimumArrayLength(nums);
            int m2 = s.minimumArrayLengthBrute(nums);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 " + Arrays.toString(nums) + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3012 随机对拍");
        System.out.println("3012 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3013. Divide an Array Into Subarrays With Minimum Cost II(将数组分成最小总代价的子数组 II)

题目描述

给你一个下标从 0 开始长度为 n 的整数数组 nums 和两个正整数 k 和 dist。

一个数组的代价是数组中的第一个元素。

你需要将 nums 分割成 k 个连续且互不相交的子数组,满足第二个子数组与第 k 个子数组中

第一个元素的下标距离不超过 dist。

返回这些子数组的最小总代价。

示例 1

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

示例 2

复制代码
nums = [10,1,2,2,2,1], k = 4, dist = 3 -> 15

示例 3

复制代码
nums = [10,8,18,9], k = 3, dist = 1 -> 36

提示:

  • 3 <= n <= 10^5
  • 1 <= nums[i] <= 10^9
  • 3 <= k <= n
  • k - 2 <= dist <= n - 2

解题思路

解法一:滑动窗口 + 对顶堆维护窗口最小 k-1 个,主提交版本

总代价 = nums0(第一个子数组首元素)+ 其余 k-1 个子数组的首元素之和。

设其余起点为 p1 < p2 < ... < p(k-1),题目约束等价于 p(k-1) - p1 <= dist,

即这些起点全部落在某个长度为 dist+1 的窗口内。

因此枚举窗口左端点 w(w 从 1 到 n-dist-1),窗口覆盖下标 w, w+dist,

取窗口内最小的 k-1 个数之和,与 nums0 相加取最小。

用两个堆(或 TreeMap)维护窗口内最小 k-1 个元素的和:

  • 大顶堆 l 存窗口内最小的 k-1 个;小顶堆 r 存其余;
  • 滑动窗口时添加右端、删除左端、调整两堆平衡,保持 l 恰好 k-1 个。
    时间复杂度 O(n log dist),空间复杂度 O(dist)。
    解法二:枚举窗口排序求和,对照
    对小数据,直接枚举每个窗口左端点 w,把窗口内元素排序取最小的 k-1 个求和,
    与 nums0 相加取最小。O(n * dist log dist),仅用于交叉验证。
    复杂度:
  • 时间复杂度:O(n log dist)
  • 空间复杂度:O(dist)

代码实现

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

public class Solution {
    // ---------- 解法一:对顶堆滑动窗口(主提交版本) ----------
    public long minimumCost(int[] nums, int k, int dist) {
        int n = nums.length;
        int need = k - 1; // 除 nums[0] 外还需选 need 个起点,窗口大小 dist+1
        // l 大顶堆:窗口内最小的 need 个;r 小顶堆:其余
        java.util.TreeMap<Integer, Integer> l = new java.util.TreeMap<>();
        java.util.TreeMap<Integer, Integer> r = new java.util.TreeMap<>();
        long sumL = 0;
        int sizeL = 0;

        // 初始窗口 [1, dist+1]
        for (int i = 1; i <= dist + 1 && i < n; i++) {
            l.merge(nums[i], 1, Integer::sum);
            sumL += nums[i];
            sizeL++;
        }
        while (sizeL > need) {
            int mx = l.lastKey();
            dec(l, mx);
            sumL -= mx;
            sizeL--;
            r.merge(mx, 1, Integer::sum);
        }
        long ans = (long) nums[0] + sumL;

        // 滑动窗口:左端 i-dist-1 移出,右端 i 加入
        for (int i = dist + 2; i < n; i++) {
            int out = nums[i - dist - 1];
            if (r.containsKey(out)) {
                dec(r, out);
            } else if (l.containsKey(out)) {
                dec(l, out);
                sumL -= out;
                sizeL--;
                // 从 r 补一个到 l
                if (!r.isEmpty()) {
                    int mn = r.firstKey();
                    dec(r, mn);
                    l.merge(mn, 1, Integer::sum);
                    sumL += mn;
                    sizeL++;
                }
            }
            int in = nums[i];
            if (sizeL < need) {
                l.merge(in, 1, Integer::sum);
                sumL += in;
                sizeL++;
            } else if (!l.isEmpty() && in < l.lastKey()) {
                int mx = l.lastKey();
                dec(l, mx);
                sumL -= mx;
                r.merge(mx, 1, Integer::sum);
                l.merge(in, 1, Integer::sum);
                sumL += in;
                sizeL++;
            } else {
                r.merge(in, 1, Integer::sum);
            }
            ans = Math.min(ans, (long) nums[0] + sumL);
        }
        return ans;
    }

    private void dec(TreeMap<Integer, Integer> m, int key) {
        int c = m.get(key);
        if (c == 1) {
            m.remove(key);
        } else {
            m.put(key, c - 1);
        }
    }

    // ---------- 解法二:枚举窗口排序(对照,小数据) ----------
    public long minimumCostBrute(int[] nums, int k, int dist) {
        int n = nums.length;
        int need = k - 1;
        long ans = Long.MAX_VALUE;
        for (int w = 1; w + dist <= n - 1; w++) {
            int[] win = new int[dist + 1];
            int idx = 0;
            for (int j = w; j <= w + dist && j < n; j++) {
                win[idx++] = nums[j];
            }
            Arrays.sort(win, 0, idx);
            long sum = nums[0];
            for (int t = 0; t < need; t++) {
                sum += win[t];
            }
            ans = Math.min(ans, sum);
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.minimumCost(new int[]{1, 3, 2, 6, 4, 2}, 3, 3) == 5, "3013 例1");
        check(s.minimumCost(new int[]{10, 1, 2, 2, 2, 1}, 4, 3) == 15, "3013 例2");
        check(s.minimumCost(new int[]{10, 8, 18, 9}, 3, 1) == 36, "3013 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            int n = 4 + rnd.nextInt(8);
            int[] nums = new int[n];
            for (int i = 0; i < n; i++) {
                nums[i] = 1 + rnd.nextInt(50);
            }
            int k = 3 + rnd.nextInt((n - 3) + 1);
            int maxDist = n - 2;
            int minDist = k - 2;
            if (minDist > maxDist) continue;
            int dist = minDist + rnd.nextInt(maxDist - minDist + 1);
            long m1 = s.minimumCost(nums, k, dist);
            long m2 = s.minimumCostBrute(nums, k, dist);
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 nums=" + Arrays.toString(nums) + " k=" + k + " dist=" + dist + " 主=" + m1 + " 暴力=" + m2);
                break;
            }
        }
        check(allOk, "3013 随机对拍");
        System.out.println("3013 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3014. Minimum Number of Pushes to Type Word I(输入单词需要的最少按键次数 I)

题目描述

给你一个字符串 word,由不同小写英文字母组成。

电话键盘上的按键 2~9 可以重新映射到不同字母集合,每个按键可映射任意数量的字母,

但每个字母必须恰好映射到一个按键上。输入 word 时,字母在按键上的位置决定按键次数

(第 1 个字母按 1 次,第 2 个按 2 次......)。

返回重新映射按键后输入 word 所需的最少按键次数。

示例 1

复制代码
word = "abcde" -> 5(5 个字母各在 5 个按键首位)

示例 2

复制代码
word = "xycdefghij" -> 12

提示:

  • 1 <= word.length <= 26
  • word 仅由小写英文字母组成,所有字母互不相同

解题思路

解法一:均匀分配到 8 个按键,主提交版本

只有 8 个按键(2~9)。每个字母互不相同、出现次数均为 1,输入总成本只取决于每个字母

在按键上的"槽位"(第 1 槽成本 1、第 2 槽成本 2......)。

最优策略:把字母尽量均匀地放进 8 个按键的第 1 槽(8 个成本 1),多余字母放入第 2 槽,

以此类推。总成本 = 前 8 个成本 1 ×1 + 次 8 个成本 2 ×2 + ...

简洁公式:对 0 <= i < len,成本为 i/8 + 1,累加。

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

解法二:逐槽分配枚举,对照

模拟"往 8 个按键里轮流放字母":第 t 轮(从 1 开始)放 min(8, 剩余) 个字母,

每个成本 t,累加。与解法一公式等价,逻辑独立重写验证。

复杂度:

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

代码实现

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

public class Solution {
    // ---------- 解法一:公式累加(主提交版本) ----------
    public int minimumPushes(String word) {
        int n = word.length();
        int ans = 0;
        for (int i = 0; i < n; i++) {
            ans += i / 8 + 1;
        }
        return ans;
    }

    // ---------- 解法二:轮流分配模拟(对照) ----------
    public int minimumPushesBrute(String word) {
        int n = word.length();
        int ans = 0;
        int turn = 1;
        while (n > 0) {
            int put = Math.min(8, n);
            ans += turn * put;
            n -= put;
            turn++;
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.minimumPushes("abcde") == 5, "3014 例1");
        check(s.minimumPushes("xycdefghij") == 12, "3014 例2");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 500; t++) {
            int len = 1 + rnd.nextInt(26);
            int m1 = s.minimumPushes("abcdefghijklmnopqrstuvwxyz".substring(0, len));
            int m2 = s.minimumPushesBrute("abcdefghijklmnopqrstuvwxyz".substring(0, len));
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 len=" + len + " 主=" + m1 + " 对照=" + m2);
                break;
            }
        }
        check(allOk, "3014 随机对拍");
        System.out.println("3014 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3015. Count the Number of Houses at a Certain Distance I(按距离统计房屋对数目 I)

题目描述

给你三个正整数 n、x 和 y。在城市中,存在编号从 1 到 n 的房屋,由 n 条街道相连。

对所有 1 <= i < n,都存在一条街道连接编号为 i 的房屋与编号为 i+1 的房屋。

另存在一条街道连接编号为 x 的房屋与编号为 y 的房屋。

对于每个 k(1 <= k <= n),找出所有满足要求的房屋对 `house1`, `house2`,

即从 house1 到 house2 需要经过的最少街道数为 k。

返回下标从 1 开始且长度为 n 的数组 result,result[k] 表示距离恰好为 k 的房屋对数量

(无向,house1 != house2,每对按两个方向各计一次)。

示例 1

复制代码
n = 3, x = 1, y = 3 -> [6,0,0]

示例 2

复制代码
n = 5, x = 2, y = 4 -> [10,8,2,0,0]

示例 3

复制代码
n = 4, x = 1, y = 1 -> [6,4,2,0]

提示:

  • 2 <= n <= 100
  • 1 <= x, y <= n

解题思路

解法一:从每个起点 BFS/直接算最短路,主提交版本

图结构:1-2-...-n 的链 + 一条额外边 (x, y)。

对每对 (i, j)(i < j),最短路 = min(|i-j|, |i-x|+1+|y-j|, |i-y|+1+|x-j|),

距离 d 计入 resultd,每对贡献 2(两个方向)。

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

解法二:BFS 全源,对照

建邻接表(链 + 额外边),从每个起点做 BFS 求到所有点的最短路,

统计每个距离的出现次数(只计 i<j 避免重复)。逻辑等价,独立实现验证。

复杂度:

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

代码实现

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

public class Solution {
    // ---------- 解法一:公式最短路(主提交版本) ----------
    public int[] countOfPairs(int n, int x, int y) {
        int[] ans = new int[n];
        for (int i = 1; i <= n; i++) {
            for (int j = i + 1; j <= n; j++) {
                int d = Math.abs(i - j);
                d = Math.min(d, Math.abs(i - x) + 1 + Math.abs(j - y));
                d = Math.min(d, Math.abs(i - y) + 1 + Math.abs(j - x));
                ans[d - 1] += 2;
            }
        }
        return ans;
    }

    // ---------- 解法二:BFS(对照) ----------
    public int[] countOfPairsBfs(int n, int x, int y) {
        int[] ans = new int[n];
        for (int s = 1; s <= n; s++) {
            int[] dist = new int[n + 1];
            Arrays.fill(dist, -1);
            java.util.ArrayDeque<Integer> q = new java.util.ArrayDeque<>();
            dist[s] = 0;
            q.add(s);
            while (!q.isEmpty()) {
                int u = q.poll();
                for (int v : neighbors(u, n, x, y)) {
                    if (dist[v] == -1) {
                        dist[v] = dist[u] + 1;
                        q.add(v);
                    }
                }
            }
            for (int t = s + 1; t <= n; t++) {
                ans[dist[t] - 1] += 2;
            }
        }
        return ans;
    }

    private int[] neighbors(int u, int n, int x, int y) {
        int[] res = new int[4];
        int cnt = 0;
        if (u > 1) res[cnt++] = u - 1;
        if (u < n) res[cnt++] = u + 1;
        if (u == x && y != u) res[cnt++] = y;
        if (u == y && x != u) res[cnt++] = x;
        return java.util.Arrays.copyOf(res, cnt);
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(Arrays.equals(s.countOfPairs(3, 1, 3), new int[]{6, 0, 0}), "3015 例1");
        check(Arrays.equals(s.countOfPairs(5, 2, 4), new int[]{10, 8, 2, 0, 0}), "3015 例2");
        check(Arrays.equals(s.countOfPairs(4, 1, 1), new int[]{6, 4, 2, 0}), "3015 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 300; t++) {
            int n = 2 + rnd.nextInt(12);
            int x = 1 + rnd.nextInt(n);
            int y = 1 + rnd.nextInt(n);
            int[] m1 = s.countOfPairs(n, x, y);
            int[] m2 = s.countOfPairsBfs(n, x, y);
            if (!Arrays.equals(m1, m2)) {
                allOk = false;
                System.out.println("对拍失败 n=" + n + " x=" + x + " y=" + y + " 主=" + Arrays.toString(m1) + " 暴力=" + Arrays.toString(m2));
                break;
            }
        }
        check(allOk, "3015 随机对拍");
        System.out.println("3015 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3016. Minimum Number of Pushes to Type Word II(输入单词需要的最少按键次数 II)

题目描述

给你一个字符串 word,由小写英文字母组成(可重复)。

电话键盘上的按键 2~9 可以重新映射到不同字母集合,每个按键可映射任意数量的字母,

但每个字母必须恰好映射到一个按键上。输入 word 时,字母在按键上的位置决定按键次数

(按键上第 1 个字母按 1 次、第 2 个按 2 次......)。

返回重新映射按键后输入 word 所需的最少按键次数。

示例 1

复制代码
word = "abcde" -> 5

示例 2

复制代码
word = "xyzxyzxyzxyz" -> 12

示例 3

复制代码
word = "aabbccddeeffgghhiiiiii" -> 24

提示:

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

解题思路

解法一:频率贪心,主提交版本

总按键次数 = sum(某字母出现次数 * 该字母所在槽位)。

出现次数越多的字母应该放在越便宜的槽位(第 1 槽成本 1,第 2 槽成本 2......)。

求出 26 个字母出现频率并降序排序,依次分配槽位:第 i 个字母(0 基)成本 i/8 + 1。

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

解法二:分组累加,对照

相同逻辑不同写法:按 (i/8+1) 分组累加 cnt26-i-1,与解法一等价,独立重写验证。

复杂度:

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

代码实现

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

public class Solution {
    // ---------- 解法一:频率贪心(主提交版本) ----------
    public int minimumPushes(String word) {
        int[] cnt = new int[26];
        for (int i = 0; i < word.length(); i++) {
            cnt[word.charAt(i) - 'a']++;
        }
        Arrays.sort(cnt);
        int ans = 0;
        // cnt 升序,从高频到低频分配槽位
        for (int i = 0; i < 26; i++) {
            ans += (i / 8 + 1) * cnt[25 - i];
        }
        return ans;
    }

    // ---------- 解法二:分组累加(对照) ----------
    public int minimumPushesGroup(String word) {
        int[] cnt = new int[26];
        for (int i = 0; i < word.length(); i++) {
            cnt[word.charAt(i) - 'a']++;
        }
        int ans = 0;
        int turn = 1;
        int used = 0;
        for (int c = 25; c >= 0; c--) {
            if (cnt[c] == 0) {
                continue; // 不出现的字母不占槽位
            }
            if (used == 8) {
                turn++;
                used = 0;
            }
            ans += turn * cnt[c];
            used++;
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(s.minimumPushes("abcde") == 5, "3016 例1");
        check(s.minimumPushes("xyzxyzxyzxyz") == 12, "3016 例2");
        check(s.minimumPushes("aabbccddeeffgghhiiiiii") == 24, "3016 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 500; t++) {
            int len = 1 + rnd.nextInt(60);
            StringBuilder sb = new StringBuilder();
            int alpha = 1 + rnd.nextInt(8);
            for (int i = 0; i < len; i++) {
                sb.append((char) ('a' + rnd.nextInt(alpha)));
            }
            int m1 = s.minimumPushes(sb.toString());
            int m2 = s.minimumPushesGroup(sb.toString());
            if (m1 != m2) {
                allOk = false;
                System.out.println("对拍失败 word=" + sb + " 主=" + m1 + " 对照=" + m2);
                break;
            }
        }
        check(allOk, "3016 随机对拍");
        System.out.println("3016 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3017. Count the Number of Houses at a Certain Distance II(按距离统计房屋对数目 II)

题目描述

给你三个正整数 n、x 和 y。在城市中,存在编号从 1 到 n 的房屋,由 n 条街道相连。

对所有 1 <= i < n,都存在一条街道连接编号为 i 的房屋与编号为 i+1 的房屋。

另存在一条街道连接编号为 x 的房屋与编号为 y 的房屋。

对于每个 k(1 <= k <= n),找出所有满足要求的房屋对 `house1`, `house2`,

即从 house1 到 house2 需要经过的最少街道数为 k。

返回下标从 1 开始且长度为 n 的数组 result(无向,每对按两个方向各计一次)。

示例 1

复制代码
n = 3, x = 1, y = 3 -> [6,0,0]

示例 2

复制代码
n = 5, x = 2, y = 4 -> [10,8,2,0,0]

示例 3

复制代码
n = 4, x = 1, y = 1 -> [6,4,2,0]

提示:

  • 2 <= n <= 10^5
  • 1 <= x, y <= n

解题思路

解法一:差分数组按起点批量贡献,主提交版本

图的本质是链条 1~n 加上额外边 (a, b)(a=min(x,y),b=max(x,y)),形成环状结构。

若 a == b 则图为纯链;否则从 a 到 b 存在"沿链"与"沿额外边+反链"两条路径,构成环。

对每个起点 i,它到环上左右两侧点的最短路分布满足对称性:

  • 两侧点直线距离随 |i-j| 线性增长,先按直链距离全量 +1;
  • 环内的点可通过额外边缩短距离,用第二/第三项把缩短量折算进差分;
  • 越界超过环边界 n 与边界 1 的部分用 -1 消去,环内"折返"点用两项修正。
    每个 i 只做常数次 O(1) 区间更新,最后对差分数组前缀和即得到每个距离的出现次数。
    时间复杂度 O(n),空间复杂度 O(n)。
    解法二:双重循环最短路(对照)
    直接对每对 (i, j)(i < j)套用 3015 的最短路公式
    d = min(|i-j|, |i-x|+1+|j-y|, |i-y|+1+|j-x|),ansd-1 += 2。
    复杂度 O(n^2),仅用于小 n 交叉验证。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {
    // ---------- 解法一:差分数组(主提交版本) ----------
    public long[] countOfPairs(int n, int x, int y) {
        int a = Math.min(x, y) - 1;  // 0 基
        int b = Math.max(x, y) - 1;
        if (a > b) {
            int t = a;
            a = b;
            b = t;
        }
        long[] diff = new long[n];
        for (int i = 0; i < n; i++) {
            diff[0] += 2; // 每个起点两侧各 +1 的"基座",配合下面修正得到距离分布
            // 右侧(编号 > i)经额外边缩短
            int cut1 = Math.min(Math.abs(i - a), Math.abs(i - b) + 1);
            if (cut1 < n) diff[cut1] += 1;
            int cut2 = Math.min(Math.abs(i - b), Math.abs(i - a) + 1);
            if (cut2 < n) diff[cut2] += 1;
            // 越过环边界(1 与 n)的部分要消掉
            int cut3 = Math.min(Math.abs(i - 0), Math.abs(i - b) + 1 + Math.abs(a - 0));
            if (cut3 < n) diff[cut3] -= 1;
            int cut4 = Math.min(Math.abs(i - (n - 1)), Math.abs(i - a) + 1 + Math.abs(b - (n - 1)));
            if (cut4 < n) diff[cut4] -= 1;
            // 环内折返点(中位对称)修正
            int cut5 = Math.max(a - i, 0) + Math.max(i - b, 0) + ((b - a) + 0) / 2;
            if (cut5 < n) diff[cut5] -= 1;
            int cut6 = Math.max(a - i, 0) + Math.max(i - b, 0) + ((b - a) + 1) / 2;
            if (cut6 < n) diff[cut6] -= 1;
        }
        long[] ans = new long[n];
        long cur = 0;
        for (int d = 0; d < n; d++) {
            cur += diff[d];
            ans[d] = cur;
        }
        return ans;
    }

    // ---------- 解法二:双重循环最短路(对照) ----------
    public long[] countOfPairsBrute(int n, int x, int y) {
        long[] ans = new long[n];
        for (int i = 1; i <= n; i++) {
            for (int j = i + 1; j <= n; j++) {
                int d = Math.abs(i - j);
                d = Math.min(d, Math.abs(i - x) + 1 + Math.abs(j - y));
                d = Math.min(d, Math.abs(i - y) + 1 + Math.abs(j - x));
                ans[d - 1] += 2;
            }
        }
        return ans;
    }

    // ---------- 本地自测 ----------
    public static void main(String[] args) {
        Solution s = new Solution();
        check(Arrays.equals(s.countOfPairs(3, 1, 3), new long[]{6, 0, 0}), "3017 例1");
        check(Arrays.equals(s.countOfPairs(5, 2, 4), new long[]{10, 8, 2, 0, 0}), "3017 例2");
        check(Arrays.equals(s.countOfPairs(4, 1, 1), new long[]{6, 4, 2, 0}), "3017 例3");

        Random rnd = new Random(311);
        boolean allOk = true;
        for (int t = 0; t < 500; t++) {
            int n = 2 + rnd.nextInt(25);
            int x = 1 + rnd.nextInt(n);
            int y = 1 + rnd.nextInt(n);
            long[] m1 = s.countOfPairs(n, x, y);
            long[] m2 = s.countOfPairsBrute(n, x, y);
            if (!Arrays.equals(m1, m2)) {
                allOk = false;
                System.out.println("对拍失败 n=" + n + " x=" + x + " y=" + y);
                System.out.println("  主=" + Arrays.toString(m1));
                System.out.println("  暴=" + Arrays.toString(m2));
                break;
            }
        }
        check(allOk, "3017 随机对拍");
        System.out.println("3017 all tests done");
    }

    static void check(boolean ok, String name) {
        System.out.println((ok ? "PASS " : "FAIL ") + name);
    }
}

复杂度分析

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

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

3018. Maximum Number of Removal Queries That Can Be Processed I(可处理的最大删除操作数 I 🔒)

题目描述

给定一个下标从 0 开始的数组 nums 和一个下标从 0 开始的数组 queries。

你可以在开始时执行以下操作最多一次:用 nums 的子序列替换 nums。

我们以给定的 queries 顺序处理查询;对于 queries[i],我们执行以下操作:

  • 如果 nums 的第一个和最后一个元素都小于 queries[i],则查询处理结束;
  • 否则,从 nums 中选择第一个或最后一个元素,要求其大于或等于 queries[i],然后将其从 nums 中删除。
    返回通过以最佳方式执行该操作可以处理的最多次数。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= nums.length <= 1000
  • 1 <= queries.length <= 1000
  • 1 <= nums[i], queries[i] <= 10^9

解题思路

解法一:区间 DP,主提交版本

每次删除都发生在剩余连续区间的左端或右端,因此"处理了若干查询后剩余的部分"

始终是 nums 的一个连续子区间 i, j。开始时可以用子序列替换 nums,等价于可以

从任意初始区间 i, j(0 <= i <= j < n)开始。

定义 fij = 剩余区间为 i, j 时,已经(最多)处理掉的查询数量。

于是区间 i, j 的下一个待处理查询是 queriesf\[ij]:

  • 若 i > 0,从 i-1, j 删掉左端 numsi-1 可得到 i, j;
    令 pre = fi-1j,若 pre < m 且 numsi-1 >= queriespre 则可多处理 1 个,
    即 fij 用 pre + 1 更新(同时保留 pre 本身作为"停在这里"的下界);
  • 若 j+1 < n,同理从 i, j+1 删掉右端得到 i, j,
    fij 用 fij+1 + 1(若可删)更新。
    用"能删则删"的取最大方式松弛,得到的 fij 即剩余区间为 i,j 时的最大已处理数。
    最终答案:对每个单元素区间 i, i,尝试处理最后一个查询
    fii + (numsi >= queriesf\[ii] ? 1 : 0),取最大。
    时间复杂度 O(n^2),空间复杂度 O(n^2)。
    解法二:枚举初始子序列 + 回溯搜索(对照)
    开始时可用 nums 的任意子序列替换 nums,因此用二进制掩码枚举所有非空子序列,
    对每个子序列递归模拟处理:状态为 (剩余区间 l, r, 已处理查询数 t),每次从左端
    或右端删除一个满足 queriest 的元素,或直接放弃,取能处理的最大查询数。
    复杂度指数级,仅用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O(n^2)
  • 空间复杂度:O(n^2)

代码实现

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

public class Solution {

    // ---------- 解法一:区间 DP(主提交版本) ----------
    public int maximumProcessableQueries(int[] nums, int[] queries) {
        int n = nums.length;
        int m = queries.length;
        int[][] f = new int[n][n]; // f[i][j]: 剩余区间 [i,j] 时最多已处理的查询数
        for (int i = 0; i < n; ++i) {
            for (int j = n - 1; j >= i; --j) {
                if (i > 0) {
                    // 从 [i-1, j] 删掉左端 nums[i-1] 得到 [i, j]:
                    // 若 nums[i-1] 能满足下一个查询(queries[f[i-1][j]])则 +1
                    int pre = f[i - 1][j];
                    f[i][j] = Math.max(f[i][j],
                            pre + (pre < m && nums[i - 1] >= queries[pre] ? 1 : 0));
                }
                if (j + 1 < n) {
                    // 从 [i, j+1] 删掉右端 nums[j+1] 得到 [i, j]
                    int pre = f[i][j + 1];
                    f[i][j] = Math.max(f[i][j],
                            pre + (pre < m && nums[j + 1] >= queries[pre] ? 1 : 0));
                }
                if (f[i][j] == m) {
                    return m; // 所有查询都已处理
                }
            }
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            int t = f[i][i];
            ans = Math.max(ans, t + (t < m && nums[i] >= queries[t] ? 1 : 0));
        }
        return ans;
    }

    // ---------- 解法二:枚举初始子序列 + 回溯搜索(对照) ----------
    public int bruteForce(int[] nums, int[] queries) {
        int n = nums.length;
        int best = 0;
        // 开始时可用 nums 的任意子序列替换:用掩码枚举所有非空子序列
        for (int mask = 1; mask < (1 << n); ++mask) {
            int[] sub = new int[n];
            int len = 0;
            for (int i = 0; i < n; ++i) {
                if ((mask & (1 << i)) != 0) {
                    sub[len++] = nums[i];
                }
            }
            best = Math.max(best, dfs(sub, 0, len - 1, 0, queries));
        }
        return best;
    }

    // 模拟:剩余子序列为 sub[l..r],已处理 t 个查询,返回能处理的最大查询数
    private int dfs(int[] sub, int l, int r, int t, int[] queries) {
        int m = queries.length;
        if (t >= m) {
            return t;
        }
        if (l > r) {
            return t; // 区间已空,无法继续
        }
        int best = t;
        // 尝试删左端
        if (sub[l] >= queries[t]) {
            best = Math.max(best, dfs(sub, l + 1, r, t + 1, queries));
        }
        // 尝试删右端
        if (sub[r] >= queries[t]) {
            best = Math.max(best, dfs(sub, l, r - 1, t + 1, queries));
        }
        return best;
    }

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

        // 官方案例
        int[][] numss = {
            {1, 2, 3, 4, 5},
            {2, 3, 2},
            {3, 4, 3}
        };
        int[][] qss = {
            {1, 2, 3, 4, 6},
            {2, 2, 3},
            {4, 3, 2}
        };
        int[] expects = {4, 3, 2};
        for (int t = 0; t < numss.length; ++t) {
            int got = sol.maximumProcessableQueries(numss[t], qss[t]);
            int bf = sol.bruteForce(numss[t], qss[t]);
            System.out.println("Example " + (t + 1) + ": dp=" + got
                    + " brute=" + bf + " expected=" + expects[t]
                    + (got == expects[t] && bf == expects[t] ? " PASS" : " FAIL"));
        }

        // 随机对拍
        int trials = 500;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(7);
            int m = 1 + rnd.nextInt(7);
            int[] nums = new int[n];
            int[] queries = new int[m];
            for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(8);
            for (int i = 0; i < m; ++i) queries[i] = 1 + rnd.nextInt(8);
            int a = sol.maximumProcessableQueries(nums, queries);
            int b = sol.bruteForce(nums, queries);
            if (a != b) {
                fail++;
                System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                        + " queries=" + Arrays.toString(queries)
                        + " dp=" + a + " brute=" + b);
                if (fail > 5) break;
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 ? " ALL PASS" : " FAILED"));
    }
}

复杂度分析

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

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

3019. Number of Changing Keys(按键变更的次数)

题目描述

给你一个下标从 0 开始的字符串 s,该字符串由用户输入。按键变更的定义是:

使用与上次使用的按键不同的键。例如 s = "ab" 表示按键变更一次,而 s = "bBBb" 不存在按键变更。

返回用户输入过程中按键变更的次数。

注意:shift 或 caps lock 等修饰键不计入按键变更,也就是说,如果用户先输入字母 'a'

然后输入字母 'A',不算作按键变更。

示例 1

复制代码
s = "aAbBcC" -> 2

示例 2

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

提示:

  • 1 <= s.length <= 100
  • s 仅由英文大写字母和小写字母组成

解题思路

解法一:相邻比较,主提交版本

修饰键不计数,等价于只看字母本身,忽略大小写。从左到右扫描,把每个字符统一转成

小写(或大写)后与前一个比较,不同则计数 +1。每一对相邻字符独立判定,不依赖全局状态。

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

解法二:先归一化再遍历(对照)

先一次性把字符串转为小写,再遍历相邻位置计数。逻辑与解法一相同,仅在"何时转换大小写"

的处理上不同,用于交叉验证解题思路的一致性。

时间复杂度 O(n),空间复杂度 O(n)(需要小写副本)。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:相邻比较(主提交版本) ----------
    public int countKeyChanges(String s) {
        int ans = 0;
        char prev = Character.toLowerCase(s.charAt(0));
        for (int i = 1; i < s.length(); ++i) {
            char cur = Character.toLowerCase(s.charAt(i));
            if (cur != prev) {
                ++ans;
            }
            prev = cur;
        }
        return ans;
    }

    // ---------- 解法二:先归一化再遍历(对照) ----------
    public int countKeyChanges2(String s) {
        String lower = s.toLowerCase();
        int ans = 0;
        for (int i = 1; i < lower.length(); ++i) {
            if (lower.charAt(i) != lower.charAt(i - 1)) {
                ++ans;
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[] cases = {"aAbBcC", "AaAaAaaA", "ab", "bBBb", "a", "AAAA", "AaBbCcDd", "aAbBcCdDeEfF"};
        int[] expects = {2, 0, 1, 0, 0, 0, 3, 5};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.countKeyChanges(cases[i]);
            int b = sol.countKeyChanges2(cases[i]);
            boolean ok = (a == expects[i]) && (b == expects[i]);
            allPass &= ok;
            System.out.println("s=\"" + cases[i] + "\" -> " + a + " / brute=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }

        // 随机测试(两个解法互相校验)
        Random rnd = new Random(7);
        int trials = 2000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int len = 1 + rnd.nextInt(12);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < len; ++i) {
                char c = (char) ('a' + rnd.nextInt(26));
                if (rnd.nextBoolean()) c = Character.toUpperCase(c);
                sb.append(c);
            }
            String s = sb.toString();
            int a = sol.countKeyChanges(s);
            int b = sol.countKeyChanges2(s);
            if (a != b) {
                fail++;
                System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
                if (fail > 5) break;
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

时间复杂度 O(n),空间复杂度 O(n)(需要小写副本)。

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

3020. Find the Maximum Number of Elements in Subset(子集中元素的最大数量)

题目描述

给你一个正整数数组 nums。你需要从数组中选出一个满足下述条件的子集:

你可以将选中的元素放置在一个下标从 0 开始的数组中,并使其遵循以下模式:

`x`, `x`\^2, `x`\^4, ..., `x`\^(`k`/2), `x`\^`k`, `x`\^(`k`/2), ..., `x`\^4, `x`\^2, `x`

(注意,k 可以是任何非负的 2 的幂)。例如,2, 4, 16, 4, 2 和 3, 9, 3 都符合这一模式,

而 2, 4, 8, 4, 2 则不符合。

返回满足这些条件的子集中,元素数量的最大值。

示例 1

复制代码
nums = [5,4,1,2,2] -> 3(子集 {4,2,2} -> [2,4,2])

示例 2

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

提示:

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

解题思路

解法一:哈希计数 + 平方链,主提交版本

一个数若大于 1,则连续平方会严格递增(x -> x^2 -> x^4 -> ...),因此除 1 外

数字的平方链不会出现环,链的长度至多为 log log 级别。用 HashMap 统计每个数的出现次数。

对每个数 x(x > 1)从它开始不断平方,只要下一个数在计数表中且出现次数 >= 2,就继续

前进(每步贡献 2 个元素,链两端各一个);当无法继续时,若链当前到达的数的计数 >= 1,

还可以在尾部放一个"单个元素"(链中点的单个副本),总长再 +1。

对于 x = 1:模式为 1,1,1,...,链只能由若干个 1 组成,长度为 cnt1;

若 cnt1 为奇数则正好为 cnt1,为偶数则需取 cnt1-1(形成对称回文,中间必须是奇数个)。

对所有 x 取最大。

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

解法二:枚举起点模拟平方链(对照)

与解法一相同思路,但不用"跳链"累积,而是直接从每个候选起点出发,逐次平方并

用计数器累加可放置的个数,统计最长链。为求独立验证,用朴素方式复制计数表并

每次对单个起点计算,避免共享状态,作为交叉验证。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:哈希计数 + 平方链(主提交版本) ----------
    public int maximumLength(int[] nums) {
        Map<Long, Integer> cnt = new HashMap<>();
        for (int x : nums) {
            cnt.merge((long) x, 1, Integer::sum);
        }
        // 处理 1:全 1 链只能是 1,1,...,1,回文中间必须是奇数,奇数个 1 取全部、偶数个取 cnt-1
        Integer t = cnt.remove(1L);
        int ans = t == null ? 0 : t - (1 - t % 2);
        for (long x : cnt.keySet()) {
            t = 0;
            // 沿平方链前进:x, x^2, x^4, ...,每个中间值需要出现 >= 2 次(两端各一)
            while (cnt.getOrDefault(x, 0) > 1) {
                x = x * x; // x <= 1e9 时 x^2 <= 1e18 不会溢出 long
                t += 2;
            }
            // 链尾(峰值)只需出现 1 次;若该值不存在说明多走了一步,把多算的 2 减成 1
            t += cnt.getOrDefault(x, -1);
            ans = Math.max(ans, t);
        }
        return ans;
    }

    // ---------- 解法二:按峰值逐级验证链(对照) ----------
    public int maximumLength2(int[] nums) {
        Map<Long, Integer> cnt = new HashMap<>();
        for (int x : nums) {
            cnt.merge((long) x, 1, Integer::sum);
        }
        Integer c1 = cnt.get(1L);
        int ans = c1 == null ? 0 : c1 - (1 - c1 % 2);
        for (long root : cnt.keySet()) {
            if (root == 1L) continue;
            // 枚举链的峰值级数 p:模式 [x, x^2, ..., x^(2^p), ..., x^2, x],长度 2p+1
            for (int p = 0; ; ++p) {
                long v = root;
                boolean ok = true;
                for (int idx = 0; idx <= p; ++idx) {
                    // 端点 x 与中间对称元素各需 2 份,峰值(中心)只需 1 份
                    int need = (idx == p) ? 1 : 2;
                    if (cnt.getOrDefault(v, 0) < need) {
                        ok = false;
                        break;
                    }
                    if (idx == p) break;
                    v = v * v;
                    if (v < 0) { // long 溢出
                        ok = false;
                        break;
                    }
                }
                if (!ok) break;
                ans = Math.max(ans, 2 * p + 1);
            }
        }
        return ans;
    }

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

        // 随机对拍(小值域 √ 链的数值控制)
        Random rnd = new Random(3);
        int trials = 2000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(10);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(9);
            int a = sol.maximumLength(nums);
            int b = sol.maximumLength2(nums);
            if (a != b) {
                fail++;
                System.out.println("MISMATCH " + java.util.Arrays.toString(nums)
                        + " a=" + a + " b=" + b);
                if (fail > 5) break;
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

  • 时间复杂度:O(n * log log MAX)
  • 空间复杂度:O(n)
相关推荐
山楂树の1 小时前
Java 字符串高效处理:StringBuilder、StringBuffer、StringJoiner
java·开发语言
.痞老板.3 小时前
java ee--文件操作和IO
java·java-ee
简 洁 冬冬3 小时前
分页「向上取整」公式 `(total + size - 1) / size` 的完整推导
java·分页
装不满的克莱因瓶5 小时前
【从零搭建】AI大模型之ReactAgent智能体对接MCP实战
java·人工智能·ai·springai·mcp·springaialibaba
SimonKing5 小时前
AI Assistant被"隐藏"了?别慌,IDEA 2026.3 这波是换了个脑子
java·后端·程序员
Resean02236 小时前
SpringMVC 6+源码分析(九)异常处理
java·spring·springmvc
geats人山人海6 小时前
现代c++4.1
java·开发语言·c++
下一站春风里7 小时前
Spring IoC 控制反转 完整技术笔记
java·spring boot·笔记·spring
挖掘狂人7 小时前
用户连点两次「确认支付」,你的后端凭什么只扣一次钱?
java·后端·面试