动态规划 ---- 最长回文子串

 分析：

 

 

 完整代码：

C++实现

#include <stdio.h>
#include <iostream>
#include <cstring>
using namespace std;

const int maxn = 1010;
char S[maxn];
int dp[maxn][maxn];

int main()
{
    cin.getline(S, 1010);
    int len = strlen(S), ans = 1;
    memset(dp, 0, sizeof(dp));            // dp数组初始化为0
    // 边界
    for (int i = 0; i < len; i++){
        dp[i][i] = 1;
        if (i < len - 1){
            if (S[i] == S[i + 1]){
                dp[i][i + 1] = 1;
                ans = 2;            // 初始化是注意当前最长回文子串长度
            }
        }
    }
    // 状态转移方程
    for (int L = 3; L <= len; L++){        // 枚举子串的长度
        for (int i = 0; i + L - 1 < len; i++){        // 枚举子串的起始端点
            int j = i + L - 1;        // 子串的右端点
            if (S[i] == S[j] && dp[i + 1][j - 1] == 1){
                dp[i][j] = 1;
                ans = L;        // 更新最长回文子串的长度
            }
        }
    }

    printf("%d
", ans);

    return 0;
}

Java实现

class Solution {
    public int[][] dp;

    public String longestPalindrome(String s) {
        // 令dp[i][j]表示s[i]到s[j]之间的字符是否是回文串
        // 当s[i+1] == s[j-1]时dp[i][j] = 1
        // 否则dp[i][j] = 0;
        // 初始化dp[i][i] = 1和dp[i][i+1] = (s[i]==s[j]) ? 1:0
        // 依次照度长度为3,4...L的回文子串
        int len = s.length();

        dp = new int[len][len];
        for(int i = 0; i < len; i++){
            Arrays.fill(dp[i], 0);
        }
        // 初始化dp数组的边界
        int ans = 1;        // 存储最大回文串的长度
        for(int i = 0; i < len; i++){
            dp[i][i] = 1;
            if(i < len - 1){
                if(s.charAt(i) == s.charAt(i+1)){
                    dp[i][i+1] = 1;
                    ans = 2;
                }

            }
        }
        
        // 从长度为3开始递增长度按转态转移方程给dp数组赋值
        for(int L = 3; L <= len; L++){
            for(int i = 0; i + L - 1< len; i++){
                int j = i + L - 1;
                if(s.charAt(i) == s.charAt(j) && dp[i+1][j-1] == 1){
                    dp[i][j] = 1;
                    ans = L;
                }
            }
        }

        // 扫描一次dp[i][j]
        // 寻找第一个等于dp[i][j] == ans的值
        for(int i = 0; i + ans - 1 < len; i++){
           for(int j = i + ans - 1; j < len; j++){
                if(1 == dp[i][j]){
                    return s.substring(i, j + 1);
                }
           }
        }
        return "";
    }
}

复杂度分析：

时间花费有三部分，① 对dp[][]赋边界值，所需时间为O(n), ② 从长度为3开始递增长度按转态转移方程给dp数组赋值，可以看到有一个双重循环，所需时间为O(n^2) ③ 找到第一个长度为L的回文子串，所需时间为O(n), 所以总的时间复杂度为O(n^2).

空间复杂度则是一个二维数组的空间，复杂度为O(n^2)