LeeCode C++代码动态规划解决最长回文子串

 一.确定动态规划需要的dp数组

        “最长回文子串”顾名思义，可以拆分成一个或者多个回文子串。所以有一个回文子串的区间比如字符串的 i 位置到 j 位置，然后动态地去更新我们地二维数组。

二.确定递推公式

        首先，回文子串地起始位置和最终位置都得是同样的，比如dad。每次在原有地子串上增加元素地时候，必须是成对出现的（比如有一个是 i位置到j位置地，下一次增加就是i-1位置到j+1位置的）。

        首先是判断是否有可能是回文字符串的判断，即 if(dp[i]==dp[j])

        是回文子串的情况

if (s[i] == s[j]) {
    if (j - i == 0) { // 情况一,在相同位置的话肯定是回文字符串
        dp[i][j] = true;
    }else if (j - i == 1) { // 情况二,相邻且相同的字符也可以组成回文字符串
        dp[i][j] = true;
    } else if (dp[i + 1][j - 1]) { // 情况三，不相邻的两个相同字符要组成的话，该字符串左右各
                                    //缩进一位也得是回文字符串
        dp[i][j] = true;
    }
}

        该判断可以优化一下qaq，下面是优化版

if (s[i] == s[j]) {
    if (j - i <= 1) { // 情况一 和 情况二
        dp[i][j] = true;
    } else if (dp[i + 1][j - 1]) { // 情况三
        dp[i][j] = true;
    }
}

        或许也可以是像这样的二元表达式

j-i<=1?dp[i][j]=true:(dp[i+1][j-1]==true?true:false);

       每次进入循环的时候还得判断当前子串是否为当前最优解，并将当前字符串的位置保存起来

if (dp[i][j] && j - i + 1 > maxlenth) {
    maxlenth = j - i + 1;
    left = i;
    right = j;
}

三.初始化dp数组

        判断是否为回文子串一共只有两种情况，所以是bool类型的。初始化为true的话，每次返回的结果都是当前字符串的所有。所以必须初始化为false。

四.确认遍历顺序

        在之前的分析中，我们需要用到 dp[i + 1][j - 1] 该位置在当前位置的右上角。所以我们需要 自右自上 来遍历dp数组。

        所以，完整代码如下：

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) { // 情况一 和 情况二
                dp[i][j] = true;
            } else if (dp[i + 1][j - 1]) { // 情况三
                dp[i][j] = true;
            }
        }
        if (dp[i][j] && j - i + 1 > maxlenth) {
            maxlenth = j - i + 1;
            left = i;
            right = j;
        }
    }

}

五.举例推导出 aaa

附完整solution代码

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

        }
        return s.substr(left, right - left + 1);
    }
};