LeetCode3421~3440题目解析

LeetCode 3421-3440. 题解合集

文章目录


3421. Find Students Who Improved(查找进步的学生)

题目类型:数据库(SQL)

题目描述

表:Scores

复制代码
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| student_id  | int     |
| subject     | varchar |
| score       | int     |
| exam_date   | varchar |
+-------------+---------+

(student_id, subject, exam_date) 是此表的联合主键。表的每一行记录某学生在某门科目某次考试中的分数,score 在 0 到 100 之间(含端点)。

编写解决方案找出在相同科目上取得进步的学生。一个学生在某一科目上视为进步,需要同时满足:

  • 在该科目上至少参加两次考试(不同日期);
  • 该科目最近一次考试的分数高于其第一次考试的分数。

返回结果表包含 student_id、subject、first_score(首次分数)、latest_score(最近分数),按 student_id、subject 升序排序。

示例 1:

复制代码
输入:
Scores 表:
+------------+----------+-------+------------+
| student_id | subject  | score | exam_date  |
+------------+----------+-------+------------+
| 101        | Math     | 70    | 2023-01-15 |
| 101        | Math     | 85    | 2023-02-15 |
| 101        | Physics  | 65    | 2023-01-15 |
| 101        | Physics  | 60    | 2023-02-15 |
| 102        | Math     | 80    | 2023-01-15 |
| 102        | Math     | 85    | 2023-02-15 |
| 103        | Math     | 90    | 2023-01-15 |
| 104        | Physics  | 75    | 2023-01-15 |
| 104        | Physics  | 85    | 2023-02-15 |
+------------+----------+-------+------------+
输出:
+------------+----------+-------------+--------------+
| student_id | subject  | first_score | latest_score |
+------------+----------+-------------+--------------+
| 101        | Math     | 70          | 85           |
| 102        | Math     | 80          | 85           |
| 104        | Physics  | 75          | 85           |
+------------+----------+-------------+--------------+
解释:
101 的 Math 从 70 进步到 85;101 的 Physics 从 65 降到 60 不算;
102 的 Math 从 80 进步到 85;103 只考了一次,不符合条件;
104 的 Physics 从 75 进步到 85。

解题思路

题意拆成两步:取"每名学生每门科目最早/最晚两次考试"的分数,再比较大小。

解法一(推荐):FIRST_VALUE 双向窗口 + 分组过滤

直接对 (student_id, subject) 分区、按 exam_date 排序:

  • FIRST_VALUE(score) OVER (PARTITION BY student_id, subject ORDER BY exam_date) 拿到首次分数;
  • FIRST_VALUE(score) OVER (PARTITION BY student_id, subject ORDER BY exam_date DESC) 拿到最近分数。

外层按两列分组后取 MIN(first_score) < MAX(latest_score) 的行即为进步者。FIRST_VALUE 为每行都回填了首/末分数,分组后值不变,因此聚合取 MIN/MAX 无副作用,且只考一次的组 first_score = latest_score 自然被 HAVING 过滤。

解法二(对照):RANK() 正反序双计数

用 RANK() OVER (PARTITION BY ... ORDER BY exam_date) 把最早考试标记为 1,倒序窗口把最晚考试标记为 1,然后自连接取 r1 = 1 与 r2 = 1 的两行比较分数。写法较繁琐,但能直观校验"最早 vs 最晚"确实只取两行。

代码实现

sql 复制代码
-- 解法一(推荐):FIRST_VALUE 双向窗口 + 分组过滤
WITH scored AS (
    SELECT student_id, subject,
           FIRST_VALUE(score) OVER (PARTITION BY student_id, subject
                                    ORDER BY exam_date) AS first_score,
           FIRST_VALUE(score) OVER (PARTITION BY student_id, subject
                                    ORDER BY exam_date DESC) AS latest_score
    FROM Scores
)
SELECT student_id, subject, MIN(first_score) AS first_score, MIN(latest_score) AS latest_score
FROM scored
GROUP BY student_id, subject
HAVING MIN(first_score) < MAX(latest_score)
ORDER BY student_id, subject;

-- 解法二(对照):RANK 正反双序 + 自连接
WITH rk AS (
    SELECT *, RANK() OVER (PARTITION BY student_id, subject ORDER BY exam_date) AS r1,
              RANK() OVER (PARTITION BY student_id, subject ORDER BY exam_date DESC) AS r2
    FROM Scores
)
SELECT a.student_id, a.subject, a.score AS first_score, b.score AS latest_score
FROM rk a
JOIN rk b ON a.student_id = b.student_id AND a.subject = b.subject
WHERE a.r1 = 1 AND b.r2 = 1 AND a.r1 != a.r2
  AND a.score < b.score
ORDER BY a.student_id, a.subject;

复杂度分析

  • 时间复杂度 :O(n log n),其中 n 为 Scores 行数;窗口函数排序为瓶颈。
  • 空间复杂度 :O(n),窗口函数的中间排序结果与行数成正比。

3422. Minimum Operations to Make Subarray Elements Equal(将子数组元素变为相等所需的最小操作数 🔒)

题目描述

给定一个整数数组 nums 和一个整数 k。你可以进行任意次以下操作:

  • 给 nums 的任何元素增加或减少 1。
    返回确保至少 有一个大小为 k 的子数组的所有元素都相等所需的最小操作数。

示例 1

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

示例 2

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

提示:

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

解题思路

解法一:滑动窗口 + 两个平衡树维护中位数,主提交版本

使一段元素全部相等的开销最小化时,目标值取中位数 (元素个数为偶数时取任意

中间两个值之一)。滑动窗口维护当前 k 个元素:

  • 用两个 TreeMap(小顶堆侧 l 存较小一半、大顶堆侧 r 存较大一半,保持
    r.size - l.size <= 1)与两个段和 s1/s2 快速求中位数与开销。
  • 开销 = 中位数到所有元素的绝对距离和:
    mid * l.size - s1 + s2 - mid * r.size(中位数属于 r 侧)。
    窗口每步添加 numsi、移除 numsk 滑出元素。总复杂度 O(n log k)。
    解法二:暴力枚举窗口 + 求中位数(对照)
    对每个窗口 l, r,复制到临时数组排序取中位数,累加绝对差。O(n * k log k),仅本地小数据。
    复杂度:
  • 时间复杂度:O(n log k)
  • 空间复杂度:O(k)

代码实现

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

public class Solution {

