leetcode（5）—— Longest Palindromic Substring（最长回文子串）

longest-palindromic-substring

法1：暴力搜索（但会超时）

遍历全部子串（n+(n−1)+…+1=n(1+n)2），逐一判断：

bool isPalindromic(string s)
{
int n = s.size();
int i = 0;
while (i < n - 1 - i)
{
if (s[i] != s[n - 1 - i])
return false;
++i;
}
return true;
}

class Solution
{
public:
string longestPalindrome(string s)
{
int max_len = 0;
int idx = 0;

int i, j;
for ( i = 0; i < s.size() - 1; ++i)
{
for (j = i + 1; j < s.size(); ++j)
{
if (isPalindromic(s.substr(i, j - i + 1)) && j - i + 1> max_len)
{
max_len = j - i + 1;
idx = i;
}
}
}

return s.substr(idx, max_len);
}
};

但会超时，不可取。

法2：动态规划

暴力搜索产生大量重复判断，也即动态规划中的重叠子问题，解决重叠子问题，自然跑不了使用动态规划。

dp[i][j]：表示子字符串 s[i:j] 是否为回文；

初始化 dp[i][i] == true（自己到自己，单独的字符作为子串）, dp[i][i-1] == true，其余为false

dp[i][j] == (s[i] == s[j] && (dp[i+1][j-1]))

class Solution
{
public:
string longestPalindrome(string s)
{
bool dp[1000][1000];
memset(dp, 0, sizeof(dp));
int n = s.size();
dp[0][0] = true;

for (int i = 1; i < n; ++i)
{
dp[i][i] = true;
dp[i][i-1] = true;
}

int lft = 0, rgt = 0;
for (int k = 2; k <= n; ++k)
{
for (int i = 0; i <= n-k; ++i)       // 注意：是可以取到 n-k 的，(n-1)-(n-k)+1 == k
{
if (s[i] == s[i+k-1] && dp[i+1][i+k-2])
{
dp[i][i+k-1] = true;
if (rgt-lft + 1 < k)
{
lft = i;
rgt = i+k-1;
}
}
}
}
return s.substr(lft, rgt-lft+1);
}
};

References

[1] LeetCode:Longest Palindromic Substring 最长回文子串