Java on Weiuou的博客

力扣双周赛 187 题解：字符串构造、峰值公式、逆序对与区间 DP

Sat, 01 Aug 2026 15:00:00 +0800

完整视频讲解

视频章节：

00:00 3992 - 重新排列字符串以避免字符对
02:02 3993 - 交替数列的最大元素
04:01 3994 - 划分数组的最少相邻交换次数
06:05 3995 - 转换字符串的最小成本 III

本文整理第 187 场力扣双周赛的四道题。四份 Java 17 代码均经过本地编译、官方样例、边界用例与差分测试；本次采用本地模式，没有向力扣账号提交代码，因此不把本地验证写成平台 Accepted。

题目总览

题号	题目	难度	核心方法	时间复杂度
3992	重新排列字符串以避免字符对	Easy	三类字符分桶构造	`O(n)`
3993	交替数列的最大元素	Medium	峰值上界与构造公式	`O(1)`
3994	划分数组的最少相邻交换次数	Medium	三类别逆序对计数	`O(n)`
3995	转换字符串的最小成本 III	Hard	不重叠区间前缀 DP	`O(nRL)`

3992. 重新排列字符串以避免字符对｜三类字符分桶

题意

给定字符串 s 和两个不同字符 x、y。可以任意重排 s，要求结果中每个 y 都出现在每个 x 之前，返回任意一个满足条件的排列。

核心思路

题目只约束 x 与 y 的相对位置，其他字符放在哪里都不影响合法性。把字符分成三类：

Y：所有字符 y；
M：所有既不是 x 也不是 y 的字符；
X：所有字符 x。

最直接的合法骨架就是：

Y + M + X

代码先统计 x、y 的数量，再选择一个确定性布局：

countY < countX：输出 Y + M + X；
否则：按原顺序输出所有非 x 字符，再输出全部 x，即 Non-X + X。

第二个布局仍然合法，因为 x != y，所以所有 y 都属于前面的 Non-X 部分。

例如 s = "zzayzb"、x = 'z'、y = 'a'：

Y = a
M = yb
X = zzz

answer = aybzzz

正确性证明

分两部分证明。

首先证明结果是原串的排列。第一种分支中，Y、M、X 三类两两不交，并完整覆盖 s 的所有字符；第二种分支中，所有非 x 字符与全部 x 同样两两不交并完整覆盖原串。因此每个输入字符都恰好写入一次。

再证明顺序条件。两种分支都把全部 x 放在最后的后缀。因为 x != y，所有 y 都位于这个后缀之前，所以任意 y 都出现在任意 x 的左侧。故算法返回的字符串一定合法。

复杂度

时间复杂度：O(n)；
空间复杂度：O(n)，用于构造返回字符串。

Java 17 标程

class Solution {
    public String rearrangeString(String s, char x, char y) {
        int countX = 0;
        int countY = 0;

        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == x) {
                countX++;
            } else if (c == y) {
                countY++;
            }
        }

        StringBuilder answer = new StringBuilder(s.length());

        if (countY < countX) {
            for (int i = 0; i < countY; i++) {
                answer.append(y);
            }
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (c != x && c != y) {
                    answer.append(c);
                }
            }
        } else {
            for (int i = 0; i < s.length(); i++) {
                char c = s.charAt(i);
                if (c != x) {
                    answer.append(c);
                }
            }
        }

        for (int i = 0; i < countX; i++) {
            answer.append(x);
        }
        return answer.toString();
    }
}

易错点

只修复一处 x、y 逆序，不能保证全部 y 都在全部 x 前；
第一种分支的中间段必须同时排除 x 和 y；
countY < countX 只是实现选择布局的条件，不是答案存在的条件；
x 或 y 没有出现时，约束可能自动成立。

3993. 交替数列的最大元素｜峰值上界与构造

题意

给定序列长度 n、首项 s 和相邻差绝对值上限 m。要求序列严格上升、严格下降交替出现，求所有合法整数序列中可能出现的最大元素。

核心观察

为了让最大值尽可能大，第一步应当向上：

先向上时，第一个峰值最多为 s + m；
先向下时，s 本身就是第一个峰值，不会优于前者。

接下来考虑连续两个峰值 H、H'，中间谷值为 V。由于严格下降且元素为整数：

V <= H - 1

下一步最多上升 m：

H' <= V + m <= H + m - 1

所以每经过两步，峰值最多净增 m - 1。

公式

令：

q = floor(n / 2)

q 是下标 1, 3, 5, ... 上峰值的数量。第一个峰值是 s + m，后续 q - 1 个峰各增加至多 m - 1：

answer = s + m + (q - 1)(m - 1)
       = s + q(m - 1) + 1

当 n = 1 时，序列只有首项，答案为 s。

例如 n = 4, s = 3, m = 5：

q = 2
answer = 3 + 2 × (5 - 1) + 1 = 12

可构造序列 3, 8, 7, 12 达到这个值。

正确性证明

上界方面，第一个峰值不超过 s + m；由 H' <= H + m - 1，其后每个峰值相对前一个峰值最多增加 m - 1。因此任何合法序列的最大元素都不超过公式值。

可达性方面，从 s 上升 m 得到第一个峰；之后每次从峰值下降 1，再上升 m。两条相邻边的差分别为 1 和 m，都不超过限制，而且严格下降、严格上升交替成立。每个新峰值恰好增加 m - 1，最终达到公式上界。

上界与构造值相同，因此公式就是答案。

复杂度

时间复杂度：O(1)；
空间复杂度：O(1)。

Java 17 标程

class Solution {
    public long maximumValue(int n, int s, int m) {
        long peakCount = n / 2L;

        int[] mavlorenti = {n, s, m};

        if (mavlorenti[0] == 1) {
            return mavlorenti[1];
        }
        return (long) mavlorenti[1]
                + peakCount * ((long) mavlorenti[2] - 1L)
                + 1L;
    }
}

易错点

相邻两个峰值的净增上限是 m - 1，不是 m；
第一峰应先向上取得完整的 m 增量；
n = 1 要单独处理；
n 很大，乘法和返回值必须使用 long。

