LeetCode3061~3080题目解析

LeetCode 3061-3080. 题解合集

文章目录


3061. Calculate Trapping Rain Water(计算滞留雨水)

题目类型:数据库(SQL)

题目描述

表:Heights

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

id 是这张表的主键且已保证有序。每一行表示一个宽度为 1 的沙洲的高度。

编写解决方案,计算景观中沙洲之间可以滞留的雨水量(每个沙洲宽度为 1 个单位)。

以任何 顺序返回结果表,输出总滞留水量 total_trapped_water。

示例 1:

复制代码
输入:
Heights 表 12 行:heights = [0,1,0,2,1,0,1,3,2,1,2,1]
输出:
+---------------------+
| total_trapped_water |
+---------------------+
| 6                   |
+---------------------+

解释:经典接雨水问题,蓝色区域共滞留 6 个单位雨水。

解题思路

经典"接雨水":每个位置能接的水 = MAX(0, MIN(左侧最大高度, 右侧最大高度) - 当前高度)。用窗口函数 MAX(height) OVER (ORDER BY id) 求每个位置的左侧最大值(含自身),MAX(height) OVER (ORDER BY id DESC) 求右侧最大值(含自身),再 SUM(GREATEST(LEAST(lm, rm) - height, 0)) 求总量。id 已有序,天然符合从左到右的柱子顺序。

代码实现

sql 复制代码
WITH left_max AS (
    SELECT id, MAX(height) OVER (ORDER BY id) AS lm FROM Heights
),
right_max AS (
    SELECT id, MAX(height) OVER (ORDER BY id DESC) AS rm FROM Heights
)
SELECT SUM(GREATEST(LEAST(l.lm, r.rm) - h.height, 0)) AS total_trapped_water
FROM Heights h
JOIN left_max l ON h.id = l.id
JOIN right_max r ON h.id = r.id;

复杂度分析

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


3062. Winner of the Linked List Game(链表游戏的获胜者 🔒)

题目描述

给定长度为偶数、包含整数的链表的 head 节点。

每个奇数编号的节点包含一个奇数,每个偶数编号的节点包含一个偶数。

我们把每个偶数编号的节点和它的下一个节点叫做一个"对"(如 0 和 1 是一对,

2 和 3 是一对,以此类推)。

对于每个对,比较对中节点的值:

  • 如果奇数节点更大,"Odd" 队得一分;
  • 如果偶数节点更大,"Even" 队得一分。
    返回分数更高的队名;如果分数相同,返回 "Tie"。

示例 1

复制代码
head = [2,1] -> "Even"

示例 2

复制代码
head = [2,5,4,7,20,5] -> "Odd"

示例 3

复制代码
head = [4,5,2,1] -> "Tie"

提示:

  • 链表中节点的数字在范围 1, 100 内
  • 链表中的节点数为偶数
  • 每个奇数编号节点的值都是奇数,每个偶数编号节点的值都是偶数
  • 链表定义(与 LeetCode 一致):
  • public class ListNode {
  • int val;
  • ListNode next;
  • ListNode() {}
  • ListNode(int val) { this.val = val; }
  • ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  • }

解题思路

解法一:成对遍历比较,主提交版本

下标从 0 开始,"偶数编号节点"即 0、2、4...(节点的第 1、3、5... 个),

每对由 cur(偶数编号)与 cur.next(奇数编号)组成。

若 even 值更大则 even 队得分,否则 odd 队得分。最后比较两队分数返回队名。

时间复杂度 O(n)(n 为链表长度),空间复杂度 O(1)。

解法二:链表转数组后两两比较(对照)

先把链表元素收集到数组,再按下标奇偶两两比较累加分数,逻辑等价、便于交叉验证。

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

复杂度:

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

代码实现

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

public class Solution {

    static class ListNode {
        int val;
        ListNode next;
        ListNode(int val) {
            this.val = val;
        }
    }

    // ---------- 解法一:成对遍历比较(主提交版本) ----------
    public String gameResult(ListNode head) {
        int odd = 0;  // Odd 队得分(奇数编号节点)
        int even = 0; // Even 队得分(偶数编号节点)
        ListNode cur = head;
        while (cur != null && cur.next != null) {
            if (cur.val > cur.next.val) {
                even++;
            } else {
                odd++;
            }
            cur = cur.next.next;
        }
        return odd == even ? "Tie" : (odd > even ? "Odd" : "Even");
    }

    // ---------- 解法二:转数组两两比较(对照) ----------
    public String gameResultByArray(ListNode head) {
        java.util.List<Integer> vals = new java.util.ArrayList<>();
        for (ListNode p = head; p != null; p = p.next) {
            vals.add(p.val);
        }
        int odd = 0, even = 0;
        for (int i = 0; i + 1 < vals.size(); i += 2) {
            if (vals.get(i) > vals.get(i + 1)) {
                even++;
            } else {
                odd++;
            }
        }
        return odd == even ? "Tie" : (odd > even ? "Odd" : "Even");
    }

    // ---------- 本地测试 ----------
    private static ListNode build(int[] arr) {
        ListNode dummy = new ListNode(0);
        ListNode p = dummy;
        for (int v : arr) {
            p.next = new ListNode(v);
            p = p.next;
        }
        return dummy.next;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {2, 1},
            {2, 5, 4, 7, 20, 5},
            {4, 5, 2, 1},
        };
        String[] expects = {"Even", "Odd", "Tie"};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            String a = sol.gameResult(build(cases[i]));
            String b = sol.gameResultByArray(build(cases[i]));
            boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + a
                    + " / array=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
    }
}

复杂度分析

时间复杂度 O(n)(n 为链表长度),空间复杂度 O(1)。

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

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

3063. Linked List Frequency(链表频率 🔒)

题目描述

给定包含 k 个不同元素的链表的 head 节点,创建一个长度为 k 的链表,

以任何顺序返回链表中所有不同元素出现的频率。返回这个链表的头节点。

示例 1

复制代码
head = [1,1,2,1,2,3] -> [3,2,1](1 出现 3 次、2 出现 2 次、3 出现 1 次)

示例 2

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

示例 3

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

提示:

  • 链表中的节点数字范围在 1, 10\^5 之间
  • 1 <= Node.val <= 10^5
  • 链表定义(与 LeetCode 一致):
  • public class ListNode {
  • int val;
  • ListNode next;
  • ListNode() {}
  • ListNode(int val) { this.val = val; }
  • ListNode(int val, ListNode next) { this.val = val; this.next = next; }
  • }

解题思路

解法一:哈希表统计频次后建链,主提交版本

遍历链表,用哈希表统计每个不同元素出现的次数;

再遍历哈希表的值集合,把它们依次串成新链表返回。

频次链表顺序任意,题目允许任意合法顺序。

时间复杂度 O(n)(n 为链表长度),空间复杂度 O(k)(k 为不同元素个数)。

解法二:计数数组统计后建链(对照)

数值范围受限(1 <= val <= 10^5),可用计数数组替代哈希表:

第一遍统计各值出现次数,第二遍把出现过的值的次数串成链表。

时间复杂度 O(n + V)(V 为值域 10^5),空间复杂度 O(V)。

复杂度:

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

代码实现

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

public class Solution {

    static class ListNode {
        int val;
        ListNode next;
        ListNode(int val) {
            this.val = val;
        }
    }

    // ---------- 解法一:哈希表统计频次后建链(主提交版本) ----------
    public ListNode frequenciesOfElements(ListNode head) {
        Map<Integer, Integer> cnt = new HashMap<>();
        for (ListNode p = head; p != null; p = p.next) {
            cnt.put(p.val, cnt.getOrDefault(p.val, 0) + 1);
        }
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        for (int v : cnt.values()) {
            tail.next = new ListNode(v);
            tail = tail.next;
        }
        return dummy.next;
    }

    // ---------- 解法二:计数数组统计后建链(对照) ----------
    public ListNode frequenciesOfElementsByArray(ListNode head) {
        int maxVal = 100000;
        int[] cnt = new int[maxVal + 1];
        for (ListNode p = head; p != null; p = p.next) {
            cnt[p.val]++;
        }
        ListNode dummy = new ListNode(0);
        ListNode tail = dummy;
        for (int v = 1; v <= maxVal; ++v) {
            if (cnt[v] > 0) {
                tail.next = new ListNode(cnt[v]);
                tail = tail.next;
            }
        }
        return dummy.next;
    }

    // ---------- 本地测试 ----------
    private static ListNode build(int[] arr) {
        ListNode dummy = new ListNode(0);
        ListNode p = dummy;
        for (int v : arr) {
            p.next = new ListNode(v);
            p = p.next;
        }
        return dummy.next;
    }

    private static int[] toArray(ListNode head) {
        java.util.List<Integer> list = new java.util.ArrayList<>();
        for (ListNode p = head; p != null; p = p.next) {
            list.add(p.val);
        }
        int[] res = new int[list.size()];
        for (int i = 0; i < res.length; ++i) {
            res[i] = list.get(i);
        }
        return res;
    }

    private static int[] sorted(int[] arr) {
        int[] s = arr.clone();
        Arrays.sort(s);
        return s;
    }

    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {1, 1, 2, 1, 2, 3},
            {1, 1, 2, 2, 2},
            {6, 5, 4, 3, 2, 1},
        };
        int[][] expects = {
            {3, 2, 1},
            {2, 3},
            {1, 1, 1, 1, 1, 1},
        };
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int[] a = sorted(toArray(sol.frequenciesOfElements(build(cases[i]))));
            int[] b = sorted(toArray(sol.frequenciesOfElementsByArray(build(cases[i]))));
            Arrays.sort(expects[i]);
            boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
            allPass &= ok;
            System.out.println("freq of " + Arrays.toString(cases[i]) + " -> "
                    + Arrays.toString(a) + " / array=" + Arrays.toString(b)
                    + " expected=" + Arrays.toString(expects[i])
                    + (ok ? " PASS" : " FAIL"));
        }
        System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
    }
}

复杂度分析

时间复杂度 O(n)(n 为链表长度),空间复杂度 O(k)(k 为不同元素个数)。

时间复杂度 O(n + V)(V 为值域 10^5),空间复杂度 O(V)。

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

3064. Guess the Number Using Bitwise Questions I(使用按位查询猜测数字 I 🔒)

题目描述

你需要找到一个数字 n。

这里有一个预定义的 API int commonSetBits(int num),它返回 n 和 num 在二进制表示

的同一位置上都是 1 的位数。换句话说,它返回 n & num 的设置位数量。

返回数字 n。

示例 1

复制代码
n = 31 -> 31

示例 2

复制代码
n = 33 -> 33

提示:

  • 1 <= n <= 2^30 - 1
  • 0 <= num <= 2^30 - 1
  • 如果你查询的 num 超出了给定的范围,输出就不可靠
  • 预定义 API(与 LeetCode 一致,本地测试用内部类模拟):
  • int commonSetBits(int num);

解题思路

