LeetCode3101~3120题目解析

LeetCode 3101-3120. 题解合集

文章目录


3101. Count Alternating Subarrays(交替子数组计数)

题目描述

给你一个二进制数组 nums 。

如果一个子数组中 不存在 两个相邻元素的值相同的情况,我们称这样的子数组为交替子数组。

返回数组 nums 中交替子数组的数量。

示例 1

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

示例 2

复制代码
nums = [1,0,1,0] -> 10(每个子数组都是交替子数组)

提示:

  • 1 <= nums.length <= 10^5
  • nums[i] 不是 0 就是 1

解题思路

解法一:动态规划/滑动统计,主提交版本

统计以每个位置结尾的交替子数组数量:维护 s 表示"以当前元素结尾的最长交替连续段长度",

若 numsi != numsi-1 则 s = s + 1(可接在前一个之后),否则 s = 1(自己单独成段)。

累加所有 s 即得总数量。

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

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

枚举所有子数组,逐个检查是否交替。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:一次扫描统计(主提交版本) ----------
    public long countAlternatingSubarrays(int[] nums) {
        long ans = 0;
        long s = 0;
        for (int i = 0; i < nums.length; ++i) {
            if (i > 0 && nums[i] != nums[i - 1]) {
                s = s + 1;
            } else {
                s = 1;
            }
            ans += s;
        }
        return ans;
    }

    // ---------- 解法二:暴力枚举(对照) ----------
    public long countAlternatingSubarraysBrute(int[] nums) {
        int n = nums.length;
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = i; j < n; ++j) {
                boolean ok = true;
                for (int k = i + 1; k <= j; ++k) {
                    if (nums[k] == nums[k - 1]) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    ans++;
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = { {0, 1, 1, 1}, {1, 0, 1, 0}, {0}, {1}, {0, 0}, {1, 1, 1} };
        long[] expects = {5, 10, 1, 1, 2, 3};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            long a = sol.countAlternatingSubarrays(cases[i]);
            long b = sol.countAlternatingSubarraysBrute(cases[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(42);
        int fail = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rnd.nextInt(15);
            int[] arr = new int[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = rnd.nextInt(2);
            }
            long a = sol.countAlternatingSubarrays(arr);
            long b = sol.countAlternatingSubarraysBrute(arr);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH n=" + n + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3102. Minimize Manhattan Distances(最小化曼哈顿距离)

题目描述

给你一个下标从 0 开始的数组 points,它表示二维平面上一些点的整数坐标,

其中 points[i] = `xi`, `yi`。两点之间的距离定义为它们的曼哈顿距离。

请你恰好移除一个点,返回移除后任意两点之间的最大距离可能的最小值。

示例 1

复制代码
points = [[3,10],[5,15],[10,2],[4,4]] -> 12

示例 2

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

提示:

  • 1 <= points.length <= 10^5
  • points[i].length == 2
  • -10^8 <= xi, yi <= 10^8

解题思路

解法一:坐标变换 + TreeMap 多集,主提交版本

曼哈顿距离 |x1-x2| + |y1-y2| 可转化为切比雪夫距离:

max(|(x1+y1)-(x2+y2)|, |(x1-y1)-(x2-y2)|)。

因此任意两点的最大曼哈顿距离 =

max( (x+y) 的最大值-最小值, (x-y) 的最大值-最小值 )。

用两个 TreeMap 分别维护 x+y 和 x-y 的频数(可重复),

枚举移除每个点 p:先将其从两个 TreeMap 各删一次,

计算当前 max(最大值-最小值),取全局最小;最后把 p 加回。

时间复杂度 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.TreeMap;

public class Solution {

    // ---------- 解法一:坐标变换 + TreeMap(主提交版本) ----------
    public int minimumDistance(int[][] points) {
        TreeMap<Integer, Integer> tm1 = new TreeMap<>(); // x + y
        TreeMap<Integer, Integer> tm2 = new TreeMap<>(); // x - y
        for (int[] p : points) {
            int x = p[0], y = p[1];
            tm1.merge(x + y, 1, Integer::sum);
            tm2.merge(x - y, 1, Integer::sum);
        }
        int ans = Integer.MAX_VALUE;
        for (int[] p : points) {
            int x = p[0], y = p[1];
            int a = x + y, b = x - y;
            if (tm1.merge(a, -1, Integer::sum) == 0) {
                tm1.remove(a);
            }
            if (tm2.merge(b, -1, Integer::sum) == 0) {
                tm2.remove(b);
            }
            ans = Math.min(ans,
                Math.max(tm1.lastKey() - tm1.firstKey(), tm2.lastKey() - tm2.firstKey()));
            tm1.merge(a, 1, Integer::sum);
            tm2.merge(b, 1, Integer::sum);
        }
        return ans;
    }

    // ---------- 解法二:暴力枚举(对照) ----------
    public int minimumDistanceBrute(int[][] points) {
        int n = points.length;
        int ans = Integer.MAX_VALUE;
        for (int skip = 0; skip < n; ++skip) {
            int mx = 0;
            for (int i = 0; i < n; ++i) {
                if (i == skip) {
                    continue;
                }
                for (int j = i + 1; j < n; ++j) {
                    if (j == skip) {
                        continue;
                    }
                    int d = Math.abs(points[i][0] - points[j][0])
                          + Math.abs(points[i][1] - points[j][1]);
                    mx = Math.max(mx, d);
                }
            }
            ans = Math.min(ans, mx);
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] p1 = { {3, 10}, {5, 15}, {10, 2}, {4, 4} };
        int[][] p2 = { {1, 1}, {1, 1}, {1, 1} };
        System.out.println("case1 -> " + sol.minimumDistance(p1)
                + " brute=" + sol.minimumDistanceBrute(p1) + " expected=12");
        System.out.println("case2 -> " + sol.minimumDistance(p2)
                + " brute=" + sol.minimumDistanceBrute(p2) + " expected=0");
        boolean ok1 = sol.minimumDistance(p1) == 12 && sol.minimumDistanceBrute(p1) == 12;
        boolean ok2 = sol.minimumDistance(p2) == 0 && sol.minimumDistanceBrute(p2) == 0;
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 800; ++t) {
            int n = 2 + rnd.nextInt(6);
            int[][] pts = new int[n][2];
            for (int i = 0; i < n; ++i) {
                pts[i][0] = rnd.nextInt(21) - 10;
                pts[i][1] = rnd.nextInt(21) - 10;
            }
            int a = sol.minimumDistance(pts);
            int b = sol.minimumDistanceBrute(pts);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH a=" + a + " b=" + b + " pts=" + Arrays.deepToString(pts));
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

题目类型:数据库(SQL)

题目描述

表:Tweets

复制代码
+-------------+---------+
| Column Name | Type    |
+-------------+---------+
| user_id     | int     |
| tweet_id    | int     |
| tweet_date  | date    |
| tweet       | varchar |
+-------------+---------+

tweet_id 是这张表的主键(值互不相同的列)。这张表的每一行都包含 user_id、tweet_id、tweet_date 和 tweet。题目保证所有 tweet_date 都是 2024 年 2 月的合法日期。

编写一个解决方案来找到 2024 年 二月 的前 3 热门话题标签。一条推文可能含有多个标签。

返回结果表,根据标签的数量 和名称降序排序。

示例 1:

复制代码
输入:
Tweets 表:
+---------+----------+------------------------------------------------------------+------------+
| user_id | tweet_id | tweet                                                      | tweet_date |
+---------+----------+------------------------------------------------------------+------------+
| 135     | 13       | Enjoying a great start to the day. #HappyDay #MorningVibes | 2024-02-01 |
| 136     | 14       | Another #HappyDay with good vibes! #FeelGood               | 2024-02-03 |
| 137     | 15       | Productivity peaks! #WorkLife #ProductiveDay               | 2024-02-04 |
| 138     | 16       | Exploring new tech frontiers. #TechLife #Innovation        | 2024-02-04 |
| 139     | 17       | Gratitude for today's moments. #HappyDay #Thankful         | 2024-02-05 |
| 140     | 18       | Innovation drives us. #TechLife #FutureTech                | 2024-02-07 |
| 141     | 19       | Connecting with nature's serenity. #Nature #Peaceful       | 2024-02-09 |
+---------+----------+------------------------------------------------------------+------------+
输出:
+-----------+-------+
| hashtag   | count |
+-----------+-------+
| #HappyDay | 3     |
| #TechLife | 2     |
| #WorkLife | 1     |
+-----------+-------+

解释:#HappyDay 在 ID 13、14、17 的推文中出现共 3 次;#TechLife 在 16、18 中出现共 2 次;#WorkLife 在 15 中出现 1 次。输出表按 count 和 hashtag 降序排序。

解题思路

一条推文可能含多个标签,需要把每条推文按 # 拆分出所有标签:用递归 CTE ------锚点查询取每条推文的第一个 标签(SUBSTRING_INDEX(SUBSTRING_INDEX(tweet,'#',2),'#',-1) 再截到空格),并把 # 之前的内容从原文中剔除得到剩余串 remain_tags;递归成员对剩余串重复同样操作,直到不含 # 为止。外层对每个标签 GROUP BY 计数,按次数降序、标签名降序排序后 LIMIT 3 取前 3。

代码实现

sql 复制代码
WITH RECURSIVE t1 AS (
    SELECT tweet_id,
           SUBSTRING_INDEX(SUBSTRING_INDEX(
               SUBSTRING_INDEX(tweet, '#', 2), '#', -1), ' ', 1) AS tag,
           TRIM(LEADING SUBSTRING_INDEX(tweet, '#', 2) FROM tweet) AS remain_tags
    FROM Tweets
    WHERE tweet LIKE '%#%' AND YEAR(tweet_date) = 2024 AND MONTH(tweet_date) = 2
    UNION ALL
    SELECT tweet_id,
           SUBSTRING_INDEX(SUBSTRING_INDEX(
               SUBSTRING_INDEX(remain_tags, '#', 2), '#', -1), ' ', 1) AS tag,
           TRIM(LEADING SUBSTRING_INDEX(remain_tags, '#', 2) FROM remain_tags)
    FROM t1
    WHERE remain_tags LIKE '%#%'
)
SELECT CONCAT('#', tag) AS hashtag, COUNT(tweet_id) AS count
FROM t1
GROUP BY tag
ORDER BY count DESC, tag DESC
LIMIT 3;

复杂度分析

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


3104. Find Longest Self-Contained Substring(查找最长的自包含子串)

题目描述

给定字符串 s,你需要找到 s 的最长自包含子串的长度。

如果 s 的一个子串 t 满足 t != s 且 t 中的每一个字符在 s 的剩余部分都不存在,

则被称为是自包含的。如果存在 s 的最长自包含子串,返回它的长度,否则返回 -1。

示例 1

复制代码
s = "abba" -> 2(子串 "bb",子串外没有其它 "b")

示例 2

复制代码
s = "abab" -> -1

示例 3

复制代码
s = "abacd" -> 4(子串 "bcd" 外没有 b/c/d?答案为 4,即 "bcd"?)

提示:

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

解题思路

解法一:滑动窗口 + 首末位置(主提交版本)

预处理 first26 与 last26:每个字符第一次/最后一次出现的位置。

一个子串 l, r 是自包含的,当且仅当对子串内每个字符 c:

firstc >= l 且 lastc <= r,即子串恰好覆盖了其中所有字符的出现范围。

枚举每个字符 k 作为起点 c = firstk(子串左端点取其首字符首次出现位置),

向右扩展右端点 j,维护 mx = max(last字符);

若扫到某个字符其 first < i,说明子串不可能自包含(该字符在 i 之前出现过且不在子串内),

直接终止该起点。当 mx == j 且长度 < n 时,子串自包含,更新答案。

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

解法二:暴力(对照,小规模)

枚举所有子串 l, r(长度 < n),检查其内每个字符是否在子串外出现过(扫描 l...r 之外),

全部满足则更新答案。时间复杂度 O(n^3),仅用于小规模交叉验证。

复杂度:

  • 时间复杂度:O(26 * n)
  • 空间复杂度:O(1)(两个长度 26 数组)

代码实现

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

public class Solution {

    // ---------- 解法一:首末位置滑动(主提交版本) ----------
    public int maxSubstringLength(String s) {
        int[] first = new int[26];
        int[] last = new int[26];
        Arrays.fill(first, -1);
        int n = s.length();
        for (int i = 0; i < n; ++i) {
            int j = s.charAt(i) - 'a';
            if (first[j] == -1) {
                first[j] = i;
            }
            last[j] = i;
        }
        int ans = -1;
        for (int k = 0; k < 26; ++k) {
            int i = first[k];
            if (i == -1) {
                continue;
            }
            int mx = last[k];
            for (int j = i; j < n; ++j) {
                int c = s.charAt(j) - 'a';
                int a = first[c];
                int b = last[c];
                if (a < i) {
                    break; // 字符 c 在 i 之前也出现过,子串不可能自包含
                }
                mx = Math.max(mx, b);
                if (mx == j && j - i + 1 < n) {
                    ans = Math.max(ans, j - i + 1);
                }
            }
        }
        return ans;
    }

    // ---------- 解法二:暴力(对照) ----------
    public int maxSubstringLengthBrute(String s) {
        int n = s.length();
        int ans = -1;
        for (int l = 0; l < n; ++l) {
            for (int r = l; r < n; ++r) {
                if (r - l + 1 >= n) {
                    continue; // t != s
                }
                boolean ok = true;
                for (int p = l; p <= r; ++p) {
                    char c = s.charAt(p);
                    for (int q = 0; q < n; ++q) {
                        if (q >= l && q <= r) {
                            continue;
                        }
                        if (s.charAt(q) == c) {
                            ok = false;
                            break;
                        }
                    }
                    if (!ok) {
                        break;
                    }
                }
                if (ok) {
                    ans = Math.max(ans, r - l + 1);
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[] ss = { "abba", "abab", "abacd" };
        int[] expects = { 2, -1, 4 };
        boolean ok = true;
        for (int i = 0; i < ss.length; ++i) {
            int a = sol.maxSubstringLength(ss[i]);
            int b = sol.maxSubstringLengthBrute(ss[i]);
            boolean cur = a == expects[i] && b == expects[i];
            ok &= cur;
            System.out.println("s=\"" + ss[i] + "\" -> " + a + " brute=" + b
                    + " expected=" + expects[i] + (cur ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        String pool = "abc";
        for (int t = 0; t < 500; ++t) {
            int len = 1 + rnd.nextInt(8);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < len; ++i) {
                sb.append(pool.charAt(rnd.nextInt(pool.length())));
            }
            String s = sb.toString();
            int a = sol.maxSubstringLength(s);
            int b = sol.maxSubstringLengthBrute(s);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

全部满足则更新答案。时间复杂度 O(n^3),仅用于小规模交叉验证。

  • 时间复杂度:O(26 * n)
  • 空间复杂度:O(1)(两个长度 26 数组)

3105. Longest Strictly Increasing or Strictly Decreasing Subarray(最长的严格递增或递减子数组)

题目描述

给你一个整数数组 nums。

返回数组中最长严格递增或严格递减子数组的长度。

注意:子数组是数组中的连续非空元素序列。

示例 1

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

示例 2

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

示例 3

复制代码
nums = [3,2,1] -> 3([3,2,1] 为严格递减)

提示:

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

解题思路

解法一:两次扫描,主提交版本

第一次扫描统计最长严格递增段:t 记录以当前元素结尾的连续严格递增长度,

numsi-1 < numsi 时 t++,否则 t 重置为 1,不断更新答案。

第二次扫描对称统计最长严格递减段。

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

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

枚举所有子数组,检查是否严格递增或严格递减,取最长。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:两次扫描(主提交版本) ----------
    public int longestMonotonicSubarray(int[] nums) {
        int ans = 1;
        for (int i = 1, t = 1; i < nums.length; ++i) {
            if (nums[i - 1] < nums[i]) {
                ans = Math.max(ans, ++t);
            } else {
                t = 1;
            }
        }
        for (int i = 1, t = 1; i < nums.length; ++i) {
            if (nums[i - 1] > nums[i]) {
                ans = Math.max(ans, ++t);
            } else {
                t = 1;
            }
        }
        return ans;
    }

    // ---------- 解法二:暴力枚举(对照) ----------
    public int longestMonotonicSubarrayBrute(int[] nums) {
        int n = nums.length;
        int ans = 1;
        for (int i = 0; i < n; ++i) {
            for (int j = i + 1; j < n; ++j) {
                boolean inc = true, dec = true;
                for (int k = i + 1; k <= j; ++k) {
                    if (nums[k] <= nums[k - 1]) {
                        inc = false;
                    }
                    if (nums[k] >= nums[k - 1]) {
                        dec = false;
                    }
                }
                if (inc || dec) {
                    ans = Math.max(ans, j - i + 1);
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = { {1, 4, 3, 3, 2}, {3, 3, 3, 3}, {3, 2, 1}, {1}, {1, 2, 3, 4}, {5, 4, 3, 2, 1} };
        int[] expects = {2, 1, 3, 1, 4, 5};
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.longestMonotonicSubarray(cases[i]);
            int b = sol.longestMonotonicSubarrayBrute(cases[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(42);
        int fail = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rnd.nextInt(12);
            int[] arr = new int[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = 1 + rnd.nextInt(10);
            }
            int a = sol.longestMonotonicSubarray(arr);
            int b = sol.longestMonotonicSubarrayBrute(arr);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH n=" + n + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3106. Lexicographically Smallest String After Operations With Constraint(满足距离约束且字典序最小的字符串)

题目描述

给你一个仅由小写英文字母组成的字符串 s 和一个整数 k。

定义两个小写字母 c1 和 c2 之间的距离为它们环形的距离,即 min(|c1-c2|, 26-|c1-c2|)。

定义字符串 s 与 t 之间的距离为每对下标 i,s[i] 与 t[i] 之间的距离之和。

请你返回与 s 距离小于等于 k 的字典序最小的字符串。

如果两个字符串第一个不同的字符在 i 位置,字符 a 在字符 b 之前,那么 a 的字典序小于 b。

返回的字符串应当与 s 等长。

示例 1

复制代码
s = "zbbz", k = 3 -> "aaad"

示例 2

复制代码
s = "xaxcd", k = 4 -> "aawcd"

示例 3

复制代码
s = "lol", k = 0 -> "lol"

提示:

  • 1 <= s.length <= 100
  • 0 <= k <= 1000
  • s 仅由小写英文字母组成

解题思路

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

尽量把每个字符变成 'a':对第 i 个字符 c,计算把它变到 'a' 的环形距离 d,

若 d <= 剩余 k,则直接变成 'a'(字典序最小),k -= d;

否则在剩余 k 的限制下,把它变成字典序尽可能小的字符 c2(从 'a' 往 c 靠近,

找到满足环形距离 <= k 的最小字符)。

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

解法二:逐字符枚举回溯(对照)

依次决定每个位置:若变 'a' 可行则变,否则枚举 c2 从 'a' 到 c-1 找可行最小字符。

与解法一等价,仅实现方式不同。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:贪心(主提交版本) ----------
    public String getSmallestString(String s, int k) {
        char[] cs = s.toCharArray();
        for (int i = 0; i < cs.length; ++i) {
            char c1 = cs[i];
            int dToA = Math.min(c1 - 'a', 26 - (c1 - 'a'));
            if (dToA <= k) {
                cs[i] = 'a';
                k -= dToA;
                continue;
            }
            // 不能到 'a',在剩余限制内选最小的可行字符
            for (char c2 = 'a'; c2 < c1; ++c2) {
                int d = Math.min(c1 - c2, 26 - c1 + c2);
                if (d <= k) {
                    cs[i] = c2;
                    k -= d;
                    break;
                }
            }
        }
        return new String(cs);
    }

    // ---------- 解法二:逐字符枚举(对照实现) ----------
    public String getSmallestStringBrute(String s, int k) {
        char[] cs = s.toCharArray();
        for (int i = 0; i < cs.length && k > 0; ++i) {
            char c1 = cs[i];
            for (char c2 = 'a'; c2 < c1; ++c2) {
                int d = Math.min(c1 - c2, 26 - c1 + c2);
                if (d <= k) {
                    cs[i] = c2;
                    k -= d;
                    break;
                }
            }
        }
        return new String(cs);
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[] ss = { "zbbz", "xaxcd", "lol", "a", "zzzz", "abc" };
        int[] ks = { 3, 4, 0, 5, 1, 0 };
        String[] expects = { "aaaz", "aawcd", "lol", "a", "azzz", "abc" };
        boolean allPass = true;
        for (int i = 0; i < ss.length; ++i) {
            String a = sol.getSmallestString(ss[i], ks[i]);
            String b = sol.getSmallestStringBrute(ss[i], ks[i]);
            boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
            allPass &= ok;
            System.out.println("case " + i + " -> " + a + " / brute=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rnd.nextInt(8);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; ++i) {
                sb.append((char) ('a' + rnd.nextInt(26)));
            }
            int k = rnd.nextInt(30);
            String a = sol.getSmallestString(sb.toString(), k);
            String b = sol.getSmallestStringBrute(sb.toString(), k);
            if (!a.equals(b)) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH s=" + sb + " k=" + k + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

3107. Minimum Operations to Make Median of Array Equal to K(使数组中位数等于 K 的最少操作数)

题目描述

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

一次操作中,你可以任意选择一个下标 i(0 <= i < n),将 nums[i] 增加或减少 1。

请你返回使 nums 的中位数等于 k 所需的最少操作次数。

数组的中位数:将数组排序后,位于中间位置的元素。若 n 为偶数,则取排序后中间两个元素中较小的一个(下标 n/2)。

示例 1

复制代码
nums = [2,5,6,8,5], k = 4 -> 2(修改 5 为 4:一次)

示例 2

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

示例 3

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

提示:

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

解题思路

解法一:排序 + 中位数两侧调整,主提交版本

将 nums 排序。设中位数为 numsm(m = n/2)。

  1. 若 numsm > k:需要把中位数及其左侧所有大于 k 的元素都降为 k,
    累加 (numsi - k)(左侧元素不必动,因为中位数定义左侧小于等于中位数,
    但若左侧有值大于 k,会突破"中位数恰为 k"的约束,需一并降)。
  2. 若 numsm < k:需要把中位数及其右侧所有小于 k 的元素都升为 k,
    累加 (k - numsi)。
  3. numsm == k 时 ans = 0。
    时间复杂度 O(n log n),空间复杂度 O(log n)(排序栈空间)。
    解法二:复制数组排序(对照)
    同上原理,不修改原数组,用 copyOf 复制排序。
    复杂度:
  • 时间复杂度:O(n log n)
  • 空间复杂度:O(1)(原地排序)或 O(n)(复制)

代码实现

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

public class Solution {

    // ---------- 解法一:排序(主提交版本) ----------
    public long minOperationsToMakeMedianK(int[] nums, int k) {
        Arrays.sort(nums);
        int n = nums.length;
        int m = n >> 1;
        long ans = Math.abs((long) nums[m] - k);
        if (nums[m] > k) {
            for (int i = m - 1; i >= 0 && nums[i] > k; --i) {
                ans += nums[i] - k;
            }
        } else {
            for (int i = m + 1; i < n && nums[i] < k; ++i) {
                ans += k - nums[i];
            }
        }
        return ans;
    }

    // ---------- 解法二:复制排序(对照) ----------
    public long minOperationsToMakeMedianKCopy(int[] nums, int k) {
        int[] a = Arrays.copyOf(nums, nums.length);
        Arrays.sort(a);
        int n = a.length;
        int m = n >> 1;
        long ans = Math.abs((long) a[m] - k);
        if (a[m] > k) {
            for (int i = m - 1; i >= 0 && a[i] > k; --i) {
                ans += a[i] - k;
            }
        } else {
            for (int i = m + 1; i < n && a[i] < k; ++i) {
                ans += k - a[i];
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] nums = { {2, 5, 6, 8, 5}, {2, 5, 6, 8, 5}, {1, 2, 3, 4, 5}, {1}, {5, 5, 5}, {1, 1, 1, 10} };
        int[] ks = { 4, 7, 5, 1, 7, 1 };
        long[] expects = { 2, 3, 3, 0, 4, 0 };
        boolean allPass = true;
        for (int i = 0; i < nums.length; ++i) {
            long a = sol.minOperationsToMakeMedianK(nums[i].clone(), ks[i]);
            long b = sol.minOperationsToMakeMedianKCopy(nums[i].clone(), ks[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println("case " + i + " -> " + a + " / copy=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 500; ++t) {
            int n = 1 + rnd.nextInt(8);
            int[] arr = new int[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = 1 + rnd.nextInt(12);
            }
            int k = 1 + rnd.nextInt(12);
            long a = sol.minOperationsToMakeMedianK(arr.clone(), k);
            long b = sol.minOperationsToMakeMedianKCopy(arr.clone(), k);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH n=" + n + " k=" + k + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

  • 时间复杂度:O(n log n)
  • 空间复杂度:O(1)(原地排序)或 O(n)(复制)

3108. Minimum Cost Walk in Weighted Graph(带权图里旅途的最小代价)

题目描述

给你一个 n 个节点的带权无向图,节点编号为 0 到 n - 1。

给你一个整数 n 和一个数组 edges,其中 edges[i] = `ui`, `vi`, `wi` 表示节点 ui 和 vi 之间

有一条权值为 wi 的无向边。

一趟旅途的代价定义为经过的边权按位与 AND 的结果(与顺序无关)。

给你一个二维数组 query,其中 query[i] = `si`, `ti`。对于每一个查询,你需要找出从节点 si

开始,在节点 ti 处结束的旅途的最小代价。如果不存在这样的旅途,答案为 -1。

返回数组 answer,其中 answer[i] 表示对于查询 i 的最小旅途代价。

示例 1

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

示例 2

复制代码
n = 3, edges = [[0,2,7],[0,1,15],[1,2,6],[1,2,1]], query = [[1,2]] -> [0]

提示:

  • 1 <= n <= 10^5
  • 0 <= edges.length <= 10^5
  • 0 <= ui, vi < n
  • 1 <= wi <= 10^9
  • 1 <= query.length <= 10^5

解题思路

解法一:并查集 + 连通分量位与,主提交版本

按位与 AND 满足"多走边只会让代价变小或不变":对同一连通分量内的任意两点,

可以把分量内所有边全部走一遍(可重复走边/节点),代价 = 分量内所有边权的按位与。

因此:

  1. 先用并查集合并所有边,得到连通分量;
  2. 对每条边 e,令其所在分量根 root 的代价 groot &= e2(初值 -1,即全 1);
  3. 查询 (s, t):若 s == t 返回 0;若 s、t 不同根返回 -1;否则返回 gfind(s)。
    时间复杂度 O((n + m + q) * α(n)),空间复杂度 O(n)。
    解法二:BFS 暴力(对照,小规模)
    对每个查询,以 s 为起点做 DFS/BFS,把所有可达边权累 AND,得出 s 所在连通分量的
    全体边权 AND;再判断 t 是否与其连通。仅用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O((n + m + q) * α(n))
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:并查集 + 分量位与(主提交版本) ----------
    public int[] minimumCost(int n, int[][] edges, int[][] query) {
        int[] p = new int[n];
        for (int i = 0; i < n; ++i) {
            p[i] = i;
        }
        for (int[] e : edges) {
            union(p, e[0], e[1]);
        }
        int[] g = new int[n];
        Arrays.fill(g, -1); // -1 = 全 1 位,相当于 AND 的零元
        for (int[] e : edges) {
            int root = find(p, e[0]);
            g[root] &= e[2];
        }
        int m = query.length;
        int[] ans = new int[m];
        for (int i = 0; i < m; ++i) {
            int s = query[i][0], t = query[i][1];
            ans[i] = f(p, g, s, t);
        }
        return ans;
    }

    private int find(int[] p, int x) {
        if (p[x] != x) {
            p[x] = find(p, p[x]);
        }
        return p[x];
    }

    private void union(int[] p, int a, int b) {
        int pa = find(p, a), pb = find(p, b);
        if (pa != pb) {
            p[pa] = pb;
        }
    }

    private int f(int[] p, int[] g, int u, int v) {
        if (u == v) {
            return 0;
        }
        int a = find(p, u), b = find(p, v);
        return a == b ? g[a] : -1;
    }

    // ---------- 解法二:DFS 暴力(对照) ----------
    public int[] minimumCostBrute(int n, int[][] edges, int[][] query) {
        // 邻接表
        @SuppressWarnings({ "unchecked", "rawtypes" })
        java.util.List<int[]>[] adj = new java.util.ArrayList[n];
        for (int i = 0; i < n; ++i) {
            adj[i] = new java.util.ArrayList<>();
        }
        for (int[] e : edges) {
            adj[e[0]].add(new int[] { e[1], e[2] });
            adj[e[1]].add(new int[] { e[0], e[2] });
        }
        int m = query.length;
        int[] ans = new int[m];
        for (int i = 0; i < m; ++i) {
            int s = query[i][0], t = query[i][1];
            if (s == t) {
                ans[i] = 0;
                continue;
            }
            boolean[] vis = new boolean[n];
            int[] and = { -1 }; // 分量内所有可触及边权 AND
            dfs(s, adj, vis, and);
            if (!vis[t]) {
                ans[i] = -1;
            } else {
                ans[i] = and[0];
            }
        }
        return ans;
    }

    private void dfs(int u, java.util.List<int[]>[] adj, boolean[] vis, int[] and) {
        vis[u] = true;
        for (int[] nb : adj[u]) {
            int v = nb[0], w = nb[1];
            and[0] &= w;
            if (!vis[v]) {
                dfs(v, adj, vis, and);
            }
        }
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] e1 = { {0, 1, 7}, {1, 3, 7}, {1, 2, 1} };
        int[][] q1 = { {0, 3}, {3, 4} };
        int[][] e2 = { {0, 2, 7}, {0, 1, 15}, {1, 2, 6}, {1, 2, 1} };
        int[][] q2 = { {1, 2} };
        int[] r1 = sol.minimumCost(5, e1, q1);
        int[] b1 = sol.minimumCostBrute(5, e1, q1);
        int[] r2 = sol.minimumCost(3, e2, q2);
        int[] b2 = sol.minimumCostBrute(3, e2, q2);
        boolean ok1 = Arrays.equals(r1, new int[] {1, -1}) && Arrays.equals(b1, new int[] {1, -1});
        boolean ok2 = Arrays.equals(r2, new int[] {0}) && Arrays.equals(b2, new int[] {0});
        System.out.println("case1 -> " + Arrays.toString(r1) + " brute=" + Arrays.toString(b1)
                + (ok1 ? " PASS" : " FAIL"));
        System.out.println("case2 -> " + Arrays.toString(r2) + " brute=" + Arrays.toString(b2)
                + (ok2 ? " PASS" : " FAIL"));
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 500; ++t) {
            int n = 2 + rnd.nextInt(7);
            int m = rnd.nextInt(12);
            int[][] edges = new int[m][3];
            for (int i = 0; i < m; ++i) {
                edges[i][0] = rnd.nextInt(n);
                edges[i][1] = rnd.nextInt(n);
                edges[i][2] = 1 + rnd.nextInt(15);
            }
            int qn = 1 + rnd.nextInt(5);
            int[][] qs = new int[qn][2];
            for (int i = 0; i < qn; ++i) {
                qs[i][0] = rnd.nextInt(n);
                qs[i][1] = rnd.nextInt(n);
            }
            int[] a = sol.minimumCost(n, edges, qs);
            int[] b = sol.minimumCostBrute(n, edges, qs);
            if (!Arrays.equals(a, b)) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O((n + m + q) * α(n)),空间复杂度 O(n)。

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

3109. Find the Index of Permutation(查找排列的下标)

题目描述

给定一个长度为 n 的数组 perm,它是 1, 2, ..., `n` 的一个排列。将 1, 2, ..., `n`

所有的排列放在数组中,并以字典序排序。返回这个数组中 perm 的下标。

由于答案可能非常大,返回值对 10^9 + 7 取模。

示例 1

复制代码
perm = [1,2] -> 0(字典序最小的排列下标为 0)

示例 2

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

提示:

  • 1 <= n <= 10^5
  • perm 是 1, 2, ..., `n` 的一个排列

解题思路

解法一:康托展开 + 树状数组,主提交版本

字典序中 perm 的下标 = 所有排在它前面的排列个数。

对每个位置 i(下标 0 起),排在 perm 前面的排列数贡献:

cnt_i * (n - i - 1)!,其中 cnt_i = 在位置 i 处,取一个比 permi 小且未被用过的数

作为 permi 时,其余 n-i-1 个位置可任意排列的数量。

用树状数组维护"未使用的数字",cnt_i = (permi - 1) - (已经使用且 < permi 的个数)。

最后 ans = Σ cnt_i * (n-i-1)!(模 10^9+7)。

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

解法二:暴力(对照,小规模)

递归枚举 1...n 的全排列(字典序生成),逐位比较找到 perm 并计数。

仅用于小规模交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:康托展开 + 树状数组(主提交版本) ----------
    public int getPermutationIndex(int[] perm) {
        final int mod = (int) 1e9 + 7;
        long ans = 0;
        int n = perm.length;
        BinaryIndexedTree tree = new BinaryIndexedTree(n + 1); // 下标 1..n,标记已使用
        long[] f = new long[n];
        f[0] = 1;
        for (int i = 1; i < n; ++i) {
            f[i] = f[i - 1] * i % mod; // 阶乘
        }
        for (int i = 0; i < n; ++i) {
            int usedLess = tree.query(perm[i]); // 已使用且值 < perm[i] 的个数
            int cnt = (perm[i] - 1) - usedLess; // 剩余未使用的比 perm[i] 小的数
            ans = (ans + cnt * f[n - i - 1] % mod) % mod;
            tree.update(perm[i], 1);
        }
        return (int) ans;
    }

    // ---------- 解法二:暴力全排列(对照) ----------
    public int getPermutationIndexBrute(int[] perm) {
        int n = perm.length;
        int[] cur = new int[n];
        boolean[] used = new boolean[n + 1];
        int[] cnt = { 0 };
        dfs(0, n, cur, used, perm, cnt);
        return cnt[0];
    }

    private boolean dfs(int pos, int n, int[] cur, boolean[] used, int[] perm, int[] cnt) {
        if (pos == n) {
            if (Arrays.equals(cur, perm)) {
                return true;
            }
            cnt[0]++;
            return false;
        }
        for (int v = 1; v <= n; ++v) {
            if (used[v]) {
                continue;
            }
            cur[pos] = v;
            used[v] = true;
            if (dfs(pos + 1, n, cur, used, perm, cnt)) {
                return true;
            }
            used[v] = false;
        }
        return false;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] p1 = {1, 2};
        int[] p2 = {3, 1, 2};
        int r1 = sol.getPermutationIndex(p1);
        int b1 = sol.getPermutationIndexBrute(p1);
        int r2 = sol.getPermutationIndex(p2);
        int b2 = sol.getPermutationIndexBrute(p2);
        boolean ok1 = r1 == 0 && b1 == 0;
        boolean ok2 = r2 == 4 && b2 == 4;
        System.out.println("perm=" + Arrays.toString(p1) + " -> " + r1 + " brute=" + b1
                + " expected=0 " + (ok1 ? "PASS" : "FAIL"));
        System.out.println("perm=" + Arrays.toString(p2) + " -> " + r2 + " brute=" + b2
                + " expected=4 " + (ok2 ? "PASS" : "FAIL"));
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 300; ++t) {
            int n = 1 + rnd.nextInt(7);
            int[] perm = new int[n];
            for (int i = 0; i < n; ++i) {
                perm[i] = i + 1;
            }
            // 随机洗牌
            for (int i = n - 1; i > 0; --i) {
                int j = rnd.nextInt(i + 1);
                int tmp = perm[i];
                perm[i] = perm[j];
                perm[j] = tmp;
            }
            // 复制避免洗牌影响
            int[] permCopy = Arrays.copyOf(perm, n);
            int a = sol.getPermutationIndex(perm);
            int b = sol.getPermutationIndexBrute(permCopy);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH perm=" + Arrays.toString(perm) + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
    }
}

class BinaryIndexedTree {
    private int n;
    private int[] c;

    public BinaryIndexedTree(int n) {
        this.n = n;
        this.c = new int[n + 1];
    }

    public void update(int x, int delta) {
        for (; x <= n; x += x & -x) {
            c[x] += delta;
        }
    }

    public int query(int x) {
        int s = 0;
        for (; x > 0; x -= x & -x) {
            s += c[x];
        }
        return s;
    }
}

复杂度分析

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

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

3110. Score of a String(字符串的分数)

题目描述

给你一个字符串 s。字符串的分数定义为相邻字符的 ASCII 码差值绝对值之和:

score(s) = sum_{i=1}^{n-1} |s[i] - s[i-1]|

返回字符串的分数。

示例 1

复制代码
s = "hello" -> 13(|104-101| + |101-108| + |108-108| + |108-111| = 3 + 7 + 0 + 3 = 13)

示例 2

复制代码
s = "zaz" -> 50(|122-97| + |97-122| = 25 + 25 = 50)

提示:

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

解题思路

解法一:一次扫描,主提交版本

遍历 i 从 1 到 n-1,累加相邻字符 ASCII 差的绝对值。

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

解法二:流式求和(对照)

用 while 循环逐位累加,逻辑相同。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:一次扫描(主提交版本) ----------
    public int scoreOfString(String s) {
        int ans = 0;
        for (int i = 1; i < s.length(); ++i) {
            ans += Math.abs(s.charAt(i - 1) - s.charAt(i));
        }
        return ans;
    }

    // ---------- 解法二:while 循环(对照) ----------
    public int scoreOfStringLoop(String s) {
        int ans = 0;
        int i = 1;
        while (i < s.length()) {
            ans += Math.abs(s.charAt(i) - s.charAt(i - 1));
            ++i;
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[] ss = { "hello", "zaz", "ab", "az", "abcdef" };
        int[] expects = { 13, 50, 1, 25, 5 };
        boolean allPass = true;
        for (int i = 0; i < ss.length; ++i) {
            int a = sol.scoreOfString(ss[i]);
            int b = sol.scoreOfStringLoop(ss[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(ss[i] + " -> " + a + " / loop=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }
        // 对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 2 + rnd.nextInt(20);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < n; ++i) {
                sb.append((char) ('a' + rnd.nextInt(26)));
            }
            int a = sol.scoreOfString(sb.toString());
            int b = sol.scoreOfStringLoop(sb.toString());
            if (a != b) {
                fail++;
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

3111. Minimum Rectangles to Cover Points(覆盖所有点的最少矩形数目)

题目描述

给你一个二维整数数组 points,其中 points[i] = `xi`, `yi` 表示二维平面内的一个点。

同时给你一个整数 w。你需要用矩形覆盖所有点。

每个矩形的左下角在某个点 (x1, 0) 处,且右上角在某个点 (x2, y2) 处,

其中 x1 <= x2 且 y2 >= 0,同时对于每个矩形都必须满足 x2 - x1 <= w。

如果一个点在矩形内或者在边上,我们说这个点被矩形覆盖了。

请你在确保每个点都至少被一个矩形覆盖的前提下,最少需要多少个矩形。

注意:一个点可以被多个矩形覆盖。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 1 <= points.length <= 10^5
  • points[i].length == 2
  • 0 <= xi <= 10^9
  • 0 <= yi <= 10^9
  • 0 <= w <= 10^9

解题思路

解法一:按 x 排序贪心,主提交版本

矩形的高度 y2 与宽度约束无关(y2 >= 0 即可),因此问题只看 x 坐标:

按 x 升序排序后,从左到右用宽度为 w 的区间覆盖所有点。

贪心:维护上一个区间的右端点 x1(第一个矩形从第一个点的 x 开始,右端 x + w),

每当遇到点的 x > x1(即超出当前区间),新建一个矩形,并更新 x1 = x + w。

区间数即最少矩形数。

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

解法二:暴力(对照,小规模)

枚举从左到右的覆盖方式:排序后每层贪心从最左未覆盖点开始覆盖 x, x+w,

与解法一同构,这里用循环模拟完整覆盖过程作交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:按 x 排序贪心(主提交版本) ----------
    public int minRectanglesToCoverPoints(int[][] points, int w) {
        Arrays.sort(points, (a, b) -> a[0] - b[0]);
        int ans = 0, x1 = -1; // x1 = 当前矩形右端的 x 坐标
        for (int[] p : points) {
            int x = p[0];
            if (x > x1) { // 当前点无法被已打开的矩形覆盖
                ++ans;
                x1 = x + w;
            }
        }
        return ans;
    }

    // ---------- 解法二:模拟覆盖(对照) ----------
    public int minRectanglesToCoverPointsBrute(int[][] points, int w) {
        int n = points.length;
        int[] xs = new int[n];
        for (int i = 0; i < n; ++i) {
            xs[i] = points[i][0];
        }
        Arrays.sort(xs);
        int ans = 0;
        int i = 0;
        while (i < n) {
            ++ans;
            int right = xs[i] + w;
            while (i < n && xs[i] <= right) {
                ++i;
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] p1 = { {2, 1}, {1, 0}, {1, 4}, {1, 8}, {3, 5}, {4, 6} };
        int[][] p2 = { {0, 0}, {1, 1}, {2, 2}, {3, 3}, {4, 4}, {5, 5}, {6, 6} };
        int[][] p3 = { {2, 3}, {1, 2} };
        int w1 = 1, w2 = 2, w3 = 0;
        boolean ok1 = sol.minRectanglesToCoverPoints(p1, w1) == 2
                && sol.minRectanglesToCoverPointsBrute(p1, w1) == 2;
        boolean ok2 = sol.minRectanglesToCoverPoints(p2, w2) == 3
                && sol.minRectanglesToCoverPointsBrute(p2, w2) == 3;
        boolean ok3 = sol.minRectanglesToCoverPoints(p3, w3) == 2
                && sol.minRectanglesToCoverPointsBrute(p3, w3) == 2;
        System.out.println("case1 -> " + sol.minRectanglesToCoverPoints(p1, w1)
                + " brute=" + sol.minRectanglesToCoverPointsBrute(p1, w1)
                + " expected=2 " + (ok1 ? "PASS" : "FAIL"));
        System.out.println("case2 -> " + sol.minRectanglesToCoverPoints(p2, w2)
                + " brute=" + sol.minRectanglesToCoverPointsBrute(p2, w2)
                + " expected=3 " + (ok2 ? "PASS" : "FAIL"));
        System.out.println("case3 -> " + sol.minRectanglesToCoverPoints(p3, w3)
                + " brute=" + sol.minRectanglesToCoverPointsBrute(p3, w3)
                + " expected=2 " + (ok3 ? "PASS" : "FAIL"));
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 800; ++t) {
            int n = 1 + rnd.nextInt(10);
            int[][] pts = new int[n][2];
            for (int i = 0; i < n; ++i) {
                pts[i][0] = rnd.nextInt(31);
                pts[i][1] = rnd.nextInt(31);
            }
            int w = rnd.nextInt(6);
            int a = sol.minRectanglesToCoverPoints(pts, w);
            int b = sol.minRectanglesToCoverPointsBrute(pts, w);
            if (a != b) {
                ++fail;
                if (fail <= 3) {
                    System.out.println("MISMATCH a=" + a + " b=" + b + " w=" + w
                            + " pts=" + Arrays.deepToString(pts));
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 && ok3 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

3112. Minimum Time to Visit Disappearing Nodes(访问消失节点的最少时间)

题目描述

给你一个二维数组 edges 表示一个 n 个点的无向图,其中 edges[i] = `ui`, `vi`, `lengthi`

表示节点 ui 和节点 vi 之间有一条需要 lengthi 单位时间通过的无向边。

同时给你一个数组 disappear,其中 disappear[i] 表示节点 i 从图中消失的时间点,

在那一刻及以后,你无法再访问这个节点。

注意,图有可能一开始是不连通的,两个节点之间也可能有多条边。

返回数组 answer,answer[i] 表示从节点 0 到节点 i 需要的最少单位时间。

如果从节点 0 出发无法到达节点 i,那么 answer[i] 为 -1。

示例 1

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

示例 2

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

示例 3

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

提示:

  • 2 <= n <= 10^5
  • 1 <= edges.length <= 10^5
  • 0 <= ui, vi <= n - 1
  • 1 <= lengthi <= 10^5
  • disappear.length == n
  • 0 <= disappear[i] <= 10^9

解题思路

解法一:Dijkstra 最短路,主提交版本

节点 i 在 disappeari 时刻及以后无法访问,因此松弛边 (u, v, w) 时,

只有当 distu + w < disappearv 才允许更新 distv。

起点 0 的 dist 为 0;最终 answeri = disti < disappeari ? disti : -1。

用优先队列实现堆优化 Dijkstra。

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

解法二:Bellman-Ford(对照,小规模)

重复 n-1 轮,每轮对所有无向边松弛两次(带消失时间约束),直到不再更新。

与堆优化的写法完全不同(朴素逐轮松弛),用于交叉验证。

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

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:Dijkstra 堆优化(主提交版本) ----------
    public int[] minimumTime(int n, int[][] edges, int[] disappear) {
        List<int[]>[] g = new List[n];
        for (int i = 0; i < n; ++i) {
            g[i] = new ArrayList<>();
        }
        for (int[] e : edges) {
            int u = e[0], v = e[1], w = e[2];
            g[u].add(new int[] {v, w});
            g[v].add(new int[] {u, w});
        }
        int[] dist = new int[n];
        Arrays.fill(dist, Integer.MAX_VALUE / 2);
        dist[0] = 0;
        PriorityQueue<int[]> pq = new PriorityQueue<>((a, b) -> a[0] - b[0]);
        pq.offer(new int[] {0, 0});
        while (!pq.isEmpty()) {
            int[] cur = pq.poll();
            int d = cur[0], u = cur[1];
            if (d > dist[u]) {
                continue;
            }
            for (int[] nx : g[u]) {
                int v = nx[0], w = nx[1];
                int nd = d + w;
                if (nd < dist[v] && nd < disappear[v]) {
                    dist[v] = nd;
                    pq.offer(new int[] {nd, v});
                }
            }
        }
        int[] ans = new int[n];
        for (int i = 0; i < n; ++i) {
            ans[i] = dist[i] < disappear[i] ? dist[i] : -1;
        }
        return ans;
    }

    // ---------- 解法二:Bellman-Ford(对照) ----------
    public int[] minimumTimeBF(int n, int[][] edges, int[] disappear) {
        int[] dist = new int[n];
        Arrays.fill(dist, Integer.MAX_VALUE / 2);
        dist[0] = 0;
        for (int r = 0; r < n - 1; ++r) {
            boolean changed = false;
            for (int[] e : edges) {
                int u = e[0], v = e[1], w = e[2];
                if (dist[u] + w < dist[v] && dist[u] + w < disappear[v]) {
                    dist[v] = dist[u] + w;
                    changed = true;
                }
                if (dist[v] + w < dist[u] && dist[v] + w < disappear[u]) {
                    dist[u] = dist[v] + w;
                    changed = true;
                }
            }
            if (!changed) {
                break;
            }
        }
        int[] ans = new int[n];
        for (int i = 0; i < n; ++i) {
            ans[i] = dist[i] < disappear[i] ? dist[i] : -1;
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] e1 = { {0, 1, 2}, {1, 2, 1}, {0, 2, 4} };
        int[] d1 = {1, 1, 5};
        int[] d2 = {1, 3, 5};
        int[][] e3 = { {0, 1, 1} };
        int[] d3 = {1, 1};
        boolean ok1 = Arrays.equals(sol.minimumTime(3, e1, d1), new int[] {0, -1, 4})
                && Arrays.equals(sol.minimumTimeBF(3, e1, d1), new int[] {0, -1, 4});
        boolean ok2 = Arrays.equals(sol.minimumTime(3, e1, d2), new int[] {0, 2, 3})
                && Arrays.equals(sol.minimumTimeBF(3, e1, d2), new int[] {0, 2, 3});
        boolean ok3 = Arrays.equals(sol.minimumTime(2, e3, d3), new int[] {0, -1})
                && Arrays.equals(sol.minimumTimeBF(2, e3, d3), new int[] {0, -1});
        System.out.println("case1 -> " + Arrays.toString(sol.minimumTime(3, e1, d1))
                + (ok1 ? " PASS" : " FAIL"));
        System.out.println("case2 -> " + Arrays.toString(sol.minimumTime(3, e1, d2))
                + (ok2 ? " PASS" : " FAIL"));
        System.out.println("case3 -> " + Arrays.toString(sol.minimumTime(2, e3, d3))
                + (ok3 ? " PASS" : " FAIL"));
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 500; ++t) {
            int n = 2 + rnd.nextInt(6);
            int m = rnd.nextInt(10);
            int[][] edges = new int[m][3];
            for (int i = 0; i < m; ++i) {
                edges[i][0] = rnd.nextInt(n);
                edges[i][1] = rnd.nextInt(n);
                edges[i][2] = 1 + rnd.nextInt(8);
            }
            int[] dis = new int[n];
            for (int i = 0; i < n; ++i) {
                dis[i] = 1 + rnd.nextInt(15);
            }
            int[] a = sol.minimumTime(n, edges, dis);
            int[] b = sol.minimumTimeBF(n, edges, dis);
            if (!Arrays.equals(a, b)) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH a=" + Arrays.toString(a) + " b=" + Arrays.toString(b));
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 && ok3 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

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

3113. Find the Number of Subarrays Where Boundary Elements Are Maximum

题目描述

(边界元素是最大值的子数组数目)

给你一个正整数数组 nums。

请你求出 nums 中有多少个子数组,满足子数组中第一个和最后一个元素都是这个子数组中的最大值。

示例 1

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

示例 2

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

提示:

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

解题思路

解法一:单调栈 + 同值计数,主提交版本

依次将每个元素 x 作为子数组的"右端点"考虑,统计以当前位为末尾、

且首尾都是最大值的子数组个数。

维护一个严格"单调不增"的栈(栈内元素自底向上非增,同时统计相同值的出现次数):

  1. 弹出所有小于 x 的栈顶(它们不可能再与后续元素形成"首尾最大"子数组);
  2. 若栈空或栈顶值 > x:push (x, 1);
  3. 若栈顶值 == x:栈顶计数 +1。
    每步把栈顶(即 x)的计数加到答案:这统计了"以 x 结尾、以 x 开头"且中间无更大值的
    所有子数组(内含 k 个连续 x 的所有后缀组合)。
    时间复杂度 O(n),空间复杂度 O(n)。
    解法二:暴力(对照,小规模)
    枚举所有子数组 i, j,扫描区间找最大值,检查 numsi == 最大值 && numsj == 最大值。
    仅用于小规模交叉验证。
    复杂度:
  • 时间复杂度:O(n)
  • 空间复杂度:O(n)

代码实现

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

public class Solution {

    // ---------- 解法一:单调栈(主提交版本) ----------
    public long numberOfSubarrays(int[] nums) {
        Deque<int[]> stk = new ArrayDeque<>(); // [值, 该值连续出现次数]
        long ans = 0;
        for (int x : nums) {
            while (!stk.isEmpty() && stk.peek()[0] < x) {
                stk.pop();
            }
            if (stk.isEmpty() || stk.peek()[0] > x) {
                stk.push(new int[] {x, 1});
            } else {
                stk.peek()[1]++;
            }
            ans += stk.peek()[1];
        }
        return ans;
    }

    // ---------- 解法二:暴力(对照) ----------
    public long numberOfSubarraysBrute(int[] nums) {
        int n = nums.length;
        long ans = 0;
        for (int i = 0; i < n; ++i) {
            for (int j = i; j < n; ++j) {
                int mx = nums[i];
                for (int k = i + 1; k <= j; ++k) {
                    mx = Math.max(mx, nums[k]);
                }
                if (nums[i] == mx && nums[j] == mx) {
                    ans++;
                }
            }
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] n1 = {1, 4, 3, 3, 2};
        int[] n2 = {3, 3, 3};
        boolean ok1 = sol.numberOfSubarrays(n1) == 6 && sol.numberOfSubarraysBrute(n1) == 6;
        boolean ok2 = sol.numberOfSubarrays(n2) == 6 && sol.numberOfSubarraysBrute(n2) == 6;
        System.out.println("case1 -> " + sol.numberOfSubarrays(n1) + " brute="
                + sol.numberOfSubarraysBrute(n1) + " expected=6 " + (ok1 ? "PASS" : "FAIL"));
        System.out.println("case2 -> " + sol.numberOfSubarrays(n2) + " brute="
                + sol.numberOfSubarraysBrute(n2) + " expected=6 " + (ok2 ? "PASS" : "FAIL"));
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 800; ++t) {
            int n = 1 + rnd.nextInt(9);
            int[] arr = new int[n];
            for (int i = 0; i < n; ++i) {
                arr[i] = 1 + rnd.nextInt(5);
            }
            long a = sol.numberOfSubarrays(arr);
            long b = sol.numberOfSubarraysBrute(arr);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH a=" + a + " b=" + b + " arr=" + Arrays.toString(arr));
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

3114. Latest Time You Can Obtain After Replacing Characters(替换字符可以得到的最晚时间)

题目描述

给你一个字符串 s,表示一个 12 小时制的时间格式,其中一些数字(可能没有)被 "?" 替换。

12 小时制时间格式为 "HH:MM",其中 HH 的取值范围为 00 至 11,MM 的取值范围为 00 至 59。

最早的时间为 00:00,最晚的时间为 11:59。

你需要将 s 中的所有 "?" 字符替换为数字,使得结果字符串代表的时间是一个有效的 12 小时制时间,

并且是可能的最晚时间。返回结果字符串。

示例 1

复制代码
s = "1?:?4" -> "11:54"

示例 2

复制代码
s = "0?:5?" -> "09:59"

提示:

  • s.length == 5,s[2] 是字符 ":"
  • 除 s[2] 外,其他字符都是数字或 "?"
  • 输入保证存在至少一个介于 "00:00" 和 "11:59" 之间的时间

解题思路

解法一:倒序枚举,主提交版本

从最晚时间 11:59 开始倒序枚举所有 12 小时制时间 HH:MM,

检查当前时间是否与 s 的每个非 '?' 字符匹配,第一个匹配即答案。

枚举范围有限(12 * 60 = 720 种),时间空间均很小。

时间复杂度 O(12 * 60 * 5),空间复杂度 O(1)。

解法二:按位贪心构造(对照)

直接按位确定:第一位尽量取满足约束的最大数字,

但由于 HH 的十位和个位相互制约,需逐位检查。

实现复杂度略高,用于交叉验证。

复杂度:

  • 时间复杂度:O(1)(枚举上限固定)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {

    // ---------- 解法一:倒序枚举(主提交版本) ----------
    public String findLatestTime(String s) {
        for (int h = 11; h >= 0; --h) {
            for (int m = 59; m >= 0; --m) {
                String t = String.format("%02d:%02d", h, m);
                boolean ok = true;
                for (int i = 0; i < s.length(); ++i) {
                    if (s.charAt(i) != '?' && s.charAt(i) != t.charAt(i)) {
                        ok = false;
                        break;
                    }
                }
                if (ok) {
                    return t;
                }
            }
        }
        return "";
    }

    // ---------- 解法二:按位贪心(对照) ----------
    public String findLatestTimeGreedy(String s) {
        char[] cs = s.toCharArray();
        // 时
        if (cs[0] == '?' && cs[1] == '?') {
            cs[0] = '1';
            cs[1] = '1';
        } else if (cs[0] == '?') {
            cs[0] = (cs[1] <= '1') ? '1' : '0';
        } else if (cs[1] == '?') {
            cs[1] = (cs[0] == '1') ? '1' : '9';
        }
        // 分
        if (cs[3] == '?') {
            cs[3] = '5';
        }
        if (cs[4] == '?') {
            cs[4] = '9';
        }
        return new String(cs);
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[] ss = { "1?:?4", "0?:5?", "??:??", "0?:??", "?3:??", "11:59", "00:00" };
        String[] expects = { "11:54", "09:59", "11:59", "09:59", "03:59", "11:59", "00:00" };
        boolean allPass = true;
        for (int i = 0; i < ss.length; ++i) {
            String a = sol.findLatestTime(ss[i]);
            String b = sol.findLatestTimeGreedy(ss[i]);
            boolean ok = a.equals(expects[i]) && b.equals(expects[i]);
            allPass &= ok;
            System.out.println(ss[i] + " -> " + a + " / greedy=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }
        // 全量对拍所有合法 ? 组合(随机生成)
        Random rnd = new Random(42);
        int fail = 0;
        String chars = "0123456789?";
        for (int t = 0; t < 3000; ++t) {
            StringBuilder sb = new StringBuilder();
            sb.append(chars.charAt(rnd.nextInt(11)));
            sb.append(chars.charAt(rnd.nextInt(11)));
            sb.append(':');
            sb.append(chars.charAt(rnd.nextInt(11)));
            sb.append(chars.charAt(rnd.nextInt(11)));
            String s = sb.toString();
            // 只保留存在合法解的模式(用枚举法判)
            boolean has = false;
            for (int h = 0; h < 12 && !has; ++h) {
                for (int m = 0; m < 60 && !has; ++m) {
                    String tt = String.format("%02d:%02d", h, m);
                    boolean ok = true;
                    for (int i = 0; i < 5; ++i) {
                        if (s.charAt(i) != '?' && s.charAt(i) != tt.charAt(i)) {
                            ok = false;
                            break;
                        }
                    }
                    has = ok;
                }
            }
            if (!has) {
                continue;
            }
            String a = sol.findLatestTime(s);
            String b = sol.findLatestTimeGreedy(s);
            if (!a.equals(b)) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH s=" + s + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(12 * 60 * 5),空间复杂度 O(1)。

  • 时间复杂度:O(1)(枚举上限固定)
  • 空间复杂度:O(1)

3115. Maximum Prime Difference(质数的最大距离)

题目描述

给你一个整数数组 nums,返回两个(不一定不同的)质数在 nums 中下标的最大距离。

两个下标 i 和 j 的距离定义为 |i - j|。nums 中至少存在一个质数。

示例 1

复制代码
nums = [4,2,9,5,3] -> 3(2 在下标 1,3 在下标 4,|4-1|=3)

示例 2

复制代码
nums = [4,8,2,8] -> 0(只有一个质数 2,|2-2|=0)

提示:

  • 1 <= nums.length <= 3 * 10^5
  • 1 <= nums[i] <= 100
  • nums 中至少有一个质数

解题思路

解法一:两端双指针,主提交版本

从左向右找第一个质数下标 i,从右向左找最后一个质数下标 j,

答案为 j - i。

判断质数用试除法:x < 2 不是质数,枚举 v 从 2 到 sqrt(x) 检查因子。

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

解法二:先收集所有质数下标(对照)

从左到右扫描收集所有质数下标,答案为首尾下标之差。

复杂度:

  • 时间复杂度:O(n * sqrt(V)),V 为最大元素值(100)
  • 空间复杂度:O(1)

代码实现

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

public class Solution {

    // ---------- 解法一:两端双指针(主提交版本) ----------
    public int maximumPrimeDifference(int[] nums) {
        for (int i = 0; ; ++i) {
            if (isPrime(nums[i])) {
                for (int j = nums.length - 1; ; --j) {
                    if (isPrime(nums[j])) {
                        return j - i;
                    }
                }
            }
        }
    }

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

    // ---------- 解法二:收集下标(对照) ----------
    public int maximumPrimeDifferenceList(int[] nums) {
        int first = -1, last = -1;
        for (int i = 0; i < nums.length; ++i) {
            if (isPrime(nums[i])) {
                if (first == -1) {
                    first = i;
                }
                last = i;
            }
        }
        return last - first;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[][] cases = { {4, 2, 9, 5, 3}, {4, 8, 2, 8}, {2}, {7}, {1, 2, 3, 4, 5, 6, 7}, {11, 4, 8} };
        int[] expects = { 3, 0, 0, 0, 5, 0 };
        boolean allPass = true;
        for (int i = 0; i < cases.length; ++i) {
            int a = sol.maximumPrimeDifference(cases[i]);
            int b = sol.maximumPrimeDifferenceList(cases[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println("case " + i + " -> " + a + " / list=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 2000; ++t) {
            int n = 1 + rnd.nextInt(10);
            int[] arr = new int[n];
            boolean hasPrime = false;
            for (int i = 0; i < n; ++i) {
                arr[i] = 1 + rnd.nextInt(50);
                hasPrime |= sol.isPrime(arr[i]);
            }
            if (!hasPrime) {
                arr[rnd.nextInt(n)] = 2;
            }
            int a = sol.maximumPrimeDifference(arr);
            int b = sol.maximumPrimeDifferenceList(arr);
            if (a != b) {
                fail++;
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && allPass ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

  • 时间复杂度:O(n * sqrt(V)),V 为最大元素值(100)
  • 空间复杂度:O(1)

3116. Kth Smallest Amount With Single Denomination Combination

题目描述

(单面值组合的第 K 小金额)

给你一个整数数组 coins 表示不同面额的硬币,另给你一个整数 k。

你有无限量的每种面额的硬币。但是,你不能组合使用不同面额的硬币。

返回使用这些硬币能制造的第 k 小金额。

示例 1

复制代码
coins = [3,6,9], k = 3 -> 9

示例 2

复制代码
coins = [5,2], k = 7 -> 12

提示:

  • 1 <= coins.length <= 15
  • 1 <= coins[i] <= 25
  • 1 <= k <= 2 * 10^9

解题思路

解法一:二分答案 + 容斥原理,主提交版本

不能组合不同面额,因此能制造的金额集合 = 各面额正倍数集合的并。

f(m) = <= m 的金额个数 = Σ_{非空子集 S} (-1)^(|S|+1) * floor(m / lcm(S))。

对 m 二分:"f(m) >= k" 的最小 m 即答案。面额两两可能不互质,

lcm 可能爆 long,遇到 lcm > m 直接剪枝(该子集贡献为 0)。

子集枚举用位运算(coins.length <= 15,共 2^15 个子集)。

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

解法二:小堆/集合暴力(对照,小规模)

维护 TreeSet 存储各面额倍数,重复取最小 k 次(每个面额维护游标)。

仅用于小规模交叉验证(k 小、max 小)。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:二分 + 容斥(主提交版本) ----------
    public long findKthSmallest(int[] coins, int k) {
        long l = 1, r = (long) 1e11;
        while (l < r) {
            long mid = (l + r) >> 1;
            if (check(coins, mid) >= k) {
                r = mid;
            } else {
                l = mid + 1;
            }
        }
        return l;
    }

    private long check(int[] coins, long mx) {
        long cnt = 0;
        int n = coins.length;
        for (int mask = 1; mask < 1 << n; ++mask) {
            long v = 1;
            for (int j = 0; j < n; ++j) {
                if ((mask >> j & 1) == 1) {
                    v = lcm(v, coins[j]);
                    if (v > mx) {
                        break; // 超过上界,该子集贡献为 0
                    }
                }
            }
            if (v > mx) {
                continue;
            }
            int bit = Integer.bitCount(mask);
            if ((bit & 1) == 1) {
                cnt += mx / v;
            } else {
                cnt -= mx / v;
            }
        }
        return cnt;
    }

    private long lcm(long a, long b) {
        if (a == 0 || b == 0) {
            return 1;
        }
        return a / gcd(a, b) * b;
    }

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

    // ---------- 解法二:TreeSet 暴力(对照) ----------
    public long findKthSmallestBrute(int[] coins, int k) {
        // 每个面额维护当前倍数游标
        long[] cur = new long[coins.length];
        TreeSet<long[]> set = new TreeSet<>((a, b) ->
                a[0] != b[0] ? Long.compare(a[0], b[0]) : Long.compare(a[1], b[1]));
        for (int i = 0; i < coins.length; ++i) {
            cur[i] = coins[i];
            set.add(new long[] {cur[i], i});
        }
        long last = 0;
        int taken = 0;
        while (taken < k) {
            long[] top = set.pollFirst();
            long val = top[0];
            int idx = (int) top[1];
            if (val != last) { // 去重
                last = val;
                taken++;
            }
            cur[idx] += coins[idx];
            set.add(new long[] {cur[idx], idx});
        }
        return last;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] c1 = {3, 6, 9};
        int[] c2 = {5, 2};
        boolean ok1 = sol.findKthSmallest(c1, 3) == 9 && sol.findKthSmallestBrute(c1, 3) == 9;
        boolean ok2 = sol.findKthSmallest(c2, 7) == 12 && sol.findKthSmallestBrute(c2, 7) == 12;
        System.out.println("case1 -> " + sol.findKthSmallest(c1, 3) + " brute="
                + sol.findKthSmallestBrute(c1, 3) + " expected=9 " + (ok1 ? "PASS" : "FAIL"));
        System.out.println("case2 -> " + sol.findKthSmallest(c2, 7) + " brute="
                + sol.findKthSmallestBrute(c2, 7) + " expected=12 " + (ok2 ? "PASS" : "FAIL"));
        // 随机对拍(k 小)
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 300; ++t) {
            int n = 1 + rnd.nextInt(4);
            int[] coins = new int[n];
            for (int i = 0; i < n; ++i) {
                coins[i] = 1 + rnd.nextInt(12);
            }
            int k = 1 + rnd.nextInt(25);
            long a = sol.findKthSmallest(coins, k);
            long b = sol.findKthSmallestBrute(coins, k);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH coins=" + Arrays.toString(coins) + " k=" + k
                            + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

3117. Minimum Sum of Values by Dividing Array(划分数组得到最小的值之和)

题目描述

给你两个数组 nums 和 andValues,长度分别为 n 和 m。

数组的值等于该数组的最后一个元素。

你需要将 nums 划分为 m 个不相交的连续子数组,对于第 ith 个子数组 `li`, `ri`,

子数组元素的按位 AND 运算结果等于 andValues[i]。

返回将 nums 划分为 m 个子数组所能得到的可能的最小子数组值之和。

如果无法完成这样的划分,则返回 -1。

示例 1

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

示例 2

复制代码
nums = [2,3,5,7,7,7,5], andValues = [0,7,5] -> 17

提示:

  • 1 <= n == nums.length <= 10^4
  • 1 <= m == andValues.length <= min(n, 10)
  • 1 <= nums[i] < 2^17
  • 0 <= andValues[j] < 2^17

解题思路

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

dfs(i, j, a):从 numsi 开始、还要划分 andValuesj... 段、当前段已累积 AND 为 a 的

最小"段值之和"(若不可行返回 inf)。

转移:

a' = a & numsi;若 a' < andValuesj 直接返回 inf(AND 只会变小,不可能再等于目标);

继续扩展当前段:dfs(i+1, j, a');

若 a' == andValuesj,可以在此处结束段 j:numsi + dfs(i+1, j+1, -1)。

剪枝:剩余可分配元素不足(n - i < m - j)返回 inf。

记忆化 key 用 (i, j, a) 打包成 long。

时间复杂度 O(n * m * 2^17),空间复杂度 O(n * m * 2^17)(实际远小于,剪枝极强)。

解法二:DP 自底向上(对照)

dpij = 把 nums0...i-1 划分为 j 段的最小值之和(INF 表示不可行)。

枚举最后一段的起点 l,若 numsl...i-1 的 AND == andValuesj-1,

则 dpij = min(dpij, dplj-1 + numsi-1)。

两法完全独立实现,交叉验证。

复杂度:

  • 时间复杂度:O(m * n * m)(实际 + 剪枝)
  • 空间复杂度:O(m * n)

代码实现

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

public class Solution {

    private static final int INF = 1 << 29;

    // ---------- 解法一:记忆化 DFS(主提交版本) ----------
    private int[] nums;
    private int[] andValues;
    private Map<Long, Integer> memo;

    public int minimumValueSum(int[] nums, int[] andValues) {
        this.nums = nums;
        this.andValues = andValues;
        this.memo = new HashMap<>();
        int ans = dfs(0, 0, -1);
        return ans >= INF ? -1 : ans;
    }

    private int dfs(int i, int j, int a) {
        if (nums.length - i < andValues.length - j) {
            return INF; // 剩余元素不够分
        }
        if (j == andValues.length) {
            return i == nums.length ? 0 : INF;
        }
        a &= nums[i];
        if (a < andValues[j]) {
            return INF; // AND 只会继续变小,不可能再等于 andValues[j]
        }
        long key = ((long) i << 36) | ((long) j << 32) | (a & 0xffffffffL);
        if (memo.containsKey(key)) {
            return memo.get(key);
        }
        int ans = dfs(i + 1, j, a); // 当前段继续扩张
        if (a == andValues[j]) {
            // 在此处结束当前段,nums[i] 是本段最后一个元素(段的值)
            ans = Math.min(ans, dfs(i + 1, j + 1, -1) + nums[i]);
        }
        memo.put(key, ans);
        return ans;
    }

    // ---------- 解法二:自底向上 DP(对照) ----------
    public int minimumValueSumDP(int[] nums, int[] andValues) {
        int n = nums.length, m = andValues.length;
        int[][] dp = new int[m + 1][n + 1];
        for (int[] row : dp) {
            Arrays.fill(row, INF);
        }
        dp[0][0] = 0;
        // 简化实现:三重循环,内层从右向左累积 AND
        for (int j = 1; j <= m; ++j) {
            for (int i = 1; i <= n; ++i) {
                int and = -1;
                for (int l = i - 1; l >= 0; --l) {
                    and &= nums[l];
                    if (and == andValues[j - 1]) {
                        if (dp[j - 1][l] != INF) {
                            dp[j][i] = Math.min(dp[j][i], dp[j - 1][l] + nums[i - 1]);
                        }
                    } else if (and < andValues[j - 1]) {
                        break; // 再往前 AND 只会更小
                    }
                }
            }
        }
        return dp[m][n] >= INF ? -1 : dp[m][n];
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        int[] nums1 = {1, 4, 3, 3, 2};
        int[] av1 = {0, 3, 3, 2};
        int[] nums2 = {2, 3, 5, 7, 7, 7, 5};
        int[] av2 = {0, 7, 5};
        boolean ok1 = sol.minimumValueSum(nums1, av1) == 12
                && sol.minimumValueSumDP(nums1, av1) == 12;
        boolean ok2 = sol.minimumValueSum(nums2, av2) == 17
                && sol.minimumValueSumDP(nums2, av2) == 17;
        System.out.println("case1 -> " + sol.minimumValueSum(nums1, av1) + " dp="
                + sol.minimumValueSumDP(nums1, av1) + " expected=12 " + (ok1 ? "PASS" : "FAIL"));
        System.out.println("case2 -> " + sol.minimumValueSum(nums2, av2) + " dp="
                + sol.minimumValueSumDP(nums2, av2) + " expected=17 " + (ok2 ? "PASS" : "FAIL"));
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 300; ++t) {
            int n = 3 + rnd.nextInt(7);
            int m = 1 + rnd.nextInt(Math.min(4, n));
            int[] nums = new int[n];
            int[] av = new int[m];
            for (int i = 0; i < n; ++i) {
                nums[i] = rnd.nextInt(16);
            }
            // 生成合法段:随机划分并计算 AND 作为目标
            int l = 0;
            for (int j = 0; j < m; ++j) {
                int r = l + 1 + rnd.nextInt(Math.max(1, (n - l) / (m - j)));
                if (r > n) {
                    r = n;
                }
                int a = -1;
                for (int k = l; k < r && k < n; ++k) {
                    a &= nums[k];
                }
                av[j] = j + 1 == m ? 0 : a; // 最后一组不一定用上
                l = r;
            }
            // 简化:直接用随机目标(可能无解,DP 与 DFS 应一致)
            for (int j = 0; j < m; ++j) {
                av[j] = rnd.nextInt(16);
            }
            int a = sol.minimumValueSum(nums, av);
            int b = sol.minimumValueSumDP(nums, av);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH nums=" + Arrays.toString(nums)
                            + " av=" + Arrays.toString(av) + " dfs=" + a + " dp=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

时间复杂度 O(n * m * 2^17),空间复杂度 O(n * m * 2^17)(实际远小于,剪枝极强)。

  • 时间复杂度:O(m * n * m)(实际 + 剪枝)
  • 空间复杂度:O(m * n)

3118. Friday Purchase III(发生在周五的交易 III)

题目类型:数据库(SQL)

题目描述

表:Purchases

复制代码
+---------------+------+
| Column Name   | Type |
+---------------+------+
| user_id       | int  |
| purchase_date | date |
| amount_spend  | int  |
+---------------+------+

(user_id, purchase_date, amount_spend) 是该表的主键(具有唯一值的列)。purchase_date 的范围从 2023 年 11 月 1 日到 2023 年 11 月 30 日,并包括这两个日期。

表:Users

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

user_id 是这张表的主键。membership 是 ('Standard', 'Premium', 'VIP') 的枚举类型。

编写一个解决方案来计算 Premium 和 VIP 会员在 2023 年 11 月每周的周五 的总花费 。如果某个周五没有 Premium 或 VIP 会员购买,把它当作 0。

按照每月的周次序 升序排列结果表,然后以 membership 升序排序。

示例 1:

复制代码
输入:
Purchases 表(user_id 11/15/17/12/8/1/10/13,11 月各周五及 22/21 日消费)
Users 表:11 Premier、15 VIP、17 Standard、12 VIP、8 Premium、1 VIP、10 Standard、13 Premium
输出:
+---------------+-------------+--------------+
| week_of_month | membership  | total_amount |
+---------------+-------------+--------------+
| 1             | Premium     | 1126         |
| 1             | VIP         | 0            |
| 2             | Premium     | 0            |
| 2             | VIP         | 7473         |
| 3             | Premium     | 0            |
| 3             | VIP         | 0            |
| 4             | Premium     | 5117         |
| 4             | VIP         | 14933        |
+---------------+-------------+--------------+

解释:第 1 周周五(11-03)仅 Premium 的 1126 消费;第 2 周周五(11-10)仅 VIP 的 7473;第 3 周周五(11-17)无交易输出 0;第 4 周周五(11-24)Premium 5117、VIP 9692+5241=14933。输出表以 week_of_month 和 membership 升序排序。

解题思路

要求的输出是完整的 4 周 × 2 种会员 的 8 行,即使某组合没有交易也要补 0,因此需要先生成一个全组合骨架再左连接:用递归 CTE T 生成 week_of_month 1~4,用 M 常量表生成 Premium、VIP;把 Purchases 与 Users 连接后仅保留周五(DAYOFWEEK = 6),用 CEIL(DAYOFMONTH(purchase_date) / 7) 计算所在周次;最后 T JOIN M 与聚合后的 P 做 LEFT JOIN,IFNULL(SUM(amount_spend), 0) 补零,按周次、会员升序输出。

代码实现

sql 复制代码
WITH RECURSIVE T AS (
    SELECT 1 AS week_of_month
    UNION
    SELECT week_of_month + 1 FROM T WHERE week_of_month < 4
),
M AS (
    SELECT 'Premium' AS membership
    UNION
    SELECT 'VIP'
),
P AS (
    SELECT CEIL(DAYOFMONTH(purchase_date) / 7) AS week_of_month,
           membership,
           amount_spend
    FROM Purchases
    JOIN Users USING (user_id)
    WHERE DAYOFWEEK(purchase_date) = 6
)
SELECT week_of_month, membership,
       IFNULL(SUM(amount_spend), 0) AS total_amount
FROM T JOIN M
LEFT JOIN P USING (week_of_month, membership)
GROUP BY 1, 2
ORDER BY 1, 2;

复杂度分析

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


3119. Maximum Number of Potholes That Can Be Fixed(最大数量的可修复坑洼)

题目描述

给定一个字符串 road,只包含字符 'x' 和 '.',其中每个 'x' 代表一个坑洼,

每个 '.' 代表一个平滑的道路,以及一个整数 budget。

在一次修复操作中,您可以以 n + 1 的价格修复 n 个连续坑洼(n >= 1)。

返回可以修复的坑洼的最大数量,以便所有修复的价格总和不会超过给定的预算 budget。

示例 1

复制代码
road = "..", budget = 5 -> 0

示例 2

复制代码
road = "..xxxxx", budget = 4 -> 3

示例 3

复制代码
road = "x.x.xxx...x", budget = 14 -> 6

提示:

  • 1 <= road.length <= 10^5
  • 1 <= budget <= 10^9

解题思路

解法一:贪心 + 连续段计数,主提交版本

修复操作只能作用于"连续坑洼段"。一次修复 k 个连续坑洼花费 k + 1。

若把一个连续段拆成多个小段修,总花费会超过一次性修:修复一段长度 k 的费用 k+1,

而拆成两段 a、b(a+b=k)费用 (a+1)+(b+1) = k+2,更贵。

因此"同一坑洼段永远整段修"最优;但要修某段得先花 1 的"启动成本"。

策略:按长度从大到小贪心消费预算------把每个坑洼段的长度 k 视为

"修复 k 个坑洼、消耗预算 k+1"的候选;优先修长段(同样占用一段启动成本,

修复个数更多)。

实现:统计每种长度 k 的段数 cntk,从大到小遍历,能整段修的行段修,

预算不足时把剩余段"拆一部分"(在 cntk 段中修若干段,剩下的坑洼并入长度 k-1 的段:

因为多付出的 1 个启动成本不划算,拆出的 k 个坑洼按 k-1 处理,等下一轮再考虑)。

正确性由官方贪心保证:余下的坑洼若再修,会重新产生启动成本,因此统一降级为

长度 k-1 的段(少修 1 个坑洼但省 1 个启动成本,与修 k-1 个坑洼等价)。

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

解法二:暴力(对照,小规模)

枚举所有"段划分 + 每段是否拆修"不可行(组合爆炸),改用等价的 DP/搜索:

把所有坑洼段长度收集起来;对每段枚举"修 t 个(1 <= t <= k,费用 t+1)"或 "0 个",

求预算内最大修复数。仅用于小规模交叉验证。

复杂度:

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

代码实现

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

public class Solution {

    // ---------- 解法一:贪心(主提交版本) ----------
    public int maxPotholes(String road, int budget) {
        road += ".";
        int n = road.length();
        int[] cnt = new int[n]; // cnt[k] = 长度为 k 的坑洼段数
        int k = 0;
        for (char c : road.toCharArray()) {
            if (c == 'x') {
                ++k;
            } else if (k > 0) {
                ++cnt[k];
                k = 0;
            }
        }
        int ans = 0;
        for (k = n - 1; k > 0 && budget > 0; --k) {
            if (cnt[k] == 0) {
                continue;
            }
            int t = Math.min(budget / (k + 1), cnt[k]); // 预算内最多整段修 t 段
            ans += t * k;
            budget -= t * (k + 1);
            // 剩余的 cnt[k] - t 段不整段修:降级为长度 k-1 的段(省 1 个启动成本)
            cnt[k - 1] += cnt[k] - t;
        }
        return ans;
    }

    // ---------- 解法二:DP 搜索(对照) ----------
    public int maxPotholesBrute(String road, int budget) {
        // 收集所有坑洼段长度
        int n = road.length();
        java.util.List<Integer> segs = new java.util.ArrayList<>();
        int k = 0;
        for (char c : road.toCharArray()) {
            if (c == 'x') {
                ++k;
            } else if (k > 0) {
                segs.add(k);
                k = 0;
            }
        }
        if (k > 0) {
            segs.add(k);
        }
        // dp[c] = 花费恰好 c(<= budget)时最多修复的坑洼数
        int[] dp = new int[budget + 1];
        Arrays.fill(dp, -1);
        dp[0] = 0;
        for (int len : segs) {
            int[] ndp = dp.clone();
            for (int cost = 0; cost <= budget; ++cost) {
                if (dp[cost] < 0) {
                    continue;
                }
                // 修 t 个(1 <= t <= len),费用 t+1
                for (int t = 1; t <= len; ++t) {
                    int nc = cost + t + 1;
                    if (nc <= budget) {
                        ndp[nc] = Math.max(ndp[nc], dp[cost] + t);
                    }
                }
            }
            dp = ndp;
        }
        int ans = 0;
        for (int v : dp) {
            ans = Math.max(ans, v);
        }
        return ans;
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        boolean ok1 = sol.maxPotholes("..", 5) == 0 && sol.maxPotholesBrute("..", 5) == 0;
        boolean ok2 = sol.maxPotholes("..xxxxx", 4) == 3 && sol.maxPotholesBrute("..xxxxx", 4) == 3;
        boolean ok3 = sol.maxPotholes("x.x.xxx...x", 14) == 6 && sol.maxPotholesBrute("x.x.xxx...x", 14) == 6;
        System.out.println("case1 -> " + sol.maxPotholes("..", 5) + " brute="
                + sol.maxPotholesBrute("..", 5) + " expected=0 " + (ok1 ? "PASS" : "FAIL"));
        System.out.println("case2 -> " + sol.maxPotholes("..xxxxx", 4) + " brute="
                + sol.maxPotholesBrute("..xxxxx", 4) + " expected=3 " + (ok2 ? "PASS" : "FAIL"));
        System.out.println("case3 -> " + sol.maxPotholes("x.x.xxx...x", 14) + " brute="
                + sol.maxPotholesBrute("x.x.xxx...x", 14) + " expected=6 " + (ok3 ? "PASS" : "FAIL"));
        // 随机对拍
        Random rnd = new Random(42);
        int fail = 0;
        for (int t = 0; t < 500; ++t) {
            int len = 1 + rnd.nextInt(12);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < len; ++i) {
                sb.append(rnd.nextInt(3) == 0 ? 'x' : '.');
            }
            String road = sb.toString();
            int budget = rnd.nextInt(20);
            int a = sol.maxPotholes(road, budget);
            int b = sol.maxPotholesBrute(road, budget);
            if (a != b) {
                fail++;
                if (fail <= 3) {
                    System.out.println("MISMATCH road=" + road + " budget=" + budget
                            + " a=" + a + " b=" + b);
                }
            }
        }
        System.out.println("Random fail=" + fail + (fail == 0 && ok1 && ok2 && ok3 ? " ALL PASS" : " CHECK FAILED"));
    }
}

复杂度分析

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

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

3120. Count the Number of Special Characters I(统计特殊字母的数量 I)

题目描述

给你一个字符串 word。如果 word 中同时存在某个字母的小写形式和大写形式,则称这个字母为特殊字母。

返回 word 中特殊字母的数量。

示例 1

复制代码
word = "aaAbcBC" -> 3('a'、'b'、'c')

示例 2

复制代码
word = "abc" -> 0

示例 3

复制代码
word = "abBCab" -> 1('b')

提示:

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

解题思路

解法一:布尔数组标记,主提交版本

用两个布尔数组分别记录每个字母的小写/大写形式是否出现过,

最后统计大小写同时出现的字母个数。

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

解法二:位掩码(对照)

用 26 位整数 maskLower / maskUpper 记录出现过的小写/大写字母,

答案 = Integer.bitCount(maskLower & maskUpper)。

复杂度:

  • 时间复杂度:O(n)
  • 空间复杂度:O(1)(固定 26 大小)

代码实现

java 复制代码
public class Solution {

    // ---------- 解法一:布尔数组(主提交版本) ----------
    public int numberOfSpecialChars(String word) {
        boolean[] lower = new boolean[26];
        boolean[] upper = new boolean[26];
        for (int i = 0; i < word.length(); ++i) {
            char c = word.charAt(i);
            if (c >= 'a' && c <= 'z') {
                lower[c - 'a'] = true;
            } else {
                upper[c - 'A'] = true;
            }
        }
        int ans = 0;
        for (int i = 0; i < 26; ++i) {
            if (lower[i] && upper[i]) {
                ++ans;
            }
        }
        return ans;
    }

    // ---------- 解法二:位掩码(对照) ----------
    public int numberOfSpecialCharsMask(String word) {
        int maskLower = 0, maskUpper = 0;
        for (int i = 0; i < word.length(); ++i) {
            char c = word.charAt(i);
            if (c >= 'a' && c <= 'z') {
                maskLower |= 1 << (c - 'a');
            } else {
                maskUpper |= 1 << (c - 'A');
            }
        }
        return Integer.bitCount(maskLower & maskUpper);
    }

    // ---------- 本地测试 ----------
    public static void main(String[] args) {
        Solution sol = new Solution();
        String[] words = { "aaAbcBC", "abc", "abBCab", "a", "A", "aA", "aAbBcCdD" };
        int[] expects = { 3, 0, 1, 0, 0, 1, 4 };
        boolean allPass = true;
        for (int i = 0; i < words.length; ++i) {
            int a = sol.numberOfSpecialChars(words[i]);
            int b = sol.numberOfSpecialCharsMask(words[i]);
            boolean ok = a == expects[i] && b == expects[i];
            allPass &= ok;
            System.out.println(words[i] + " -> " + a + " / mask=" + b
                    + " expected=" + expects[i] + (ok ? " PASS" : " FAIL"));
        }
        System.out.println(allPass ? "ALL PASS" : "CHECK FAILED");
    }
}

复杂度分析

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

  • 时间复杂度:O(n)
  • 空间复杂度:O(1)(固定 26 大小)
相关推荐
Misnearch41 分钟前
ScheduledExecutorService
java·线程池
ashiho2 小时前
【LeetCode hot 100】3. 无重复字符的最长子串 (三种解法)
java·数据结构·后端·算法·leetcode·滑动窗口
T_Wizard2 小时前
AI 回复为什么要转圈 3 秒才「啪」一下全出来?把流式输出拆开看,顺便踩了 6 个坑
java·ai编程
CoderYanger2 小时前
Java EE 进阶:9.MyBatis 操作数据库(进阶)(第二弹)
java·数据库·面试·职场和发展·java-ee·tomcat·mybatis
小满、4 小时前
Java 值传递
java·java 值传递
IT枫斗者枫哥4 小时前
Java 异步导出只测最终行数,为什么下载时仍会少一行?
java·后端
张紫娃4 小时前
idea 如何看一个类的 .class 文件
java·ide·intellij-idea
南宫鑫4 小时前
Java底层实现
java
AI人工智能+电脑小能手4 小时前
IP地址合法性校验,这个Java工具类4个方法纯字符不查DNS
java·网络工具·ip校验·ipv6归一·字符校验
斯维赤4 小时前
SpringBoot接口调不通排查终极方案
java·后端·spring