刷题-回文串系列

最长回文串

给你一个字符串 s，找到 s 中最长的 回文子串。

示例 1：

输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

示例 2：

输入：s = "cbbd"
输出："bb"

代码：

class Solution {
public:
    string longestPalindrome(string s) {
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size()));
        int left = 0;
        int right = 0;
        int maxlen = 0;
        for (int i = 0; i < s.size(); i++) dp[i][i] = true;
        for (int i = s.size() - 1; i >= 0; i--)
        {
            for (int j = i; j < s.size(); j++) //注意，因为下面有判断j和i的差距，所以这里j=i即可，不要j=i+1
            {
                if (s[i] == s[j])
                {
                    if (j - i <= 1)
                    {
                        dp[i][j] = true;
                        
                    }
                    else if(dp[i + 1][j - 1])
                    {
                        dp[i][j] = true;
                        
                    }
                    
                }
                if (dp[i][j] && maxlen < j - i + 1)
                    {
                        maxlen = j - i + 1;
                        left = i;
                        right = j;
                    }
            }
        }
        return s.substr(left, right - left + 1);
    }
};

分割回文串Ⅰ

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是 回文串 。返回 s 所有可能的分割方案。

示例 1：

输入：s = "aab"
输出：[["a","a","b"],["aa","b"]]

示例 2：

输入：s = "a"
输出：[["a"]]

代码：

  

class Solution {
public:
    vector<vector<string>> partition(string s) {
        func(s, 0);
        return res;
    }
private:
    vector<vector<string>> res;
    vector<string> path;
    void func(string s, int start) //start 表示当前分割到哪里了，用来判断终止条件
    {
        if (start >= s.size())
        {
            res.push_back(path);
            return;
        }
        for (int i = start; i < s.size(); i++)
        {
            
            if (isValid(s, start, i))
            {
                string str = s.substr(start, i - start + 1);
                path.push_back(str);
                func(s, i + 1);
                path.pop_back();
            }
        }
    }
    bool isValid(string s, int start, int end)
    {
        for (int i = start, j = end; i < j; i++, j--)
        {
            if (s[i] != s[j]) return false;
        }
        return true;
    }
};

分割回文串Ⅱ

给你一个字符串 s，请你将 s 分割成一些子串，使每个子串都是回文。返回符合要求的 最少分割次数 。

示例 1：

输入：s = "aab"
输出：1
解释：只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。

示例 2：

输入：s = "a"
输出：0

代码

class Solution {
public:
    int minCut(string s) {
        vector<vector<bool>> isPalindromic(s.size(), vector<bool>(s.size(), false));
        for (int i = 0; i < s.size(); i++)
        {
            isPalindromic[i][i] = true;
        }
        for (int i = s.size() - 1; i >= 0; i--)
        {
            for (int j = i; j < s.size(); j++)
            {
                if (s[i] == s[j])
                {
                    if (j - i <= 1) isPalindromic[i][j] = true;
                    else if (isPalindromic[i + 1][j - 1]) isPalindromic[i][j] = true;
                }
            }
        }
        
        vector<int> dp(s.size());
        for (int i = 0; i < s.size(); i++) dp[i] = i;//初始化为i，表示以当前下标结束的字符串最多需要i个分割次数
        for (int i = 0; i < s.size(); i++)
        {
            if (isPalindromic[0][i])
            {
                dp[i] = 0;
                continue;
            }
            for (int j= 0; j < i; j++)
            {
                if  (isPalindromic[j + 1][i]) //这里要j+1
                {
                    dp[i] = min(dp[i], dp[j] + 1);
                }
            }
        }
        return dp[s.size() - 1];
    }
};

最长回文子序列

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。

示例 2：

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。

代码：

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));

        for (int i = 0; i < s.size(); i++) dp[i][i] = 1; //这里要初始化为1
        for (int i = s.size(); i >= 0; i--)
        {
            for (int j = i + 1; j < s.size(); j++) //因为下面没有对j和i的距离的判断，所以为了防止越界，这里必须要j=i+1
            {
                if (s[i] == s[j]) dp[i][j] = dp[i + 1][j - 1] + 2;
                else dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);
   
            }
        }
        return dp[0][s.size() -1];
    
    }
};

回文子串

给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

示例 1：

输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"

示例 2：

输入：s = "aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

代码：

class Solution {
public:
    int countSubstrings(string s) {
        vector<vector<bool>> dp(s.size(), vector<bool>(s.size(),false));
        for (int i = 0; i < s.size(); i++) dp[i][i] = true;
        int res = 0; //记录个数的，初始化为0
        for (int i = s.size() - 1; i >= 0; i--)
        {
            for (int j = i; j < s.size(); j++) //和上面一样，因为下面有对j和i的距离的判断，所以这里j=i即可，不用担心数组越绝
            {
                if (s[i] == s[j])
                {
                    if (j - i <= 1)
                    {
                        res++;
                        dp[i][j] = true;
                    }
                    else if(dp[i + 1][j - 1]) 
                    {
                        res++;
                        dp[i][j] = true;
                    }
                }
            }
        }
        return res;
    }
};