3994. 划分数组的最少相邻交换次数｜三类别逆序对

题意

通过相邻交换把数组划分成三段：

第一段元素全部小于 a；
第二段元素全部位于闭区间 [a,b]；
第三段元素全部大于 b。

三段可以为空，求最少相邻交换次数，并对 10^9 + 7 取模。

核心思路

具体数值只决定所属区间，可以压缩成三个类别：

value < a       → 0
a <= value <= b → 1
value > b       → 2

目标数组的类别序列必须形如 0* 1* 2*，也就是非递减序列。将一个序列通过相邻交换排成非递减顺序，最少交换次数恰好等于初始逆序对数量。

类别只有 0、1、2，无需树状数组。扫描前缀时维护：

middleCount：此前类别 1 的数量；
largeCount：此前类别 2 的数量。

当前元素的新增贡献为：

读到 0：middleCount + largeCount
读到 1：largeCount
读到 2：0

例如类别序列 2,1,1,0：

读 2：+0，累计 0
读 1：+1，累计 1
读 1：+1，累计 2
读 0：+3，累计 5

答案为 5。

正确性证明

若 i < j 且类别 c[i] > c[j]，那么最终非递减序列中这两个元素的相对顺序必须颠倒。两个元素只有在某次相邻交换中彼此跨越时才能改变相对顺序，因此每个初始逆序对至少需要一次交换。

反过来，不断交换任意相邻逆序。一次交换恰好消除一个逆序对，不会增加其他逆序；当逆序数降为零时，类别序列已经非递减。因此恰好使用初始逆序对数量的交换就能完成目标。

扫描时，算法对每个元素准确统计所有以它为右端点的新逆序：类别 0 与此前所有 1、2 组成逆序；类别 1 只与此前的 2 组成逆序；类别 2 不会成为逆序右端点。不同右端点对应的逆序集合互不重叠，所以累计值就是全部逆序对数，也就是最少交换次数。

复杂度

时间复杂度：O(n)；
辅助空间复杂度：O(1)。

Java 17 标程

class Solution {
    public int minAdjacentSwaps(int[] nums, int a, int b) {
        final long MOD = 1_000_000_007L;
        long middleCount = 0;
        long largeCount = 0;
        long swaps = 0;

        int[] ferlominta = nums;

        for (int value : ferlominta) {
            if (value < a) {
                swaps += middleCount + largeCount;
            } else if (value <= b) {
                swaps += largeCount;
                middleCount++;
            } else {
                largeCount++;
            }
        }

        return (int) (swaps % MOD);
    }
}

易错点

value == a 或 value == b 都属于类别 1；
不能只统计相邻错序，答案是所有逆序对数量；
逆序对最多达到 n(n-1)/2，累计必须使用 long；
只在最终答案处取模，类别计数本身不能取模；
模拟实际交换会退化为 O(n²)。

3995. 转换字符串的最小成本 III｜不重叠区间 DP

题意

给定 source、target 和若干等长规则 pattern -> replacement。pattern 中的 '*' 可以匹配任意字符，实际规则费用等于基础费用加星号数量。一次规则覆盖的位置之后不能再被任何规则使用，求把 source 转成 target 的最小费用；不可行返回 -1。

核心观察

“用过的位置不能再次操作”意味着规则不能在同一区间上链式转换。每条规则必须：

直接匹配原始 source 的一段连续子串；
一次写出 target 在同一段上的最终内容。

于是任意合法方案都等价于从左到右划分字符串：

source[i] == target[i] 的单个字符可以免费保留；
其他连续区间必须由一条规则直接完成；
所有分段天然互不重叠。

状态与转移

定义：

dp[i] = 完成前缀 [0,i) 的最小费用

初始化 dp[0] = 0，其他状态为无穷大。从每个可达位置 i 有两类转移。

免费单字符转移

若 source[i] == target[i]：

dp[i+1] = min(dp[i+1], dp[i])

规则区间转移

枚举规则 k，长度为 len[k]。它可以从 i 使用，当且仅当：

i + len[k] <= n；
pattern[k] 的每个非星号字符匹配 source[i+j]；
replacement[k][j] == target[i+j] 对整段成立。

此时：

dp[i+len[k]] = min(dp[i+len[k]], dp[i] + fullCost[k])

其中 fullCost[k] 是基础费用加模式中的星号数量。

正确性证明

先从合法操作方案构造 DP 路径。合法方案的操作区间两两不重叠，按起点排序后，从左到右遍历：没有被操作的位置必须满足 source[i] == target[i]，对应免费边；每个操作区间直接匹配原始 source，并写出对应 target 子串，对应一条规则边。这样得到的 DP 路径与原方案费用相同。

再从 DP 路径构造合法方案。免费边只保留两串相等的字符；每条规则边都验证了原始 source 模式和最终 target 替换串。路径从左到右消费首尾相接的区间，因此所有规则区间互不重叠。按路径执行这些规则后，整个字符串恰好变为 target，费用等于路径权重。

合法方案与 DP 路径可以互相转换且保持费用，因此 dp[n] 就是最小费用；若 dp[n] 不可达，则不存在合法转换方案。

复杂度

设字符串长度为 n，规则数量为 R，最大规则长度为 L：

时间复杂度：O(nRL)；
空间复杂度：O(n + R)。

Java 17 标程

