leetcode5. 最长回文子串 冲鸭冲，倒计时4天

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

示例 1：

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

示例 2：

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

示例 3：

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

示例 4：

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

结题思路1：
暴力解法，超时
两次循环，找到最长的子串

class Solution {
public:
    string longestPalindrome(string s) {
        //return  to_string(isTrue(s, 0, s.size() - 1));
        int left = 0;
        int nlength = s.size() - 1;
        int maxlength = 0;
        for (int i = 0; i < s.size(); i++) {
            for (int j = i; j < s.size(); j++) {
                if (isTrue(s,i,j)) {
                    if (maxlength < (j - i + 1)) {
                        maxlength = j - i + 1;
                        left = i;
                    }
                }
            }
        }
        return s.substr(left, maxlength);
    }
    bool isTrue(string s, int start, int end) {
        if (start >= end) return 1;
        if (s[start] != s[end]) return 0;
        return isTrue(s, start + 1, end - 1);
    }
};

结题思路2： 动态规划
用一个dp[i][j]数组存放字符串s[i] - s[j]的状态
1、初始化：
dp[i][i] = 1;

2、动态规划函数：
dp[i][j] = dp[i + 1][j - 1] && s[i] == s[j]
既是：
先判断s[i] ==s[j]
如果不等于，直接d[i] [j ] = 0;
如果等于，再判断dp[i + 1][j - 1，既是dp[i][j] = dp[i + 1][j - 1] ；

3、注意维护一个begin作为字符串起始位置，以及maxlength作为最大长度。
既每次找出一个dp[i][j] 后，都要判断一下
dp[i][j] = 1，再看maxlength > j -i +1;
如果成立，更新begin 和maxlenth，
最后返回

class Solution {
public:
    string longestPalindrome(string s) {
        int begin = 0;
        int maxlength = 1;
        int nLength = s.size();
        vector<vector<bool>> dp(nLength, vector<bool> (nLength, 0));
        for (int i = 0; i < nLength; i++) {
            dp[i][i] = 1;
        }
        for (int j = 0; j < nLength; j++) {
            for (int i = 0; i < j; i++) {
                if (s[i] != s[j]) {
                    dp[i][j] = 0;
                }
                else {
                    if (j - i == 1) {
                        dp[i][j] = 1;
                    }
                    else {
                        dp[i][j] = dp[i + 1][j - 1];
                    }
                }
                if (dp[i][j] == 1&& j - i + 1 > maxlength) {
                    maxlength = j - i + 1;
                    begin = i;
                }
            }

        }
        return s.substr(begin, maxlength);
        
    }

};