题目描述

小扣出去秋游，途中收集了一些红叶和黄叶，
他利用这些叶子初步整理了一份秋叶收藏集 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

dp

dp[i][0] 表示i长度的字符串 
全部为'r'的情况的最小操作数

dp[i][1] 表示i长度的字符串 
符合 n*'r' m*'y'的要求的最小操作数 (n>=1 ,m>=1 ,m+n=i)

dp[i][2] 表示i长度的字符串 
符合 n*'r' m*'y' p*'r'的要求的最小操作数 (n>=1 ,m>=1,p>=1 ,m+n+p=i) 

dp[leaves.size()-1][2] 就是题目要求的答案

C++ 代码

class Solution {
public:
int dp[999999][3];
int minimumOperations(string leaves) {
    //插入一个值 方便DP 从索引1开始计算
    leaves.insert(leaves.begin(), '#');

    dp[0][0] = 0;
    dp[1][1] = 999999;
    dp[2][2] = 999999;

    for (int i = 1; i < leaves.size(); i++) {
        if (leaves[i] == 'r') {
            dp[i][0] = dp[i - 1][0];
        }
        else {
            dp[i][0] = dp[i - 1][0] + 1;
        }
    }

    for (int i = 2; i < leaves.size(); i++) {
        if (leaves[i] == 'r') {
            dp[i][1] = min(dp[i-1][1],dp[i-1][0]) + 1;
        }
        else {
            dp[i][1] = min(dp[i - 1][1], dp[i - 1][0]);
        }
    }

    for (int i = 3; i < leaves.size(); i++) {
        if (leaves[i] == 'r') {
            dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]);
        }
        else {
            dp[i][2] = min(dp[i - 1][2], dp[i - 1][1]) + 1;
        }
    }

    return dp[leaves.size() - 1][2];
}


};

简化下代码

class Solution {
public:
   int dp[999999][3];

int minimumOperations(string leaves) {
    leaves.insert(leaves.begin(), '#');

    for (int i = 1; i < leaves.size(); i++) {
        if (leaves[i] == 'r') {
            dp[i][0] = dp[i - 1][0];
            dp[i][1] = i<2 ? 999999: min(dp[i - 1][1], dp[i - 1][0]) + 1;
            dp[i][2] = i<3 ? 999999:min(dp[i - 1][2], dp[i - 1][1]);
        }
        else {
            dp[i][0] = dp[i - 1][0] + 1;
            dp[i][1] = i < 2 ? 999999 : min(dp[i - 1][1], dp[i - 1][0]);
            dp[i][2] = i < 3 ? 999999 : min(dp[i - 1][2], dp[i - 1][1]) + 1;
        }
    }


    return dp[leaves.size() - 1][2];
}

};

动态滚动的DP其实可以再优化下

int minimumOperations(string leaves) {
    leaves.insert(leaves.begin(), '#');
    int f0 = 0; int f1 = 0; int f2 = 0;
    for (int i = 1; i < leaves.size(); i++) {
        if (leaves[i] == 'r') {
            f2 = i < 3 ? 999999:min(f2, f1);
            f1 = i < 2 ? 999999 : min(f1, f0) + 1;
        }
        else {
            f2 = i < 3 ? 999999 : min(f2, f1)+1;
            f1 = i < 2 ? 999999 : min(f1, f0);
            f0 = f0+1;
        }
    }
    return f2;
}

我的leetcode视频题解空间