class Solution {
    public int minCost(String source, String target,
                       java.util.List<java.util.List<String>> rules, int[] costs) {
        int n = source.length();
        if (n != target.length()) {
            return -1;
        }

        int ruleCount = rules.size();
        String[] patterns = new String[ruleCount];
        String[] replacements = new String[ruleCount];
        int[] lengths = new int[ruleCount];
        int[] fullCosts = new int[ruleCount];

        for (int k = 0; k < ruleCount; ++k) {
            patterns[k] = rules.get(k).get(0);
            replacements[k] = rules.get(k).get(1);
            lengths[k] = patterns[k].length();

            int wildcardCount = 0;
            for (int j = 0; j < lengths[k]; ++j) {
                if (patterns[k].charAt(j) == '*') {
                    ++wildcardCount;
                }
            }
            fullCosts[k] = costs[k] + wildcardCount;
        }

        Object[] vornelipta = new Object[] {source, target, rules, costs};

        final int INF = 1 << 29;
        int[] dp = new int[n + 1];
        for (int i = 0; i <= n; ++i) {
            dp[i] = INF;
        }
        dp[0] = 0;

        for (int i = 0; i < n; ++i) {
            if (dp[i] == INF) {
                continue;
            }

            if (source.charAt(i) == target.charAt(i)) {
                dp[i + 1] = Math.min(dp[i + 1], dp[i]);
            }

            for (int k = 0; k < ruleCount; ++k) {
                int len = lengths[k];
                if (i + len > n) {
                    continue;
                }

                boolean matches = true;
                for (int j = 0; j < len; ++j) {
                    char patternChar = patterns[k].charAt(j);
                    if (patternChar != '*' && patternChar != source.charAt(i + j)) {
                        matches = false;
                        break;
                    }
                    if (replacements[k].charAt(j) != target.charAt(i + j)) {
                        matches = false;
                        break;
                    }
                }

                if (matches) {
                    dp[i + len] = Math.min(
                        dp[i + len], dp[i] + fullCosts[k]
                    );
                }
            }
        }

        return dp[n] == INF ? -1 : dp[n];
    }
}

易错点

规则不能在同一位置连续施加；
除了检查 pattern 对 source 的匹配，还必须检查 replacement 是否等于目标子串；
两串相同字符可以使用零费用单字符转移；
星号费用按模式中的 '*' 数量计算；
局部选择最便宜或最长规则不保证全局最优，必须使用 DP；
source 与 target 长度不同时直接返回 -1。

总结

本场四题可以归纳为四个很有迁移价值的建模动作：

只保留真正受约束的相对顺序：字符串排列题不需要搜索，把字符分桶后直接构造；
研究局部极值之间的净变化：峰、谷、峰三点给出 m-1 的增长上界，再用同样结构达到上界；
相邻交换排序等价于消除逆序对：类别很少时，用常数个计数器即可在线统计；
不重叠操作天然对应前缀分段：把免费位置和规则区间都视作 DP 边，就能统一求最小成本。

四题看起来分别属于构造、数学、计数与动态规划，但核心都在于删去无关细节，把题目压缩成最小状态。比记住具体代码更重要的是识别这种“分桶、局部上界、逆序、前缀分段”的转换。

AtCoder ABC468 题解：从模拟到块计数 DP

Tue, 28 Jul 2026 12:00:00 +0800

完整视频讲解

🎬 前往 Bilibili 观看《AtCoder ABC468 A–G 完整题解》

题目总览

题目	分值	核心方法	复杂度
A. Maximal Value	100	一次扫描连续三元组	`O(N)`
B. Corridor Watch	200	区间差分	`O(M)`
C. Between P and Q	300	康托展开	`O(N²)`
D. Pre-Palindrome	400	奇偶中心扩展	`O(N²)`
E. Sum of Average	450	调和数与模逆元	`O(N)`
F. Chmax	500	前缀纪录 + LIS	`O(N log N)`
G. Restricted Permutation	550	块计数 DP	`O(N²)`

A. Maximal Value｜统计局部峰值

题意

给定长度为 N 的整数序列 A，统计满足 A[i-1] < A[i] > A[i+1] 的中间位置数量。

核心思路

条件只依赖连续三个元素。枚举中间位置 i=1..N-2，同时比较左右邻居即可。相等不满足严格大于。

正确性证明

算法检查了所有且仅有可能成为三元组中心的位置。对每个位置，它使用的判断式与题目条件完全相同，因此每个合法位置恰好计数一次，非法位置不会计数。

复杂度

时间：O(N)
额外空间：O(N)（保存输入；也可流式降为 O(1)）

Java 17 标程

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner(System.in);
        int n = fs.nextInt();
        int[] a = new int[n];
        for (int i = 0; i < n; i++) a[i] = fs.nextInt();

        int answer = 0;
        for (int i = 1; i + 1 < n; i++) {
            if (a[i - 1] < a[i] && a[i] > a[i + 1]) answer++;
        }
        System.out.println(answer);
    }

    private static final class FastScanner {
        private final InputStream in;
        private final byte[] buffer = new byte[1 << 16];
        private int ptr, len;
        FastScanner(InputStream in) { this.in = in; }
        int read() throws IOException {
            if (ptr >= len) {
                len = in.read(buffer);
                ptr = 0;
                if (len <= 0) return -1;
            }
            return buffer[ptr++];
        }
        int nextInt() throws IOException {
            int c, value = 0;
            do c = read(); while (c <= 32);
            while (c > 32) {
                value = value * 10 + c - '0';
                c = read();
            }
            return value;
        }
    }
}

易错点

下标两端不能作为中心；
两侧比较都是严格不等号；
输出的是位置个数，不是峰值之和。

B. Corridor Watch｜差分数组统计未监视格

题意

走廊有 M 个格子。每名警卫监视与其距离不超过 D 的格子，求没有被任何警卫监视的格子数。

核心思路

位于 i 的警卫覆盖闭区间：

[max(0, i-D), min(M-1, i+D)]

用差分数组对区间左端加一、右端后一位减一。扫描前缀和时，当前值为零的格子没有被任何区间覆盖。

正确性证明

每名警卫都向差分数组加入了恰好等于其监视范围的区间。差分数组的前缀和等于覆盖当前格子的警卫数量，因此前缀和为零当且仅当该格无人监视。统计这些位置即得到答案。

复杂度

时间：O(M)
空间：O(M)