    // ---------- 解法一:滑动窗口 + 双平衡树(主提交版本) ----------
    public long minOperations(int[] nums, int k) {
        TreeMap<Integer, Integer> l = new TreeMap<Integer, Integer>();
        TreeMap<Integer, Integer> r = new TreeMap<Integer, Integer>();
        long s1 = 0, s2 = 0;
        int sz1 = 0, sz2 = 0;
        long ans = Long.MAX_VALUE;
        for (int i = 0; i < nums.length; ++i) {
            // 插入到 l
            l.merge(nums[i], 1, Integer::sum);
            s1 += nums[i];
            ++sz1;
            // 平衡:把 l 的最大搬到 r
            int y = l.lastKey();
            if (l.merge(y, -1, Integer::sum) == 0) {
                l.remove(y);
            }
            s1 -= y;
            --sz1;
            r.merge(y, 1, Integer::sum);
            s2 += y;
            ++sz2;
            if (sz2 - sz1 > 1) {
                y = r.firstKey();
                if (r.merge(y, -1, Integer::sum) == 0) {
                    r.remove(y);
                }
                s2 -= y;
                --sz2;
                l.merge(y, 1, Integer::sum);
                s1 += y;
                ++sz1;
            }
            if (i >= k - 1) {
                // 中位数 = r.firstKey(sz2 >= sz1)
                long mid = r.firstKey();
                ans = Math.min(ans, mid * sz1 - s1 + s2 - mid * sz2);
                // 移除窗口最左元素
                int j = i - k + 1;
                if (r.containsKey(nums[j])) {
                    if (r.merge(nums[j], -1, Integer::sum) == 0) {
                        r.remove(nums[j]);
                    }
                    s2 -= nums[j];
                    --sz2;
                } else {
                    if (l.merge(nums[j], -1, Integer::sum) == 0) {
                        l.remove(nums[j]);
                    }
                    s1 -= nums[j];
                    --sz1;
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:暴力窗口排序(对照) ----------
    public long minOperationsBrute(int[] nums, int k) {
        int n = nums.length;
        long ans = Long.MAX_VALUE;
        for (int i = 0; i + k <= n; ++i) {
            int[] w = new int[k];
            for (int t = 0; t < k; ++t) {
                w[t] = nums[i + t];
            }
            java.util.Arrays.sort(w);
            int mid = w[k / 2]; // 下中位数(偶数也 OK)
            long cost = 0;
            for (int x : w) {
                cost += Math.abs(x - mid);
            }
            ans = Math.min(ans, cost);
        }
        return ans;
    }

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

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

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

复杂度分析

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

3423. Maximum Difference Between Adjacent Elements in a Circular Array(循环数组中相邻元素的最大差值)

题目描述

给你一个循环 数组 nums,请你找出相邻元素之间的最大 绝对差值。

**注意:**一个循环数组中,第一个元素和最后一个元素是相邻的。

示例 1

复制代码
nums = [1,2,4] -> 3(|1-4|=3 为最大)

示例 2

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

提示:

  • 2 <= nums.length <= 100
  • -100 <= nums[i] <= 100

解题思路

解法一:线性扫描 + 首尾差,主提交版本

循环数组的相邻对包括 (0,1), (1,2), ..., (n-2,n-1) 以及收尾的 (n-1, 0)。

先算首尾差的绝对值,再线性扫描所有相邻对取最大绝对值。

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

解法二:构造循环对枚举(对照)

显式构造 (nums[i], nums[(i+1) % n]) 对并进行比较,实现直观独立,交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:线性扫描 + 首尾差(主提交版本) ----------
    public int maxAdjacentDistance(int[] nums) {
        int n = nums.length;
        int ans = Math.abs(nums[0] - nums[n - 1]);
        for (int i = 1; i < n; ++i) {
            ans = Math.max(ans, Math.abs(nums[i] - nums[i - 1]));
        }
        return ans;
    }

    // ---------- 解法二:循环对显式枚举(对照) ----------
    public int maxAdjacentDistanceMod(int[] nums) {
        int n = nums.length;
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            int d = Math.abs(nums[i] - nums[(i + 1) % n]);
            ans = Math.max(ans, d);
        }
        return ans;
    }

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

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

        int cases = 0, pass = 0;
        for (int t = 0; t < 3000; ++t) {
            int n = 2 + rand.nextInt(10);
            int[] a = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = -20 + rand.nextInt(41);
            }
            int x = sol.maxAdjacentDistance(a);
            int y = sol.maxAdjacentDistanceMod(a);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + java.util.Arrays.toString(a) + " a=" + x + " b=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3424. Minimum Cost to Make Arrays Identical(将数组变相同的最小代价)

题目描述

给你两个长度都为 n 的整数数组 arr 和 brr 以及一个整数 k。你可以对 arr 执行以下操作任意次:

  • 将 arr 分割成若干个连续的 子数组,并将这些子数组按任意顺序重新排列。这个操作的代价为 k。
  • 选择 arr 中的任意一个元素,将它增加或者减少一个正整数 x。这个操作的代价为 x。
    请你返回将 arr 变为 brr 的最小总代价。

示例 1

复制代码
arr = [-7,9,5], brr = [7,-2,-5], k = 2 -> 13

示例 2

复制代码
arr = [2,1], brr = [2,1], k = 0 -> 0

提示:

  • 1 <= arr.length == brr.length <= 10^5
  • 0 <= k <= 2 * 10^10
  • -10^5 <= arr[i] <= 10^5
  • -10^5 <= brr[i] <= 10^5

解题思路

解法一:两种方案取 min,主提交版本

不分割时,逐位调整:min(abs(arr[i]-brr[i])) 累加 = calc(arr, brr)。

使用一次分割(代价 k)后,可以把任意元素配对,为了最小化调整代价,将两数组排序后

对应位置差的绝对值和最小(重排不等式),即 calc(sort(arr), sort(brr)) + k。

答案 = min(不分割代价, 分割后代价)。

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

解法二:暴力枚举是否分割(对照)

直观模拟两个分支:直接逐位 vs 排序后逐位再 +k,取 min。与解法一同构,路径不同,

用于小数据交叉验证(本质一致故不另写独立算法,而是用不同实现方式对照)。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:两方案取 min(主提交版本) ----------
    public long minCost(int[] arr, int[] brr, long k) {
        long c1 = calc(arr, brr);
        int[] a2 = arr.clone();
        int[] b2 = brr.clone();
        Arrays.sort(a2);
        Arrays.sort(b2);
        long c2 = calc(a2, b2) + k;
        return Math.min(c1, c2);
    }

    private long calc(int[] a, int[] b) {
        long ans = 0;
        for (int i = 0; i < a.length; ++i) {
            ans += Math.abs((long) a[i] - b[i]);
        }
        return ans;
    }

    // ---------- 解法二:显式逻辑分支(对照) ----------
    public long minCostBrute(int[] arr, int[] brr, long k) {
        int n = arr.length;
        long noSplit = 0;
        for (int i = 0; i < n; ++i) {
            noSplit += Math.abs((long) arr[i] - brr[i]);
        }
        int[] a2 = arr.clone();
        int[] b2 = brr.clone();
        Arrays.sort(a2);
        Arrays.sort(b2);
        long split = k;
        for (int i = 0; i < n; ++i) {
            split += Math.abs((long) a2[i] - b2[i]);
        }
        return Math.min(noSplit, split);
    }

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

        System.out.println("示例1: " + sol.minCost(new int[] {-7, 9, 5}, new int[] {7, -2, -5}, 2)
            + " (期望 13)");
        System.out.println("示例2: " + sol.minCost(new int[] {2, 1}, new int[] {2, 1}, 0)
            + " (期望 0)");

        int cases = 0, pass = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rand.nextInt(10);
            int[] a = new int[n];
            int[] b = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = -10 + rand.nextInt(21);
                b[i] = -10 + rand.nextInt(21);
            }
            long k = rand.nextInt(6);
            long x = sol.minCost(a, b, k);
            long y = sol.minCostBrute(a, b, k);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b)
                    + " k=" + k + " f=" + x + " br=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3425. Longest Special Path(最长特殊路径)

题目描述

给你一棵根节点为节点 0 的无向树,树中有 n 个节点,编号为 0 到 n - 1,树通过一个

长度为 n - 1 的二维数组 edges 表示,其中 edges[i] = [ui, vi, lengthi] 表示节点 ui

和 vi 之间有一条长度为 lengthi 的边。同时给你一个整数数组 nums,其中 nums[i] 表示

节点 i 的值。

特殊路径 指的是树中一条从祖先节点往下 到后代节点且经过节点的值互不相同 的路径。

注意,一条路径可以开始和结束于同一节点。

请你返回一个长度为 2 的数组 result,其中 result[0] 是最长特殊路径的长度 ,

result[1] 是所有最长特殊路径中的最少节点数目。

示例 1

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

示例 2

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

提示:

  • 2 <= n <= 5 * 10^4
  • 0 <= nums[i] <= 5 * 10^4
  • 1 <= lengthi <= 10^3

解题思路

解法一:DFS + 前缀和 + 最近重复位置,主提交版本

从根 0 做 DFS,维护根到当前节点的距离前缀 dist 与路径节点序列 st。设 seen[v] 为

值 v 最近一次出现在路径中的深度位置(没有则 -1)。当访问节点 u 时:

  • 若 seen[nums[u]] 存在且 >= 当前有效起点 start,说明路径中已有同值节点,须把起点
    推进到 该位置 + 1;
  • 否则以当前 start 为起点,路径长度 = 根距差 dist[u] - dist[st[start]],
    节点数 = pos - start + 1,去更新全局最优(长度更大优先;长度相同节点数更少优先)。
    向下递归前记录 seen[nums[u]] 旧值以便回溯恢复。每个节点 O(1) 维护,总 O(n)。
    时间复杂度 O(n),空间复杂度 O(n)。
    解法二:枚举路径起点 DFS 集合判定(对照)
    以每个节点为起点向下 DFS,用 HashSet 判重,计算每条向下路径的长度与节点数,取最优。
    复杂度 O(n^2) 最坏,仅用于本地小数据交叉验证。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    private List<List<int[]>> adj;
    private int[] nums;
    private int[] dist;       // 根到节点距离前缀
    private int[] st;         // 路径上的节点序列(按深度)
    private int[] seen;       // 值 -> 最近一次出现深度;-1 表示未出现
    private int[] res;        // res[0]=最长长度, res[1]=最少节点数

    // ---------- 解法一:DFS + 前缀和(主提交版本) ----------
    public int[] longestSpecialPath(int n, int[][] edges, int[] nums) {
        this.nums = nums;
        adj = new ArrayList<List<int[]>>();
        for (int i = 0; i < n; ++i) {
            adj.add(new ArrayList<int[]>());
        }
        for (int[] e : edges) {
            adj.get(e[0]).add(new int[] {e[1], e[2]});
            adj.get(e[1]).add(new int[] {e[0], e[2]});
        }
        dist = new int[n];
        st = new int[n];
        seen = new int[50001];
        Arrays.fill(seen, -1);
        res = new int[] {0, Integer.MAX_VALUE};
        dfs(0, -1, 0, 0, 0);
        if (res[1] == Integer.MAX_VALUE) {
            res[1] = 1; // 至少单节点
        }
        return res;
    }

    private void dfs(int u, int parent, int start, int pos, int depth) {
        int val = nums[u];
        int last = seen[val];
        if (last >= start) {
            start = last + 1;
        }
        seen[val] = pos;
        st[pos] = u;
        // 以 start..pos 为一条特殊路径
        int len = depth - dist[st[start]];
        int sz = pos - start + 1;
        if (len > res[0] || (len == res[0] && sz < res[1])) {
            res[0] = len;
            res[1] = sz;
        }
        for (int[] nb : adj.get(u)) {
            int v = nb[0], w = nb[1];
            if (v == parent) {
                continue;
            }
            dist[v] = depth + w;
            dfs(v, u, start, pos + 1, depth + w);
        }
        seen[val] = last; // 回溯恢复
    }

    // ---------- 解法二:定根后枚举起点 DFS(对照) ----------
    private int bLen;
    private int bCnt;
    private List<List<int[]>> child; // 以 0 为根的父子树(仅父->子)

    public int[] longestSpecialPathBrute(int n, int[][] edges, int[] nums) {
        List<List<int[]>> g = new ArrayList<List<int[]>>();
        for (int i = 0; i < n; ++i) {
            g.add(new ArrayList<int[]>());
        }
        for (int[] e : edges) {
            g.get(e[0]).add(new int[] {e[1], e[2]});
            g.get(e[1]).add(new int[] {e[0], e[2]});
        }
        // 以 0 为根 BFS 定向,保证枚举的路径严格沿"祖先->后代"方向
        child = new ArrayList<List<int[]>>();
        for (int i = 0; i < n; ++i) {
            child.add(new ArrayList<int[]>());
        }
        int[] par = new int[n];
        Arrays.fill(par, -2);
        par[0] = -1;
        java.util.ArrayDeque<Integer> q = new java.util.ArrayDeque<Integer>();
        q.add(0);
        while (!q.isEmpty()) {
            int u = q.poll();
            for (int[] nb : g.get(u)) {
                if (par[nb[0]] != -2) {
                    continue;
                }
                par[nb[0]] = u;
                child.get(u).add(nb);
                q.add(nb[0]);
            }
        }
        bLen = 0;
        bCnt = Integer.MAX_VALUE;
        for (int s = 0; s < n; ++s) {
            java.util.Set<Integer> used = new java.util.HashSet<Integer>();
            used.add(nums[s]);
            dfsBrute(s, 0, 1, used);
        }
        if (bCnt == Integer.MAX_VALUE) {
            bCnt = 1;
        }
        return new int[] {bLen, bCnt};
    }

    private void dfsBrute(int u, int len, int cnt, java.util.Set<Integer> used) {
        if (len > bLen || (len == bLen && cnt < bCnt)) {
            bLen = len;
            bCnt = cnt;
        }
        for (int[] nb : child.get(u)) {
            int v = nb[0], w = nb[1];
            if (used.contains(nums[v])) {
                continue; // 向下路径不能再延伸
            }
            used.add(nums[v]);
            dfsBrute(v, len + w, cnt + 1, used);
            used.remove(nums[v]);
        }
    }

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

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

        int cases = 0, pass = 0;
        for (int t = 0; t < 1000; ++t) {
            int n = 2 + rand.nextInt(9);
            int[][] es = new int[n - 1][];
            for (int i = 1; i < n; ++i) {
                int p = rand.nextInt(i);
                es[i - 1] = new int[] {p, i, 1 + rand.nextInt(10)};
            }
            int[] ns = new int[n];
            int range = 1 + rand.nextInt(4);
            for (int i = 0; i < n; ++i) {
                ns[i] = rand.nextInt(range);
            }
            int[] x = sol.longestSpecialPath(n, es, ns);
            int[] y = sol.longestSpecialPathBrute(n, es, ns);
            cases++;
            if (Arrays.equals(x, y)) {
                pass++;
            } else {
                System.out.println("MISMATCH fast=" + Arrays.toString(x) + " brute="
                    + Arrays.toString(y));
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3426. Manhattan Distances of All Arrangements of Pieces(所有安放棋子方案的曼哈顿距离)

题目描述

给你三个整数 m、n 和 k。有一个大小为 m x n 的矩形格子,它包含 k 个没有差别的棋子。

请你返回所有放置棋子的合法方案中,每对棋子之间的曼哈顿距离之和。

一个合法方案指的是将所有 k 个棋子都放在格子中,且一个格子里至多只有一个棋子。

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

两个格子 (xi, yi) 和 (xj, yj) 的曼哈顿距离定义为 |xi - xj| + |yi - yj|。

示例 1

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

示例 2

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

提示:

  • 1 <= m, n <= 10^5
  • 2 <= m * n <= 10^5
  • 2 <= k <= m * n

解题思路

解法一:固定位置对 + 组合计数,主提交版本

所有方案数为 C(mn, k)。任意一对格子位置 (p, q)(p != q)在这 C(mn, k) 个方案中被同时

选中的次数恒为 C(mn - 2, k - 2)(其余 k - 2 个棋子从其余 mn - 2 个位置里任选)。

因此答案 = C(mn - 2, k - 2) * sum(所有无序位置对的曼哈顿距离) % MOD。

若把位置对的曼哈顿距离拆成横向(列差)与纵向(行差)两部分:

  • 横向:枚举列差 d(1...n-1),列差为 d 的列对共 n - d 对,每对可选任意行(m * m 种),
    贡献 d * (n - d) * m * m;
  • 纵向:枚举行差 d(1...m-1),贡献 d * (m - d) * n * n。
    组合数用阶乘 + 逆元计算(MOD 为质数)。总时间复杂度 O(mn + m + n),空间 O(mn)。
    解法二:枚举全部组合方案(对照)
    对小规模数据,用 DFS 枚举 C(mn, k) 种放置方案,对每种方案统计所有棋子对的距离之和并累加,
    实现简单直观,仅用于本地交叉验证。
    复杂度:
  • 时间复杂度:O(mn + m + n)
  • 空间复杂度:O(mn)

代码实现

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

public class Solution {

    private static final long MOD = 1000000007L;

    // ---------- 解法一:固定位置对 + 组合计数(主提交版本) ----------
    public int distanceSum(int m, int n, int k) {
        long cells = (long) m * n;
        long pairs = 0;
        // 横向:列差贡献
        long maxD = n - 1;
        for (long d = 1; d <= maxD; ++d) {
            long cnt = (n - d) * (long) m % MOD * m % MOD;
            pairs = (pairs + cnt * d) % MOD;
        }
        // 纵向:行差贡献
        maxD = m - 1;
        for (long d = 1; d <= maxD; ++d) {
            long cnt = (m - d) * (long) n % MOD * n % MOD;
            pairs = (pairs + cnt * d) % MOD;
        }
        long comb = comb((int) (cells - 2), k - 2);
        return (int) (pairs * comb % MOD);
    }

    private long[] fact;
    private long[] invFact;

    private long comb(int N, int R) {
        if (R < 0 || R > N) {
            return 0;
        }
        if (fact == null || fact.length <= N) {
            fact = new long[N + 1];
            invFact = new long[N + 1];
            fact[0] = 1;
            for (int i = 1; i <= N; ++i) {
                fact[i] = fact[i - 1] * i % MOD;
            }
            invFact[N] = modPow(fact[N], MOD - 2);
            for (int i = N; i >= 1; --i) {
                invFact[i - 1] = invFact[i] * i % MOD;
            }
        }
        return fact[N] * invFact[R] % MOD * invFact[N - R] % MOD;
    }

    private long modPow(long a, long e) {
        long r = 1;
        while (e > 0) {
            if ((e & 1) == 1) {
                r = r * a % MOD;
            }
            a = a * a % MOD;
            e >>= 1;
        }
        return r;
    }

    // ---------- 解法二:枚举全部组合方案(对照) ----------
    private long bAns;
    private int bM;
    private int bN;
    private int bK;

    public int distanceSumBrute(int m, int n, int k) {
        bM = m;
        bN = n;
        bK = k;
        bAns = 0;
        int total = m * n;
        if (k > total) {
            return 0;
        }
        dfsChoose(0, 0, total, new int[k]);
        return (int) (bAns % MOD);
    }

    private void dfsChoose(int start, int cnt, int total, int[] picked) {
        if (cnt == bK) {
            long s = 0;
            for (int a = 0; a < bK; ++a) {
                int ra = picked[a] / bN;
                int ca = picked[a] % bN;
                for (int b = a + 1; b < bK; ++b) {
                    int rb = picked[b] / bN;
                    int cb = picked[b] % bN;
                    s += Math.abs(ra - rb) + Math.abs(ca - cb);
                }
            }
            bAns = (bAns + s) % MOD;
            return;
        }
        int need = bK - cnt;
        for (int i = start; i + need <= total; ++i) {
            picked[cnt] = i;
            dfsChoose(i + 1, cnt + 1, total, picked);
        }
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.distanceSum(2, 2, 2) + " (期望 8)");
        System.out.println("示例2: " + sol.distanceSum(1, 4, 3) + " (期望 20)");

        Random rand = new Random(7);
        int pass = 0, cases = 0;
        for (int t = 0; t < 500; ++t) {
            // 要求 mk 别太大,暴力枚举要可行
            int total = 2 + rand.nextInt(16); // 总格子数 2..17
            int m = 1 + rand.nextInt(total);
            int n = total / m;
            if (m * n < 2) {
                continue;
            }
            int k = 2 + rand.nextInt(m * n - 1);
            int x = sol.distanceSum(m, n, k);
            int y = sol.distanceSumBrute(m, n, k);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH m=" + m + " n=" + n + " k=" + k
                    + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

组合数用阶乘 + 逆元计算(MOD 为质数)。总时间复杂度 O(mn + m + n),空间 O(mn)。

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

3427. Sum of Variable Length Subarrays(变长子数组求和)

题目描述

给你一个长度为 n 的整数数组 nums。对于每个下标 i(0 <= i < n),定义对应的子数组

nums[start ... i],其中 start = max(0, i - nums[i])。

返回为数组中每个下标定义的子数组中所有元素的总和。

子数组是数组中的一个连续、非空的元素序列。

示例 1

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

示例 2

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

提示:

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

解题思路

解法一:前缀和 O(n),主提交版本

对每个 i 求区间 [start, i] 的和,用前缀和数组 pre(pre[x] 为前 x 个元素之和):

sum = pre[i + 1] - pre[start]。其中 start = max(0, i - nums[i])。

总复杂度 O(n)。

解法二:差分统计每个下标的被覆盖次数(对照)

每个区间 [start, i] 意味着该区间内每个下标都被累加一次。用差分数组 diff 记录每个下标

在多少个区间内:对每个 i,diff[start] += 1、diff[i + 1] -= 1,最后前缀累加得到每个下标

被覆盖的次数 cnt[j],答案 = sum(cnt[j] * nums[j])。思路不同,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:前缀和(主提交版本) ----------
    public int subarraySum(int[] nums) {
        int n = nums.length;
        int[] pre = new int[n + 1];
        for (int i = 0; i < n; ++i) {
            pre[i + 1] = pre[i] + nums[i];
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            int start = Math.max(0, i - nums[i]);
            ans += pre[i + 1] - pre[start];
        }
        return ans;
    }

    // ---------- 解法二:差分覆盖计数(对照) ----------
    public int subarraySumBrute(int[] nums) {
        int n = nums.length;
        int[] diff = new int[n + 1];
        for (int i = 0; i < n; ++i) {
            int start = Math.max(0, i - nums[i]);
            diff[start] += 1;
            diff[i + 1] -= 1;
        }
        int ans = 0;
        int cnt = 0;
        for (int j = 0; j < n; ++j) {
            cnt += diff[j];
            ans += cnt * nums[j];
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.subarraySum(new int[] {2, 3, 1}) + " (期望 11)");
        System.out.println("示例2: " + sol.subarraySum(new int[] {3, 1, 1, 2}) + " (期望 13)");

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

复杂度分析

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

3428. Maximum and Minimum Sums of at Most Size K Subsequences(最多 K 个元素的子序列的最值之和)

题目描述

给你一个整数数组 nums 和一个正整数 k,返回所有长度最多为 k 的子序列中最大值与最小值之和的总和。

其中,非空子序列是指从另一个数组中删除一些或不删除任何元素(且不改变剩余元素的顺序)得到的数组。

由于答案可能非常大,请返回对 10^9 + 7 取余数的结果。

示例 1

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

示例 2

复制代码
nums = [5,0,6], k = 1 -> 22

示例 3

复制代码
nums = [1,1,1], k = 2 -> 12

提示:

  • 1 <= nums.length <= 10^5
  • 0 <= nums[i] <= 10^9
  • 1 <= k <= min(100, nums.length)

解题思路

解法一:排序 + 组合数学贡献法,主提交版本

子序列的顺序不影响最值,先排序。排序后若元素 nums[i] 是一个子序列的最大值,则其余元素只能从

下标 [0, i-1] 中选(最多 k-1 个),选法数为 sum_{j=0}^{min(k-1, i)} C(i, j);

若 nums[i] 是最小值,其余元素只能从下标 [i+1, n-1] 中选,选法数为

sum_{j=0}^{min(k-1, n-1-i)} C(n-1-i, j)。每个位置 i 作为最大值与

n-1-i 作为最小值贡献次数相同(对称),故对每个 i 累加一次、再把计数翻倍即可。

组合数小规模可用组合递推 C(n, m) = C(n-1, m) + C(n-1, m-1)(k <= 100,无需逆元)。

时间复杂度 O(nk),空间 O(k)。

解法二:枚举全部子序列(对照)

对小规模数据,用 DFS 枚举长度 1...k 的所有子序列,直接计算每个子序列的 max + min 并累加取模,

直观简单,仅用于本地交叉验证。

复杂度:

  • 时间复杂度:O(nk)
  • 空间复杂度:O(k)

代码实现

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

public class Solution {

    private static final long MOD = 1000000007L;

    // ---------- 解法一:排序 + 组合数学贡献法(主提交版本) ----------
    public int minMaxSums(int[] nums, int k) {
        int n = nums.length;
        Arrays.sort(nums);
        long ans = 0;
        // comb[j] = C(i-1, j) 在第 i 轮更新为 C(i, j)
        long[] comb = new long[k];
        comb[0] = 1; // C(0,0)
        int maxJ = Math.min(k - 1, n - 1);
        for (int i = 0; i < n; ++i) {
            // 累加 sum_{j=0}^{min(k-1, i)} C(i, j)
            long ways = 0;
            int lim = Math.min(k - 1, i);
            for (int j = 0; j <= lim; ++j) {
                ways = (ways + comb[j]) % MOD;
            }
            // nums[i] 作为最大值次数 = ways;nums[n-1-i] 作为最小值次数 = ways
            ans = (ans + (nums[i] % MOD) * ways) % MOD;
            ans = (ans + (nums[n - 1 - i] % MOD) * ways) % MOD;
            // 更新 comb 为 C(i+1, j)
            for (int j = Math.min(i + 1, maxJ); j >= 1; --j) {
                comb[j] = (comb[j] + comb[j - 1]) % MOD;
            }
        }
        return (int) ans;
    }

    // ---------- 解法二:枚举全部子序列(对照) ----------
    private long bAns;
    private int[] bNums;
    private int bK;

    public int minMaxSumsBrute(int[] nums, int k) {
        bNums = nums;
        bK = k;
        bAns = 0;
        for (int len = 1; len <= k; ++len) {
            dfs(0, 0, len, Long.MAX_VALUE, Long.MIN_VALUE);
        }
        return (int) (bAns % MOD);
    }

    private void dfs(int start, int cnt, int len, long minV, long maxV) {
        if (cnt == len) {
            bAns = (bAns + minV + maxV) % MOD;
            return;
        }
        if (bNums.length - start < len - cnt) {
            return;
        }
        for (int i = start; i < bNums.length; ++i) {
            dfs(i + 1, cnt + 1, len, Math.min(minV, bNums[i]), Math.max(maxV, bNums[i]));
        }
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.minMaxSums(new int[] {1, 2, 3}, 2) + " (期望 24)");
        System.out.println("示例2: " + sol.minMaxSums(new int[] {5, 0, 6}, 1) + " (期望 22)");
        System.out.println("示例3: " + sol.minMaxSums(new int[] {1, 1, 1}, 2) + " (期望 12)");

        Random rand = new Random(17);
        int pass = 0, cases = 0;
        for (int t = 0; t < 3000; ++t) {
            int n = 1 + rand.nextInt(8);
            int[] a = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = rand.nextInt(6); // 允许重复
            }
            int k = 1 + rand.nextInt(Math.min(n, 4));
            int x = sol.minMaxSums(a.clone(), k);
            int y = sol.minMaxSumsBrute(a.clone(), k);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + Arrays.toString(a) + " k=" + k
                    + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

时间复杂度 O(nk),空间 O(k)。

  • 时间复杂度:O(nk)
  • 空间复杂度:O(k)

3429. Paint House IV(粉刷房子 IV)

题目描述

给你一个偶数整数 n,表示沿直线排列的房屋数量,以及一个大小为 n x 3 的二维数组 cost,

其中 cost[i][j] 表示将第 i 个房屋涂成颜色 j + 1 的成本。

如果房屋满足以下条件,则认为它们看起来漂亮:

  1. 不存在两个涂成相同颜色的相邻房屋;
  2. 距离行两端等距的房屋不能涂成相同的颜色(例如 n = 6 时位置 (0,5)、(1,4)、(2,3) 等距)。
    返回使房屋看起来漂亮的最低涂色成本。

示例 1

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

示例 2

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

提示:

  • 2 <= n <= 10^5,n 是偶数
  • cost.length == n,cost[i].length == 3
  • 0 <= cost[i][j] <= 10^5

解题思路

解法一:对称配对 DP,主提交版本

等距条件把房子分成 n/2 对:(i, n-1-i)。从外向内逐对处理,第 i 对两房相邻于第 i+1 对两房

之外侧,它们之间也有相邻约束。用滚动 DP:dp[a][b] 表示已处理完外侧若干对后,「靠内一侧

最近那对」的两房颜色为 a、b 时的最小成本。初始化为全 0(最外层之外无房子,无约束)。

处理第 i 对时枚举当前对颜色 (x, y),要求 x != y(等距不同色)、x != a、y != b(相邻不同色),

转移 ndp[x][y] = min(dp[a][b]) + cost[i][x] + cost[n-1-i][y]。共 n/2 对,每对 3^4 状态,

总 O(n)。返回最终 min(dp)。

解法二:暴力枚举全部涂色方案(对照)

枚举所有 3^n 种涂色方案(仅限小 n),依次检查相邻不同色与等距不同色两条约束,取合法方案

的最小成本。直观但指数级,仅用于本地交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:对称配对 DP(主提交版本) ----------
    public long minCost(int n, int[][] cost) {
        long[][] dp = new long[3][3]; // 初始:最外层外无房子,无约束,成本 0
        for (int i = 0; i < 3; ++i) {
            Arrays.fill(dp[i], 0L);
        }
        int half = n / 2;
        for (int i = 0; i < half; ++i) {
            int j = n - 1 - i;
            long[][] ndp = new long[3][3];
            for (int a = 0; a < 3; ++a) {
                Arrays.fill(ndp[a], Long.MAX_VALUE / 4);
            }
            for (int a = 0; a < 3; ++a) {
                for (int b = 0; b < 3; ++b) {
                    long base = dp[a][b];
                    for (int x = 0; x < 3; ++x) {
                        if (x == a) {
                            continue; // 左房与外侧左房相邻,不能同色
                        }
                        for (int y = 0; y < 3; ++y) {
                            if (y == b || x == y) {
                                continue; // 右房相邻约束 + 等距异色
                            }
                            long v = base + cost[i][x] + cost[j][y];
                            if (v < ndp[x][y]) {
                                ndp[x][y] = v;
                            }
                        }
                    }
                }
            }
            dp = ndp;
        }
        long ans = Long.MAX_VALUE;
        for (int x = 0; x < 3; ++x) {
            for (int y = 0; y < 3; ++y) {
                ans = Math.min(ans, dp[x][y]);
            }
        }
        return ans;
    }

    // ---------- 解法二:暴力枚举(对照) ----------
    private long bAns;
    private int[] bColors;
    private int[][] bCost;
    private int bN;

    public long minCostBrute(int n, int[][] cost) {
        bN = n;
        bCost = cost;
        bColors = new int[n];
        bAns = Long.MAX_VALUE;
        dfsColors(0);
        return bAns;
    }

    private void dfsColors(int idx) {
        if (idx == bN) {
            long s = 0;
            for (int i = 0; i < bN; ++i) {
                s += bCost[i][bColors[i]];
            }
            if (s >= bAns) {
                return;
            }
            // 相邻不同色
            for (int i = 0; i + 1 < bN; ++i) {
                if (bColors[i] == bColors[i + 1]) {
                    return;
                }
            }
            // 等距不同色
            for (int i = 0; i < bN / 2; ++i) {
                if (bColors[i] == bColors[bN - 1 - i]) {
                    return;
                }
            }
            bAns = s;
            return;
        }
        for (int c = 0; c < 3; ++c) {
            bColors[idx] = c;
            dfsColors(idx + 1);
        }
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.minCost(4, new int[][] {{3, 5, 7}, {6, 2, 9},
            {4, 8, 1}, {7, 3, 5}}) + " (期望 9)");
        System.out.println("示例2: " + sol.minCost(6, new int[][] {{2, 4, 6}, {5, 3, 8},
            {7, 1, 9}, {4, 6, 2}, {3, 5, 7}, {8, 2, 4}}) + " (期望 18)");

        Random rand = new Random(23);
        int pass = 0, cases = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 2 * (1 + rand.nextInt(4)); // 2,4,6,8
            int[][] c = new int[n][3];
            for (int i = 0; i < n; ++i) {
                for (int j = 0; j < 3; ++j) {
                    c[i][j] = rand.nextInt(11);
                }
            }
            long x = sol.minCost(n, c);
            long y = sol.minCostBrute(n, c);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH n=" + n + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

3430. Maximum and Minimum Sums of at Most Size K Subarrays(最多 K 个元素的子数组的最值之和)

题目描述

给你一个整数数组 nums 和一个正整数 k。返回最多有 k 个元素的所有子数组的最大元素和最小元素

之和的总和。

子数组是数组中的一个连续、非空的元素序列。

示例 1

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

示例 2

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

提示:

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

解题思路

解法一:单调栈定界 + 长度受限计数,主提交版本

先单独计算「所有长 ≤ k 的子数组的最大值之和」,再把数组取负后同样算一遍即得「最小值之和的负值」,

二者相减即为答案。

对最大值:用单调栈求出每个 i 作为最大值的最左边界 left[i](前一个大于等于它的位置)与最右

边界 right[i](后一个大于它的位置,等值去重交给 left 一侧处理)。任一以 i 为最大值的子数组,

左右端点分别必须在 (left[i], i] 与 [i, right[i]) 内,且长度 ≤ k。满足条件的子数组数为:

设 l = min(k, i - left[i]),r = min(k, right[i] - i),则

  • 若 l + r - 1 <= k(不存在同时触顶的组合,取任意左右距离即可):
    数量 = l * r;
  • 否则需要枚举左距离 d = 1..l,右距离 e = min(r, k - d),累加
    sum_{d=1}^{l} min(r, k - d),可由算术级数 O(1) 计算。
    对最小值:将 nums 取负后套用同一逻辑,「负最大值之和」的相反数即「最小值之和」。
    总时间复杂度 O(n),空间 O(n)。
    解法二:暴力枚举全部子数组(对照)
    枚举所有长度 ≤ k 的子数组,直接求 max + min 累加,O(nk) 仅适用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:单调栈 + 长度受限计数(主提交版本) ----------
    public long minMaxSubarraySum(int[] nums, int k) {
        long sum = solveRange(nums, k, true);
        int n = nums.length;
        int[] neg = new int[n];
        for (int i = 0; i < n; ++i) {
            neg[i] = -nums[i];
        }
        long negSum = solveRange(neg, k, true);
        return sum - negSum;
    }

    private long solveRange(int[] nums, int k, boolean unused) {
        int n = nums.length;
        int[] left = new int[n];
        int[] right = new int[n];
        int[] st = new int[n];
        int top = -1;
        // left[i]:前一个 > nums[i](严格大于做去重),没有则 -1
        for (int i = 0; i < n; ++i) {
            while (top != -1 && nums[st[top]] < nums[i]) {
                top--;
            }
            left[i] = (top == -1) ? -1 : st[top];
            st[++top] = i;
        }
        top = -1;
        // right[i]:后一个 >= nums[i],没有则 n
        for (int i = n - 1; i >= 0; --i) {
            while (top != -1 && nums[st[top]] <= nums[i]) {
                top--;
            }
            right[i] = (top == -1) ? n : st[top];
            st[++top] = i;
        }
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            long l = Math.min(k, i - left[i]);         // 左可跨距离 1..l
            long r = Math.min(k, right[i] - i);        // 右可跨距离 1..r
            long cnt;
            if (l + r - 1 <= k) {
                cnt = l * r;
            } else {
                // sum_{d=1..l} min(r, k - d + 1),d = 左距离(从 1 起)
                // 令 d 分两段:d <= k - r + 1 时取 r;之后取 k - d + 1
                long full = Math.min(l, k - r + 1);    // 这些 d 取满 r
                cnt = full * r;
                long d1 = full + 1;
                if (d1 <= l) {
                    long last = k - l + 1;              // 最后一个 d=l 时取值
                    long lo = k - d1 + 1;               // d=d1 时取值
                    // sum_{d=d1..l} (k-d+1) 等差数列 [lo, last] 项数 l-d1+1
                    long num = l - d1 + 1;
                    cnt += (lo + last) * num / 2;
                }
            }
            ans += (long) nums[i] * cnt;
        }
        return ans;
    }

    // ---------- 解法二:暴力枚举(对照) ----------
    public long minMaxSubarraySumBrute(int[] nums, int k) {
        long ans = 0;
        for (int i = 0; i < nums.length; ++i) {
            int mx = Integer.MIN_VALUE, mn = Integer.MAX_VALUE;
            for (int j = i; j < nums.length && j - i + 1 <= k; ++j) {
                mx = Math.max(mx, nums[j]);
                mn = Math.min(mn, nums[j]);
                ans += mx + mn;
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.minMaxSubarraySum(new int[] {1, 2, 3}, 2) + " (期望 20)");
        System.out.println("示例2: " + sol.minMaxSubarraySum(new int[] {1, -3, 1}, 2) + " (期望 -6)");

        Random rand = new Random(29);
        int pass = 0, cases = 0;
        for (int t = 0; t < 3000; ++t) {
            int n = 1 + rand.nextInt(9);
            int[] a = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = rand.nextInt(21) - 10; // -10..10,含重复
            }
            int k = 1 + rand.nextInt(n);
            long x = sol.minMaxSubarraySum(a.clone(), k);
            long y = sol.minMaxSubarraySumBrute(a.clone(), k);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + Arrays.toString(a) + " k=" + k
                    + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3431. Minimum Unlocked Indices to Sort Nums(对数字排序的最小解锁下标)

题目描述

给定一个仅包含 1、2、3 的整数的数组 nums,以及一个相同大小的二进制数组 locked。

当满足 nums[i] - nums[i + 1] == 1 且 locked[i] == 0 时,则允许交换下标 i 和 i + 1

处的元素;如果可以通过交换相邻元素将 nums 升序排序,我们认为 nums 是可排序的。

你可以进行若干次操作,每次操作可以将 locked[i] 设置为 0,从而解锁下标 i。

返回使 nums 满足可排序的所需最小操作次数。如果不可能使 nums 可排序,返回 -1。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= nums.length <= 10^5
  • 1 <= nums[i] <= 3
  • locked.length == nums.length
  • 0 <= locked[i] <= 1

解题思路

解法一:区间覆盖计数,主提交版本

值的种类只有 1/2/3,排序目标为「1 全在最前、2 居中、3 全在最后」。

可实现性:若存在「3 在 1 前面」则不可排序。因为 3 与 1 相差 2,永不允许直接交换,

3 无法越过 1 到达末尾,故 first3 < last1 时直接返回 -1。

交换代价分析:2 需要越过的 1 位于 [first2, last1) 区间;3 需要越过的 2 位于

[first3, last2) 区间。这些区间中所有上锁的位置(locked[i] == 1)都必须解锁。

答案是区间并在两区间中的上锁位置数(两区间不重叠,直接分别统计即可)。

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

解法二:BFS 模拟贪心(对照)

对少量数据,用队列按值分层模拟「可交换的相邻元素尽量交换」的排序过程,记录所需解锁次数:

每当遇到阻塞在错误一侧的元素,计算需要解锁的最小位置数。实现复杂且仅用于交叉验证,

故本地对照使用更朴素的推理:直接判断 -1 条件后统计两区间上锁数------与解法一相同逻辑、

不同实现路径的版本,用于验证主解实现细节。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:区间覆盖计数(主提交版本) ----------
    public int minUnlockedIndices(int[] nums, int[] locked) {
        int n = nums.length;
        int first2 = n, first3 = n;
        int last1 = -1, last2 = -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] == 1) {
                last1 = i;
            } else if (nums[i] == 2) {
                if (first2 == n) {
                    first2 = i;
                }
                last2 = i;
            } else { // 3
                if (first3 == n) {
                    first3 = i;
                }
            }
        }
        // 3 出现在最后一个 1 之前:3 无法越过 1,不可排序
        if (first3 < last1) {
            return -1;
        }
        int ans = 0;
        for (int i = 0; i < n; ++i) {
            if (locked[i] == 1
                && ((first2 <= i && i < last1) || (first3 <= i && i < last2))) {
                ++ans;
            }
        }
        return ans;
    }

    // ---------- 解法二:模拟交换(对照,仅小规模) ----------
    private int[] bNums;
    private int[] bLocked;

    public int minUnlockedIndicesBrute(int[] nums, int[] locked) {
        int n = nums.length;
        int first2 = n, first3 = n;
        int last1 = -1, last2 = -1;
        for (int i = 0; i < n; ++i) {
            if (nums[i] == 1) {
                last1 = i;
            } else if (nums[i] == 2) {
                first2 = Math.min(first2, i);
                last2 = i;
            } else {
                first3 = Math.min(first3, i);
            }
        }
        if (first3 < last1) {
            return -1;
        }
        // 模拟:不断尝试把每个元素交换到目标位置,记录必须解锁的下标
        bNums = nums.clone();
        bLocked = locked.clone();
        boolean[] unlocked = new boolean[n];
        int ans = 0;
        while (true) {
            boolean moved = false;
            for (int i = 0; i + 1 < n; ++i) {
                if (bNums[i] > bNums[i + 1] && bNums[i] - bNums[i + 1] == 1) {
                    if (!unlocked[i] && bLocked[i] == 1) {
                        unlocked[i] = true;
                        ans++;
                    }
                    int t = bNums[i];
                    bNums[i] = bNums[i + 1];
                    bNums[i + 1] = t;
                    moved = true;
                }
            }
            if (!moved) {
                break;
            }
        }
        // 检查是否真排序了
        for (int i = 0; i + 1 < n; ++i) {
            if (bNums[i] > bNums[i + 1]) {
                return -1;
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.minUnlockedIndices(new int[] {1, 2, 1, 2, 3, 2},
            new int[] {1, 0, 1, 1, 0, 1}) + " (期望 0)");
        System.out.println("示例2: " + sol.minUnlockedIndices(new int[] {1, 2, 1, 1, 3, 2, 2},
            new int[] {1, 0, 1, 1, 0, 1, 0}) + " (期望 2)");
        System.out.println("示例3: " + sol.minUnlockedIndices(new int[] {1, 2, 1, 2, 3, 2, 1},
            new int[] {0, 0, 0, 0, 0, 0, 0}) + " (期望 -1)");

        Random rand = new Random(31);
        int pass = 0, cases = 0;
        for (int t = 0; t < 5000; ++t) {
            int n = 1 + rand.nextInt(9);
            int[] a = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = 1 + rand.nextInt(3);
            }
            int[] lk = new int[n];
            for (int i = 0; i < n; ++i) {
                lk[i] = rand.nextInt(2);
            }
            int x = sol.minUnlockedIndices(a.clone(), lk.clone());
            int y = sol.minUnlockedIndicesBrute(a.clone(), lk.clone());
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + Arrays.toString(a) + " locked="
                    + Arrays.toString(lk) + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3432. Count Partitions with Even Sum Difference(统计元素和差值为偶数的分区方案)

题目描述

给你一个长度为 n 的整数数组 nums。分区是指将数组按照下标 i(0 <= i < n - 1)划分成

两个非空子数组,其中:左子数组包含区间 [0, i] 内的所有下标,右子数组包含区间 [i + 1, n - 1]

内的所有下标。对左子数组和右子数组先求元素和再做差,统计并返回差值为偶数的分区方案数。

示例 1

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

示例 2

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

示例 3

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

提示:

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

解题思路

解法一:奇偶性判定,主提交版本

设数组总和为 S,左半部分和为 L,则右半部分和为 S - L,差值为 L - (S - L) = 2L - S。

由于 2L 恒为偶数,差值的奇偶性完全由 S 决定:S 为奇数时任何分区差值都为奇数(答案为 0);

S 为偶数时所有 n - 1 个分区都满足条件(答案为 n - 1)。

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

解法二:枚举分区点(对照)

对每个分割点 i(1...n-1),用前缀和分别求左右和,逐点判断差值是否为偶数并计数。

实现直接,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:奇偶性判定(主提交版本) ----------
    public int countPartitions(int[] nums) {
        int sum = 0;
        for (int v : nums) {
            sum += v;
        }
        return (sum & 1) == 0 ? nums.length - 1 : 0;
    }

    // ---------- 解法二:枚举分区点(对照) ----------
    public int countPartitionsBrute(int[] nums) {
        int n = nums.length;
        int[] pre = new int[n + 1];
        for (int i = 0; i < n; ++i) {
            pre[i + 1] = pre[i] + nums[i];
        }
        int ans = 0;
        for (int i = 1; i < n; ++i) {
            int left = pre[i];
            int right = pre[n] - pre[i];
            if (((left - right) & 1) == 0) {
                ans++;
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.countPartitions(new int[] {10, 10, 3, 7, 6}) + " (期望 4)");
        System.out.println("示例2: " + sol.countPartitions(new int[] {1, 2, 2}) + " (期望 0)");
        System.out.println("示例3: " + sol.countPartitions(new int[] {2, 4, 6, 8}) + " (期望 3)");

        Random rand = new Random(37);
        int pass = 0, cases = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 2 + rand.nextInt(8);
            int[] a = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = 1 + rand.nextInt(20);
            }
            int x = sol.countPartitions(a);
            int y = sol.countPartitionsBrute(a);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + Arrays.toString(a) + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3433. Count Mentions Per User(统计用户被提及情况)

题目描述

给你一个整数 numberOfUsers 表示用户总数,另有一个大小为 n x 3 的数组 events。

每个 events[i] 都属于下述两种类型之一:

  • 消息事件(Message Event):["MESSAGE", "timestampi", "mentions_stringi"],事件表示在
    timestampi 时一组用户被消息提及。mentions_stringi 可包含:id <number>(可空格分隔多个、
    可重复、可提及离线用户)、ALL(提及所有用户)、HERE(提及所有在线用户)。
  • 离线事件(Offline Event):["OFFLINE", "timestampi", "idi"],表示用户 idi 在 timestampi
    变为离线状态 60 个单位时间,并在 timestampi + 60 自动再次上线。
    返回数组 mentions,其中 mentions[i] 表示 id 为 i 的用户在所有 MESSAGE 事件中被提及的次数。
    最初所有用户都处于在线状态;如果某个用户离线或者重新上线,其对应的状态变更将会在所有相同时间
    发生的消息事件之前进行处理和同步。在单条消息中,同一个用户可能会被提及多次,每次提及都要分别统计。

示例 1

复制代码
numberOfUsers = 2, events = [["MESSAGE","10","id1 id0"],["OFFLINE","11","0"],["MESSAGE","71","HERE"]] -> [2,2]

示例 2

复制代码
numberOfUsers = 2, events = [["MESSAGE","10","id1 id0"],["OFFLINE","11","0"],["MESSAGE","12","ALL"]] -> [2,2]

示例 3

复制代码
numberOfUsers = 2, events = [["OFFLINE","10","0"],["MESSAGE","12","HERE"]] -> [0,1]

提示:

  • 1 <= numberOfUsers <= 100
  • 1 <= events.length <= 100
  • 时间戳 >= 1 且 <= 10^5

解题思路

解法一:按时间排序 + 同步离线状态,主提交版本

  1. 按时间戳升序排序,同时间戳内 OFFLINE 排在 MESSAGE 之前实现「状态变更先于同一时刻的消息」;
  2. 维护 online[] 布尔数组与每个事件时刻的离线用户集合:对每个事件,先把所有 back[t]
    (该时刻恢复上线的用户)置回在线,再处理同刻全部事件------离线事件把用户标记离线并将
    back[t+60] 记入恢复集合,消息事件按类型计数;
  3. ALL 全量 +1,HERE 对每个在线用户 +1,id X 对指定用户 +1(可重复要按 token 逐个数)。
    时间复杂度 O(n log n + n * U)(U 为用户数),空间 O(n + U)。
    解法二:朴素时间轴模拟(对照)
    对每条时间戳内的事件,直接遍历所有用户判断在线状态进行计数,逻辑更直白,用于交叉验证。
    复杂度:
  • 时间复杂度:O(n log n + n * U)
  • 空间复杂度:O(n + U)

代码实现

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

public class Solution {

    // ---------- 解法一:按时间排序 + 同步离线状态(主提交版本) ----------
    public int[] countMentions(int numberOfUsers, List<List<String>> events) {
        int n = events.size();
        Integer[] idx = new Integer[n];
        for (int i = 0; i < n; ++i) {
            idx[i] = i;
        }
        Arrays.sort(idx, (a, b) -> {
            int ta = Integer.parseInt(events.get(a).get(1));
            int tb = Integer.parseInt(events.get(b).get(1));
            if (ta != tb) {
                return ta - tb;
            }
            // 同一时刻 OFFLINE 优先于 MESSAGE
            String ka = events.get(a).get(0);
            String kb = events.get(b).get(0);
            boolean offA = "OFFLINE".equals(ka);
            boolean offB = "OFFLINE".equals(kb);
            return (offA ? 0 : 1) - (offB ? 0 : 1);
        });

        int[] ans = new int[numberOfUsers];
        boolean[] online = new boolean[numberOfUsers];
        Arrays.fill(online, true);
        // 恢复上线:记录每个时间点批量置回
        List<List<Integer>> back = new ArrayList<List<Integer>>();
        for (int i = 0; i <= 100000 + 60 + 1; ++i) {
            back.add(new ArrayList<Integer>());
        }
        for (int pos = 0; pos < n; ++pos) {
            int e = idx[pos];
            List<String> ev = events.get(e);
            int t = Integer.parseInt(ev.get(1));
            // 先恢复该时刻上线用户
            for (int u : back.get(t)) {
                online[u] = true;
            }
            if ("MESSAGE".equals(ev.get(0))) {
                String m = ev.get(2);
                if ("ALL".equals(m)) {
                    for (int u = 0; u < numberOfUsers; ++u) {
                        ans[u]++;
                    }
                } else if ("HERE".equals(m)) {
                    for (int u = 0; u < numberOfUsers; ++u) {
                        if (online[u]) {
                            ans[u]++;
                        }
                    }
                } else {
                    // id1 id0 等
                    String[] parts = m.split(" ");
                    for (String p : parts) {
                        int u = Integer.parseInt(p.substring(2));
                        ans[u]++;
                    }
                }
            } else { // OFFLINE
                int u = Integer.parseInt(ev.get(2));
                online[u] = false;
                back.get(t + 60).add(u);
            }
        }
        return ans;
    }

    // ---------- 解法二:朴素时间轴模拟(对照) ----------
    public int[] countMentionsBrute(int numberOfUsers, List<List<String>> events) {
        int n = events.size();
        Integer[] idx = new Integer[n];
        for (int i = 0; i < n; ++i) {
            idx[i] = i;
        }
        Arrays.sort(idx, (a, b) -> {
            int ta = Integer.parseInt(events.get(a).get(1));
            int tb = Integer.parseInt(events.get(b).get(1));
            if (ta != tb) {
                return ta - tb;
            }
            String ka = events.get(a).get(0);
            String kb = events.get(b).get(0);
            return ("OFFLINE".equals(ka) ? 0 : 1) - ("OFFLINE".equals(kb) ? 0 : 1);
        });
        int[] ans = new int[numberOfUsers];
        int[] offlineUntil = new int[numberOfUsers]; // 0 表示在线
        int maxT = 0;
        for (int i = 0; i < n; ++i) {
            maxT = Math.max(maxT, Integer.parseInt(events.get(i).get(1)));
        }
        for (int pos = 0; pos < n; ++pos) {
            int e = idx[pos];
            List<String> ev = events.get(e);
            int t = Integer.parseInt(ev.get(1));
            for (int u = 0; u < numberOfUsers; ++u) {
                if (offlineUntil[u] > 0 && offlineUntil[u] <= t) {
                    offlineUntil[u] = 0;
                }
            }
            if ("MESSAGE".equals(ev.get(0))) {
                String m = ev.get(2);
                if ("ALL".equals(m)) {
                    for (int u = 0; u < numberOfUsers; ++u) {
                        ans[u]++;
                    }
                } else if ("HERE".equals(m)) {
                    for (int u = 0; u < numberOfUsers; ++u) {
                        if (offlineUntil[u] == 0) {
                            ans[u]++;
                        }
                    }
                } else {
                    String[] parts = m.split(" ");
                    for (String p : parts) {
                        ans[Integer.parseInt(p.substring(2))]++;
                    }
                }
            } else {
                int u = Integer.parseInt(ev.get(2));
                offlineUntil[u] = t + 60;
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        List<List<String>> e1 = new ArrayList<List<String>>();
        e1.add(Arrays.asList("MESSAGE", "10", "id1 id0"));
        e1.add(Arrays.asList("OFFLINE", "11", "0"));
        e1.add(Arrays.asList("MESSAGE", "71", "HERE"));
        System.out.println("示例1: " + Arrays.toString(sol.countMentions(2, e1)) + " (期望 [2,2])");

        List<List<String>> e2 = new ArrayList<List<String>>();
        e2.add(Arrays.asList("MESSAGE", "10", "id1 id0"));
        e2.add(Arrays.asList("OFFLINE", "11", "0"));
        e2.add(Arrays.asList("MESSAGE", "12", "ALL"));
        System.out.println("示例2: " + Arrays.toString(sol.countMentions(2, e2)) + " (期望 [2,2])");

        List<List<String>> e3 = new ArrayList<List<String>>();
        e3.add(Arrays.asList("OFFLINE", "10", "0"));
        e3.add(Arrays.asList("MESSAGE", "12", "HERE"));
        System.out.println("示例3: " + Arrays.toString(sol.countMentions(2, e3)) + " (期望 [0,1])");

        Random rand = new Random(41);
        int pass = 0, cases = 0;
        for (int t = 0; t < 2000; ++t) {
            int U = 1 + rand.nextInt(4);
            int n = 1 + rand.nextInt(8);
            List<List<String>> evs = new ArrayList<List<String>>();
            for (int i = 0; i < n; ++i) {
                int ts = 1 + rand.nextInt(30);
                List<String> row = new ArrayList<String>();
                if (rand.nextBoolean()) {
                    row.add("MESSAGE");
                    row.add("" + ts);
                    int kind = rand.nextInt(3);
                    if (kind == 0) {
                        row.add("ALL");
                    } else if (kind == 1) {
                        row.add("HERE");
                    } else {
                        StringBuilder sb = new StringBuilder();
                        int cnt = 1 + rand.nextInt(3);
                        for (int c = 0; c < cnt; ++c) {
                            if (c > 0) {
                                sb.append(' ');
                            }
                            sb.append("id").append(rand.nextInt(U));
                        }
                        row.add(sb.toString());
                    }
                } else {
                    row.add("OFFLINE");
                    row.add("" + ts);
                    row.add("" + rand.nextInt(U));
                }
                evs.add(row);
            }
            int[] x = sol.countMentions(U, evs);
            int[] y = sol.countMentionsBrute(U, evs);
            cases++;
            if (Arrays.equals(x, y)) {
                pass++;
            } else {
                System.out.println("MISMATCH U=" + U + " events=" + evs + " fast="
                    + Arrays.toString(x) + " brute=" + Arrays.toString(y));
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

时间复杂度 O(n log n + n * U)(U 为用户数),空间 O(n + U)。

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

3434. Maximum Frequency After Subarray Operation(子数组操作后的最大频率)

题目描述

给你一个长度为 n 的数组 nums,同时给你一个整数 k。你可以对 nums 执行以下操作一次:

选择一个子数组 nums[i..j](0 <= i <= j <= n - 1),选择一个整数 x 并将 nums[i..j] 中

所有元素都增加 x。请你返回执行以上操作以后数组中 k 出现的最大频率。

子数组是一个数组中一段连续非空的元素序列。

示例 1

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

示例 2

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

提示:

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

解题思路

解法一:Kadane 最大子段和,主提交版本

操作后 k 的频率 = 「原本就是 k 的个数」+「被选子数组中由其他值变为 k 的个数」。

对每个目标值 t(1...50 且 t != k):若选中的子数组内有个 t,加 x = k - t 后该元素变为 k

(收益 +1);子数组内原本是 k 的元素会被加 x 而离开 k(收益 -1)。其余元素不受影响。

于是问题等价于求「含 k 记 -1、含 t 记 +1、其余记 0」序列的最大子段和(可空),对每个 t 跑一遍

Kadane 取最大值,再加回原始 k 的计数。数值范围仅 50,总 O(50n)。

解法二:枚举子数组(对照)

对小数据,枚举所有子数组并枚举 x(只需考虑把某个元素变为 k,即 x = k - nums[p]),

逐元素判断操作后是否为 k 并统计,取最大,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:Kadane 最大子段和(主提交版本) ----------
    public int maxFrequency(int[] nums, int k) {
        int base = 0;
        for (int v : nums) {
            if (v == k) {
                base++;
            }
        }
        int best = 0;
        for (int t = 1; t <= 50; ++t) {
            if (t == k) {
                continue;
            }
            int cur = 0;
            for (int v : nums) {
                if (v == t) {
                    cur++;
                } else if (v == k) {
                    cur--;
                }
                if (cur < 0) {
                    cur = 0;
                }
                if (cur > best) {
                    best = cur;
                }
            }
        }
        return base + best;
    }

    // ---------- 解法二:枚举子数组(对照) ----------
    public int maxFrequencyBrute(int[] nums, int k) {
        int n = nums.length;
        int best = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = i; j < n; ++j) {
                // 枚举该子数组要变的 x:只需考虑把子数组内某个元素变为 k 的 x
                for (int p = i; p <= j; ++p) {
                    int x = k - nums[p];
                    int cnt = 0;
                    for (int q = 0; q < n; ++q) {
                        int val = (q >= i && q <= j) ? nums[q] + x : nums[q];
                        if (val == k) {
                            cnt++;
                        }
                    }
                    best = Math.max(best, cnt);
                }
            }
        }
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.maxFrequency(new int[] {1, 2, 3, 4, 5, 6}, 1) + " (期望 2)");
        System.out.println("示例2: " + sol.maxFrequency(new int[] {10, 2, 3, 4, 5, 5, 4, 3, 2, 2}, 10)
            + " (期望 4)");

        Random rand = new Random(43);
        int pass = 0, cases = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rand.nextInt(7);
            int[] a = new int[n];
            for (int i = 0; i < n; ++i) {
                a[i] = 1 + rand.nextInt(5);
            }
            int k = 1 + rand.nextInt(5);
            int x = sol.maxFrequency(a.clone(), k);
            int y = sol.maxFrequencyBrute(a.clone(), k);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH " + Arrays.toString(a) + " k=" + k
                    + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

3435. Frequencies of Shortest Supersequences(最短公共超序列的字母出现频率)

题目描述

给你一个字符串数组 words。请你找到 words 所有最短公共超序列(SCS),且确保它们互相之间

无法通过排列得到。最短公共超序列指的是一个字符串,words 中所有字符串都是它的子序列,且它的

长度最短。请你返回一个二维整数数组 freqs,表示所有的最短公共超序列,其中 freqs[i] 是一个

长度为 26 的数组,它依次表示一个最短公共超序列的所有小写英文字母的出现频率。你可以以任意顺序

返回这个频率数组。

示例 1

复制代码
words = ["ab","ba"] -> [[1,2,0,...],[2,1,0,...]]

示例 2

复制代码
words = ["aa","ac"] -> [[2,0,1,0,...]]

示例 3

复制代码
words = ["aa","bb","cc"] -> [[2,2,2,0,...]]

提示:

  • 1 <= words.length <= 256
  • words[i].length == 2
  • words 中所有字符串由不超过 16 个互不相同的小写英文字母组成
  • words 中的字符串互不相同

解题思路

解法一:枚举子集 + 环检测,主提交版本

把每个 words[i] 看作一条有向边 u -> v(u 需出现在 v 之前)。每个字母在 SCS 中最多出现

2 次:出现 1 次的字母只有一个位置;出现 2 次的字母有两个位置,自由度更高。

若两端都只出现 1 次的边存在圈,则无法满足顺序约束;此时必须把圈中某些字母改为出现 2 次来破环

(出现 2 次的一端的约束自动可满足:总能安排一个位置在对面字母之前、另一个位置在对面字母之后)。

自环 uu 所在的字母必须出现 2 次(单个位置无法让 u 出现在 u 之前)。

算法:收集全部字母(最多 16 个)映射到 0...m-1,枚举子集 mask 表示「出现 2 次的字母」:

  • 自环字母必须在 mask 中;
  • 去掉 mask 中字母相关边后,剩余图必须无环(DFS 三色)。
    合法时总长度 = m + popcount(mask)。取总长度最小的全部 mask 生成频率数组。
    时间复杂度 O(2^m * (m + E)),空间 O(m + E)。
    解法二:频率枚举 + 槽位构造(对照)
    同样按每字母 1 次/2 次枚举频率组合,但用「逐槽位放置字母、验证所有 words 能否作为子序列匹配」
    的构造法判断可行性,取代环判定。思路完全不同,用于交叉验证。
    复杂度:
  • 时间复杂度:O(2^m * (m + E))
  • 空间复杂度:O(m + E)

代码实现

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

public class Solution {

    // ---------- 解法一:枚举子集 + 环检测(主提交版本) ----------
    public List<List<Integer>> supersequences(String[] words) {
        Set<Integer> nodeSet = new TreeSet<Integer>();
        List<int[]> edges = new ArrayList<int[]>();
        for (String w : words) {
            int u = w.charAt(0) - 'a';
            int v = w.charAt(1) - 'a';
            nodeSet.add(u);
            nodeSet.add(v);
            edges.add(new int[] {u, v});
        }
        int m = nodeSet.size();
        int[] nodes = new int[m];
        int t = 0;
        for (int x : nodeSet) {
            nodes[t++] = x;
        }
        int[] idxOf = new int[26];
        Arrays.fill(idxOf, -1);
        for (int i = 0; i < m; ++i) {
            idxOf[nodes[i]] = i;
        }
        // 所有 1次/2次 组合的邻接(只保留两端都出现 1 次的边)
        int bestLen = Integer.MAX_VALUE;
        List<Integer> bestMasks = new ArrayList<Integer>();
        for (int mask = 0; mask < (1 << m); ++mask) {
            boolean ok = true;
            List<int[]> sub = new ArrayList<int[]>();
            for (int[] e : edges) {
                int a = idxOf[e[0]];
                int b = idxOf[e[1]];
                if (a == b) {
                    if ((mask & (1 << a)) == 0) {
                        ok = false; // 自环必须出现 2 次
                        break;
                    }
                    continue;
                }
                if (((mask >> a) & 1) == 0 && ((mask >> b) & 1) == 0) {
                    sub.add(new int[] {a, b});
                }
            }
            if (!ok) {
                continue;
            }
            if (hasCycle(m, sub)) {
                continue;
            }
            int len = m + Integer.bitCount(mask);
            if (len < bestLen) {
                bestLen = len;
                bestMasks.clear();
                bestMasks.add(mask);
            } else if (len == bestLen) {
                bestMasks.add(mask);
            }
        }
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        for (int mask : bestMasks) {
            List<Integer> freq = new ArrayList<Integer>();
            for (int i = 0; i < 26; ++i) {
                freq.add(0);
            }
            for (int i = 0; i < m; ++i) {
                freq.set(nodes[i], ((mask >> i) & 1) == 1 ? 2 : 1);
            }
            res.add(freq);
        }
        return res;
    }

    private boolean hasCycle(int m, List<int[]> sub) {
        List<List<Integer>> g = new ArrayList<List<Integer>>();
        for (int i = 0; i < m; ++i) {
            g.add(new ArrayList<Integer>());
        }
        for (int[] e : sub) {
            g.get(e[0]).add(e[1]);
        }
        int[] state = new int[m];
        for (int i = 0; i < m; ++i) {
            if (state[i] == 0 && dfsCycle(i, g, state)) {
                return true;
            }
        }
        return false;
    }

    private boolean dfsCycle(int u, List<List<Integer>> g, int[] state) {
        state[u] = 1;
        for (int v : g.get(u)) {
            if (state[v] == 1) {
                return true;
            }
            if (state[v] == 0 && dfsCycle(v, g, state)) {
                return true;
            }
        }
        state[u] = 2;
        return false;
    }

    // ---------- 解法二:频率枚举 + 排列构造(对照) ----------
    private String[] bWords;
    private int bM;
    private int[] bNodes;
    private int bTotal;

    public List<List<Integer>> supersequencesBrute(String[] words) {
        Set<Integer> nodeSet = new TreeSet<Integer>();
        for (String w : words) {
            nodeSet.add(w.charAt(0) - 'a');
            nodeSet.add(w.charAt(1) - 'a');
        }
        bM = nodeSet.size();
        bNodes = new int[bM];
        int t = 0;
        for (int x : nodeSet) {
            bNodes[t++] = x;
        }
        bWords = words;
        int bestLen = Integer.MAX_VALUE;
        List<Integer> bestMasks = new ArrayList<Integer>();
        for (int mask = 0; mask < (1 << bM); ++mask) {
            bTotal = bM + Integer.bitCount(mask);
            if (bTotal > bestLen) {
                continue;
            }
            if (canConstruct(mask)) {
                if (bTotal < bestLen) {
                    bestLen = bTotal;
                    bestMasks.clear();
                    bestMasks.add(mask);
                } else {
                    bestMasks.add(mask);
                }
            }
        }
        List<List<Integer>> res = new ArrayList<List<Integer>>();
        for (int mask : bestMasks) {
            List<Integer> freq = new ArrayList<Integer>();
            for (int i = 0; i < 26; ++i) {
                freq.add(0);
            }
            for (int i = 0; i < bM; ++i) {
                freq.set(bNodes[i], ((mask >> i) & 1) == 1 ? 2 : 1);
            }
            res.add(freq);
        }
        return res;
    }

    private boolean canConstruct(int mask) {
        int[] cnt = new int[bM];
        for (int i = 0; i < bM; ++i) {
            cnt[i] = ((mask >> i) & 1) == 1 ? 2 : 1;
        }
        char[] cur = new char[bTotal];
        return permute(0, cnt, cur);
    }

    private boolean permute(int pos, int[] cnt, char[] cur) {
        if (pos == bTotal) {
            for (String w : bWords) {
                if (!isSubseq(w, cur, pos)) {
                    return false;
                }
            }
            return true;
        }
        boolean[] usedCh = new boolean[26];
        for (int i = 0; i < bM; ++i) {
            if (cnt[i] == 0 || usedCh[bNodes[i]]) {
                continue;
            }
            usedCh[bNodes[i]] = true;
            cnt[i]--;
            cur[pos] = (char) (bNodes[i] + 'a');
            if (permute(pos + 1, cnt, cur)) {
                return true;
            }
            cnt[i]++;
        }
        return false;
    }

    private boolean isSubseq(String w, char[] seq, int len) {
        int p = 0;
        for (int i = 0; i < len && p < 2; ++i) {
            if (seq[i] == w.charAt(p)) {
                p++;
            }
        }
        return p == 2;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + show(sol.supersequences(new String[] {"ab", "ba"}))
            + " (期望 2 组)");
        System.out.println("示例2: " + show(sol.supersequences(new String[] {"aa", "ac"}))
            + " (期望 [[2,0,1,0..]])");
        System.out.println("示例3: " + show(sol.supersequences(new String[] {"aa", "bb", "cc"}))
            + " (期望 [[2,2,2,0..]])");

        Random rand = new Random(47);
        int pass = 0, cases = 0;
        for (int t = 0; t < 800; ++t) {
            int letters = 2 + rand.nextInt(3); // 2..4 个字母
            String alpha = "abcdef";
            List<String> ws = new ArrayList<String>();
            int cnt = 1 + rand.nextInt(5);
            for (int i = 0; i < cnt; ++i) {
                char a = alpha.charAt(rand.nextInt(letters));
                char b = alpha.charAt(rand.nextInt(letters));
                String wd = "" + a + b;
                if (!ws.contains(wd)) {
                    ws.add(wd);
                }
            }
            if (ws.isEmpty()) {
                continue;
            }
            List<List<Integer>> x = sol.supersequences(ws.toArray(new String[0]));
            List<List<Integer>> y = sol.supersequencesBrute(ws.toArray(new String[0]));
            cases++;
            if (sameSet(x, y)) {
                pass++;
            } else {
                System.out.println("MISMATCH words=" + ws + " fast=" + show(x) + " brute=" + show(y));
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }

    private static boolean sameSet(List<List<Integer>> a, List<List<Integer>> b) {
        if (a.size() != b.size()) {
            return false;
        }
        boolean[] used = new boolean[b.size()];
        for (List<Integer> x : a) {
            boolean found = false;
            for (int j = 0; j < b.size(); ++j) {
                if (!used[j] && x.equals(b.get(j))) {
                    used[j] = true;
                    found = true;
                    break;
                }
            }
            if (!found) {
                return false;
            }
        }
        return true;
    }

    private static String show(List<List<Integer>> lists) {
        StringBuilder sb = new StringBuilder("[");
        for (List<Integer> l : lists) {
            sb.append(Arrays.toString(l.toArray(new Integer[0]))).append(",");
        }
        if (sb.length() > 1) {
            sb.setLength(sb.length() - 1);
        }
        sb.append("]");
        return sb.toString();
    }
}

复杂度分析

时间复杂度 O(2^m * (m + E)),空间 O(m + E)。

  • 时间复杂度:O(2^m * (m + E))
  • 空间复杂度:O(m + E)

3436. Find Valid Emails(查找合法邮箱)

题目类型:数据库(SQL)

题目描述

表:Users

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

user_id 是此表的唯一主键。表的每一行包含用户的唯一 ID 和邮箱地址。

编写解决方案找出所有合法邮箱。一个合法邮箱必须同时满足:

  • 恰好包含一个 @ 符号;
  • 以 .com 结尾;
  • @ 之前的部分只包含字母数字字符和下划线;
  • @ 之后、.com 之前的部分(域名)只包含字母。

返回结果表按 user_id 升序排序。

示例 1:

复制代码
输入:
Users 表:
+---------+---------------------+
| user_id | email               |
+---------+---------------------+
| 1       | alice@example.com   |
| 2       | bob_at_example.com  |
| 3       | charlie@example.net |
| 4       | david@domain.com    |
| 5       | eve@invalid         |
+---------+---------------------+
输出:
+---------+-------------------+
| user_id | email             |
+---------+-------------------+
| 1       | alice@example.com |
| 4       | david@domain.com  |
+---------+-------------------+
解释:
alice@example.com 合法:一个 @,alice 是字母数字,example.com 以字母开头并 .com 结尾。
bob_at_example.com 非法:没有 @(@ 的位置是下划线);
charlie@example.net 非法:不是 .com 结尾;
eve@invalid 非法:不是 .com 结尾。

解题思路

规则很适合用一条全锚定正则 表达:两端都加上 ^...$ 强制整串匹配。

解法一(推荐):单条 REGEXP_LIKE 全锚定

^[A-Za-z0-9_]+@[A-Za-z]+\.com$:

  • [A-Za-z0-9_]+:@ 前的本地部分,字母数字下划线,至少 1 个字符;
  • @:正则里只出现一次,天然限制"恰好一个 @";
  • [A-Za-z]+:域名只能字母,至少 1 个字符;
  • \.com$:以字面 .com 结尾(\. 转义点号),^/$ 锚点保证整串。

解法二(对照):LIKE 手工拆分

LIKE '%@%.com' 等方式无法同时校验"恰好一个 @"、"域名全字母"等约束,需要多个条件叠加,容易漏边界,不推荐。正则一行即可覆盖全部规则。

代码实现

sql 复制代码
-- 解法一(推荐):单条全锚定正则
SELECT user_id, email
FROM Users
WHERE REGEXP_LIKE(email, '^[A-Za-z0-9_]+@[A-Za-z]+\.com$')
ORDER BY user_id;

复杂度分析

  • 时间复杂度 :O(n),其中 n 为 Users 行数,每行做一次正则匹配。
  • 空间复杂度 :O(1),仅需常量级中间状态。

3437. Permutations III(全排列 III)

题目描述

给定一个正整数 n,返回 1 到 n 的所有排列,使得相邻的两个数不同奇偶。

答案按字典序从小到大返回。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= n <= 10

解题思路

解法一:回溯 + 奇偶约束,主提交版本

按 1...n 升序尝试填入 cur 的每个位置,若 i > 0 则要求当前数与前一数奇偶性不同。

由于枚举顺序天然升序,结果即为字典序。使用 vis[] 标记已用数字,回溯还原。

时间 O(n!),空间 O(n)(不含答案)。

解法二:next_permutation 字典序全排 + 筛选(对照)

按字典序生成全部排列(重复调用 next permutation),逐个检查相邻奇偶不同,

收集合法排列。思路与回溯完全独立,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:回溯 + 奇偶约束(主提交版本) ----------
    public int[][] permute(int n) {
        List<int[]> res = new ArrayList<int[]>();
        int[] cur = new int[n];
        boolean[] vis = new boolean[n + 1];
        dfs(0, n, cur, vis, res);
        return res.toArray(new int[res.size()][]);
    }

    private void dfs(int i, int n, int[] cur, boolean[] vis, List<int[]> res) {
        if (i == n) {
            res.add(cur.clone());
            return;
        }
        for (int j = 1; j <= n; ++j) {
            if (vis[j]) {
                continue;
            }
            if (i > 0 && (cur[i - 1] % 2) == (j % 2)) {
                continue; // 相邻不同奇偶
            }
            vis[j] = true;
            cur[i] = j;
            dfs(i + 1, n, cur, vis, res);
            vis[j] = false;
        }
    }

    // ---------- 解法二:next_permutation + 筛选(对照) ----------
    public int[][] permuteBrute(int n) {
        List<int[]> res = new ArrayList<int[]>();
        int[] a = new int[n];
        for (int i = 0; i < n; ++i) {
            a[i] = i + 1;
        }
        while (true) {
            boolean ok = true;
            for (int i = 0; i + 1 < n; ++i) {
                if ((a[i] % 2) == (a[i + 1] % 2)) {
                    ok = false;
                    break;
                }
            }
            if (ok) {
                res.add(a.clone());
            }
            if (!nextPerm(a)) {
                break;
            }
        }
        return res.toArray(new int[res.size()][]);
    }

    private boolean nextPerm(int[] a) {
        int n = a.length;
        int i = n - 2;
        while (i >= 0 && a[i] >= a[i + 1]) {
            i--;
        }
        if (i < 0) {
            return false;
        }
        int j = n - 1;
        while (a[j] <= a[i]) {
            j--;
        }
        int t = a[i];
        a[i] = a[j];
        a[j] = t;
        for (int l = i + 1, r = n - 1; l < r; ++l, --r) {
            t = a[l];
            a[l] = a[r];
            a[r] = t;
        }
        return true;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        for (int n = 1; n <= 7; ++n) {
            int[][] x = sol.permute(n);
            int[][] y = sol.permuteBrute(n);
            boolean same = x.length == y.length;
            if (same) {
                for (int i = 0; i < x.length; ++i) {
                    if (!Arrays.equals(x[i], y[i])) {
                        same = false;
                        break;
                    }
                }
            }
            if (same) {
                System.out.println("n=" + n + " PASS (" + x.length + " 个排列)");
            } else {
                System.out.println("n=" + n + " MISMATCH fast=" + x.length + " brute=" + y.length);
                System.out.println("fast=" + Arrays.deepToString(x));
                System.out.println("brute=" + Arrays.deepToString(y));
            }
        }
    }
}

复杂度分析

时间 O(n!),空间 O(n)(不含答案)。

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

3438. Find Valid Pair of Adjacent Digits in String(找到字符串中合法的相邻数字)

题目描述

给你一个只包含数字的字符串 s。如果 s 中两个相邻的数字满足以下条件,我们称它们是合法的:

  1. 前面的数字不等于第二个数字;
  2. 两个数字在 s 中出现的次数恰好分别等于这个数字本身。
    请你从左到右遍历字符串 s,并返回最先找到的合法相邻数字。如果这样的相邻数字不存在,
    请你返回一个空字符串。

示例 1

复制代码
s = "2523533" -> "23"

示例 2

复制代码
s = "221" -> "21"

示例 3

复制代码
s = "22" -> ""

提示:

  • 2 <= s.length <= 100
  • s 只包含 '1' 到 '9' 的数字

解题思路

解法一:频率统计 + 线性扫描,主提交版本

先统计每个数字 d 在 s 中的出现次数 cnt[d],然后从左到右检查每一对相邻数字 (x, y):

要求 x != y、cnt[x] == x、cnt[y] == y,命中即返回 "" + x + y。复杂度 O(n)。

解法二:逐对直接验证(对照)

对每个位置对,临时统计全串次数再判断,代码更直观,用于交叉验证(O(n^2))。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:频率统计 + 线性扫描(主提交版本) ----------
    public String findValidPair(String s) {
        int[] cnt = new int[10];
        for (int i = 0; i < s.length(); ++i) {
            cnt[s.charAt(i) - '0']++;
        }
        for (int i = 1; i < s.length(); ++i) {
            int x = s.charAt(i - 1) - '0';
            int y = s.charAt(i) - '0';
            if (x != y && cnt[x] == x && cnt[y] == y) {
                return "" + x + y;
            }
        }
        return "";
    }

    // ---------- 解法二:逐对直接验证(对照) ----------
    public String findValidPairBrute(String s) {
        for (int i = 1; i < s.length(); ++i) {
            int x = s.charAt(i - 1) - '0';
            int y = s.charAt(i) - '0';
            if (x == y) {
                continue;
            }
            int cx = 0, cy = 0;
            for (int j = 0; j < s.length(); ++j) {
                int d = s.charAt(j) - '0';
                if (d == x) {
                    cx++;
                } else if (d == y) {
                    cy++;
                }
            }
            if (cx == x && cy == y) {
                return "" + x + y;
            }
        }
        return "";
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.findValidPair("2523533") + " (期望 23)");
        System.out.println("示例2: " + sol.findValidPair("221") + " (期望 21)");
        System.out.println("示例3: " + sol.findValidPair("22") + " (期望 \"\")");

        Random rand = new Random(53);
        int pass = 0, cases = 0;
        for (int t = 0; t < 3000; ++t) {
            int n = 2 + rand.nextInt(8);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; ++i) {
                sb.append((char) ('1' + rand.nextInt(9)));
            }
            String s = sb.toString();
            String x = sol.findValidPair(s);
            String y = sol.findValidPairBrute(s);
            cases++;
            if (x.equals(y)) {
                pass++;
            } else {
                System.out.println("MISMATCH s=" + s + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

3439. Reschedule Meetings for Maximum Free Time I(重新安排会议得到最多空余时间 I)

题目描述

给你一个整数 eventTime 表示一个活动的总时长,这个活动开始于 t = 0,结束于 t = eventTime。

同时给你两个长度为 n 的整数数组 startTime 和 endTime。它们表示这次活动中 n 个时间没有

重叠的会议,其中第 i 个会议的时间为 [startTime[i], endTime[i]]。

你可以重新安排至多 k 个会议,安排的规则是将会议时间平移,且保持原来的会议时长。你的目的是

移动会议后最大化相邻两个会议之间的最长连续空余时间。移动前后所有会议之间的相对顺序需要保持

不变,而且会议时间也需要保持互不重叠。请你返回重新安排会议以后可以得到的最大空余时间。

注意,会议不能安排到整个活动的时间以外。

示例 1

复制代码
eventTime = 5, k = 1, startTime = [1,3], endTime = [2,5] -> 2

示例 2

复制代码
eventTime = 10, k = 1, startTime = [0,2,9], endTime = [1,4,10] -> 6

示例 3

复制代码
eventTime = 5, k = 2, startTime = [0,1,2,3,4], endTime = [1,2,3,4,5] -> 0

提示:

  • 1 <= eventTime <= 10^9
  • n == startTime.length == endTime.length
  • 2 <= n <= 10^5
  • 1 <= k <= n
  • 0 <= startTime[i] < endTime[i] <= eventTime
  • endTime[i] <= startTime[i + 1]

解题思路

解法一:滑动窗口空隙和,主提交版本

定义 gaps:gaps[0] = startTime[0](活动开始到首个会议)、gaps[i] = startTime[i] - endTime[i-1]

(会议间空隙,i = 1...n-1)、gaps[n] = eventTime - endTime[n-1](末会议后空隙)。

若把连续 k 个会议各自平移(保持顺序与时长),可以将这 k 个会议压缩到它们原所在连续区块的

开头(或任意一端),从而把它们之间及两端的 k + 1 个空隙合并为一个长空隙,其长度恰为这

k + 1 个 gaps 之和。故对每个窗口(长度 k + 1 的 gaps 连续和)取最大值即可。

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

解法二:直接枚举窗口(对照)

同样构建 gaps,用朴素双层循环枚举所有长度为 k + 1 的窗口求和取最大,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:滑动窗口空隙和(主提交版本) ----------
    public int maxFreeTime(int eventTime, int k, int[] startTime, int[] endTime) {
        int n = startTime.length;
        long[] gaps = new long[n + 1];
        gaps[0] = startTime[0];
        for (int i = 1; i < n; ++i) {
            gaps[i] = startTime[i] - endTime[i - 1];
        }
        gaps[n] = eventTime - endTime[n - 1];
        long win = 0;
        for (int i = 0; i <= k && i <= n; ++i) {
            win += gaps[i];
        }
        long best = win;
        for (int i = k + 1; i <= n; ++i) {
            win += gaps[i] - gaps[i - (k + 1)];
            if (win > best) {
                best = win;
            }
        }
        return (int) best;
    }

    // ---------- 解法二:直接枚举窗口(对照) ----------
    public int maxFreeTimeBrute(int eventTime, int k, int[] startTime, int[] endTime) {
        int n = startTime.length;
        long[] gaps = new long[n + 1];
        gaps[0] = startTime[0];
        for (int i = 1; i < n; ++i) {
            gaps[i] = startTime[i] - endTime[i - 1];
        }
        gaps[n] = eventTime - endTime[n - 1];
        long best = 0;
        int window = Math.min(k + 1, n + 1);
        for (int i = 0; i + window <= n + 1; ++i) {
            long s = 0;
            for (int j = 0; j < window; ++j) {
                s += gaps[i + j];
            }
            best = Math.max(best, s);
        }
        return (int) best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.maxFreeTime(5, 1, new int[] {1, 3}, new int[] {2, 5})
            + " (期望 2)");
        System.out.println("示例2: " + sol.maxFreeTime(10, 1, new int[] {0, 2, 9},
            new int[] {1, 4, 10}) + " (期望 6)");
        System.out.println("示例3: " + sol.maxFreeTime(5, 2, new int[] {0, 1, 2, 3, 4},
            new int[] {1, 2, 3, 4, 5}) + " (期望 0)");

        Random rand = new Random(59);
        int pass = 0, cases = 0;
        for (int t = 0; t < 3000; ++t) {
            int n = 2 + rand.nextInt(7);
            int[] st = new int[n];
            int[] et = new int[n];
            int cur = rand.nextInt(3);
            for (int i = 0; i < n; ++i) {
                int dur = 1 + rand.nextInt(4);
                st[i] = cur;
                et[i] = cur + dur;
                cur += dur + rand.nextInt(3); // 空隙 0..2
            }
            int eventTime = cur + rand.nextInt(4);
            int k = 1 + rand.nextInt(n);
            int x = sol.maxFreeTime(eventTime, k, st, et);
            int y = sol.maxFreeTimeBrute(eventTime, k, st, et);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH eventTime=" + eventTime + " k=" + k
                    + " st=" + Arrays.toString(st) + " et=" + Arrays.toString(et)
                    + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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

3440. Reschedule Meetings for Maximum Free Time II(重新安排会议得到最多空余时间 II)

题目描述

给你一个整数 eventTime 表示一个活动的总时长,这个活动开始于 t = 0,结束于 t = eventTime。

同时给你两个长度为 n 的整数数组 startTime 和 endTime。它们表示这次活动中 n 个时间没有

重叠的会议,其中第 i 个会议的时间为 [startTime[i], endTime[i]]。

你可以重新安排至多一个会议,安排的规则是将会议时间平移,且保持原来的会议时长。你的目的是移动

会议后最大化最长连续空余时间。注意:重新安排会议以后,会议之间的顺序可以发生改变。

请你返回重新安排会议以后可以得到的最大空余时间。

示例 1

复制代码
eventTime = 5, startTime = [1,3], endTime = [2,5] -> 2

示例 2

复制代码
eventTime = 10, startTime = [0,7,9], endTime = [1,8,10] -> 7

示例 3

复制代码
eventTime = 10, startTime = [0,3,7,9], endTime = [1,4,8,10] -> 6

示例 4

复制代码
eventTime = 5, startTime = [0,1,2,3,4], endTime = [1,2,3,4,5] -> 0

提示:

  • 1 <= eventTime <= 10^9
  • n == startTime.length == endTime.length
  • 2 <= n <= 10^5
  • 0 <= startTime[i] < endTime[i] <= eventTime
  • endTime[i] <= startTime[i + 1]

解题思路

解法一:维护前三大的空隙 + 枚举会议,主提交版本

把会议看作「桌子」,会议之间(含两端)的空闲时间看作「空位」。枚举要移动的会议 i:

若存在一个不与 i 左右两侧相邻 的空位(长度 >= 会议时长),把 i 移过去,则 i 两侧的空位

与会议本身合并成一个新空位,长度 = 左空位 + 右空位 + 会议时长;

若不存在这样的空位(最长空位/次长空位恰好都在 i 两侧),则保持 i 在原位置最划算,

空位长度 = 左空位 + 右空位。

为快速判断「非两侧的最长空位」,只需维护全部空位中长度最大的三个:若最大空位在 i 两侧之一,

看次大;若次大也在两侧,则只能用第三大(若存在且够长)。i 左右各只有一个相邻空位,

故最多 2 个空位在两侧,前三大的枚举一定覆盖所有情况。

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

解法二:直接模拟移动每个会议(对照)

对每个会议 i,尝试把它移动到所有不与它重叠且够长的空位中,逐一重算移动后的最长空隙并取最大

(小规模数据)。思路直接、无需维护前三,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:前三空隙 + 枚举会议(主提交版本) ----------
    public int maxFreeTime(int eventTime, int[] startTime, int[] endTime) {
        int n = startTime.length;
        long[] gap = new long[n + 1];
        gap[0] = startTime[0];
        for (int i = 1; i < n; ++i) {
            gap[i] = startTime[i] - endTime[i - 1];
        }
        gap[n] = eventTime - endTime[n - 1];
        // 前三大空隙 (len, idx)
        long[] top = new long[3];
        int[] topIdx = new int[3];
        Arrays.fill(top, -1);
        Arrays.fill(topIdx, -1);
        for (int i = 0; i <= n; ++i) {
            long v = gap[i];
            for (int r = 0; r < 3; ++r) {
                if (v > top[r]) {
                    for (int s = 2; s > r; --s) {
                        top[s] = top[s - 1];
                        topIdx[s] = topIdx[s - 1];
                    }
                    top[r] = v;
                    topIdx[r] = i;
                    break;
                }
            }
        }
        long best = 0;
        for (int i = 0; i < n; ++i) {
            long left = gap[i];
            long right = gap[i + 1];
            long dur = endTime[i] - startTime[i];
            // 找一个不在 i 两侧的空位
            long target = -1;
            for (int r = 0; r < 3; ++r) {
                if (top[r] < 0) {
                    continue;
                }
                if (topIdx[r] != i && topIdx[r] != i + 1) {
                    target = top[r];
                    break;
                }
            }
            long cand;
            if (target >= dur) {
                cand = left + right + dur;
            } else {
                cand = left + right;
            }
            if (cand > best) {
                best = cand;
            }
        }
        return (int) best;
    }

    // ---------- 解法二:直接模拟移动(对照,仅小规模) ----------
    public int maxFreeTimeBrute(int eventTime, int[] startTime, int[] endTime) {
        int n = startTime.length;
        long[] gap = new long[n + 1];
        gap[0] = startTime[0];
        for (int i = 1; i < n; ++i) {
            gap[i] = startTime[i] - endTime[i - 1];
        }
        gap[n] = eventTime - endTime[n - 1];
        long best = 0;
        for (int i = 0; i < n; ++i) {
            long dur = endTime[i] - startTime[i];
            // 不移动 i 时:
            best = Math.max(best, gap[i] + gap[i + 1]);
            // 尝试移到其它空位
            for (int g = 0; g <= n; ++g) {
                if (g == i || g == i + 1) {
                    continue;
                }
                if (gap[g] >= dur) {
                    // 移走 i:i 两侧空隙合并
                    long merged = gap[i] + gap[i + 1] + dur;
                    // 目标空位被会议占用,剩余 = gap[g] - dur
                    best = Math.max(best, Math.max(merged, gap[g] - dur));
                }
            }
        }
        return (int) best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        System.out.println("示例1: " + sol.maxFreeTime(5, new int[] {1, 3}, new int[] {2, 5})
            + " (期望 2)");
        System.out.println("示例2: " + sol.maxFreeTime(10, new int[] {0, 7, 9},
            new int[] {1, 8, 10}) + " (期望 7)");
        System.out.println("示例3: " + sol.maxFreeTime(10, new int[] {0, 3, 7, 9},
            new int[] {1, 4, 8, 10}) + " (期望 6)");
        System.out.println("示例4: " + sol.maxFreeTime(5, new int[] {0, 1, 2, 3, 4},
            new int[] {1, 2, 3, 4, 5}) + " (期望 0)");

        Random rand = new Random(61);
        int pass = 0, cases = 0;
        for (int t = 0; t < 5000; ++t) {
            int n = 2 + rand.nextInt(6);
            int[] st = new int[n];
            int[] et = new int[n];
            int cur = rand.nextInt(3);
            for (int i = 0; i < n; ++i) {
                int dur = 1 + rand.nextInt(4);
                st[i] = cur;
                et[i] = cur + dur;
                cur += dur + rand.nextInt(4); // 空隙 0..3
            }
            int eventTime = cur + rand.nextInt(5);
            int x = sol.maxFreeTime(eventTime, st, et);
            int y = sol.maxFreeTimeBrute(eventTime, st, et);
            cases++;
            if (x == y) {
                pass++;
            } else {
                System.out.println("MISMATCH eventTime=" + eventTime
                    + " st=" + Arrays.toString(st) + " et=" + Arrays.toString(et)
                    + " fast=" + x + " brute=" + y);
            }
        }
        System.out.println("ALL PASS (" + pass + "/" + cases + ")");
    }
}

复杂度分析

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

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