力扣5. 最长回文子串_给字符串排序，求回文子串数量最多 力扣

1.题目

给你一个字符串 s，找到 s 中最长的回文子串。题目链接

示例 1：
输入：s = "babad"
输出："bab"
解释："aba" 同样是符合题意的答案。

示例 2：
输入：s = "cbbd"
输出："bb"
1
2
3
4
5
6
7
8

2.暴力求解+优化

思路：求字符串中的最长回文子串，那么可以拆分成：遍历判断该字符串的所有子串是否是回文串，然后再找出最长的回文子串。这样的做法是暴力求解，基本是会超时的。那么进行一定的优化，在遍历子串时，如果该子串的长度小于目前已知的最长回文子串的长度，那么这个子串就无需判断了，因为就算它是回文串，那也不是最长的，求出来没有用。

class Solution {
public:
    bool ishuiwen( const string &s,int start,int end)//判断是否是回文串
    {//两个指针分别指向两端，向中间靠近
        while(start<=end)
        {
            if(s[start]==s[end])
            {
                start++;
                end--;
            }
            else
            return false;
        }
        return true;
    }

    string longestPalindrome(string s) {

        int len=s.size();
        int maxlen=0;//记录最长回文串的长度
        int index=0;//记录最长回文串的起点位置
        
        for(int i=0;i<len;i++)
        {
            for(int j=i;j<len;j++)//截取子串，判断是否是回文串
            {
                if(j-i+1<maxlen)//这里做了优化，如果子串的长度没有最长的回文串长，那么就跳过
                continue;
                if(ishuiwen(s,i,j))//如果是回文串，则比较长度
                {
                    int l=j-i+1;
                    if(l>maxlen)
                    {
                        index=i;
                        maxlen=l;
                    }
                }
            }     
        }
        return s.substr(index,maxlen);  
    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

3.动态规划

思路：对于一个回文串而言，如果长度大于2，那么将首位两个字母去除之后，它仍然是一个回文串。例如“abcba",如果已经知道了”bcb"是回文串，那么"abcba"一定也是回文串，因为它的首尾字母都是”a"。
那么根据上面的思路，用dp[i][j]表示字符串s的第i到第j个字母组成的子串是否是回文串。
$$dp[i][j]=\{\begin{array}{l}true，如果子串s[i,j]是回文串\\ false，其他情况\end{array}$$
这里的其他情况包括：

• s[i,j]不是回文串
• i>j,此时s[i,j]不存在

那么就可写出状态转移方程
dp[i][j]=dp[i+1][j-1]&&(s[i]==s[j])
也就是说，只有 s[i+1:j-1]s[i+1:j−1] 是回文串，并且 s 的第 i 和 jj个字母相同时，s[i:j]才会是回文串。
注意：在状态转移方程中，我们是从长度较短的字符串向长度较长的字符串进行转移的，因此一定要注意动态规划的循环顺序。

class Solution {
public:
    string longestPalindrome(string s) {
        int len=s.size();
        if(len<2)
        {
            return s;
        }
        int maxlen=1;
        int begin=0;
        bool dp[1005][1005];

        for(int i=0;i<len;i++)//每一个单独的字母都是回文串
        {
            for(int j=0;j<len;j++)
            dp[i][j]=true;
        }
        
        for(int j=1;j<len;j++)
        {
            for(int i=0;i<j;i++)
            {
                if(s[i]!=s[j])
                {
                    dp[i][j]=false;
                }
                else
                {
                    if(j-i<3)
                    {
                        dp[i][j]=true;
                    }
                    else
                    {
                        dp[i][j]=dp[i+1][j-1];
                    }
                }

                if(dp[i][j]&&j-i+1>maxlen)
                {
                    maxlen=j-i+1;
                    begin=i;
                }
            }
        }
        return s.substr(begin,maxlen);

    }
};
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49