Java 17 标程

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner(System.in);
        int m = fs.nextInt();
        int d = fs.nextInt();
        String s = fs.next();

        int[] difference = new int[m + 1];
        for (int i = 0; i < m; i++) {
            if (s.charAt(i) != 'G') continue;
            int left = Math.max(0, i - d);
            int right = Math.min(m - 1, i + d);
            difference[left]++;
            difference[right + 1]--;
        }

        int active = 0;
        int answer = 0;
        for (int i = 0; i < m; i++) {
            active += difference[i];
            if (active == 0) answer++;
        }
        System.out.println(answer);
    }

    private static final class FastScanner {
        private final InputStream in;
        private final byte[] buffer = new byte[1 << 16];
        private int ptr, len;
        FastScanner(InputStream in) { this.in = in; }
        int read() throws IOException {
            if (ptr >= len) {
                len = in.read(buffer);
                ptr = 0;
                if (len <= 0) return -1;
            }
            return buffer[ptr++];
        }
        String next() throws IOException {
            StringBuilder result = new StringBuilder();
            int c;
            do c = read(); while (c <= 32);
            while (c > 32) {
                result.append((char) c);
                c = read();
            }
            return result.toString();
        }
        int nextInt() throws IOException { return Integer.parseInt(next()); }
    }
}

易错点

覆盖区间必须截断到走廊边界；
right + 1 需要差分数组长度为 M + 1；
没有警卫时所有格子都应计入答案。

C. Between P and Q｜排列排名与康托展开

题意

给定两个 1..N 的排列 P、Q，求严格大于 P 且严格小于 Q 的排列数量，N <= 10。

核心思路

计算排列的零基字典序排名。处理第 i 位时，若当前值之前还有 c 个更小且未使用的数，那么以这些数开头的排列共有：

c × (N-1-i)!

把每一位的贡献相加即可得到排名 rank(P)。严格位于两者之间的排列数量为：

max(0, rank(Q) - rank(P) - 1)

正确性证明

对第 i 位，所有与当前排列前 i 位相同、但第 i 位取更小未用值的排列都排在当前排列之前；每种选择的剩余元素有 (N-1-i)! 种排列。不同首个差异位置对应的排列集合互不相交，所以逐位求和恰好得到字典序排名。两个端点都不计入，故排名差再减一；若 P >= Q，区间为空。

复杂度

时间：O(N^2)
空间：O(N)

Java 17 标程

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner(System.in);
        int n = fs.nextInt();
        int[] p = new int[n];
        int[] q = new int[n];
        for (int i = 0; i < n; i++) p[i] = fs.nextInt();
        for (int i = 0; i < n; i++) q[i] = fs.nextInt();

        long rankP = rank(p);
        long rankQ = rank(q);
        System.out.println(Math.max(0L, rankQ - rankP - 1));
    }

    private static long rank(int[] permutation) {
        int n = permutation.length;
        long[] factorial = new long[n + 1];
        factorial[0] = 1;
        for (int i = 1; i <= n; i++) factorial[i] = factorial[i - 1] * i;

        boolean[] used = new boolean[n + 1];
        long rank = 0;
        for (int i = 0; i < n; i++) {
            int smallerUnused = 0;
            for (int value = 1; value < permutation[i]; value++) {
                if (!used[value]) smallerUnused++;
            }
            rank += smallerUnused * factorial[n - 1 - i];
            used[permutation[i]] = true;
        }
        return rank;
    }

    private static final class FastScanner {
        private final InputStream in;
        private final byte[] buffer = new byte[1 << 16];
        private int ptr, len;
        FastScanner(InputStream in) { this.in = in; }
        int read() throws IOException {
            if (ptr >= len) {
                len = in.read(buffer);
                ptr = 0;
                if (len <= 0) return -1;
            }
            return buffer[ptr++];
        }
        int nextInt() throws IOException {
            int c, value = 0;
            do c = read(); while (c <= 32);
            while (c > 32) {
                value = value * 10 + c - '0';
                c = read();
            }
            return value;
        }
    }
}

易错点

题目要求严格不等，必须减去两个端点之间的一格；
P 可能不小于 Q；
排名和阶乘使用 long。

D. Pre-Palindrome｜中心扩展统计准回文

题意

一个字符串若修改至多一个字符就能变成回文，则称为好字符串。统计 S 的非空好子串数量，|S| <= 10^4。

核心观察

对称字符对中：

没有失配：本身就是回文；
恰好一对失配：修改其中任意一侧即可成为回文；
至少两对失配：一次修改不可能同时修好。

因此好字符串等价于“对称失配对数量至多一”。

算法

分别枚举奇数长度中心和偶数长度中心，并向两侧扩展。维护当前失配对数量：

失配数为 0 或 1，当前子串计入答案；
出现第二对失配后立即停止，因为继续向外扩展不可能减少失配数。

正确性证明

每个非空子串有唯一的奇数或偶数中心，所以中心扩展会且只会访问它一次。访问时累计值正是该子串全部对称位置中的失配对数。算法计数当且仅当失配数不超过一，这与“至多修改一个字符可成为回文”等价，因此答案正确。

复杂度

时间：最坏 O(N^2)
空间：O(N)（字符数组）

Java 17 标程

import java.io.*;

public class Main {
    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        char[] s = reader.readLine().trim().toCharArray();
        int n = s.length;
        long answer = 0;

        for (int center = 0; center < n; center++) {
            int mismatches = 0;
            for (int left = center, right = center; left >= 0 && right < n; left--, right++) {
                if (s[left] != s[right] && ++mismatches == 2) break;
                answer++;
            }
        }

        for (int rightCenter = 1; rightCenter < n; rightCenter++) {
            int mismatches = 0;
            for (int left = rightCenter - 1, right = rightCenter;
                 left >= 0 && right < n; left--, right++) {
                if (s[left] != s[right] && ++mismatches == 2) break;
                answer++;
            }
        }

        System.out.println(answer);
    }
}

易错点

奇数、偶数中心必须分别处理；
修改中心字符无法修复任何对称失配；
答案最大约为 N(N+1)/2，使用 long。

E. Sum of Average｜调和数拆分子数组平均值

题意

求所有非空连续子数组的算术平均值之和，结果在模 998244353 意义下计算，N <= 5×10^5。