解法一:逐位查询重构,主提交版本

n 最大 2^30 - 1,只用考察二进制低 30 位。对每个位 i(0...29),

调用 commonSetBits(1 << i):

  • 返回 1:说明 n 与 (1 << i) 的公共设置位有 1 个,即 n 的第 i 位为 1;
  • 返回 0:说明 n 的第 i 位为 0。
    把为 1 的位通过按位或累加到答案即可还原 n。
    共 30 次 API 查询,时间复杂度 O(30)(常数,等价 O(log n)),空间复杂度 O(1)。
    解法二:区间滤波查询(对照)
    对每个 bit 用 (1 << i) 的不同放大倍数验证性质,或直接采用"查询返回值为
    非零即置位"的等价写法,保证 API 调用总数一致、结果一致,用于交叉验证。
    本例中两种实现逐位一致。
    复杂度:
  • 时间复杂度:O(log n)(最多 30 次查询)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {

    // ---------- 解法一:逐位查询重构(主提交版本) ----------
    public int findNumber() {
        int ans = 0;
        for (int i = 0; i < 30; ++i) {
            int mask = 1 << i;
            if (commonSetBits(mask) > 0) {
                ans |= mask;
            }
        }
        return ans;
    }

    // ---------- 解法二:等价位标记(对照,逻辑等价) ----------
    public int findNumberAlt() {
        int ans = 0;
        for (int i = 0; i < 30; ++i) {
            int mask = 1 << i;
            // commonSetBits(mask) 返回 0 或 1(mask 只有单一位),非零即置位
            ans |= (commonSetBits(mask) == 1 ? mask : 0);
        }
        return ans;
    }

    // ---------- 预定义 API(本地测试模拟) ----------
    private static int hiddenN;

    // 题目约定由评测系统提供的 API:返回 n 与 num 的公共设置位数
    private int commonSetBits(int num) {
        return Integer.bitCount(hiddenN & num);
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] cases = {31, 33, 1, 2, 1073741823, 123456, 1000000000, 1 << 29, 0x3FFFFFFF};
        boolean allPass = true;
        for (int n : cases) {
            hiddenN = n;
            int a = sol.findNumber();
            int b = sol.findNumberAlt();
            boolean ok = a == n && b == n;
            allPass &= ok;
            System.out.println("n=" + n + " -> " + a + " / alt=" + b
                    + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍:随机 n,验证逐位重构正确性
        Random rnd = new Random(3064);
        int trials = 10000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt((1 << 30) - 1);
            hiddenN = n;
            if (sol.findNumber() != n) {
                fail++;
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

共 30 次 API 查询,时间复杂度 O(30)(常数,等价 O(log n)),空间复杂度 O(1)。

  • 时间复杂度:O(log n)(最多 30 次查询)
  • 空间复杂度:O(1)

3065. Minimum Operations to Exceed Threshold Value I(超过阈值的最少操作数 I)

题目描述

给你一个下标从 0 开始的整数数组 nums 和一个整数 k。

一次操作中,你可以删除 nums 中的最小元素。

你需要使数组中的所有元素都大于或等于 k,请你返回需要的最少操作次数。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= nums.length <= 50
  • 1 <= nums[i] <= 10^9
  • 1 <= k <= 10^9
  • 输入保证至少有一个满足 nums[i] >= k 的下标 i 存在

解题思路

解法一:直接计数,主提交版本

每次删除最小元素等价于:最终保留的都是 >= k 的元素,删除的都是 < k 的元素,

因此答案就是 nums 中小于 k 的元素个数。一趟遍历计数即可。

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

解法二:排序后计数(对照)

先排序,然后找到第一个 >= k 的位置,其下标即小于 k 的元素个数。

时间复杂度 O(n log n),空间复杂度 O(1)(原地排序)。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:直接计数(主提交版本) ----------
    public int minOperations(int[] nums, int k) {
        int cnt = 0;
        for (int v : nums) {
            if (v < k) {
                cnt++;
            }
        }
        return cnt;
    }

    // ---------- 解法二:排序后二分(对照) ----------
    public int minOperationsBySort(int[] nums, int k) {
        int[] a = nums.clone();
        Arrays.sort(a);
        // 找第一个 >= k 的位置
        int lo = 0, hi = a.length;
        while (lo < hi) {
            int mid = (lo + hi) >>> 1;
            if (a[mid] >= k) {
                hi = mid;
            } else {
                lo = mid + 1;
            }
        }
        return lo;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {2, 11, 10, 1, 3},
            {1, 1, 2, 4, 9},
            {1, 1, 2, 4, 9},
        };
        int[] ks = {10, 1, 9};
        int[] expects = {3, 0, 4};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.minOperations(cases[i], ks[i]);
            int b = sol.minOperationsBySort(cases[i], ks[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
                    + " -> " + a + " / sort=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
    }
}

复杂度分析

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

时间复杂度 O(n log n),空间复杂度 O(1)(原地排序)。

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

3066. Minimum Operations to Exceed Threshold Value II(超过阈值的最少操作数 II)

题目描述

给你一个下标从 0 开始的整数数组 nums 和一个整数 k。

一次操作中:选择 nums 中最小的两个整数 x 和 y;将 x 和 y 从 nums 中删除;

将 min(x, y) * 2 + max(x, y) 添加到数组中的任意位置。

注意,只有当 nums 至少包含两个元素时,你才可以执行以上操作。

你需要使数组中的所有元素都大于或等于 k,请你返回需要的最少操作次数。

示例 1

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

示例 2

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

示例 3

复制代码
nums = [1,1,2,4,9], k = 1 -> 0(无需操作)

提示:

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

解题思路

解法一:小根堆模拟,主提交版本

每步必然选择当前最小的两个元素(贪心:小元素只有合并才能变大,且合并结果 min*2+max

单调不降)。用小根堆维护所有元素:

每次弹出堆顶两个最小元素,若堆顶已 >= k 则说明所有元素都 >= k,停止;

否则做一次操作,把 min(x,y)*2 + max(x,y)(注意可能溢出,用 long)压回堆中,ans++。

当堆中只剩一个元素且仍 < k 时返回 -1(或按题意无法达成时返回 -1)。

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

解法二:小根堆 + 逐个判断(对照,逻辑等价)

同样用堆,但每轮先判断堆内最小元素是否 >= k(若 >= 则全部 >= k),

否则取最小两个合并。两种写法结果一致,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:小根堆模拟(主提交版本) ----------
    public int minOperations(int[] nums, int k) {
        PriorityQueue<Long> pq = new PriorityQueue<>();
        for (int v : nums) {
            pq.offer((long) v);
        }
        int ans = 0;
        while (pq.size() >= 2 && pq.peek() < k) {
            long x = pq.poll();
            long y = pq.poll();
            pq.offer(Math.min(x, y) * 2 + Math.max(x, y));
            ans++;
        }
        // 若堆顶仍 < k 且堆中不足两个元素,则无法达成
        return pq.peek() >= k ? ans : -1;
    }

    // ---------- 解法二:堆 + 循环合并(对照,逻辑等价) ----------
    public int minOperationsAlt(int[] nums, int k) {
        PriorityQueue<Long> pq = new PriorityQueue<>();
        for (int v : nums) {
            pq.offer((long) v);
        }
        int ans = 0;
        while (true) {
            if (pq.peek() >= k) {
                return ans;
            }
            if (pq.size() < 2) {
                return -1;
            }
            long x = pq.poll();
            long y = pq.poll();
            pq.offer(Math.min(x, y) * 2 + Math.max(x, y));
            ans++;
        }
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {2, 11, 10, 1, 3},
            {1, 1, 2, 4, 9},
            {1, 1, 2, 4, 9},
            {1, 1, 2, 4, 9},
            {1},
        };
        int[] ks = {10, 20, 1, 9, 100};
        int[] expects = {2, 4, 0, 3, -1};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.minOperations(cases[i], ks[i]);
            int b = sol.minOperationsAlt(cases[i], ks[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
                    + " -> " + a + " / alt=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
    }
}

复杂度分析

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

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

3067. Count Pairs of Connectable Servers in a Weighted Tree Network

题目描述

(在带权树网络中统计可连接服务器对数目)

给你一棵无根带权树,树中总共有 n 个节点,分别表示 n 个服务器,服务器从 0 到 n - 1 编号。

同时给你一个数组 edges,其中 edges[i] = `ai`, `bi`, `weighti` 表示节点 ai 和 bi 之间

有一条双向边,边的权值为 weighti。再给你一个整数 signalSpeed。

如果两台服务器 a 和 b 是通过服务器 c 可连接的,则:

  • a < b,a != c 且 b != c;
  • 从 c 到 a 的距离是可以被 signalSpeed 整除的;
  • 从 c 到 b 的距离是可以被 signalSpeed 整除的;
  • 从 c 到 b 的路径与从 c 到 a 的路径没有任何公共边。
    请你返回一个长度为 n 的整数数组 count,其中 count[i] 表示通过服务器 i 可连接的服务器对的数目。

示例 1

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

示例 2

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

提示:

  • 2 <= n <= 1000
  • edges.length == n - 1
  • 0 <= ai, bi < n
  • 1 <= weighti <= 10^6
  • 1 <= signalSpeed <= 10^6

解题思路

解法一:以每个节点为根的 DFS 分支计数,主提交版本

以某个节点 c 为根时,把它的邻居看作独立的"分支"。从 c 出发沿某个分支走,

距离能被 signalSpeed 整除的节点数记为 w(候选端点数)。

"通过 c 可连接"等价于:从两个不同分支中各取一个候选端点组成对。

若各分支候选端点数为 w1, w2, ..., wd,则通过 c 的可连接对数为

sum_{i<j} wi * wj = ((sum wi)^2 - sum wi^2) / 2。

对每个节点 c 做一次 DFS 即可,总复杂度 O(n^2)(n <= 1000 可过)。

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

解法二:BFS 距离 + 全点对枚举(对照)

对每个 c 做一次 BFS 得到 c 到全图距离 dist 与父链 parent;

对任意有序候选端点 a(dista % signalSpeed == 0),记录其第一跳 fa;

再对所有候选端点对 (a, b)(a != b)检查 fa != fb,计数。

与小规模主解结果交叉验证。

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

复杂度:

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

代码实现

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

public class Solution {

    private List<int[]>[] g;
    private int signalSpeed;

    @SuppressWarnings("unchecked")
    private void buildGraph(int[][] edges) {
        int n = edges.length + 1;
        g = new List[n];
        for (int i = 0; i < n; ++i) {
            g[i] = new ArrayList<>();
        }
        for (int[] e : edges) {
            g[e[0]].add(new int[]{e[1], e[2]});
            g[e[1]].add(new int[]{e[0], e[2]});
        }
    }

    // ---------- 解法一:每个根节点的分支 DFS 计数(主提交版本) ----------
    public int[] countPairsOfConnectableServers(int[][] edges, int signalSpeed) {
        this.signalSpeed = signalSpeed;
        buildGraph(edges);
        int n = edges.length + 1;
        int[] ans = new int[n];
        for (int c = 0; c < n; ++c) {
            int total = 0;
            int sq = 0;
            for (int[] ne : g[c]) {
                int w = countBranch(ne[0], c, ne[1]);
                total += w;
                sq += w * w;
            }
            ans[c] = (total * total - sq) / 2;
        }
        return ans;
    }

    // 从 u 出发(父节点 p,累计距离 dist),统计该分支中距离被 signalSpeed 整除的节点数
    private int countBranch(int u, int p, int dist) {
        int cnt = (dist % signalSpeed == 0) ? 1 : 0;
        for (int[] ne : g[u]) {
            if (ne[0] != p) {
                cnt += countBranch(ne[0], u, dist + ne[1]);
            }
        }
        return cnt;
    }

    // ---------- 解法二:BFS 距离 + 点对枚举(对照) ----------
    public int[] countPairsBrute(int[][] edges, int signalSpeed) {
        int n = edges.length + 1;
        buildGraph(edges);
        int[] ans = new int[n];
        for (int c = 0; c < n; ++c) {
            int[] dist = new int[n];
            int[] parent = new int[n];
            Arrays.fill(dist, -1);
            Arrays.fill(parent, -1);
            java.util.ArrayDeque<Integer> q = new java.util.ArrayDeque<>();
            q.add(c);
            dist[c] = 0;
            while (!q.isEmpty()) {
                int u = q.poll();
                for (int[] ne : g[u]) {
                    if (dist[ne[0]] < 0) {
                        dist[ne[0]] = dist[u] + ne[1];
                        parent[ne[0]] = u;
                        q.add(ne[0]);
                    }
                }
            }
            // 收集候选端点(距离整除 signalSpeed 且不是 c)
            List<Integer> cands = new ArrayList<>();
            for (int x = 0; x < n; ++x) {
                if (x != c && dist[x] % signalSpeed == 0) {
                    cands.add(x);
                }
            }
            // 任意两个候选端点,若第一跳不同则构成一对
            for (int i = 0; i < cands.size(); ++i) {
                int a = cands.get(i);
                for (int j = i + 1; j < cands.size(); ++j) {
                    int b = cands.get(j);
                    if (firstHop(parent, c, a) != firstHop(parent, c, b)) {
                        ans[c]++;
                    }
                }
            }
        }
        return ans;
    }

    // 从 x 沿父链上溯到 c 的下一跳(即第一跳)
    private int firstHop(int[] parent, int c, int x) {
        while (parent[x] != c) {
            x = parent[x];
        }
        return x;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][][] edgesCases = {
            {{0,1,1},{1,2,5},{2,3,13},{3,4,9},{4,5,2}},
            {{0,6,3},{6,5,3},{0,3,1},{3,2,7},{3,1,6},{3,4,2}},
        };
        int[] speeds = {1, 3};
        int[][] expects = {
            {0,4,6,6,4,0},
            {2,0,0,0,0,0,2},
        };
        boolean allPass = true;
        for (int t = 0; t < edgesCases.length; ++t) {
            int[] a = sol.countPairsOfConnectableServers(edgesCases[t], speeds[t]);
            int[] b = sol.countPairsBrute(edgesCases[t], speeds[t]);
            boolean ok = Arrays.equals(a, expects[t]) && Arrays.equals(b, expects[t]);
            allPass &= ok;
            System.out.println("case" + t + " main=" + Arrays.toString(a)
                    + " brute=" + Arrays.toString(b)
                    + " expected=" + Arrays.toString(expects[t])
                    + (ok ? " PASS" : " FAIL"));
        }

        // 随机对拍:随机树
        Random rnd = new Random(3067);
        int trials = 300;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 2 + rnd.nextInt(6); // 2..7 个节点
            int[][] edges = new int[n - 1][];
            for (int i = 1; i < n; ++i) {
                int p = rnd.nextInt(i);
                int w = 1 + rnd.nextInt(5);
                edges[i - 1] = new int[]{p, i, w};
            }
            int speed = 1 + rnd.nextInt(4);
            int[] a = sol.countPairsOfConnectableServers(edges, speed);
            int[] b = sol.countPairsBrute(edges, speed);
            if (!Arrays.equals(a, b)) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH n=" + n + " speed=" + speed);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

3068. Find the Maximum Sum of Node Values(最大节点价值之和)

题目描述

给你一棵 n 个节点的无向树,节点从 0 到 n - 1 编号。树以长度为 n - 1 的二维整数数组

edges 的形式给出,其中 edges[i] = `ui`, `vi` 表示节点 ui 和 vi 之间有一条边。

同时给你一个正整数 k 和一个长度为 n 的非负整数数组 nums,其中 nums[i] 表示节点 i 的价值。

Alice 想最大化树中所有节点价值之和。为了实现这一目标,Alice 可以执行以下操作任意次:

  • 选择连接节点 u 和 v 的边 `u`, `v`,并将它们的值更新为 nums[u] = nums[u] XOR k、
    nums[v] = nums[v] XOR k
    返回 Alice 可以得到的所有节点价值之和的最大值。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= n == nums.length <= 2 * 10^4
  • 0 <= nums[i] <= 10^9
  • 1 <= k <= 10^9

解题思路

解法一:XOR 收益贪心,主提交版本

每次操作选择一条边,两个端点同时 XOR k。由于树连通,通过多次操作可以翻转任意

偶数个节点(把树看作通信网络,一次操作"翻转"两个端点;选定任意偶数个节点的

集合 T,总能用边把它们两两配对操作实现翻转)。反过来,能被翻转的节点个数必为偶数。

对每个节点计算翻转收益 deltai = (numsi XOR k) - numsi。

问题归结为:选任意多个节点翻转,使 Σ delta 最大(翻转节点数必须为偶数)。

贪心:先取所有 delta > 0 的节点;若个数为奇数,则要么舍弃最小的正 delta,

要么补上最大的负 delta(绝对值最小),取两者中收益更优者。

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

解法二:枚举翻转集合(对照)

对可连通翻转的树,翻转集合为任意偶数子集------用小规模场景枚举所有偶数子集,

计算 Σ (numsi XOR k 若 i 选中, 否则 numsi),取最大,与主解交叉验证。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:XOR 收益贪心(主提交版本) ----------
    public long maximumValueSum(int[] nums, int k, int[][] edges) {
        int n = nums.length;
        long sum = 0;
        List<Long> delta = new ArrayList<>();
        for (int v : nums) {
            sum += v;
            delta.add((long) ((v ^ k) - v));
        }
        java.util.Collections.sort(delta, java.util.Collections.reverseOrder());
        long gain = 0;
        int cnt = 0; // delta > 0 的个数
        // 先累加所有正收益;同时记录最小的正收益与最接近 0 的负收益
        long minPos = Long.MAX_VALUE;
        long maxNeg = Long.MIN_VALUE;
        for (long d : delta) {
            if (d > 0) {
                gain += d;
                cnt++;
                minPos = Math.min(minPos, d);
            } else if (d < 0) {
                maxNeg = Math.max(maxNeg, d);
            }
        }
        if (cnt % 2 == 1) {
            // 奇数个正收益:要么去掉最小的正收益,要么补上最大的负收益,取更好
            gain -= Math.min(minPos, maxNeg == Long.MIN_VALUE ? Long.MAX_VALUE : -maxNeg);
        }
        return sum + gain;
    }

    // ---------- 解法二:枚举偶数子集翻转(对照) ----------
    public long maximumValueSumBrute(int[] nums, int k, int[][] edges) {
        int n = nums.length;
        long best = Long.MIN_VALUE;
        for (int mask = 0; mask < (1 << n); ++mask) {
            if (Integer.bitCount(mask) % 2 != 0) {
                continue; // 只能翻转偶数个节点
            }
            long s = 0;
            for (int i = 0; i < n; ++i) {
                s += ((mask >> i) & 1) == 1 ? (nums[i] ^ k) : nums[i];
            }
            best = Math.max(best, s);
        }
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] numss = {{1, 2, 1}, {2, 3}, {7, 7, 7, 7, 7, 7}, {0}, {1, 2, 3, 4}};
        int[] ks = {3, 7, 3, 10, 5};
        int[][][] edgesCases = {
            {{0, 1}, {0, 2}},
            {{0, 1}},
            {{0, 1}, {0, 2}, {0, 3}, {0, 4}, {0, 5}},
            {},
            {{0, 1}, {1, 2}, {2, 3}},
        };
        long[] expects = {6, 9, 42, 0, 18};
        boolean allPass = true;
        for (int i = 0; i < numss.length; ++i) {
            long a = sol.maximumValueSum(numss[i], ks[i], edgesCases[i]);
            long b = sol.maximumValueSumBrute(numss[i], ks[i], edgesCases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(numss[i]) + " k=" + ks[i]
                    + " -> " + a + " / brute=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍(小规模)
        Random rnd = new Random(3068);
        int trials = 300;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(6);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = rnd.nextInt(20);
            int k = 1 + rnd.nextInt(15);
            int[][] edges = new int[n - 1][];
            for (int i = 1; i < n; ++i) {
                edges[i - 1] = new int[]{rnd.nextInt(i), i};
            }
            long a = sol.maximumValueSum(nums, k, edges);
            long b = sol.maximumValueSumBrute(nums, k, edges);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                            + " k=" + k + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3069. Distribute Elements Into Two Arrays I(将元素分配到两个数组中 I)

题目描述

给你一个下标从 1 开始、包含不同整数的数组 nums,数组长度为 n。

你需要通过 n 次操作,将 nums 中的所有元素分配到两个数组 arr1 和 arr2 中。

在第一次操作中,将 nums[1] 追加到 arr1;第二次操作将 nums[2] 追加到 arr2。

之后,在第 i 次操作中:如果 arr1 的最后一个元素大于 arr2 的最后一个元素,

就将 nums[i] 追加到 arr1;否则追加到 arr2。

通过连接数组 arr1 和 arr2 形成数组 result(arr2 追加到 arr1 末尾)。返回 result。

示例 1

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

示例 2

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

提示:

  • 3 <= n <= 50
  • 1 <= nums[i] <= 100
  • nums 中的所有元素都互不相同

解题思路

解法一:双列表模拟,主提交版本

用两个 ArrayList 分别充当 arr1、arr2,按规则依次追加,最后连接返回。

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

解法二:数组 + 尾指针模拟(对照)

直接用一个数组 res 存结果,用两个指针维护 arr1、arr2 已填充位置,

规则相同,最后按序拷贝。逻辑等价,用于交叉验证。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:双列表模拟(主提交版本) ----------
    public int[] resultArray(int[] nums) {
        List<Integer> arr1 = new ArrayList<>();
        List<Integer> arr2 = new ArrayList<>();
        arr1.add(nums[0]);
        arr2.add(nums[1]);
        for (int i = 2; i < nums.length; ++i) {
            if (arr1.get(arr1.size() - 1) > arr2.get(arr2.size() - 1)) {
                arr1.add(nums[i]);
            } else {
                arr2.add(nums[i]);
            }
        }
        int[] res = new int[nums.length];
        int idx = 0;
        for (int v : arr1) res[idx++] = v;
        for (int v : arr2) res[idx++] = v;
        return res;
    }

    // ---------- 解法二:数组 + 尾指针模拟(对照) ----------
    public int[] resultArrayByIndex(int[] nums) {
        int n = nums.length;
        int[] arr1 = new int[n];
        int[] arr2 = new int[n];
        arr1[0] = nums[0];
        arr2[0] = nums[1];
        int p1 = 1, p2 = 1;
        for (int i = 2; i < n; ++i) {
            if (arr1[p1 - 1] > arr2[p2 - 1]) {
                arr1[p1++] = nums[i];
            } else {
                arr2[p2++] = nums[i];
            }
        }
        int[] res = new int[n];
        int idx = 0;
        for (int i = 0; i < p1; ++i) res[idx++] = arr1[i];
        for (int i = 0; i < p2; ++i) res[idx++] = arr2[i];
        return res;
    }

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

复杂度分析

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

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

3070. Count Submatrices with Top-Left Element and Sum Less Than k

题目描述

(元素和小于等于 k 的子矩阵的数目)

给你一个下标从 0 开始的整数矩阵 grid 和一个整数 k。

返回包含 grid 左上角元素、元素和小于或等于 k 的子矩阵的数目。

示例 1

复制代码
grid = [[7,6,3],[6,6,1]], k = 18 -> 4

示例 2

复制代码
grid = [[7,2,9],[1,5,0],[2,6,6]], k = 20 -> 6

提示:

  • m == grid.length, n == grid[i].length
  • 1 <= n, m <= 1000
  • 0 <= grid[i][j] <= 1000
  • 1 <= k <= 10^9

解题思路

解法一:二维前缀和 + 双循环计数,主提交版本

包含左上角 (0,0) 的子矩阵由"右下角"唯一确定:子矩阵 (0,0)...(i,j)。

先构建二维前缀和 prei+1j+1 表示 grid0...i0...j 元素和,

然后枚举 i、j,若 prei+1j+1 <= k 则计数 +1。

由于 grid 元素非负,前缀和随 i、j 单调不减,但本题 n、m <= 1000,

直接 O(nm) 枚举即足够(10^6 量级)。
时间复杂度 O(n
m),空间复杂度 O(nm)。
解法二:暴力前缀累计(对照)
对每个位置 (i, j) 直接暴力累加 grid0...i0...j 判断是否 <= k。
时间复杂度 O(n
m*min(n,m)),仅用于小规模交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:二维前缀和(主提交版本) ----------
    public int countSubmatrices(int[][] grid, int k) {
        int m = grid.length;
        int n = grid[0].length;
        long[][] pre = new long[m + 1][n + 1];
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                pre[i + 1][j + 1] = pre[i][j + 1] + pre[i + 1][j] - pre[i][j] + grid[i][j];
            }
        }
        int ans = 0;
        for (int i = 1; i <= m; ++i) {
            for (int j = 1; j <= n; ++j) {
                if (pre[i][j] <= k) {
                    ans++;
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:暴力累计(对照) ----------
    public int countSubmatricesBrute(int[][] grid, int k) {
        int m = grid.length;
        int n = grid[0].length;
        int ans = 0;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                long s = 0;
                for (int x = 0; x <= i; ++x) {
                    for (int y = 0; y <= j; ++y) {
                        s += grid[x][y];
                    }
                }
                if (s <= k) {
                    ans++;
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][][] grids = {
            {{7, 6, 3}, {6, 6, 1}},
            {{7, 2, 9}, {1, 5, 0}, {2, 6, 6}},
            {{1}},
            {{0, 0}, {0, 0}},
        };
        int[] ks = {18, 20, 5, 1};
        int[] expects = {4, 6, 1, 4};
        boolean allPass = true;
        for (int i = 0; i < grids.length; ++i) {
            int a = sol.countSubmatrices(grids[i], ks[i]);
            int b = sol.countSubmatricesBrute(grids[i], ks[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println("grid" + i + " k=" + ks[i] + " -> " + a
                    + " / brute=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍(小规模)
        Random rnd = new Random(3070);
        int trials = 300;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int m = 1 + rnd.nextInt(5);
            int n = 1 + rnd.nextInt(5);
            int[][] grid = new int[m][n];
            for (int i = 0; i < m; ++i)
                for (int j = 0; j < n; ++j)
                    grid[i][j] = rnd.nextInt(6);
            int k = rnd.nextInt(40);
            int a = sol.countSubmatrices(grid, k);
            int b = sol.countSubmatricesBrute(grid, k);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH m=" + m + " n=" + n
                            + " k=" + k + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

时间复杂度 O(nmmin(n,m)),仅用于小规模交叉验证。

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

3071. Minimum Operations to Write the Letter Y on a Grid

题目描述

(在矩阵上写出字母 Y 所需的最少操作次数)

给你一个下标从 0 开始、大小为 n x n 的矩阵 grid,其中 n 为奇数,且 grid[r][c] 的值为 0、1 或 2。

如果一个单元格属于以下三条线中的任一一条,我们就认为它是字母 Y 的一部分:

  • 从左上角单元格开始到矩阵中心单元格结束的对角线;
  • 从右上角单元格开始到矩阵中心单元格结束的对角线;
  • 从中心单元格开始到矩阵底部边界结束的垂直线。
    当且仅当满足以下全部条件时,可以判定矩阵上写有字母 Y:
  • 属于 Y 的所有单元格的值相等;
  • 不属于 Y 的所有单元格的值相等;
  • 属于 Y 的单元格的值与不属于 Y 的单元格的值不同。
    每次操作你可以将任意单元格的值改变为 0、1 或 2。返回在矩阵上写出字母 Y 所需的最少操作次数。

示例 1

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

示例 2

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

提示:

  • 3 <= n <= 49
  • n == grid.length == grid[i].length
  • 0 <= grid[i][j] <= 2
  • n 为奇数

解题思路

解法一:分类统计 + 枚举取值,主提交版本

先确定 Y 区域:设中心 mid = n / 2。

  • 左上到中心对角线上:i == j 且 i <= mid;
  • 右上到中心对角线上:i + j == n - 1 且 i <= mid;
  • 中心到底部垂直线:j == mid 且 i >= mid。
    统计 Y 内、Y 外 0/1/2 出现的次数 cy3、co3。
    枚举 Y 的目标值 a 与非 Y 的目标值 b(a != b,a、b ∈ {0,1,2}),
    改动次数 = (Y 单元格数 - cya) + (非 Y 单元格数 - cob),取最小。
    时间复杂度 O(n^2),空间复杂度 O(1)。
    解法二:按定义直接逐个判断 + 暴力遍历取值(对照)
    用 isY 谓词逐单元格分类,再暴力枚举 (a,b) 全部组合计改动数。
    时间复杂度 O(n^2 * 6),逻辑等价,用于交叉验证。
    复杂度:
  • 时间复杂度:O(n^2)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {

    // ---------- 解法一:分类统计 + 枚举取值(主提交版本) ----------
    public int minimumOperationsToWriteY(int[][] grid) {
        int n = grid.length;
        int mid = n / 2;
        int[] cy = new int[3];
        int[] co = new int[3];
        int yCnt = 0, oCnt = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = 0; j < n; ++j) {
                boolean inY = isY(i, j, n, mid);
                if (inY) {
                    cy[grid[i][j]]++;
                    yCnt++;
                } else {
                    co[grid[i][j]]++;
                    oCnt++;
                }
            }
        }
        int best = Integer.MAX_VALUE;
        for (int a = 0; a < 3; ++a) {
            for (int b = 0; b < 3; ++b) {
                if (a == b) {
                    continue;
                }
                int ops = (yCnt - cy[a]) + (oCnt - co[b]);
                best = Math.min(best, ops);
            }
        }
        return best;
    }

    private boolean isY(int i, int j, int n, int mid) {
        if (j == mid && i >= mid) {
            return true; // 中心垂直向下线
        }
        if (i <= mid && (j == i || i + j == n - 1)) {
            return true; // 两条对角线(含中心点)
        }
        return false;
    }

    // ---------- 解法二:谓词分类 + 暴力枚举(对照) ----------
    public int minimumOperationsToWriteYBrute(int[][] grid) {
        int n = grid.length;
        int mid = n / 2;
        int best = Integer.MAX_VALUE;
        for (int a = 0; a < 3; ++a) {
            for (int b = 0; b < 3; ++b) {
                if (a == b) {
                    continue;
                }
                int ops = 0;
                for (int i = 0; i < n; ++i) {
                    for (int j = 0; j < n; ++j) {
                        boolean inY = isY(i, j, n, mid);
                        int need = inY ? a : b;
                        if (grid[i][j] != need) {
                            ops++;
                        }
                    }
                }
                best = Math.min(best, ops);
            }
        }
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][][] grids = {
            {{1, 2, 2}, {1, 1, 0}, {0, 1, 0}},
            {{0, 1, 0, 1, 0}, {2, 1, 0, 1, 2}, {2, 2, 2, 0, 1}, {2, 2, 2, 2, 2}, {2, 1, 2, 2, 2}},
            {{0, 0, 0}, {0, 0, 0}, {0, 0, 0}},
        };
        int[] expects = {3, 12, 4};
        boolean allPass = true;
        for (int i = 0; i < grids.length; ++i) {
            int a = sol.minimumOperationsToWriteY(grids[i]);
            int b = sol.minimumOperationsToWriteYBrute(grids[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println("case" + i + " -> " + a + " / brute=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍(小规模)
        Random rnd = new Random(3071);
        int trials = 500;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 3 + 2 * rnd.nextInt(3); // 3,5,7
            int[][] grid = new int[n][n];
            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j)
                    grid[i][j] = rnd.nextInt(3);
            int a = sol.minimumOperationsToWriteY(grid);
            int b = sol.minimumOperationsToWriteYBrute(grid);
            if (a != b) {
                fail++;
                if (fail <= 5) System.out.println("MISMATCH n=" + n + " a=" + a + " b=" + b);
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

时间复杂度 O(n^2 * 6),逻辑等价,用于交叉验证。

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

3072. Distribute Elements Into Two Arrays II(将元素分配到两个数组中 II)

题目描述

给你一个下标从 1 开始、长度为 n 的整数数组 nums。

定义函数 greaterCount(arr, val) 返回数组 arr 中严格大于 val 的元素数量。

使用 n 次操作分配:第一次将 nums[1] 追加到 arr1,第二次将 nums[2] 追加到 arr2。

之后第 i 次操作:

  • 如果 greaterCount(arr1, nums[i]) > greaterCount(arr2, nums[i]),追加到 arr1;
  • 如果 <,追加到 arr2;
  • 如果相等,追加到元素数量较少的数组;
  • 如果仍相等,追加到 arr1。
    连接 arr1 和 arr2 形成 result(arr2 追加到 arr1 末尾),返回 result。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 3 <= n <= 10^5
  • 1 <= nums[i] <= 10^9

解题思路

解法一:离散化 + 双树状数组,主提交版本

需要高频执行 greaterCount(arr, val)(查询严格大于 val 的元素个数),

用两个树状数组(Fenwick)分别维护 arr1、arr2 中已出现值的频次:

  • 先将所有数离散化到 1...m;
  • greaterCount(arr, val) = arr 中元素总数 - 前缀查询(rank(val));
    按题意规则分配每个元素,最后拼接两个数组。
    时间复杂度 O(n log n),空间复杂度 O(n)。
    解法二:暴力线性统计(对照)
    小规模场景:两个 ArrayList 维护,greaterCount 每次线性遍历统计。
    时间复杂度 O(n^2),仅用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O(n log n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    static class Fenwick {
        private final int[] tree;
        private final int n;

        Fenwick(int n) {
            this.n = n;
            this.tree = new int[n + 1];
        }

        void add(int i, int v) {
            for (; i <= n; i += i & (-i)) {
                tree[i] += v;
            }
        }

        int sum(int i) {
            int s = 0;
            for (; i > 0; i -= i & (-i)) {
                s += tree[i];
            }
            return s;
        }
    }

    // ---------- 解法一:离散化 + 双树状数组(主提交版本) ----------
    public int[] resultArray(int[] nums) {
        int n = nums.length;
        // 离散化
        int[] sorted = nums.clone();
        Arrays.sort(sorted);
        Map<Integer, Integer> rank = new HashMap<>();
        for (int v : sorted) {
            rank.putIfAbsent(v, rank.size() + 1);
        }
        Fenwick f1 = new Fenwick(n);
        Fenwick f2 = new Fenwick(n);
        int[] arr1 = new int[n];
        int[] arr2 = new int[n];
        int p1 = 1, p2 = 1;
        arr1[0] = nums[0];
        arr2[0] = nums[1];
        f1.add(rank.get(nums[0]), 1);
        f2.add(rank.get(nums[1]), 1);
        for (int i = 2; i < n; ++i) {
            int r = rank.get(nums[i]);
            // greaterCount = 总数 - 前缀 <= 该值
            int gt1 = p1 - f1.sum(r);
            int gt2 = p2 - f2.sum(r);
            if (gt1 > gt2) {
                arr1[p1++] = nums[i];
                f1.add(r, 1);
            } else if (gt1 < gt2) {
                arr2[p2++] = nums[i];
                f2.add(r, 1);
            } else if (p1 <= p2) {
                arr1[p1++] = nums[i];
                f1.add(r, 1);
            } else {
                arr2[p2++] = nums[i];
                f2.add(r, 1);
            }
        }
        int[] res = new int[n];
        int idx = 0;
        for (int i = 0; i < p1; ++i) res[idx++] = arr1[i];
        for (int i = 0; i < p2; ++i) res[idx++] = arr2[i];
        return res;
    }

    // ---------- 解法二:暴力线性统计(对照) ----------
    public int[] resultArrayBrute(int[] nums) {
        int n = nums.length;
        java.util.List<Integer> a1 = new java.util.ArrayList<>();
        java.util.List<Integer> a2 = new java.util.ArrayList<>();
        a1.add(nums[0]);
        a2.add(nums[1]);
        for (int i = 2; i < n; ++i) {
            int v = nums[i];
            int gt1 = greaterCount(a1, v);
            int gt2 = greaterCount(a2, v);
            if (gt1 > gt2) {
                a1.add(v);
            } else if (gt1 < gt2) {
                a2.add(v);
            } else if (a1.size() <= a2.size()) {
                a1.add(v);
            } else {
                a2.add(v);
            }
        }
        int[] res = new int[n];
        int idx = 0;
        for (int v : a1) res[idx++] = v;
        for (int v : a2) res[idx++] = v;
        return res;
    }

    private int greaterCount(java.util.List<Integer> arr, int val) {
        int cnt = 0;
        for (int v : arr) {
            if (v > val) cnt++;
        }
        return cnt;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {2, 1, 3, 3},
            {5, 14, 3, 1, 2},
            {3, 3, 3, 3},
            {1, 2, 3, 4, 5},
            {5, 4, 3, 2, 1},
        };
        int[][] expects = {
            {2, 3, 1, 3},
            {5, 3, 1, 2, 14},
            {3, 3, 3, 3},
            {1, 3, 5, 2, 4},
            {5, 3, 2, 1, 4},
        };
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int[] a = sol.resultArray(cases[i]);
            int[] b = sol.resultArrayBrute(cases[i]);
            boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + Arrays.toString(a)
                    + " / brute=" + Arrays.toString(b) + " expected="
                    + Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(3072);
        int trials = 2000;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 3 + rnd.nextInt(8);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(30);
            int[] a = sol.resultArray(nums);
            int[] b = sol.resultArrayBrute(nums);
            if (!Arrays.equals(a, b)) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                            + " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3073. Maximum Increasing Triplet Value(最大递增三元组 🔒)

题目描述

给定一个数组 nums,返回满足 i < j < k 且 nums[i] < nums[j] < nums[k] 的三元组 (i, j, k) 的最大值。

三元组 (i, j, k) 的值为 nums[i] - nums[j] + nums[k]。

示例 1

复制代码
nums = [5,6,9] -> 8

示例 2

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

提示:

  • 3 <= nums.length <= 10^5
  • 1 <= nums[i] <= 10^9
  • 输入数据保证至少一个三元组满足给定条件

解题思路

解法一:前后缀最佳值 + 枚举 j,主提交版本

固定中间下标 j,需要 numsi < numsj < numsk,最大化 numsi - numsj + numsk。

对每个 j:

  • 前缀中选择满足 numsi < numsj 的最大 numsi(用有序集合/树状数组维护前缀值,
    取严格小于 numsj 的最大值);
  • 后缀中选择满足 numsk > numsj 的最大 numsk(维护后缀最大值,且必须 > numsj)。
    两者都非空时更新答案。
    前缀"严格小于"可用 TreeSet 维护已遍历值,lower(numsj) 即最优 i 候选;
    后缀维护 suffixMaxj+1...n-1 的最大值。
    时间复杂度 O(n log n),空间复杂度 O(n)。
    解法二:三重循环(对照)
    小规模场景:直接枚举所有 i < j < k 且严格递增的三元组,计算值取最大。
    时间复杂度 O(n^3),仅用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O(n log n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:前后缀 + 枚举 j(主提交版本) ----------
    public long maximumTripletValue(int[] nums) {
        int n = nums.length;
        // 后缀最大值:suf[i] = max(nums[i..n-1])
        long[] suf = new long[n];
        suf[n - 1] = nums[n - 1];
        for (int i = n - 2; i >= 0; --i) {
            suf[i] = Math.max(nums[i], suf[i + 1]);
        }
        TreeSet<Integer> pre = new TreeSet<>();
        pre.add(nums[0]);
        long ans = Long.MIN_VALUE;
        for (int j = 1; j + 1 < n; ++j) {
            // 取严格小于 nums[j] 的最大前缀值
            Integer left = pre.lower(nums[j]);
            if (left != null && suf[j + 1] > nums[j]) {
                // 后缀取 > nums[j] 的最大值 = suf[j+1](若 suf[j+1] > nums[j])
                ans = Math.max(ans, (long) left - nums[j] + suf[j + 1]);
            }
            pre.add(nums[j]);
        }
        return ans;
    }

    // ---------- 解法二:三重循环(对照) ----------
    public long maximumTripletValueBrute(int[] nums) {
        int n = nums.length;
        long ans = Long.MIN_VALUE;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                if (nums[i] >= nums[j]) continue;
                for (int k = j + 1; k < n; ++k) {
                    if (nums[j] < nums[k]) {
                        ans = Math.max(ans, (long) nums[i] - nums[j] + nums[k]);
                    }
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {5, 6, 9},
            {1, 5, 3, 6},
            {1, 2, 3, 4},
            {4, 3, 2, 1},
            {2, 4, 1, 5, 3},
        };
        long[] expects = {8, 4, 3, Long.MIN_VALUE, 3}; // case3 最大为 2-3+4=3;case5 最大为 2-4+5=3
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            long a = sol.maximumTripletValue(cases[i]);
            long b = sol.maximumTripletValueBrute(cases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + a
                    + " / brute=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(3073);
        int trials = 400;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 3 + rnd.nextInt(7);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(20);
            long a = sol.maximumTripletValue(nums);
            long b = sol.maximumTripletValueBrute(nums);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                            + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3074. Apple Redistribution into Boxes(重新分装苹果)

题目描述

给你一个长度为 n 的数组 apple 和另一个长度为 m 的数组 capacity。

一共有 n 个包裹,其中第 i 个包裹中装着 apple[i] 个苹果。同时,还有 m 个箱子,

第 i 个箱子的容量为 capacity[i] 个苹果。

请你选择一些箱子来将这 n 个包裹中的苹果重新分装到箱子中,返回你需要选择的箱子的最小数量。

注意,同一个包裹中的苹果可以分装到不同的箱子中。

示例 1

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

示例 2

复制代码
apple = [5,5,5], capacity = [2,4,2,7] -> 4

提示:

  • 1 <= n == apple.length <= 50
  • 1 <= m == capacity.length <= 50
  • 1 <= apple[i], capacity[i] <= 50
  • 输入数据保证可以将包裹中的苹果重新分装到箱子中

解题思路

解法一:贪心选最大容量箱,主提交版本

所有苹果总能拆开分装,因此只需保证所选箱子容量之和 >= 苹果总数。

将 capacity 降序排列,从大到小累加直到 >= sum(apple),累加的箱子数即答案。

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

解法二:暴力枚举箱子组合(对照)

小规模场景:枚举所有非空箱子组合,容量和 >= 苹果总数的最小箱子数。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:贪心选最大容量箱(主提交版本) ----------
    public int minimumBoxes(int[] apple, int[] capacity) {
        int total = 0;
        for (int v : apple) {
            total += v;
        }
        Arrays.sort(capacity);
        int sum = 0;
        int cnt = 0;
        for (int i = capacity.length - 1; i >= 0; --i) {
            sum += capacity[i];
            cnt++;
            if (sum >= total) {
                break;
            }
        }
        return cnt;
    }

    // ---------- 解法二:枚举箱子组合(对照) ----------
    public int minimumBoxesBrute(int[] apple, int[] capacity) {
        int total = 0;
        for (int v : apple) total += v;
        int m = capacity.length;
        int best = m;
        for (int mask = 1; mask < (1 << m); ++mask) {
            int s = 0;
            int c = Integer.bitCount(mask);
            if (c >= best) continue;
            for (int i = 0; i < m; ++i) {
                if ((mask >> i & 1) == 1) {
                    s += capacity[i];
                }
            }
            if (s >= total) {
                best = c;
            }
        }
        return best;
    }

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

复杂度分析

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

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

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

3075. Maximize Happiness of Selected Children(幸福值最大化的选择方案)

题目描述

给你一个长度为 n 的数组 happiness,以及一个正整数 k。

n 个孩子站成一队,其中第 i 个孩子的幸福值是 happiness[i]。

你计划组织 k 轮筛选从这 n 个孩子中选出 k 个孩子。

在每一轮选择一个孩子时,所有尚未被选中的孩子的幸福值将减少 1。

注意,幸福值不能变成负数,且只有在它是正数的情况下才会减少。

选择 k 个孩子,并使你选中的孩子幸福值之和最大,返回你能得到的最大值。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= n == happiness.length <= 2 * 10^5
  • 1 <= happiness[i] <= 10^8
  • 1 <= k <= n

解题思路

解法一:降序贪心,主提交版本

最优策略是优先选择幸福值最大的孩子。每多等一轮,尚未被选中的孩子幸福值减 1,

因此第 i 个被选中的孩子(i 从 0 开始)实际贡献为 max(happiness降序i - i, 0)。

将 happiness 降序排列,累加前 k 个的 max(hi - i, 0) 即可。

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

解法二:模拟选择(对照)

小规模场景:每轮枚举当前可选孩子,选"当前幸福值最大"者(模拟减 1 过程),

累加贡献。与主解结果交叉验证。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:降序贪心(主提交版本) ----------
    public long maximumHappinessSum(int[] happiness, int k) {
        Integer[] h = new Integer[happiness.length];
        for (int i = 0; i < happiness.length; ++i) {
            h[i] = happiness[i];
        }
        Arrays.sort(h, (a, b) -> b - a);
        long ans = 0;
        for (int i = 0; i < k; ++i) {
            ans += Math.max(0, (long) h[i] - i);
        }
        return ans;
    }

    // ---------- 解法二:模拟选择(对照) ----------
    public long maximumHappinessSumBrute(int[] happiness, int k) {
        int n = happiness.length;
        boolean[] taken = new boolean[n];
        long ans = 0;
        for (int round = 0; round < k; ++round) {
            // 选当前幸福值最大的未选孩子
            int best = -1;
            for (int i = 0; i < n; ++i) {
                if (!taken[i]) {
                    int cur = Math.max(0, happiness[i] - round);
                    if (best < 0 || cur > Math.max(0, happiness[best] - round)) {
                        best = i;
                    }
                }
            }
            if (best < 0) break;
            ans += Math.max(0, happiness[best] - round);
            taken[best] = true;
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cas = {{1, 2, 3}, {1, 1, 1, 1}, {2, 3, 4, 5}, {5, 4, 3, 2, 1}};
        int[] ks = {2, 2, 1, 3};
        long[] expects = {4, 1, 5, 9};
        boolean allPass = true;
        for (int i = 0; i < cas.length; ++i) {
            long a = sol.maximumHappinessSum(cas[i], ks[i]);
            long b = sol.maximumHappinessSumBrute(cas[i], ks[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cas[i]) + " k=" + ks[i]
                    + " -> " + a + " / brute=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(3075);
        int trials = 500;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(7);
            int k = 1 + rnd.nextInt(n);
            int[] h = new int[n];
            for (int i = 0; i < n; ++i) h[i] = 1 + rnd.nextInt(10);
            long a = sol.maximumHappinessSum(h, k);
            long b = sol.maximumHappinessSumBrute(h, k);
            if (a != b) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH h=" + Arrays.toString(h)
                            + " k=" + k + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3076. Shortest Uncommon Substring in an Array(数组中的最短非公共子字符串)

题目描述

给你一个数组 arr,数组中有 n 个非空字符串。

求出一个长度为 n 的字符串数组 answer,满足:

  • answer[i] 是 arr[i] 最短的子字符串,且它不是 arr 中其他任何字符串的子字符串。
  • 如果有多个这样的子字符串存在,answer[i] 应该是它们中字典序最小的一个。
  • 如果不存在这样的子字符串,answer[i] 为空字符串。

示例 1

复制代码
arr = ["cab","ad","bad","c"] -> ["ab","","ba",""]

示例 2

复制代码
arr = ["abc","bcd","abcd"] -> ["","","abcd"]

提示:

  • n == arr.length, 2 <= n <= 100
  • 1 <= arr[i].length <= 20
  • arr[i] 只包含小写英文字母

解题思路

解法一:集合排除 + 枚举子串,主提交版本

对每个字符串 s = arri:

  1. 收集除 s 外所有字符串的全部子串到集合 other(长度 ≤ 20,每个字符串至多 210 个子串,
    总量 n * 210 可控);
  2. 枚举 s 的所有子串 t:若 t 不在 other 中,记录 (长度, 字典序) 最优者。
    时间复杂度 O(n * L^3)(L ≤ 20),空间复杂度 O(n * L^2)。
    解法二:逐个 isSubstring 判断(对照)
    对每个子串 t 与每个其他字符串做 contains 判断,逻辑更直观:
    枚举 s 的全部子串按 (长度, 字典序) 排序,逐个检查是否为其他串的子串,
    第一个不被包含的即答案。两法结果一致。
    时间复杂度 O(n^2 * L^4),仅用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O(n * L^3)
  • 空间复杂度:O(n * L^2)

代码实现

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

public class Solution {

    // ---------- 解法一:集合排除 + 枚举子串(主提交版本) ----------
    public String[] shortestSubstrings(String[] arr) {
        int n = arr.length;
        // 每个串的全部子串集合
        List<Set<String>> allSubs = new ArrayList<>();
        for (String s : arr) {
            allSubs.add(allSubstrings(s));
        }
        String[] ans = new String[n];
        for (int i = 0; i < n; ++i) {
            // 其他字符串的子串集合
            Set<String> other = new HashSet<>();
            for (int j = 0; j < n; ++j) {
                if (j != i) {
                    other.addAll(allSubs.get(j));
                }
            }
            String best = null;
            // 枚举 arr[i] 的子串,按长度短到长、字典序优先
            for (int len = 1; len <= arr[i].length(); ++len) {
                for (int st = 0; st + len <= arr[i].length(); ++st) {
                    String t = arr[i].substring(st, st + len);
                    if (!other.contains(t)) {
                        if (best == null || t.compareTo(best) < 0) {
                            best = t;
                        }
                    }
                }
                if (best != null) {
                    break; // 已找到该长度下最优,更短的已无解,更长的不如它
                }
            }
            ans[i] = best == null ? "" : best;
        }
        return ans;
    }

    private Set<String> allSubstrings(String s) {
        Set<String> set = new HashSet<>();
        for (int i = 0; i < s.length(); ++i) {
            for (int j = i + 1; j <= s.length(); ++j) {
                set.add(s.substring(i, j));
            }
        }
        return set;
    }

    // ---------- 解法二:逐子串 contains 检查(对照) ----------
    public String[] shortestSubstringsBrute(String[] arr) {
        int n = arr.length;
        String[] ans = new String[n];
        for (int i = 0; i < n; ++i) {
            String s = arr[i];
            String best = null;
            for (int len = 1; len <= s.length(); ++len) {
                List<String> cands = new ArrayList<>();
                for (int st = 0; st + len <= s.length(); ++st) {
                    String t = s.substring(st, st + len);
                    boolean inOther = false;
                    for (int j = 0; j < n; ++j) {
                        if (j != i && arr[j].contains(t)) {
                            inOther = true;
                            break;
                        }
                    }
                    if (!inOther) {
                        cands.add(t);
                    }
                }
                if (!cands.isEmpty()) {
                    java.util.Collections.sort(cands);
                    best = cands.get(0);
                    break;
                }
            }
            ans[i] = best == null ? "" : best;
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[][] cases = {
            {"cab", "ad", "bad", "c"},
            {"abc", "bcd", "abcd"},
            {"abc", "def", "ghi"},
            {"a", "aa", "aaa"},
        };
        String[][] expects = {
            {"ab", "", "ba", ""},
            {"", "", "abcd"},
            {"a", "d", "g"},
            {"", "", "aaa"},
        };
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            String[] a = sol.shortestSubstrings(cases[i]);
            String[] b = sol.shortestSubstringsBrute(cases[i]);
            boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + Arrays.toString(a)
                    + " / brute=" + Arrays.toString(b) + " expected="
                    + Arrays.toString(expects[i]) + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(3076);
        int trials = 300;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 2 + rnd.nextInt(4);
            String[] arr = new String[n];
            for (int i = 0; i < n; ++i) {
                int len = 1 + rnd.nextInt(5);
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < len; ++j) {
                    sb.append((char) ('a' + rnd.nextInt(4)));
                }
                arr[i] = sb.toString();
            }
            String[] a = sol.shortestSubstrings(arr);
            String[] b = sol.shortestSubstringsBrute(arr);
            if (!Arrays.equals(a, b)) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH arr=" + Arrays.toString(arr)
                            + " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3077. Maximum Strength of K Disjoint Subarrays(K 个不相交子数组的最大能量值)

题目描述

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

x 个子数组的能量值定义为

strength = sum[1]*x - sum[2]*(x-1) + sum[3]*(x-2) - ... + sum[x]*1,

其中 sum[i] 是第 i 个子数组的和。更正式地,

strength = Σ_{i=1..x} (-1)^(i+1) * sum[i] * (x - i + 1)

你需要在 nums 中选择 k 个不相交子数组,使得能量值最大,返回最大能量值。

注意,选出来的所有子数组不需要覆盖整个数组。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= n <= 10^4
  • -10^9 <= nums[i] <= 10^9
  • 1 <= k <= n
  • 1 <= n * k <= 10^6
  • k 是奇数

解题思路

解法一:双状态滚动 DP,主提交版本

把第 j 段子数组的系数 (-1)^(j+1) * (k - j + 1) 分摊到它覆盖的每个元素上,

问题转化为:选 k 段互不重叠的子数组,每段内元素乘该段系数后求和最大。

设 dpj0 表示处理到当前位置、共安排了 j 段、且当前元素不在段内

(j 段全部闭合)的最大值;dpj1 表示第 j 段"打开"(包含当前位置)的最大值。

处理每个元素 v(它在第 j 段的贡献为 signwv,其中 w = k-j+1):

  • 延续:dpj1' = max(dpj1) + c;
  • 新开:dpj1' = max(dpj-10 + c);
  • 闭合/跳过:dpj0' = max(dpj0, dpj1)。
    答案 = max(dpk0, dpk1)。
    时间复杂度 O(nk),空间复杂度 O(k)。
    解法二:记忆化搜索(对照)
    f(idx, j, in):从 idx 开始还需选 j 段;in=0 表示 idx 前不在段内、in=1 在段内。
    枚举:新开段(含 idx 并延伸/只含 idx)/ 延续段 / 跳过不在段内。
    段号 seg = k - j + 1 决定系数,与 DP 完全一致的收益定义,用于交叉验证。
    时间复杂度 O(n
    k),空间复杂度 O(n*k)。
    复杂度:
  • 时间复杂度:O(n*k)
  • 空间复杂度:O(k)

代码实现

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

public class Solution {

    // ---------- 解法一:双状态滚动 DP(主提交版本) ----------
    public long maximumStrength(int[] nums, int k) {
        int n = nums.length;
        long NEG = Long.MIN_VALUE / 4;
        long[][] dp = new long[k + 1][2];
        for (long[] row : dp) {
            Arrays.fill(row, NEG);
        }
        dp[0][0] = 0;
        for (int i = 0; i < n; ++i) {
            long v = nums[i];
            long[][] ndp = new long[k + 1][2];
            for (long[] row : ndp) {
                Arrays.fill(row, NEG);
            }
            // 先计算"到 i-1 为止第 j 段已闭合"的最优值(含刚在 i-1 闭合的)
            long[] close = new long[k + 1];
            for (int j = 0; j <= k; ++j) {
                close[j] = Math.max(dp[j][0], dp[j][1]);
            }
            for (int j = 1; j <= k; ++j) {
                long w = k - j + 1;
                long sign = ((j - 1) % 2 == 0) ? 1 : -1; // (-1)^(j+1)
                long c = sign * w * v;
                // 保持闭合(第 j 段此前已闭合,跳过 v)
                ndp[j][0] = Math.max(ndp[j][0], close[j]);
                // 延续第 j 段
                if (dp[j][1] != NEG) {
                    ndp[j][1] = Math.max(ndp[j][1], dp[j][1] + c);
                }
                // 以 v 新开第 j 段(j-1 段已闭合,含刚在 i-1 闭合的)
                if (close[j - 1] != NEG) {
                    ndp[j][1] = Math.max(ndp[j][1], close[j - 1] + c);
                }
            }
            dp = ndp;
        }
        return Math.max(dp[k][0], dp[k][1]);
    }

    // ---------- 解法二:记忆化搜索(对照) ----------
    private long[][][] memo;
    private int[] arr;
    private int kk;

    public long maximumStrengthBrute(int[] nums, int k) {
        this.arr = nums;
        this.kk = k;
        int n = nums.length;
        memo = new long[n + 1][k + 1][2];
        for (long[][] a : memo) {
            for (long[] b : a) {
                Arrays.fill(b, Long.MIN_VALUE / 4);
            }
        }
        return dfs(0, k, 0);
    }

    // idx 当前下标;j 还需选几段;in=1 表示当前处于某段之中(该段已包含前面的元素)
    private long dfs(int idx, int j, int in) {
        if (j == 0) {
            return 0;
        }
        if (idx >= arr.length) {
            return Long.MIN_VALUE / 4; // 段数不够
        }
        if (memo[idx][j][in] != Long.MIN_VALUE / 4) {
            return memo[idx][j][in];
        }
        int seg = kk - j + 1; // 当前(或将要开的)段的序号
        long w = kk - seg + 1;
        long sign = ((seg - 1) % 2 == 0) ? 1 : -1;
        long c = sign * w * arr[idx];
        long best = Long.MIN_VALUE / 4;
        if (in == 0) {
            // 跳过 idx(不开段)
            long skip = dfs(idx + 1, j, 0);
            best = Math.max(best, skip);
            // 以 idx 新开一段
            long cont = dfs(idx + 1, j, 1);
            if (cont != Long.MIN_VALUE / 4) {
                best = Math.max(best, cont + c); // 段延伸
            }
            long close = dfs(idx + 1, j - 1, 0);
            if (close != Long.MIN_VALUE / 4) {
                best = Math.max(best, c + close); // 段只含 idx
            }
        } else {
            // 延伸当前段
            long cont = dfs(idx + 1, j, 1);
            if (cont != Long.MIN_VALUE / 4) {
                best = Math.max(best, cont + c);
            }
            // 在 idx 处结束当前段
            long close = dfs(idx + 1, j - 1, 0);
            if (close != Long.MIN_VALUE / 4) {
                best = Math.max(best, c + close);
            }
        }
        memo[idx][j][in] = best;
        return best;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {1, 2, 3, -1, 2},
            {12, -2, -2, -2, -2},
            {-1, -2, -3},
            {1, -1, 1, -1},
            {5, 5, 5, 5},
            {-3, -2, -1},
        };
        int[] ks = {3, 5, 1, 2, 3, 2};
        long[] expects = {22, 64, -1, 3, 25, -3}; // 均经 Python 枚举段组合验证
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            long a = sol.maximumStrength(cases[i], ks[i]);
            long b = sol.maximumStrengthBrute(cases[i], ks[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " k=" + ks[i]
                    + " -> " + a + " / brute=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
    }
}

复杂度分析

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

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

3078. Match Alphanumerical Pattern in Matrix I(矩阵中的字母数字模式匹配 I 🔒)

题目描述

给定一个二维整数矩阵 board 和一个二维字符矩阵 pattern。

其中 0 <= board[r][c] <= 9 并且 pattern 的每个元素是一个数字或一个小写英文字母。

你的任务是找到匹配 board 的子矩阵 pattern。

如果我们能用一些数字(每个不同的字母对应不同的数字)替换 pattern 中包含的字母,

使得结果矩阵与整数矩阵 part 相同,则称整数矩阵 part 与 pattern 匹配:

  • 这两个矩阵具有相同的维数;
  • 如果 pattern[r][c] 是一个数字,那么 part[r][c] 必须是相同的数字;
  • 如果 pattern[r][c] 是一个字母 x:
  • 对于每个 pattern[i][j] == x,part[i][j] 一定与 part[r][c] 相同;
  • 对于每个 pattern[i][j] != x,part[i][j] 一定与 part[r][c] 不同。
    返回一个长度为 2 的数组,包含匹配 pattern 的 board 的子矩阵左上角的行号和列号。
    如果有多个这样的子矩阵,返回行号更小的子矩阵;若仍有多个,返回列号更小的。
    如果没有符合的答案,返回 -1, -1。

示例 1

复制代码
board = [[1,2,2],[2,2,3],[2,3,3]], pattern = ["ab","bb"] -> [0,0]

示例 2

复制代码
board = [[1,1,2],[3,3,4],[6,6,6]], pattern = ["ab","66"] -> [1,1]

示例 3

复制代码
board = [[1,2],[2,1]], pattern = ["xx"] -> [-1,-1]

提示:

  • 1 <= board.length, board[i].length <= 50
  • 0 <= board[i][j] <= 9
  • 1 <= pattern.length, pattern[i].length <= 50
  • pattern[i][j] 表示为数字的字符串或一个小写英文字母

解题思路

解法一:滑动窗口 + 映射一致性检查,主提交版本

对 board 的每个左上角 (r, c)(满足 r + ph <= bh、c + pw <= bw),

尝试把 pattern 放上去:

  • 维护 letterMap'a'...'z' -> 数字(-1 表示未映射),used0...9 表示数字已被占用;
  • 扫描 pattern 每个位置:
  • 若为数字 '0'...'9',要求 boardr+ic+j == 该数字;
  • 若为字母 ch:若 ch 已映射,则要求 board 值等于映射值;否则为 ch 分配
    board 值(要求该数字未被其他字母占用)。
    全部通过即匹配,按行优先顺序返回第一个。
    时间复杂度 O(B * P)(B 为 board 位置数,P 为 pattern 大小),空间复杂度 O(26)。
    解法二:独立映射 + 双重校验(对照)
    对每个位置同样枚举,但额外校验"同一数字不能赋给两个不同字母"------与主解等价,
    用不同的实现结构交叉验证。
    复杂度:
  • 时间复杂度:O(h * w * ph * pw)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {

    // ---------- 解法一:滑动窗口 + 映射一致性检查(主提交版本) ----------
    public int[] findPattern(int[][] board, String[] pattern) {
        int bh = board.length, bw = board[0].length;
        int ph = pattern.length, pw = pattern[0].length();
        for (int r = 0; r + ph <= bh; ++r) {
            for (int c = 0; c + pw <= bw; ++c) {
                if (match(board, pattern, r, c)) {
                    return new int[]{r, c};
                }
            }
        }
        return new int[]{-1, -1};
    }

    private boolean match(int[][] board, String[] pattern, int r, int c) {
        int ph = pattern.length, pw = pattern[0].length();
        int[] letterMap = new int[26];
        Arrays.fill(letterMap, -1);
        boolean[] used = new boolean[10];
        for (int i = 0; i < ph; ++i) {
            for (int j = 0; j < pw; ++j) {
                char ch = pattern[i].charAt(j);
                int val = board[r + i][c + j];
                if (ch >= '0' && ch <= '9') {
                    if (val != ch - '0') {
                        return false;
                    }
                } else {
                    int idx = ch - 'a';
                    if (letterMap[idx] == -1) {
                        if (used[val]) {
                            return false; // 该数字已被其他字母占用
                        }
                        letterMap[idx] = val;
                        used[val] = true;
                    } else if (letterMap[idx] != val) {
                        return false;
                    }
                }
            }
        }
        return true;
    }

    // ---------- 解法二:独立实现(对照) ----------
    public int[] findPatternBrute(int[][] board, String[] pattern) {
        int bh = board.length, bw = board[0].length;
        int ph = pattern.length, pw = pattern[0].length();
        for (int r = 0; r + ph <= bh; ++r) {
            for (int c = 0; c + pw <= bw; ++c) {
                Map<Character, Integer> mp = new HashMap<>();
                Map<Integer, Character> rev = new HashMap<>();
                boolean ok = true;
                for (int i = 0; i < ph && ok; ++i) {
                    for (int j = 0; j < pw && ok; ++j) {
                        char ch = pattern[i].charAt(j);
                        int val = board[r + i][c + j];
                        if (ch >= '0' && ch <= '9') {
                            if (val != ch - '0') {
                                ok = false;
                            }
                        } else if (mp.containsKey(ch)) {
                            if (mp.get(ch) != val) {
                                ok = false;
                            }
                        } else if (rev.containsKey(val)) {
                            ok = false; // 数字已被其他字母占用
                        } else {
                            mp.put(ch, val);
                            rev.put(val, ch);
                        }
                    }
                }
                if (ok) {
                    return new int[]{r, c};
                }
            }
        }
        return new int[]{-1, -1};
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][][] boards = {
            {{1, 2, 2}, {2, 2, 3}, {2, 3, 3}},
            {{1, 1, 2}, {3, 3, 4}, {6, 6, 6}},
            {{1, 2}, {2, 1}},
        };
        String[][] pats = {
            {"ab", "bb"},
            {"ab", "66"},
            {"xx"},
        };
        int[][] expects = {{0, 0}, {1, 1}, {-1, -1}};
        boolean allPass = true;
        for (int i = 0; i < boards.length; ++i) {
            int[] a = sol.findPattern(boards[i], pats[i]);
            int[] b = sol.findPatternBrute(boards[i], pats[i]);
            boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
            allPass &= ok;
            System.out.println("case" + i + " -> " + Arrays.toString(a)
                    + " / brute=" + Arrays.toString(b)
                    + " expected=" + Arrays.toString(expects[i])
                    + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(3078);
        int trials = 300;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int bh = 2 + rnd.nextInt(4);
            int bw = 2 + rnd.nextInt(4);
            int[][] board = new int[bh][bw];
            for (int i = 0; i < bh; ++i)
                for (int j = 0; j < bw; ++j)
                    board[i][j] = rnd.nextInt(4);
            int ph = 1 + rnd.nextInt(2);
            int pw = 1 + rnd.nextInt(2);
            String[] pat = new String[ph];
            for (int i = 0; i < ph; ++i) {
                StringBuilder sb = new StringBuilder();
                for (int j = 0; j < pw; ++j) {
                    int kind = rnd.nextInt(2);
                    if (kind == 0) {
                        sb.append((char) ('0' + rnd.nextInt(3)));
                    } else {
                        sb.append((char) ('a' + rnd.nextInt(3)));
                    }
                }
                pat[i] = sb.toString();
            }
            int[] a = sol.findPattern(board, pat);
            int[] b = sol.findPatternBrute(board, pat);
            if (!Arrays.equals(a, b)) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH board=" + Arrays.deepToString(board)
                            + " pat=" + Arrays.toString(pat)
                            + " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(B * P)(B 为 board 位置数,P 为 pattern 大小),空间复杂度 O(26)。

  • 时间复杂度:O(h * w * ph * pw)
  • 空间复杂度:O(1)

3079. Find the Sum of Encrypted Integers(求出加密整数的和)

题目描述

给你一个整数数组 nums,数组中的元素都是正整数。定义一个加密函数 encrypt,

encrypt(x) 将一个整数 x 中每一个数位都用 x 中的最大数位替换。

比方说 encrypt(523) = 555 且 encrypt(213) = 333。

请你返回数组中所有元素加密后的和。

示例 1

复制代码
nums = [1,2,3] -> 6(encrypt 后 [1,2,3])

示例 2

复制代码
nums = [10,21,31] -> 66(encrypt 后 [11,22,33])

提示:

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

解题思路

解法一:逐数求最大数位后按位扩展,主提交版本

对每个 x 求出最大数位 mx 与位数 d,加密结果为 d 位全为 mx 的数:

encrypt(x) = mx * (111...1 共 d 位)。累加所有加密值。

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

解法二:字符串替换(对照)

把 x 转字符串,统计最大数位字符,然后把它用该字符重复 d 次转回整数。

逻辑等价,用于交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:数位处理(主提交版本) ----------
    public int sumOfEncryptedInt(int[] nums) {
        int ans = 0;
        for (int v : nums) {
            ans += encrypt(v);
        }
        return ans;
    }

    private int encrypt(int x) {
        int mx = 0;
        int tmp = x;
        int d = 0;
        while (tmp > 0) {
            mx = Math.max(mx, tmp % 10);
            tmp /= 10;
            d++;
        }
        int res = 0;
        for (int i = 0; i < d; ++i) {
            res = res * 10 + mx;
        }
        return res;
    }

    // ---------- 解法二:字符串替换(对照) ----------
    public int sumOfEncryptedIntByStr(int[] nums) {
        int ans = 0;
        for (int v : nums) {
            String s = Integer.toString(v);
            char mx = '0';
            for (char c : s.toCharArray()) {
                if (c > mx) mx = c;
            }
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < s.length(); ++i) {
                sb.append(mx);
            }
            ans += Integer.parseInt(sb.toString());
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {1, 2, 3},
            {10, 21, 31},
            {523, 213},
            {1000},
            {9, 99, 999},
        };
        int[] expects = {6, 66, 888, 1111, 9 + 99 + 999};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.sumOfEncryptedInt(cases[i]);
            int b = sol.sumOfEncryptedIntByStr(cases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(Arrays.toString(cases[i]) + " -> " + a
                    + " / str=" + b + " expected=" + expects[i]
                    + (ok ? " PASS" : " FAIL"));
        }
        System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
    }
}

复杂度分析

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

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

3080. Mark Elements on Array by Performing Queries(执行操作标记数组中的元素)

题目描述

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

同时给你一个长度为 m 的二维操作数组 queries,其中 queries[i] = `indexi`, `ki`。

一开始,数组中的所有元素都未标记。

你需要依次对数组执行 m 次操作,第 i 次操作中,你需要执行:

  • 如果下标 indexi 对应的元素还没标记,那么标记这个元素;
  • 然后标记 ki 个数组中还没有标记的最小元素。如果有元素的值相等,那么优先标记
    它们中下标较小的。如果少于 ki 个未标记元素存在,那么将它们全部标记。
    返回一个长度为 m 的数组 answer,其中 answer[i] 是第 i 次操作后数组中还没标记元素的和。

示例 1

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

示例 2

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

提示:

  • n == nums.length, m == queries.length
  • 1 <= m <= n <= 10^5
  • 1 <= nums[i] <= 10^5
  • queries[i].length == 2
  • 0 <= indexi, ki <= n - 1

解题思路

解法一:标记数组 + 小根堆,主提交版本

  • 维护 long total 为当前未标记元素和;
  • 把所有元素按 (值, 下标) 放入小根堆;
  • 每次操作:先尝试标记 indexi;再从堆顶不断弹出已标记元素丢弃,
    取出 ki 个未标记的最小元素标记并扣减 total。
    每个元素最多入堆一次、出堆一次,总复杂度 O((n + m) log n)。
    时间复杂度 O((n + m) log n),空间复杂度 O(n)。
    解法二:暴力线性扫描(对照)
    小规模场景:每次操作线性找最小未标记元素。时间复杂度 O(m * n),
    仅用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O((n + m) log n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:标记数组 + 小根堆(主提交版本) ----------
    public long[] unmarkedSumArray(int[] nums, int[][] queries) {
        int n = nums.length;
        int m = queries.length;
        boolean[] marked = new boolean[n];
        long total = 0;
        // 堆元素:[值, 下标]
        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) ->
                a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
        for (int i = 0; i < n; ++i) {
            total += nums[i];
            pq.offer(new int[]{nums[i], i});
        }
        long[] ans = new long[m];
        for (int q = 0; q < m; ++q) {
            int idx = queries[q][0];
            int k = queries[q][1];
            if (!marked[idx]) {
                marked[idx] = true;
                total -= nums[idx];
            }
            while (k > 0 && !pq.isEmpty()) {
                int[] top = pq.poll();
                if (marked[top[1]]) {
                    continue;
                }
                marked[top[1]] = true;
                total -= top[0];
                k--;
            }
            ans[q] = total;
        }
        return ans;
    }

    // ---------- 解法二:暴力线性扫描(对照) ----------
    public long[] unmarkedSumArrayBrute(int[] nums, int[][] queries) {
        int n = nums.length;
        int m = queries.length;
        boolean[] marked = new boolean[n];
        long total = 0;
        for (int v : nums) total += v;
        long[] ans = new long[m];
        for (int q = 0; q < m; ++q) {
            int idx = queries[q][0];
            int k = queries[q][1];
            if (!marked[idx]) {
                marked[idx] = true;
                total -= nums[idx];
            }
            while (k > 0) {
                int best = -1;
                for (int i = 0; i < n; ++i) {
                    if (!marked[i]) {
                        if (best < 0 || nums[i] < nums[best]
                                || (nums[i] == nums[best] && i < best)) {
                            best = i;
                        }
                    }
                }
                if (best < 0) break;
                marked[best] = true;
                total -= nums[best];
                k--;
            }
            ans[q] = total;
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = {
            {1, 2, 2, 1, 2, 3, 1},
            {1, 4, 2, 3},
            {5, 5, 5},
        };
        int[][][] qs = {
            {{1, 2}, {3, 3}, {4, 2}},
            {{0, 1}},
            {{0, 1}, {1, 2}},
        };
        long[][] expects = {
            {8, 3, 0},
            {7},
            {5, 0},
        };
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            long[] a = sol.unmarkedSumArray(cases[i], qs[i]);
            long[] b = sol.unmarkedSumArrayBrute(cases[i], qs[i]);
            boolean ok = Arrays.equals(a, expects[i]) && Arrays.equals(b, expects[i]);
            allPass &= ok;
            System.out.println("case" + i + " -> " + Arrays.toString(a)
                    + " / brute=" + Arrays.toString(b)
                    + " expected=" + Arrays.toString(expects[i])
                    + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(3080);
        int trials = 300;
        int fail = 0;
        for (int t = 0; t < trials; ++t) {
            int n = 1 + rnd.nextInt(8);
            int m = 1 + rnd.nextInt(6);
            int[] nums = new int[n];
            for (int i = 0; i < n; ++i) nums[i] = 1 + rnd.nextInt(10);
            int[][] q = new int[m][2];
            for (int i = 0; i < m; ++i) {
                q[i][0] = rnd.nextInt(n);
                q[i][1] = rnd.nextInt(n);
            }
            long[] a = sol.unmarkedSumArray(nums, q);
            long[] b = sol.unmarkedSumArrayBrute(nums, q);
            if (!Arrays.equals(a, b)) {
                fail++;
                if (fail <= 5) {
                    System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                            + " q=" + Arrays.deepToString(q)
                            + " a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
                }
            }
        }
        System.out.println("Random trials=" + trials + " fail=" + fail
                + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

小规模场景:每次操作线性找最小未标记元素。时间复杂度 O(m * n),

  • 时间复杂度:O((n + m) log n)
  • 空间复杂度:O(n)
相关推荐
装不满的克莱因瓶27 分钟前
【AI时代必学】一篇文章教会你从零搭建Serverless架构
java·人工智能·ai·云原生·架构·serverless
七夜zippoe2 小时前
多轮对话管理:Session/记忆在 Java 后端怎么存(存储设计实战)
java·开发语言·ai·session·记忆
杨凯凡2 小时前
Spring Boot 事务提交后消息仍会丢?TransactionalEventListener 与 Outbox 可靠投递实战
java·spring boot
Java后端的Ai之路2 小时前
Java并发编程22-Lock接口
java·人工智能·prompt·lock
文丑颜不良啊3 小时前
LeetCode3081~3100题目解析
java·leetcode
SimonKing3 小时前
快讯!local-notes素笺笔记又又又更新了!
java·后端·程序员
Rain的Java大神之路3 小时前
面试官:设计一个自动售货机系统。我:别急着写代码,先问5个问题|状态机+防超卖+断电自愈,一套答法讲透
java·后端·面试
挖掘狂人3 小时前
飞书群聊已读,是怎么实现的?
java·程序员·架构
吴名氏.5 小时前
Java转AI Agent教程(第十五周)政策时效:过期政策不该被召回,也不能被删掉
java·人工智能·python·ai·ai agent