回文串系列总结

回文串的总结

Leecode 5 最长回文子串

找到最长的回文序列（连续的）

动态规划 dp[i][j]的含义 ： 从 i到j的子序列是不是回文串
转移方程： 判断 s[i] 和 s[j] 是否相等 ，不相等的话肯定不是回文串，相等就要做判断了， 1.如果说长度 <=2 ,那么已经构成回文串了， 2. 若是 i j 夹住的那个序列也是回文子序列，那么 i j 夹住的也是回文子序列

class Solution {
public:
    string longestPalindrome(string s) {
        
      int start;
      int maxlen = INT_MIN;
      int len; // 用于输出
      int slen = s.size();
      if(slen < 2) return s;
      vector<vector<bool>> dp(slen,vector<bool>(slen,false));
      
      for(int i = 0; i< slen;i++)
      {
        dp[i][i] = true;
      }//初始化
        // 因为dp[i+1][j-1] 那么只有后面那个倒三角的有效 不然会有重复判断
        for(int i =slen -1; i >=0; i --)
        {
            for(int j = i ; j< slen; j++)
            {
            if(s[i] == s[j] && (j-i+1 <=2 || dp[i+1][j-1]))
            {
                dp[i][j] = true;
                if(j-i+1 > maxlen)
                {
                    maxlen = j-i+1;
                    len = maxlen;
                    start = i;
                }
            }
        }
      }
      return s.substr(start,len);
    }
};

Leecode 647 回文子串

这题跟上面的思路一样，只不过求得东西变成了数量，那么在dp[i][j] 为true的时候，count ++即可

class Solution {
public:
    int countSubstrings(string s) {
        int count= 0; // 记录回文子串的个数
        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-1 ; i >=0; i--)
        {
            for( int j = i; j < n; j++)
            {
                if(s[i] == s[j] && (j - i+1 <=2 || dp[i+1][j-1]))
                {
                    dp[i][j] = true;
                }
                if( dp[i][j]) count ++;
            }
        }
    return count;
    }
};

Leecode 516

这里就和上面不同了， 这里是不连续的序列的情况， 在 i j 中可以删除任意个数的元素，留下最长的回文串长度即可，
那么 dp[i][j] 就代表 i j 中最长的回文串长度

若 s[i] == s[j] ， 那么 直接加入即可 dp[i][j] = dp[i+1][j-1] + 2;
， 若不相等 ， 那么就看看加入其中一个的最大值是什么
max ( dp[i+1][j] , dp[i][j-1])

class Solution {
public:
    int longestPalindromeSubseq(string s) {
            // 两边出现相同元素时 ，直接 +2 ， 因为可以随意删除字符

            int size = s.size();
            vector<vector<int>> dp(size,vector<int>(size,0));

            for( int i = 0; i< size ;i++)
            {
                dp[i][i] = 1;
            }

            for(int i = size-1; i>=0;i--)
            {
                for( int j = i+1 ;j<size ;j++)
                {
                    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][size-1];
    }
};

注意每一个循环的起始值， j从i+1开始是因为若j不为i+1下面的dp[i+1][j-1] 会越界