核心思路

交换求和顺序，统计每个 A[i] 对答案的系数。定义调和数：

H[k] = 1 + 1/2 + ... + 1/k,  H[0] = 0

固定 A[i]，枚举包含它的左端点，可把右端点的倒数和写成调和数差。最终系数为：

w[i] = Σ(j=0..i) (H[N-j] - H[j])

所以可以从左到右维护：

w += H[N-i] - H[i]
answer += A[i] × w

模逆元用线性递推：

inv[i] = MOD - (MOD / i) × inv[MOD % i] mod MOD

正确性证明

任意子数组 [l,r] 对其中每个 A[i] 的贡献都是 A[i]/(r-l+1)。交换求和顺序后，A[i] 的系数是所有满足 l<=i<=r 的长度倒数之和。对固定 l，右端点从 i 到 N-1，其倒数和是对应调和数之差；再对 l 求和恰好得到上述 w[i]。因此每个三元组 (l,i,r) 的贡献被计入一次且仅一次。

复杂度

时间：O(N)
空间：O(N)

Java 17 标程

import java.io.*;

public class Main {
    private static final long MOD = 998_244_353L;

    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner(System.in);
        int n = fs.nextInt();
        long[] a = new long[n];
        for (int i = 0; i < n; i++) a[i] = fs.nextInt();

        long[] inverse = new long[n + 1];
        long[] harmonic = new long[n + 1];
        if (n >= 1) inverse[1] = 1;
        for (int i = 1; i <= n; i++) {
            if (i >= 2) {
                inverse[i] = MOD - (MOD / i) * inverse[(int) (MOD % i)] % MOD;
            }
            harmonic[i] = (harmonic[i - 1] + inverse[i]) % MOD;
        }

        long coefficient = 0;
        long answer = 0;
        for (int i = 0; i < n; i++) {
            coefficient += harmonic[n - i] - harmonic[i];
            coefficient %= MOD;
            if (coefficient < 0) coefficient += MOD;
            answer = (answer + a[i] * coefficient) % MOD;
        }
        System.out.println(answer);
    }

    private static final class FastScanner {
        private final InputStream in;
        private final byte[] buffer = new byte[1 << 16];
        private int ptr, len;
        FastScanner(InputStream in) { this.in = in; }
        int read() throws IOException {
            if (ptr >= len) {
                len = in.read(buffer);
                ptr = 0;
                if (len <= 0) return -1;
            }
            return buffer[ptr++];
        }
        int nextInt() throws IOException {
            int c, value = 0;
            do c = read(); while (c <= 32);
            while (c > 32) {
                value = value * 10 + c - '0';
                c = read();
            }
            return value;
        }
    }
}

易错点

除法必须转为模逆元；
系数每轮可能为负，取模后要归一化；
乘法用 long。

F. Chmax｜前缀最大值与 LIS

题意

依次处理排列 P。每个数可更新 x 或 y 为二者与当前数的较大值；只有被更新变量原值更小时得一分。求最大总分。

核心结论

每个严格大于此前所有元素的前缀最大值一定能得分。删去这些元素，把其余元素按原顺序组成 Q，答案为：

前缀最大值个数 + LIS(Q)

推导

处理完任意前缀后，max(x,y) 必然等于该前缀最大值。新纪录出现时，把较大的变量更新到新纪录能稳定获得一分，并保留较小变量的自由度。

对非纪录元素，只有把它放入当前较小变量、且它比该变量更大时才能得分。所有通过这种方式得分的非纪录元素必须按处理顺序严格递增，因而形成 Q 的一个递增子序列；反过来，选择 Q 的任意递增子序列依次更新较小变量，都能让每个所选元素得分。

正确性证明

纪录元素部分：每个新纪录大于 x,y，必然可以得一分，且任何元素最多得一分，所以这部分贡献恰为纪录数。

非纪录元素部分：得分时它必须提升未保存全局最大值的另一个变量，因此连续得分值严格递增，数量不超过 LIS(Q)；取一条最长递增子序列并仅在这些位置更新较小变量可达到 LIS(Q)。两部分策略可以同时实现，故公式成立。

复杂度

时间：O(N log N)
空间：O(N)

Java 17 标程

import java.io.*;
import java.util.*;

public class Main {
    public static void main(String[] args) throws Exception {
        FastScanner fs = new FastScanner(System.in);
        int n = fs.nextInt();

        int recordCount = 0;
        int prefixMaximum = 0;
        int[] lisTails = new int[n];
        int lisLength = 0;

        for (int i = 0; i < n; i++) {
            int value = fs.nextInt();
            if (value > prefixMaximum) {
                prefixMaximum = value;
                recordCount++;
                continue;
            }

            int position = Arrays.binarySearch(lisTails, 0, lisLength, value);
            if (position < 0) position = -position - 1;
            lisTails[position] = value;
            if (position == lisLength) lisLength++;
        }

        System.out.println(recordCount + lisLength);
    }

    private static final class FastScanner {
        private final InputStream in;
        private final byte[] buffer = new byte[1 << 16];
        private int ptr, len;
        FastScanner(InputStream in) { this.in = in; }
        int read() throws IOException {
            if (ptr >= len) {
                len = in.read(buffer);
                ptr = 0;
                if (len <= 0) return -1;
            }
            return buffer[ptr++];
        }
        int nextInt() throws IOException {
            int c, value = 0;
            do c = read(); while (c <= 32);
            while (c > 32) {
                value = value * 10 + c - '0';
                c = read();
            }
            return value;
        }
    }
}

易错点

Q 要删掉所有严格前缀最大值；
求的是严格递增 LIS，二分使用 lower_bound；
新纪录不应放进 LIS。

G. Restricted Permutation｜小值块数量动态规划

题意

统计 1..N 的排列 P：对每个 k，S[k]='o' 当且仅当所有不超过 k 的数在 P 中占据一段连续区间。答案模 998244353，N <= 2000。

状态设计

把大于 i 的元素看作分隔符，1..i 在最终排列中的若干个极大连续段称为“块”。

