方法一:时间O(N^2) 空间O(N^2)
// A dynamic programming solution for longest palindr.
// This code is adopted from following link
// http://www.leetcode.com/2011/11/longest-palindromic-substring-part-i.html
#include <stdio.h>
#include <string.h>
// A utility function to print a substring str[low..high]
void printSubStr( char* str, int low, int high )
{
for( int i = low; i <= high; ++i )
printf("%c", str[i]);
}
// This function prints the longest palindrome substring of str[].
// It also returns the length of the longest palindrome
int longestPalSubstr( char *str )
{
const int n = strlen( str ); // get length of input string
// table[i][j] will be false if substring str[i..j] is not palindrome.
// Else table[i][j] will be true
bool table[n][n];
memset( table, 0, sizeof( table ) );
// All substrings of length 1 are palindromes
int maxLength = 1;
for( int i = 0; i < n; ++i )
table[i][i] = true;
// check for sub-string of length 2.
int start = 0;
for( int i = 0; i < n-1; ++i )
{
if( str[i] == str[i+1] )
{
table[i][i+1] = true;
start = i;
maxLength = 2;
}
}
// Check for lengths greater than 2. k is length of substring
for( int k = 3; k <= n; ++k )
{
// Fix the starting index
for( int i = 0; i < n - k + 1 ; ++i )
{
// Get the ending index of substring from starting index i and length k
int j = i + k - 1;
// checking for sub-string from ith index to jth index iff str[i+1]
// to str[j-1] is a palindrome
if( table[i+1][j-1] && str[i] == str[j] )
{
table[i][j] = true;
if( k > maxLength )
{
start = i;
maxLength = k;
}
}
}
}
printf("Longest palindrome substring is: ");
printSubStr( str, start, start + maxLength - 1 );
return maxLength; // return length of LPS
}
写的简便些则如下:
string longestPalindrome(string &s)
{
const int n = s.size();
bool f[n][n];
memset(f,0,sizeof(f));
int max_len = 1,start = 0;
for(int i = 0; i < n;++i)
{
f[i][i] = true;
for(int j = 0; j < i;++j)
{
f[j][i] = (s[j]==s[i] && (i-j<2 || f[j+1][i-1]));
if(f[j][i] && max_len < i-j+1)
{
max_len = i-j+1;
start = j;
}
}
}
return s.substr(start,max_len);
}
方法二:时间O(N^2) 空间O(1)
// A O(n^2) time and O(1) space program to find the longest palindromic substring
#include <stdio.h>
#include <string.h>
// A utility function to print a substring str[low..high]
void printSubStr(char* str, int low, int high)
{
for( int i = low; i <= high; ++i )
printf("%c", str[i]);
}
// This function prints the longest palindrome substring (LPS)
// of str[]. It also returns the length of the longest palindrome
int longestPalSubstr(char *str)
{
int maxLength = 1; // The result (length of LPS)
int start = 0;
int len = strlen(str);
int low, high;
// One by one consider every character as center point of
// even and length palindromes
for (int i = 1; i < len; ++i)
{
// Find the longest even length palindrome with center points
// as i-1 and i.
low = i - 1;
high = i;
while (low >= 0 && high < len && str[low] == str[high])
{
if (high - low + 1 > maxLength)
{
start = low;
maxLength = high - low + 1;
}
--low;
++high;
}
// Find the longest odd length palindrome with center
// point as i
low = i - 1;
high = i + 1;
while (low >= 0 && high < len && str[low] == str[high])
{
if (high - low + 1 > maxLength)
{
start = low;
maxLength = high - low + 1;
}
--low;
++high;
}
}
printf("Longest palindrome substring is: ");
printSubStr(str, start, start + maxLength - 1);
return maxLength;
}
http://leetcode.com/2011/11/longest-palindromic-substring-part-i.html
方法三:时间O(N) 空间O(N)
// Transform S into T.
// For example, S = "abba", T = "^#a#b#b#a#$".
// ^ and $ signs are sentinels appended to each end to avoid bounds checking
string preProcess(string s) {
int n = s.length();
if (n == 0) return "^$";
string ret = "^";
for (int i = 0; i < n; i++)
ret += "#" + s.substr(i, 1);
ret += "#$";
return ret;
}
string longestPalindrome(string s) {
string T = preProcess(s);
int n = T.length();
int *P = new int[n];
int C = 0, R = 0;
for (int i = 1; i < n-1; i++) {
int i_mirror = 2*C-i; // equals to i' = C - (i-C)
P[i] = (R > i) ? min(R-i, P[i_mirror]) : 0;
// Attempt to expand palindrome centered at i
while (T[i + 1 + P[i]] == T[i - 1 - P[i]])
P[i]++;
// If palindrome centered at i expand past R,
// adjust center based on expanded palindrome.
if (i + P[i] > R) {
C = i;
R = i + P[i];
}
}
// Find the maximum element in P.
int maxLen = 0;
int centerIndex = 0;
for (int i = 1; i < n-1; i++) {
if (P[i] > maxLen) {
maxLen = P[i];
centerIndex = i;
}
}
delete[] P;
return s.substr((centerIndex - 1 - maxLen)/2, maxLen);
}
http://leetcode.com/2011/11/longest-palindromic-substring-part-ii.html