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的问题。