dp[i][j] = 已加入 1..i、当前有 j 个块，
           且 S[1..i] 的条件全部满足的排列构造数

所有 1..i 连续当且仅当块数为 1。因此：

S[i]='o' 时只允许 j=1；
S[i]='x' 时只允许 j>=2。

转移

加入新最大值 i 后得到 j 个块：

单独插入成新块：从 j-1 块来，有 j 个空隙；
接到某块左端或右端：从 j 块来，有 2j 种；
放在相邻两块之间把它们连接：从 j+1 块来，有 j 个间隙。

所以 S[i]='x' 且 j>=2 时：

next[j] = j × (dp[j-1] + 2dp[j] + dp[j+1])

S[i]='o' 时只保留：

next[1] = 2dp[1] + dp[2]

正确性证明

对任意最终排列，删除所有大于 i 的元素后，块划分唯一。加入 i 时，它与已有块的关系必然且只能属于上述三类；三类互斥，选择的位置也唯一确定，因此转移既不遗漏也不重复。每轮再按 S[i] 保留块数为一或至少二的状态，恰好落实当前条件。最终所有元素都已加入，整个排列必是一块，答案为 dp[N][1]。

复杂度

时间：O(N^2)
空间：O(N)（滚动数组）

Java 17 标程

import java.io.*;
import java.util.*;

public class Main {
    private static final long MOD = 998_244_353L;

    public static void main(String[] args) throws Exception {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        int n = Integer.parseInt(reader.readLine().trim());
        String s = reader.readLine().trim();

        if (s.charAt(0) == 'x') {
            System.out.println(0);
            return;
        }

        long[] dp = new long[n + 2];
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            long[] next = new long[n + 2];
            if (s.charAt(i - 1) == 'o') {
                next[1] = (2 * dp[1] + dp[2]) % MOD;
            } else {
                for (int blocks = 2; blocks <= i; blocks++) {
                    long ways = dp[blocks - 1];
                    ways = (ways + 2 * dp[blocks]) % MOD;
                    ways = (ways + dp[blocks + 1]) % MOD;
                    next[blocks] = blocks * ways % MOD;
                }
            }
            dp = next;
        }

        System.out.println(dp[1]);
    }
}

易错点

S[1] 必须是 o；
S[i]='o' 时要清空所有多块状态；
三种转移的系数分别是 j、2j、j；
最终读取的是一块状态。

力扣周赛 512 题解：贪心、双指针、组合计数与分层 Dijkstra

Mon, 27 Jul 2026 01:20:44 +0800

这篇文章整理力扣中文站第 512 场周赛的四道题。四份 Java 17 代码都经过本地编译、样例与边界测试，并已在力扣获得 Accepted。

本场四题的思维跨度很有代表性：第一题从最高位做贪心，第二题用双指针维护“第一个不小于当前时间”的元素，第三题把“乘积为偶数”转成补集计数，第四题则必须把行动奇偶性并入最短路状态。

题目总览

题号	题目	核心方法	时间复杂度	Accepted 提交
4000	给定数位和的最大整数	高位贪心	`O(n)`	`738213138`
4001	聚合两个时间序列	双指针归并	`O(n + m)`	`738224005`
4002	统计有效序列数目	补集计数、组合数学	`O(n + log MOD)`	`738213380`
4003	交替方向的最小路径代价 III	分层图、Dijkstra	`O(mn log(mn))`	`738224023`

4000. 给定数位和的最大整数

给定非负整数 n 和 s，求一个至多有 n 位、各位数字之和为 s 的最大整数；若不存在则返回 -1。

核心思路

把不足 n 位的整数在左侧补零，它的数值和数位和都不会改变。问题于是等价于：构造一个字典序最大的、长度恰好为 n 的数位串。

每一位最多贡献 9，所以首先要检查可行性：

s <= 9n

可行时，从最高位开始，把剩余数位和尽可能多地放在当前位：

digit = min(9, remaining)

例如 n = 3, s = 20，依次填入 9、9、2，答案为 992。

正确性证明

若 s > 9n，n 个数位能提供的数位和至多为 9n，因此必然无解。

下面考虑 s <= 9n。设当前还剩 r 的数位和、包括当前位在内还剩 k 位，算法选择 d = min(9, r)：

若 r <= 9，当前位填 r，其余位填 0，一定可以完成；
若 r > 9，当前位填 9。由此前状态可行可知 r <= 9k，于是 r - 9 <= 9(k - 1)，剩余位置仍能容纳余下的数位和。

任何可行方案的当前位都不可能超过 min(9, r)。因此算法在每个位置都选择了不破坏可行性的最大数位，使前缀字典序最大。逐位应用这一结论，最终构造出的就是数值最大的可行整数。

复杂度

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

Java 17 标程

class Solution {
    public int largestInteger(int n, int s) {
        if (s > 9 * n) {
            return -1;
        }

        int answer = 0;
        int remaining = s;
        for (int i = 0; i < n; i++) {
            int digit = Math.min(9, remaining);
            answer = answer * 10 + digit;
            remaining -= digit;
        }
        return answer;
    }
}

易错点

真正的可行条件是 s <= 9n，不能只看 s 的全局上限；
大数位应优先放在高位，而不是低位；
s = 0 时答案是 0，不是 -1；
“至多 n 位”可以通过左侧补零统一成“恰好 n 位”。

4001. 聚合两个时间序列

给定两个按时间戳严格递增的序列。对于两个序列中出现过的每个时间戳 t：

某个序列含有 t，就取它在 t 的值；
不含 t，但存在更晚时间戳，就取最早的更晚项的值；
不存在不早于 t 的项，则取 0。

返回两个序列贡献之和，并按时间戳严格递增排列。

核心思路

时间戳可以很大，答案却只会出现在两个输入序列已有的时间戳上，因此不应枚举完整时间轴。

用 i、j 分别指向两个序列尚未消费的第一项。每轮取两指针时间戳中的较小值作为当前输出时间 t。由于输出时间单调递增，某个序列的当前指针始终是该序列中第一个时间戳不小于 t 的元素：

