回文子串

647. 回文子串 - 力扣（LeetCode）

暴力解法

遍历字符串中的所有子串，并判断是否为回文串，若为回文串，则要返回的结果+1，最后返回所要求的结果，神奇的事居然能过，虽然时间和消耗内存都很大。

class Solution {
public:// 函数isreverse用于判断字符串s中从索引begin到end的子串是否为回文bool isreverse(string s, int begin, int end){// 当begin小于等于end时，进行循环while(begin <= end){// 如果在begin和end位置的字符不相等，则返回false，表示不是回文if(s[begin] != s[end]){return false;}// 将begin索引向前移动，将end索引向后移动begin++;end--;}// 如果循环完成，所有字符都相等，返回true，表示是回文return true;}int countSubstrings(string s) {// 初始化结果变量result为0int result = 0;// 外层循环遍历字符串s的每个字符作为子串的起始字符for(int i = 0; i < s.size(); i++){// 内层循环遍历字符串s的每个字符作为子串的结束字符for(int j = i; j < s.size(); j++){// 如果从i到j的子串是回文，则将result加1if(isreverse(s, i, j))result++;}}// 返回计算出的回文子串数量return result;}
};

算法的时间复杂度为O(n^3)，空间复杂度为O(1)。

中心扩展（双指针）

回文子串可以从它的中心向外扩展得到，而中心可能事一个字符（奇数长度的回文）或两个相邻字符（偶数长度的回文）。

class Solution {
public:// 函数countSubstrings用于计算字符串s中回文子串的数量int countSubstrings(string s) {// 初始化结果变量result为0int result = 0;// 遍历所有可能的中心点，中心点可能是一个字符（奇数长度的回文）或两个相邻字符（偶数长度的回文）for (int center = 0; center < 2 * s.size() - 1; center++) {// 计算当前中心点对应的左边界索引leftint left = center / 2;// 计算当前中心点对应的右边界索引rightint right = left + center % 2;// 当左边界索引大于等于0，右边界索引小于字符串长度，且左右边界对应的字符相同时，进行循环while (left >= 0 && right < s.size() && s[left] == s[right]) {// 回文子串数量加1result++;// 将左边界索引向左移动left--;// 将右边界索引向右移动right++;}}// 返回计算出的回文子串数量return result;}
};

算法的时间复杂度为O(n^2)，空间复杂度为O(1)。

动态规划

代码随想录 (programmercarl.com)

动态规划，字符串性质决定了DP数组的定义 | LeetCode：647.回文子串_哔哩哔哩_bilibili

dp[i][j],i到j的子串是否为回文串，感觉就是中心扩展的思路。

如果s[i] == s[j]，

i == j 回文子串

j-i == 1回文子串

j-i>1，需要判断dp[i+1][j-1]是否为回文子串。

if(s[i]==s[j]){if(j-i<=1){dp[i][j] = true;result++;}if(j-i>1){if(dp[i+1][j-1])dp[i][j] = true;result++;}
}

dp[i][j]的初始化为false。

遍历顺序 从底向上，从左向右，看遍历公式。

最后返回result，dp数组中true的数目

class Solution {
public:int countSubstrings(string s) {vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), false));int result = 0;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) { // 情况一 和 情况二result++;dp[i][j] = true;} else if (dp[i + 1][j - 1]) { // 情况三result++;dp[i][j] = true;}}}}return result;}
};

算法的时间复杂度为O(n^2)，空间复杂度为O(n^2)。

最长回文子序列

516. 最长回文子序列 - 力扣（LeetCode）

动态规划一

dp[i][j]:字符串s在[i,j]范围内最长的回文子序列的长度为dp[i][j]。

递推关系

若s[i] == s[j]，则dp[i][j] = dp[i+1][j-1]+2，考虑回文串前后相等，则长度加2.

若不相等，则同时加入不能形成回文串，则考虑分别加入时是否能形成回文串

dp[i][j] = max(dp[i+1][j],dp[i][j-1]).

从递推公式可知，当i、j相同时，递推公式是无效的，对于i、j相同的情况，我们需要手动将dp[i][j] = 1.其他值全部初始为0.

根据递推公式，考虑从左下到右上。

最后返回dp[0][s.size()-1]

class Solution {
public:int longestPalindromeSubseq(string s) {// 创建二维动态规划数组dp，大小为s.size() x s.size()，初始化为0vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));// 初始化对角线，每个字符自身构成长度为1的回文子序列for (int i = 0; i < s.size(); i++)dp[i][i] = 1;// 从下往上，从左往右遍历动态规划数组for (int i = s.size() - 1; i >= 0; i--) {for (int j = i + 1; j < s.size(); j++) {// 如果s的第i个字符和第j个字符相同if (s[i] == s[j]) {// dp[i][j]等于dp[i+1][j-1]加2，因为两边的字符可以构成回文dp[i][j] = dp[i + 1][j - 1] + 2;} else {// 否则，dp[i][j]等于dp[i+1][j]和dp[i][j-1]中的较大值dp[i][j] = max(dp[i + 1][j], dp[i][j - 1]);}}}// 返回dp[0][s.size()-1]，即整个字符串s的最长回文子序列的长度return dp[0][s.size() - 1];}
};

算法的时间复杂度为O(n^2)，空间复杂度为O(n^2)。

动态规划二

看到leetcode上一个叫Clever hodes的思路，将序列反转之后得到序列2，求两个序列的最长公共子序列就好了。很巧妙的思路，但相比动态规划一复杂度更高。

class Solution {
public:int longestPalindromeSubseq(string s) {// 创建字符串s的反转s2string s2(s);reverse(s2.begin(), s2.end());// 创建二维动态规划数组dp，大小为(s.size()+1) x (s.size()+1)，初始化为0vector<vector<int>> dp(s.size() + 1, vector<int>(s.size() + 1, 0));// 遍历字符串s的每个字符for (int i = 1; i <= s.size(); i++) {// 遍历字符串s2的每个字符for (int j = 1; j <= s.size(); j++) {// 如果s的第i个字符和s2的第j个字符相同if (s[i - 1] == s2[j - 1]) {// dp[i][j]等于dp[i-1][j-1]加1dp[i][j] = dp[i - 1][j - 1] + 1;} else {// 否则，dp[i][j]等于dp[i-1][j]和dp[i][j-1]中的较大值dp[i][j] = max(dp[i - 1][j], dp[i][j - 1]);}}}// 返回dp[s.size()][s.size()]，即最长回文子序列的长度return dp[s.size()][s.size()];}
};

算法的时间复杂度为O(n^2)，空间复杂度为O((n+1)^2)。