LeetCode （5）Longest Palindromic Substring

（5）Longest Palindromic Substring

题目：给定一个字符串s，找出s中最长的回文子串，假设s最大长度是1000。

例子：输入“babad”，输出“bab”。

再例：输入“cbbd”，输出“bb”。

通过动态规划的方式，判断长的子串是不是回文子串的时候，只需要判断子串首位是否相同，同时内部子串是否是回文子串，那么就定义一个dp[][]，通过第i位和第j位的字符对比，如果相同，则dp[i][j]=dp[i+1][j-1]，也就是说从i位到j位的字符串取决于从i+1位到j-1位的子串是否是回文。

在初步定义的时候，如果i是大于或等于j的时候，就将dp[i][j]定义为1，表示是回文子串，因为如果是只有一位，那么直接就是这位，如果没有的话，也就是空，那么就返回空，不然就暂定为0，这样就可以通过动态规划的方式对各种子串进行判断处理，变化为子问题了。

下面是代码：

int dp[1000][1000];
class Solution {
public:
    string longestPalindrome(string s) {
        int len = s.size();
        int i = 0, j = 0;
        if(len == 1){
            return s;
        }
        if(len == 0){
            return "";
        }
        for(i = 0; i < len; i ++){
            for(j = 0; j <len; j ++){
                if(i >= j){
                    dp[i][j] = 1;
                }
                else{
                    dp[i][j] = 0;
                }
            }
        }
        int maxlen = 1;
        int lef = 0, rig = 0, k;
        for(k = 1; k < len; k ++){
            for(i = 0; i < len - k; i ++){
                j = i + k;
                if(s.substr(i,1)!=s.substr(j,1)){
                    dp[i][j] = 0;
                }
                else{
                    dp[i][j] = dp[ i + 1][j -1];
                    if(dp[i][j] == 1){
                        if(k+1 > maxlen){
                            maxlen = k+1;
                            lef = i;
                            rig = j;
                        }
                    }
                }
            }
        }
        return s.substr(lef, rig - lef + 1);
    }
};

另：在C++和C中都存在一个问题就是定义数组的时候，不能再内部定义超过一百万的数组，只能使用外部定义宏变量的方式，否则会产生编译过程中就出现了overflow的问题。