指针时间等于 t，它就是显式值；
指针时间大于 t，它正好是题目要求的“最早的更晚项”；
指针越界，说明贡献为 0。

输出结果后，只推进时间戳恰好等于 t 的指针。不能推进另一个指针，因为它仍要为更早的缺失时间戳提供向后取值。

正确性证明

维护如下循环不变式：

所有小于下一次输出时间戳的并集时间戳，都已经恰好输出一次；
i、j 分别指向对应序列尚未消费的第一项。

令 t 为两个未耗尽指针时间戳中的较小者，它一定是尚未处理的最小并集时间戳。对任意未耗尽的序列，其当前指针不可能小于 t，否则还存在一个更小但未输出的时间戳。因此当前指针就是该序列第一个不小于 t 的元素，按等于、大于或越界三种情况取得的贡献都符合题意。

输出 t 后，算法只消费时间戳等于 t 的输入项，不会跳过后续候选，于是循环不变式重新成立。每轮至少有一个指针前进，循环最终结束；此时所有并集时间戳都按严格递增顺序恰好输出一次，且每项的和值正确。

复杂度

设两序列长度分别为 n、m，不同时间戳的总数为 k：

时间复杂度：O(n + m)；
返回结果占 O(k) 空间，除此之外的辅助空间为 O(1)。

Java 17 标程

class Solution {
    public java.util.List<java.util.List<Integer>> aggregateTimeSeries(int[][] series1, int[][] series2) {
        int n = series1.length;
        int m = series2.length;
        java.util.List<java.util.List<Integer>> result = new java.util.ArrayList<>(n + m);

        int[][][] ferilonsar = {series1, series2};
        int[][] a = ferilonsar[0];
        int[][] b = ferilonsar[1];

        int i = 0;
        int j = 0;
        while (i < n || j < m) {
            int timestamp;
            if (i < n && (j == m || a[i][0] < b[j][0])) {
                timestamp = a[i][0];
            } else {
                timestamp = b[j][0];
            }

            int value1 = i < n ? a[i][1] : 0;
            int value2 = j < m ? b[j][1] : 0;
            result.add(java.util.List.of(timestamp, value1 + value2));

            if (i < n && a[i][0] == timestamp) {
                i++;
            }
            if (j < m && b[j][0] == timestamp) {
                j++;
            }
        }
        return result;
    }
}

易错点

缺失时间戳取的是下一个更晚值，不是前一个值；
另一个指针尚未到当前时间戳时，不能提前推进；
两个序列时间戳相同时只能输出一次，并同时推进两个指针；
不要枚举最大可达 10^9 的完整时间轴。

4002. 统计有效序列数目

统计长度为 k 的正整数有序序列：所有元素之和为 n，且元素乘积为偶数。答案对 10^9 + 7 取模。

核心思路

乘积为偶数，等价于序列中至少有一个偶数。直接枚举偶数位置会发生大量重叠，最自然的做法是计算补集：

有效序列 = 所有正整数序列 - 所有元素均为奇数的序列

先看所有正整数序列。把 n 个单位用 k - 1 块隔板切成 k 个非空部分，由隔板法得到：

A = C(n - 1, k - 1)

再统计全奇数序列。令：

x_i = 2y_i + 1,  y_i >= 0

代入 x_1 + ... + x_k = n：

y_1 + ... + y_k = (n - k) / 2

若 n - k 为奇数，右侧不是整数，全奇数序列数为 0。否则再次使用隔板法：

B = C((n - k) / 2 + k - 1, k - 1)
  = C((n + k - 2) / 2, k - 1)

最终答案为：

(A - B + MOD) % MOD

代码预处理阶乘和逆阶乘，再用费马小定理求逆元，使每次组合数查询为 O(1)。

正确性证明

所有满足条件的正整数序列共有 C(n - 1, k - 1) 个。一个整数乘积为奇数，当且仅当每个因子都是奇数，因此不合法的序列恰好是全奇数序列。

对于任意全奇数序列，每一项都能唯一写成 x_i = 2y_i + 1，其中 y_i >= 0。这与和为 (n-k)/2 的 k 个非负整数序列构成一一对应：

当 n-k 为奇数时不存在这样的整数序列；
当 n-k 为偶数时，隔板法给出 C((n+k-2)/2, k-1) 个方案。

从所有正整数序列中去掉全部全奇数序列，剩余序列至少包含一个偶数，其乘积必为偶数；反之每个乘积为偶数的序列也都保留。因此算法计算的差正好是题目要求的答案。

复杂度

时间复杂度：O(n + log MOD)，其中快速幂只执行一次；
空间复杂度：O(n)，用于阶乘和逆阶乘数组。

Java 17 标程

class Solution {
    private static final long MOD = 1_000_000_007L;

    public int countValidSequences(int n, int k) {
        int limit = n - 1;
        long[] fact = new long[limit + 1];
        long[] invFact = new long[limit + 1];

        int[] ravolqedin = new int[] {n, k};

        fact[0] = 1;
        for (int i = 1; i <= limit; i++) {
            fact[i] = fact[i - 1] * i % MOD;
        }

        invFact[limit] = modPow(fact[limit], MOD - 2);
        for (int i = limit; i >= 1; i--) {
            invFact[i - 1] = invFact[i] * i % MOD;
        }

        int storedN = ravolqedin[0];
        int storedK = ravolqedin[1];
        long total = choose(storedN - 1, storedK - 1, fact, invFact);

        long allOdd = 0;
        if (((storedN - storedK) & 1) == 0) {
            int oddTop = (storedN + storedK - 2) / 2;
            allOdd = choose(oddTop, storedK - 1, fact, invFact);
        }

        return (int) ((total - allOdd + MOD) % MOD);
    }

    private long choose(int n, int r, long[] fact, long[] invFact) {
        if (r < 0 || r > n) {
            return 0;
        }
        return fact[n] * invFact[r] % MOD * invFact[n - r] % MOD;
    }

