Longest Palindromic Substring

最新推荐文章于 2020-08-11 22:16:46 发布

佳悦

最新推荐文章于 2020-08-11 22:16:46 发布

阅读量229

点赞数

分类专栏： algorithms 文章标签：回文串动态规划 string

本文链接：https://blog.csdn.net/drunkpragrammer/article/details/78828647

版权

algorithms 专栏收录该内容

18 篇文章 0 订阅

订阅专栏

【Problem】

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"

【Thinking】

This article is for intermediate readers.

这篇文章是写给中间读者的。

It introduces the following ideas:Palindrome, Dynamic Programming and String Manipulation.

它介绍了下面几个想法:回文（指顺读和倒读都一样的词语）,动态规划和字符串处理。

Make sure you understand what a palindrome means。

确定你能够理解回文代表的含义。

A palindrome is a string which reads the same in both directions. For example, $”aba”$ is a palindome, $”abc”$ is not.

回文就是在不同方向能读取到同样的字符串。例如，"aba“是一个回文，"abc"不是。

Approach #1 (Longest Common Substring) [Accepted]

方法#1 （最长公共字串）[可通过]

Common mistake

常见错误

Some people will be tempted to come up with a quick solution, which is unfortunately flawed (however can be corrected easily):

有些人尝试提出快速解法，但是不幸运的是有缺陷（但是可以被很轻松的搞定）：

Reverse and become $S^{' }$ . Find the longest common substring between $S$ and $^{ }$ , which must also be the longest palindromic substring.

反转S并且成为S'. 找到在S和S'中最长的公共字串，就一定是最长的回文字串。

This seemed to work, let’s see some examples below.

这个看上去是有用的，让我们来看下下面的一些例子。

For example,

为了解决这个，每一次我们都去找最长公共字串的候选串。

we check if the substring’s indices are the same as the reversed substring’s original indices.

我们检查子字符串的下标是否和反转字符串原始下标一致。

If it is, then we attempt to update the longest palindrome found so far; if not, we skip this and find the next candidate.

如果一致，然后我们尝试更新至今找到的最长回文字符串；如果不是，我们跳过这个然后找寻下一个候选串。

This gives us an $O(n^2)$ Dynamic Programming solution which uses $O(n^2)$ space (could be improved to use $O (n)$ space).

这个给我们提供了O(n^2) 动态规划解法需要占用 O(n^2)的空间（可以提高到使用O(n)的空间）。

Please read more about Longest Common Substring here.

请点击这里阅读更多关于最长公共子串的内容。点击打开链接

（https://en.wikipedia.org/wiki/Longest_common_substring_problem）

动态规划法可以简单参照下一篇博文

Approach #3 (Dynamic Programming) [Accepted]

To improve over the brute force solution, we first observe how we can avoid unnecessary re-computation while validating palindromes. Consider the case $\textrm{''ababa''}$ . If we already knew that $\textrm{''bab''}$ is a palindrome, it is obvious that $\textrm{''ababa''}$ must be a palindrome since the two left and right end letters are the same.

We define $P (i, j)$ as following:

P (i, j) = {true, false, if the substring S i \dots S j is a palindrome otherwise.

Therefore,

\text{ and } S_i == S_j )

The base cases are:

P (i, i) = t r u e

S_i == S_{i+1} )

This yields a straight forward DP solution, which we first initialize the one and two letters palindromes, and work our way up finding all three letters palindromes, and so on...

Complexity Analysis

Time complexity : $O(n^2)$ . This gives us a runtime complexity of $O(n^2)$ .
Space complexity : $O(n^2)$ . It uses $O(n^2)$ space to store the table.

Additional Exercise

Could you improve the above space complexity further and how?

其实搞懂了动态规划法，这道题就可以开始写了。

因为暴力破解法是超出了时间限制，所以这里就不详细探讨截取每一个字串进行比较的方法。文末是暴力破解法和动态规划的c++代码。

这道题一共有94个测试用例。

比较典型的有：

现在当我程序出bug时，我就会自己用测试用例推导一遍程序，看看哪里有逻辑错误。

碰到bug，不要急，先把思路理清，实现按着思路来，哪里有问题改哪里，多改改就好了。

一直卡在如何辨别查找的最长公共字串是否是回文字串上？

一开始我认为找到最长公共字串的下标之间的规律即可，随便举了几个例子发现原字串最长的下标+反转子串最长的下标+1=子串的长度，但是测试的时候发现不仅有这个条件，还有反转子串最长子串的第一个字母等于原子串最长子串最后一个字母也成立。

下面是五个典型测试用例，用动态规划的思想，如果两个字母相等，则在左上角的基础上加1.

a	b	c	d	a
a	1	0	0	0	1
d	0	0	0	1	0
c	0	0	1	0	0
b	0	1	0	0	0
a	1	0	0	0	1




	size-i-1=j
	b	a	b	a	d
d	0	0	0	0	1
a	0	1	0	1	0
b	1	0	2	0	0
a	0	2	0	3	0
b	1	0	3	0	0

	a	b	b
b	0	1	1
b	0	1	2
a	1	0	0



					i=1 j=2
					j+1-longest=i

	c	c	d
d	0	0	1
c	1	1	0
c	0	2	0

暴力破解法（brute force）[Time Limited Exceeded]

#include<cstring>
#include <algorithm>
class Solution {
public:
    string longestPalindrome(string s) {
        string rs;
        string sub;
        int position=0;
        int maxlen=0;
        rs=s;
        reverse(s.begin(),s.end());
        for(int i=0;i<rs.length();i++)
        {
            for(int j=rs.length()-i;j>0;j--)
            {
                sub=rs.substr(i,j);
                if(s.find(sub)!=string::npos && maxlen<sub.length() && (s.find(sub)+i+j)==rs.length())
                {
                    maxlen=sub.length();
                    position=i;
                }
            }
        }
        sub=rs.substr(position,maxlen);
        return sub;
    }
};

动态规划(Dynamic Programming) [235ms]

#include<string>
class Solution {
public:
    string longestPalindrome(string s) {
        string rs=s;
        reverse(s.begin(),s.end());
        int size=s.length();
        if(size==1)
            return rs;
        if(size==0)
            return "";
        int dynamictable[size][size];
        int longest=0;
        int start=-1;
        for(int i=0;i<size;i++)
        {
            dynamictable[0][i]=(s[0]==rs[i])?1:0;
        }
         for(int i=1;i<size;i++)
        {
            dynamictable[i][0]=(rs[0]==s[i])?1:0;
            for(int j=1;j<size;j++)
            {
                    dynamictable[i][j]=(s[i]==rs[j])?dynamictable[i-1][j-1]+1:0;
            }
        }
        for(int i=0;i<size;i++)
        {
            for(int j=0;j<size;j++)
            {
                if((i+j+1==size || rs[j+1-dynamictable[i][j]]==s[i])&& dynamictable[i][j]>longest)
                {
                       longest=dynamictable[i][j];
                        start=j-longest+1;
                }
            }
              
            
        }
     return   rs.substr(start,longest);
    }
};

想对动态规划方法进行优化的同学，可以查看ider的博客从优化到再优化，最长公共子串

http://blog.iderzheng.com/longest-common-substring-problem-optimization/