LeetCode：5.最长回文子串

思路一、

动态规划算法, $$dp[i][j]=(dp[i+1][j-1])\&\&(s[i]==s[j])$$
dp二维数组: $dp[i][j]$ 是从$i$到$j$的字符串是否是回文串,实际上是一个布尔数组

class Solution {
public:
    string longestPalindrome(string s) {
        int n = s.size();
        vector<vector<int>> dp(n, vector<int>(n));
        string ans;
        for (int l = 0; l < n; ++l) {
            for (int i = 0; i + l < n; ++i) {
                int j = i + l;
                if (l == 0) {
                    dp[i][j] = 1;
                } else if (l == 1) {
                    dp[i][j] = (s[i] == s[j]);
                } else {
                    dp[i][j] = (s[i] == s[j] && dp[i + 1][j - 1]);
                }
                if (dp[i][j] && l + 1 > ans.size()) {
                    ans = s.substr(i, l + 1);
                }
            }
        }
        return ans;
    }
};

步骤解析

1.dp是二维数组,dp[i][j]=true则说明从i到j的字符串是回文串
2.ans用来存储回文子串
3.看两层循环的意义
  3.1 l是回文子串的长度; 
  3.2 i是回文子串的起点
  3.3 j是回文子串的终点
4.模仿几步:
  4.1 l = 0, i = 0, j = 0. 由于回文子串的长度为0, dp[0][0] = 1;
  4.2 l = 0, i = 1, j = 1. 由于回文子串的长度为0, dp[1][1] = 1;
  4.3 ......
  4.4 l = 0, i = n - 1, j = n - 1. 由于回文子串的长度为0, dp[n-1][n-1] = 1;
  总结: l = 0时,字符串中的每个字符都是一个回文子串
  在每个判断结束之后,对比 dp[i][j] && l + 1 > ans.size()
  由于第一个dp[i][j] = 1 = true 且 l + 1 = 1 > ans.size() = 0, ans只在第一次(l = 0, i = 0)时被更新为s.substr(0, 1)=>起点为0,取其后的1个元素.
 
  4.5 l = 1, i = 0, j = 1. 由于回文子串的长度为1, dp[0][1] = s[0] == s[1]
  4.6 l = 1, i = 1, j = 2. 由于回文子串的长度为1, dp[1][2] = s[1] == s[2]
  4.7 ......
  4.8 l = 1, i = n - 2, j = n - 1. 由于回文子串的长度为1, dp[n-2][n-1] = s[n - 2] == s[n - 1]
  总结: 这个是判断有没有连续两个字符串为回文串,并记录存在的第一个回文串(dp[i][j] && l + 1 > ans.size())
  
  4.9 l = 2, i = 0, j = 2. 由于待判断的子串的长度为2, dp[0][2] = dp[1][1] && s[0] == s[2]
  4.10 l = 2, i = 1, j = 3. 由于待判断的子串的长度为2, dp[1][3] = dp[2][2] && s[1] == s[3]
  4.11 ......
  4.12 l = 3, i = 0, j = 3. 由于待判断的子串的长度为3, dp[0][3] = dp[1][2] && s[0] == s[3]
  4.13 ......
  ......
总结: l就像窗口(windows_size); i就像滑窗的步长(slide)
1. l = 5,则每次校验的窗口为5个字符串, i=0, 则校验的是0-5; i=1, 则校验的是1-6 ......
2. l从小到达校验, 最终校验了 n + (n - 1) + (n - 2) + ...... + 1 = (n)(n + 1)/2次,所以时间复杂度为O(n^2)

思路二、

暴力枚举(时限超了)

class Solution {
public:
    bool judge(string s) {
        if(s.size() == 0) return true;
        if(s.size() == 1) return true;
        if(s.size() == 2 && s[0] == s[1]) return true; 
        bool flag = true;
        for(int i = 0; i < s.size(); i++) {
            int j = s.size() - 1 - i;
            if(i >= j) break;
            if(s[i] != s[j]) {
                flag = false;
                break;
            }
        }
        return flag;
    }
    string longestPalindrome(string s) {
        //设置起点和长度=> 更新起点和长度
        string res = "";
        int maxn = 0;
        for(int l = 0; l < s.size(); l++) {
            for(int i = 0; i + l < s.size(); i++) {
                //判断起点为i, 长度为l + 1的子串
                if(judge(s.substr(i, l + 1))) {
                    if(l >= maxn) {
                        maxn = l + 1;
                        res = s.substr(i, l + 1);
                    }
                }
            }
        }
        return res;
    }
};