1745. 分割回文串 IV

思路

这个问题可以使用动态规划来解决。我们可以使用一个二维数组 dp 来记录字符串中所有子串是否为回文串。然后，我们可以通过遍历所有可能的分割位置来检查是否存在有效的分割，使得每个子串都是回文串。

解题方法

动态规划： 我们首先使用动态规划来填充一个二维数组 dp，其中 dp[i][j] 表示字符串从索引 i 到 j 的子串是否为回文串。我们从字符串的左侧开始，逐步扩展到右侧，更新 dp[i][j] 的值。具体来说，如果字符串从 i 到 j 是一个单字符或者两个字符的回文串，则 dp[i][j] 为 true；如果字符串从 i 到 j 的首尾字符相同并且字符串 i+1 到 j-1 也是一个回文串，则 dp[i][j] 也为 true。

检查分割： 接下来，我们遍历所有可能的分割位置。我们尝试将字符串分割成三个子串，使得每个子串都是一个回文串。具体地，我们遍历所有可能的分割位置 pos1 和 pos2，并检查是否存在合适的分割点，使得分割后的三个子串都是回文串。

复杂度

时间复杂度:
动态规划填充二维数组的时间复杂度为 $O(n^2)$

空间复杂度:
动态规划所使用的二维数组需要 $O(n^2)$ 的空间。

class Solution {
public:
    bool checkPartitioning(string s) {
    int n = s.size(); 
    vector<vector<bool>> dp(n,vector<bool>(n,false));

    for(int i=0;i<n;i++)
    dp[i][i]=true;
    for(int i = n-2;i>=0;i--)
    {
       for(int j=i+1;j<n;j++)
       {
           if(j==i+1&&s[i]==s[j]) dp[i][j] = true;
           else if(j!=i+1&&s[i]==s[j]) dp[i][j]=dp[i+1][j-1];
       }
    }

    for(int i = 1; i < n - 1; i++)
        for(int j = i; j < n - 1; j++)
         if(dp[0][i - 1] && dp[i][j] && dp[j + 1][n - 1]) return true;

    return false;
    }
};

// leetee
//动态规划    dp[i][j]是不是回文串  然后推  
//dp[0][n] 可不可以找到 pos1 和 pos2 使得dp[0][pos1] dp[pos1][pos2] dp[pos2][n]
//dp[i][j] dp[i+1][j-1]
//  abcbdd

//
//假设 pos1 和 pos2
//判断 

132. 分割回文串 II类似

class Solution {
public:
    int minCut(string s) {
        int n = s.size();
        vector<vector<int>> g(n, vector<int>(n, true));

        for (int i = n - 1; i >= 0; --i) 
        {
            for (int j = i + 1; j < n; ++j) 
            {
                g[i][j] = (s[i] == s[j]) && g[i + 1][j - 1];
            }
        }

        vector<int> f(n, INT_MAX);
        for (int i = 0; i < n; ++i) {
            if (g[0][i]) 
            {
                f[i] = 0;
            }
            else {
                for (int j = 0; j < i; ++j) 
                {
                    if (g[j + 1][i]) {
                        f[i] = min(f[i], f[j] + 1);
                    }
                }
            }
        }

        return f[n - 1];
    }
};