Leetcode:5. Longest Palindromic Substring

Description:

Given a string s, find the longest palindromic substring in s. You may assume that the maximum length of s is 1000.

Example:

Input: “babad”
Output: “bab”

Note: “aba” is also a valid answer.
Example:

Input: “cbbd”
Output: “bb”

解题思路：

本题为经典的最长回文子字符串问题，题意很清楚，就是求字符串S中的最长回文。一种比较好想到的算法思路就是中心扩展法，从下标 i 出发，用2个指针向 i 的两边扩展判断是否相等，那么只需要对0到n-1的下标都做此操作，就可以求出最长的回文子串。但需要注意的是，回文字符串有奇偶对称之分，即”abcba”与”abba”2种类型。

string longestPalindrome(string s) {        
        int n = s.length();  
        int startPos = 0;  
        int max = 1;  
        for (int i = 0; i < n; ++i) {  
            int oddLen = 0, evenLen = 0, curLen;  
            oddLen = Palindromic(s,i,i);  

            if (i + 1 < n)  
               evenLen = Palindromic(s,i,i+1);  

            curLen = oddLen > evenLen? oddLen : evenLen;  

            if (curLen > max) {  
                max = curLen;  
                //将max的高七位变成0，得到max的最低位 
                if (max & 0x1)  
                  startPos = i - max / 2;  
                else   
                  startPos = i - (max - 1) / 2;  
            }  
        }            
        return s.substr(startPos,max);  
}  

int Palindromic(const string &str, int i, int j) {  
        size_t n = str.length();  
        int curLen = 0;  

        while (i >= 0 && j < n && str[i] == str[j]) {  
            --i;  
            ++j;  
        }  
        curLen = (j-1) - (i+1) + 1;    
        return curLen;  
}  

动态规划求解

假设dp[ i ][ j ]的值为true，表示字符串s中下标从 i 到 j 的字符组成的子串是回文串。那么可以推出： dp[ i ][ j ] = dp[ i + 1][ j - 1] && s[ i ] == s[ j ]。这是一般的情况，由于需要依靠i+1, j -1，所以有可能 i + 1 = j -1, i +1 = (j - 1) -1，因此需要求出基准情况才能套用以上的公式：

a. i + 1 = j -1，即回文长度为1时，dp[ i ][ i ] = true;

b. i +1 = (j - 1) -1，即回文长度为2时，dp[ i ][ i + 1] = （s[ i ] == s[ i + 1]）。

需要注意的是动态规划需要额外的O($n^2$)的空间。

class Solution {
public:
    string longestPalindrome(string s) {        
        if (s.length() == 0) return "";
        if (s.length() == 1) return s;
        int len = s.length();
        bool dp[len][len];
        int start = 0, max = 1;

        for (int i = 0; i < len; i++) {
            dp[i][i] = true;
            if (i +1 < len)
                if (s[i] == s[i+1]) {
                    dp[i][i+1] = true;
                    start = i;
                    max = 2;
                } else {
                    dp[i][i+1] = false;
                }
        }

        //动态规划求解
        for (int k = 3; k <= len; k++) {
            for (int i = 0; i < len-k+1; i++) {
                int j = i + k-1;
                if (dp[i+1][j-1] && s[i] == s[j]) {
                    dp[i][j] = true;
                    int cur = j-i+1;
                    if (cur > max) {
                        start = i;
                        max = cur;
                    }
                } else {
                    dp[i][j] = false;
                }
            }
        }

        return s.substr(start,max);
    }  

};