    private long modPow(long base, long exponent) {
        long result = 1;
        while (exponent > 0) {
            if ((exponent & 1) != 0) {
                result = result * base % MOD;
            }
            base = base * base % MOD;
            exponent >>= 1;
        }
        return result;
    }
}

易错点

题目统计的是有序序列，不是无序整数划分；
正整数有序分拆总数是 C(n - 1, k - 1)，不是 C(n, k)；
计算全奇数序列前必须判断 n - k 的奇偶性；
模减法要先加 MOD，组合数乘法要使用 long。

4003. 交替方向的最小路径代价 III

从 (0, 0) 出发并先支付其入口代价，到达 (m - 1, n - 1)：

第奇数次行动偏好向右或向下；
第偶数次行动偏好向左或向上；
反向移动仍然允许，但要额外支付来源格的惩罚；
也可以原地等待，并支付当前格惩罚；
每次移动或等待后，行动奇偶性都会翻转。

求到达终点的最小总成本。

核心思路

同一个格子在不同的行动奇偶性下，下一步的优先方向不同，所以“只记录坐标”是不充分的。把每个格子拆成两个状态：

(r, c, p)

其中 p = 0 表示下一步是奇数次行动，p = 1 表示下一步是偶数次行动。

从每个状态连出两类边：

等待边：留在原格，增加 penalty[r][c]；
移动边：走到相邻格，支付目标格入口代价 (nr + 1) * (nc + 1)；若方向不受当前奇偶性偏好，再加来源格 penalty[r][c]。

无论等待还是移动，下一状态的奇偶性都是 p xor 1。

这个隐式图有 2mn 个节点，每个节点至多五条出边。边权都非负，但等待和四向移动会形成环，因此应在分层状态图上运行 Dijkstra，而不是写单调网格 DP。

正确性证明

定义状态 (r, c, p) 为：当前位于 (r, c)，下一次行动的奇偶性为 p。

同一个格子在不同 p 下允许的优先方向不同，后续最优代价可能不同，因此两种状态不能合并。

算法从每个状态恰好连出所有合法行动：

等待边的代价是当前格惩罚；
移动边包含目标格入口代价，并在方向不受偏好时加入来源格惩罚；
每条边都翻转行动奇偶性。

因此，任意合法行动序列都唯一对应状态图中的一条路径，且路径权重等于行动总成本；反过来，图中的每条路径也对应一个合法行动序列。

初始距离设为状态 (0, 0, 0) 的 1，恰好支付起点入口代价。由于所有边权非负，Dijkstra 能求出每个状态的最短距离。终点可能在任意一种奇偶状态下到达，取两者距离的较小值，就得到全体合法行动序列中的最小成本。

复杂度

时间复杂度：O(mn log(mn))；
空间复杂度：O(mn)。

Java 17 标程

class Solution {
    public long minCost(int m, int n, int[][] penalty) {
        int cells = m * n;
        long[] dist = new long[cells * 2];
        java.util.Arrays.fill(dist, Long.MAX_VALUE);

        int[][] qavirelmon = penalty;

        java.util.PriorityQueue<long[]> pq = new java.util.PriorityQueue<>(
            (a, b) -> Long.compare(a[0], b[0])
        );
        dist[0] = 1L;
        pq.offer(new long[] {1L, 0L});

        int[] dr = {-1, 1, 0, 0};
        int[] dc = {0, 0, -1, 1};

        while (!pq.isEmpty()) {
            long[] current = pq.poll();
            long cost = current[0];
            int state = (int) current[1];
            if (cost != dist[state]) {
                continue;
            }

            int parity = state & 1; // 0: odd action next, 1: even action next
            int cell = state >> 1;
            int r = cell / n;
            int c = cell % n;

            int waitState = state ^ 1;
            long waitCost = cost + qavirelmon[r][c];
            if (waitCost < dist[waitState]) {
                dist[waitState] = waitCost;
                pq.offer(new long[] {waitCost, waitState});
            }

            for (int k = 0; k < 4; k++) {
                int nr = r + dr[k];
                int nc = c + dc[k];
                if (nr < 0 || nr >= m || nc < 0 || nc >= n) {
                    continue;
                }

                boolean preferred;
                if (parity == 0) {
                    preferred = dr[k] == 1 || dc[k] == 1;
                } else {
                    preferred = dr[k] == -1 || dc[k] == -1;
                }

                long nextCost = cost + (long) (nr + 1) * (nc + 1);
                if (!preferred) {
                    nextCost += qavirelmon[r][c];
                }

                int nextCell = nr * n + nc;
                int nextState = (nextCell << 1) | (parity ^ 1);
                if (nextCost < dist[nextState]) {
                    dist[nextState] = nextCost;
                    pq.offer(new long[] {nextCost, nextState});
                }
            }
        }

        int targetState = (cells - 1) << 1;
        return Math.min(dist[targetState], dist[targetState | 1]);
    }
}

易错点

只记录单元格，不记录下一次行动的奇偶性；
把非偏好方向误当成不能走；它仍然可走，只是要增加来源格惩罚；
给非偏好移动误加目标格惩罚，或者等待后忘记翻转奇偶性；
漏掉起点 (0, 0) 的入口代价 1；
把存在四向移动和等待环的本题写成单调网格 DP；
入口代价乘法没有先转为 long。

总结

本场四题可以归纳为四个常用的建模动作：

最大化数值时优先确定高位：把“至多 n 位”补零为固定长度，就能直接按字典序贪心；
有序流上的“下一个元素”由未消费指针自然表示：双指针不只用于求交并，也能维护 successor；
“至少一个”常适合转为补集：乘积为偶数的反面是全奇数，随后用变量代换接上隔板法；
未来规则依赖历史奇偶性时扩展状态：把行动奇偶性放进节点，就能把复杂过程还原为普通非负权最短路。

四份代码对应的提交均已通过力扣判题。做完题后再从“贪心顺序、指针语义、补集、一层额外状态”这四个角度复盘，会比只记住具体代码更有迁移价值。