leetcode-5 Longest Palindromic Substring(回文子序列)

Given a string  S , find the longest palindromic substring in  S . You may assume that the maximum length of  S  is 1000, and there exists one unique longest palindromic substring.

1.简单解法：暴力枚举

遍历每个数字为中心，查找两侧是否是回文序列，复杂度O(n^2)(以每个数字向两边遍历是O(n)的复杂度)

技巧：

可以通过记录longestBegin, maxLen来保存字符串，不需要重新分配空间，return s.substr(longestBegin, maxLen);

2.动态规划

注：这里需要由小到大，所以如果遍历方式是     

for(int i = 0; i < size-1; i++)

        for(int j = i + 1; j < size; j++)

        {

            //  if(s[i] == s[j] && flag[i+1][j-1])

                // flag[i][j] = true;

        }

时，无法先获得P[i+1][j-1]的值，而导致无法动态规划（即要先构造出子结构的值，保证遍历到当前j时，i, i+1...~j-1的P都有值）

所以采用遍历方式：

for(int j = 0; j < size; j++)

    for(int i = 0; i < j; i++)

    {         

            //  if(s[i] == s[j] && flag[i+1][j-1])

                // flag[i][j] = true;

    }

或者遍历方式：

for (int len = 3; len <= n; len++) 

    for (int i = 0; i < n-len+1; i++) 

    {  

          // int j = i+len-1;  

          // if (s[i] == s[j] && flag[i+1][j-1]) 

     }

   

3.Manacher' s Algorithm(O(n))

思路：

http://www.cnblogs.com/bitzhuwei/p/Longest-Palindromic-Substring-Part-II.html

代码：

http://www.2cto.com/kf/201402/279057.html

首先把字符串S改造一下变成T，改造方法是：在S的每个字符之间和S首尾都插入一个"#"。这样做的理由你很快就会知道。
例如，S="abaaba"，那么T="#a#b#a#a#b#a#"。

把各个Ti处的回文半径存储到数组P，用P[i]表示以Ti为中心的回文长度。那么当我们求出所有的P[i]，取其中最大值就能找到最长回文子串：

T = # a # b # a # a # b # a #

P = 0 1 0 3 0 1 6 1 0 3 0 1 0

显然最长子串就是以P[6]为中心的"abaaba"。

优点：在插入"#"后，长度为奇数和偶数的回文都可以优雅地处理，利用此规律减少对数组P中某些元素的重复计算。

过程：

//

// start: find the longest palindromic substring in S

/************************************************************************/

/* method1: O(n^2)  find between each number                            */

/************************************************************************/

string longestPalindrome_BruteForce(string s)

{

    int size = s.size();

    if(size == 0 || size == 1)

        return s;

    if(size == 2)

    {

        return s.substr(0,1);  // string.substr(begin, length)   string(first, last)

    }

    int MaxLen = 0, longestBegin = 0;    

    for(size_t i = 1; i < size-1; i++)

    {

        int tmpLen = 1;

        while(i - tmpLen >= 0 && i + tmpLen < size && s[i-tmpLen] == s[i+tmpLen])

            tmpLen++;

        tmpLen--;

        if(tmpLen > MaxLen)

        {

            MaxLen = tmpLen;

            longestBegin = i - MaxLen;

        }        

    }

    return s.substr(longestBegin, MaxLen*2+1);  // str.substr(startpos, length);;

}

/************************************************************************/

/* method2: O(n^2)  Dynamic Programming                                 */

/************************************************************************/

const int MaxSize = 1000;

string longestPalindrome_DP(string s)

{

    int size = s.size();

    if(size == 0 || size == 1)  // string.substr(begin, length)   string(first, last)

        return s;  

    if(size == 2)

    {

        if(s[0] == s[1])

            return s;

        else

            return s.substr(0,1);

    }

    int MaxLen = 0, longestBegin = 0;

    bool flag[MaxSize][MaxSize];

    memset(flag, false, MaxSize*MaxSize*sizeof(bool));

    for(int j = 0; j < size; j++)

    {

        for(int i = 0; i < j; i++)  // j-i>=2

        {

            if(s[i] == s[j] && ((j-i<2) || flag[i+1][j-1]))  // 对每个元素赋值，j-i>=2时判断对称flag[i+1][j-1]，小于2时为两个元素，只要判断元素相等即可

            {

                flag[i][j] = true;

                int tmpSize = j - i + 1;

                if(tmpSize > MaxLen)

                {

                    MaxLen = tmpSize;

                    longestBegin = i;

                }

            } 

        }

        flag[j][j] = 1;

    }

    return s.substr(longestBegin, MaxLen);

}

// another DP

string longestPalindromeDP1(string s) {  

  int n = s.length();  

  int longestBegin = 0;  

  int maxLen = 1;  

  bool table[1000][1000] = {false};  

  for (int i = 0; i < n; i++) {  

    table[i][i] = true;  

  }  

  for (int i = 0; i < n-1; i++) {  

    if (s[i] == s[i+1]) {  

      table[i][i+1] = true;  

      longestBegin = i;  

      maxLen = 2;  

    }  

  }  

  for (int len = 3; len <= n; len++) {  

    for (int i = 0; i < n-len+1; i++) {  

      int j = i+len-1;  

      if (s[i] == s[j] && table[i+1][j-1]) {  

        table[i][j] = true;  

        longestBegin = i;  

        maxLen = len;  

      }  

    }  

  }  

  return s.substr(longestBegin, maxLen);  

} 

void test_longestPalindrome()

{

    string s1 = "abc1234543212345678909876543";

    string s2 = "abc123465432123456789";

    cout << "longestPalindrome_BruteForce: " << longestPalindrome_BruteForce(s2) << endl;

    cout << "longestPalindrome_DP: " << longestPalindrome_DP(s2) << endl;

}

// end

//