2430. 对字母串可执行的最大删除数(每日一难phase2--day25)

2430. 对字母串可执行的最大删除数

给你一个仅由小写英文字母组成的字符串 s 。在一步操作中，你可以：

删除 整个字符串 s ，或者
对于满足 1 <= i <= s.length / 2 的任意 i ，如果 s 中的 前 i 个字母和接下来的 i 个字母 相等 ，删除 前 i 个字母。
例如，如果 s = “ababc” ，那么在一步操作中，你可以删除 s 的前两个字母得到 “abc” ，因为 s 的前两个字母和接下来的两个字母都等于 “ab” 。

返回删除 s 所需的最大操作数。

示例 1：

输入：s = “abcabcdabc”
输出：2
解释：

• 删除前 3 个字母（“abc”），因为它们和接下来 3 个字母相等。现在，s = “abcdabc”。
• 删除全部字母。 一共用了 2 步操作，所以返回 2 。可以证明 2 是所需的最大操作数。 注意，在第二步操作中无法再次删除 “abc” ，因为 “abc” 的下一次出现并不是位于接下来的 3 个字母。

示例 2：

输入：s = “aaabaab”
输出：4
解释：

• 删除第一个字母（“a”），因为它和接下来的字母相等。现在，s = “aabaab”。
• 删除前 3 个字母（“aab”），因为它们和接下来 3 个字母相等。现在，s = “aab”。
• 删除第一个字母（“a”），因为它和接下来的字母相等。现在，s = “ab”。
• 删除全部字母。 一共用了 4 步操作，所以返回 4 。可以证明 4 是所需的最大操作数。

示例 3：

输入：s = “aaaaa”
输出：5
解释：在每一步操作中，都可以仅删除 s 的第一个字母。

提示：

1 <= s.length <= 4000
s 仅由小写英文字母组成

解析：

• 从后往前考虑，删除后边子串，剩下前边串，也就是子问题，因此可以使用动态规划。
• 用 dp[i] = 删除s[i:n]最大操作数，如果是 s[i:i+j]==s[i+j:i+2*j] 相同，那么dp[i]=max(dp[i],dp[i+j]+1); (j表示子串长度)。(见下图)
• 需要现在需要处理的就是判断 s[i:i+j]==s[i+j:i+2*j]，可以用理解为最长公共前缀问题，我们想判断 s[i:i+j]是否等于s[i+j:i+2j]，如果 i开头前缀，和j开头公共前缀大于等于j，说明s[i:i+j]==s[i+j:i+2j]。（见下图）
• 用lcp[i][j]表示i，j 最长公共前缀长度，则
• if s[i]==s[j] : lcp[i][j]=lcp[i+1][j+1], else : lcp[i][j] = 0
  
  最长公共前缀
  
  代码：

/*
class Solution {
public:
    // 从前往后不对aaaybcaaaaa
    int deleteString(string s) {
        int n=s.size();
        int dp[4005];
        fill(dp,dp+4005,1);
        for(int i=1;i<n;i++){
            for(int j=i;j>i/2;j--){
                string lst = s.substr(j,i-j+1);
                string fst = s.substr(2*j-i-1,i-j+1);
                // cout<<lst<<"::"<<fst<<endl;
                if(lst==fst)
                    dp[i]=max(dp[i],dp[j-1]+1);
            }
        }
        return dp[n-1];
    }
};
*/
class Solution {
public:
    // 从后往前枚举，能保证后边剩下字符与前边没有关系
    int deleteString(string s) {
        int n=s.size();
        int dp[4005];
        fill(dp,dp+4005,1);
        // 最长公共前缀
        int lcp[n+1][n+1];
        memset(lcp,0,sizeof(lcp));
        for(int i=n-1;i>=0;i--){
            for(int j=n-1;j>=0;j--){
                if(s[i]==s[j])
                    lcp[i][j]=lcp[i+1][j+1]+1;
            }
        }

        //dp[i]表示从s[i:]最大操作数，从后往前推
        for(int i=n-1;i>=0;i--){
            for(int j=1;2*j+i-1<n;j++){
                if(lcp[i][i+j]>=j)
                    dp[i]=max(dp[i],dp[i+j]+1);
            }
        }
        return dp[0];
    }
};