LeetCode 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 边，就能统一求最小成本。

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

力扣周赛 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；
“至少一个”常适合转为补集：乘积为偶数的反面是全奇数，随后用变量代换接上隔板法；
未来规则依赖历史奇偶性时扩展状态：把行动奇偶性放进节点，就能把复杂过程还原为普通非负权最短路。

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