中秋+国庆双节来一波动态规划LCP 19. 秋叶收藏集小扣出去秋游，途中收集了一些红叶和黄叶，他利用这些叶子初步整理了

前言

中秋+国庆快乐🦆

LCP 19. 秋叶收藏集

小扣出去秋游，途中收集了一些红叶和黄叶，他利用这些叶子初步整理了一份秋叶收藏集 leaves，字符串 leaves 仅包含小写字符 r 和 y，其中字符 r 表示一片红叶，字符 y 表示一片黄叶。出于美观整齐的考虑，小扣想要将收藏集中树叶的排列调整成「红、黄、红」三部分。每部分树叶数量可以不相等，但均需大于等于 1。每次调整操作，小扣可以将一片红叶替换成黄叶或者将一片黄叶替换成红叶。请问小扣最少需要多少次调整操作才能将秋叶收藏集调整完毕。

示例 1：
输入：leaves = "rrryyyrryyyrr"
输出：2
解释：调整两次，将中间的两片红叶替换成黄叶，得到 "rrryyyyyyyyrr"
    
示例 2：
输入：leaves = "ryr"
输出：0
解释：已符合要求，不需要额外操作

提示：

3 <= leaves.length <= 10^5
leaves 中只包含字符 'r' 和字符 'y'

方法1：动态规划

算法思路：

由于我们想要将收藏集中的树叶排列调整成「红、黄、红」三部分，因此我们可以用 3 个状态分别来表示其中的每一部分。

$状态0$ 表示前面的红色部分；
$状态1$ 表示黄色部分；
$状态2$ 表示后面的红色部分；

我们可以尝试使用动态规划来解决本题：

定义状态

状态数组 f[i][j] 表示对于第 $0$ 片到第 $i$ 片叶子（记为leaves[0..i]）进行调整操作，并且第 $i$ 片叶子处于状态 j 时的最小操作次数。

$i$ 表示终止下标（即每片叶子）
$j$ 表示：3个状态，0表示左半边（红色），1表示中间部分（黄色），2表示右半边（红色）

DP方程（状态转移方程）

我们分别对于三个状态进行分析，所需要的最小替换次数：

当 $j = 0$ 时，我们需要将第 $i$ 片叶子变成红色，并且第 $i - 1$ 片叶子也只能处于 $j = 0$ 的状态，因此状态转移方程为：

$f[i][0] = f[i-1][0] + isYellow(i)$

其中 $isYellow(i)$ 为示性函数，当第 i 片叶子为黄色时为 1，红色时为 0。

当 $j = 1$ 时，我们需要将第 $i$ 片叶子变成黄色，而第 $i - 1$ 片叶子即可以处于 $j = 1$ 的状态，也可以处于 $j = 0$ 的状态，我们选择其中较小值，因此状态方程为：

$f[i][1] = min\{f[i-1][0], f[i-1][1]\} + isRed(i)$

其中 isRed(i) 为示性函数，当第 i 片叶子为红色时为 1，黄色时为 0。

当 $j = 2$ 时，我们需要将第 $i$ 片叶子变成红色，而第 $i - 1$ 片叶子即可以处于 $j = 2$ 的状态，也可以处于 $j = 1$ 的状态（煮鱼这里不能处于 $j = 0$ 的状态，因为每一种状态包含的叶子数量必须至少为 1），我们选择其中的较小值，因此状态转移方程为：

$f[i][2] = min\{f[i-1][1], f[i-1][2]\} + isYellow(i)$

记录已知状态数组元素：

第一片叶子，必须是左半部分，所以只需判断是不是黄色叶子即可；
第一片叶子，必须是左半部分，所以 $f[0][1]$ 和 $f[0][2]$ 都是无效的；
第二片叶子，可以是左半分，也可以是中间部分，但是不能是右半部分（每个区间必须有叶子），因此 $f[1][2]$ 是无效的。

参考代码1:

class Solution {
    public int minimumOperations(String leaves) {
        if (leaves == null || leaves == "") {
            return 0;
        }
        int length = leaves.length();
        char[] chars = leaves.toCharArray();
        //  状态数组，dp[i][j]
        int[][] dp = new int[length][3];

        dp[0][0] = chars[0] == 'y' ? 1 : 0;
        dp[0][1] = dp[0][2] = dp[1][2] = Integer.MAX_VALUE;

        // 判断当前遍历的叶子是不是黄色
        int isYellow = 0;

        // 遍历收藏集中的叶子
        for (int i = 1; i < length; i++) {
            isYellow = chars[i] == 'y' ? 1 : 0;
            dp[i][0] = dp[i-1][0] + isYellow;
            dp[i][1] = Math.min(dp[i-1][0], dp[i-1][1]) + (1 - isYellow);
            // 右半部分的叶子，必须是第2个元素之后的元素
            if (i > 1) {
                dp[i][2] = Math.min(dp[i-1][1], dp[i-1][2]) + isYellow;
            }
        }

        // 最终结果为 dp[length-1][2]
        return dp[length - 1][2];
    }

复杂度分析

时间复杂度： $O(n)$ ，其中 n 是字符串 leaves 的长度。
空间复杂度： $O(n)$ 。

参考代码2:

用三个变量代替状态数组，即可将空间复杂度降低到 $O(1)$ 。

class Solution {
    public int minimumOperations(String leaves) {
        int n = leaves.length();
        // int[][] f = new int[n][3];
        // f[0][0] = leaves.charAt(0)=='r'?0:1;
        // f[0][1] = f[0][2] = f[1][2] = 1000000;
        int a = 1000000,b=1000000,c=1000000;
        a = leaves.charAt(0)=='r'?0:1;
        for(int i=1;i<n;i++){
            int r = leaves.charAt(i)=='r'?0:1;
            int y = r ^ 1;
            // f[i][0] = f[i-1][0] + r;
            // f[i][1] = Math.min(f[i-1][0],f[i-1][1]) + y;
            // f[i][2] = Math.min(f[i-1][1],f[i-1][2]) + r;
            int aa =a,bb = b,cc = c;
            a += r;
            b = Math.min(aa,bb) + y;
            c = Math.min(bb,cc) + r;
        }
        // return f[n-1][2];
        return c;
    }
}

部分图片来源于网络，版权归原作者，侵删。