每日leetcode--（5）最长回文子序列（动态规划及manacher算法的实现和感悟）

最新推荐文章于 2024-05-30 18:30:18 发布

ssdut_209

最新推荐文章于 2024-05-30 18:30:18 发布

阅读量1.2w

点赞数 5

本文链接：https://blog.csdn.net/ssdut_209/article/details/81749308

版权

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。

示例 1：

输入: "babad"
输出: "bab"
注意: "aba"也是一个有效答案。

示例 2：

输入: "cbbd"
输出: "bb"

（1）DP

对于字符串str，假设dp[i,j]=1表示str[i...j]是回文子串，那个必定存在dp[i+1,j-1]=1。这样最长回文子串就能分解成一系列子问题，可以利用动态规划求解了。首先构造状态转移方程

上面的状态转移方程表示，当str[i]=str[j]时，如果str[i+1...j-1]是回文串，则str[i...j]也是回文串；如果str[i+1...j-1]不是回文串，则str[i...j]不是回文串。

初始状态

dp[i][i]=1
dp[i][i+1]=1 if str[i]==str[i+1]

上式的意义是单个字符，两个相同字符都是回文串。


#include <iostream>
#include <string>
using namespace std;

// https://www.cnblogs.com/mini-coconut/p/9074315.html
// 使用动态规划进行解题（略慢）O(n^2)
// 状态：A[i,j]表示以下标为i开头，以下标为j结尾的子串是否为回文串，如果是，就赋值为1，如果不是赋值为0
// 初始化：A[i,i]=1,
// 同时遍历输入字符串，对A[i,i+1]进行赋值
// 由于i必定小于等于j，所以整个二维动态规划相当于是对一个对角矩阵（也就是代码中的A）进行赋值。
// 状态转移方程：
// 若s[i]==s[j],则A[i,j] = A[i+1,j-1],即当两端的字符相等时，这个串是不是回文的，由中间部分决定。
// 若s[i] != s[j]，则A[i,j] = 0
int A[1000][1000];
class Solution {
public:
    string longestPalindrome(string s) {
        if(s=="")return "";
        memset(A,0,sizeof(A));
        int head = 0;
        int tail = 0;
        int max_len = tail-head + 1;
        string temp = s;
        for(int i=0;i<s.size();i++)
        {
            A[i][i] = 1;
        }
        for(int i = 0;i<s.size()-1;i++)
        {
            if(s[i]==s[i+1])
            {
                A[i][i+1] = 1;
                head = i;
                tail = i+1;
                max_len = 2;
            }
        }
        for(int k=2; k<s.size();k++)
        {
            for(int i = 0;i<s.size();i++)
            {
                int j = k+i;
                if(j>s.size()-1)break;
                if(s[i]==s[j])
                {
                    A[i][j] = A[i+1][j-1];
                    if(A[i][j]==1&&k+1>max_len)
                    {
                        max_len = k+1;
                        head = i;
                        tail = j;
                    }
                }
                else
                    A[i][j] = 0;
            }
        }
        return s.substr(head,tail+1-head);
        
    }
};


int main(int argc, const char * argv[]) {
    freopen("input.txt","r",stdin);
    int total;
    cin>>total;
    while(total--)
    {
        string s;
        cin>>s;
        Solution solu;
        cout<<solu.longestPalindrome(s)<<endl;
    }
    
    
    return 0;
}

（2）Manacher法

这是一个专门用作处理最长回文子串的方法，思想很巧妙，比较难以理解，这里直接借用了别人的讲解方法。其实主要思想是，把给定的字符串的每一个字母当做中心，向两边扩展，这样来找最长的子回文串，这个叫中心扩展法，但是这个方法还要考虑到处理abba这种偶数个字符的回文串。Manacher法将所有的字符串全部变成奇数个字符。

Manacher算法原理与实现

下面介绍Manacher算法的原理与步骤。

首先，Manacher算法提供了一种巧妙地办法，将长度为奇数的回文串和长度为偶数的回文串一起考虑，具体做法是，在原字符串的每个相邻两个字符中间插入一个分隔符，同时在首尾也要添加一个分隔符，分隔符的要求是不在原串中出现，一般情况下可以用#号。下面举一个例子：

（1）Len数组简介与性质

Manacher算法用一个辅助数组Len[i]表示以字符T[i]为中心的最长回文字串的最右字符到T[i]的长度，比如以T[i]为中心的最长回文字串是T[l,r],那么Len[i]=r-i+1。

对于上面的例子，可以得出Len[i]数组为:

Len数组有一个性质，那就是Len[i]-1就是该回文子串在原字符串S中的长度，至于证明，首先在转换得到的字符串T中，所有的回文字串的长度都为奇数，那么对于以T[i]为中心的最长回文字串，其长度就为2*Len[i]-1,经过观察可知，T中所有的回文子串，其中分隔符的数量一定比其他字符的数量多1，也就是有Len[i]个分隔符，剩下Len[i]-1个字符来自原字符串，所以该回文串在原字符串中的长度就为Len[i]-1。

有了这个性质，那么原问题就转化为求所有的Len[i]。下面介绍如何在线性时间复杂度内求出所有的Len。

（2）Len数组的计算

首先从左往右依次计算Len[i]，当计算Len[i]时，Len[j](0<=j<i)已经计算完毕。设P为之前计算中最长回文子串的右端点的最大值，并且设取得这个最大值的位置为po，分两种情况：

第一种情况：i<=P

那么找到i相对于po的对称位置，设为j，那么如果Len[j]<P-i，如下图：

那么说明以j为中心的回文串一定在以po为中心的回文串的内部，且j和i关于位置po对称，由回文串的定义可知，一个回文串反过来还是一个回文串，所以以i为中心的回文串的长度至少和以j为中心的回文串一样，即Len[i]>=Len[j]。因为Len[j]<P-i,所以说i+Len[j]<P。由对称性可知Len[i]=Len[j]。

如果Len[j]>=P-i,由对称性，说明以i为中心的回文串可能会延伸到P之外，而大于P的部分我们还没有进行匹配，所以要从P+1位置开始一个一个进行匹配，直到发生失配，从而更新P和对应的po以及Len[i]。

第二种情况: i>P

如果i比P还要大，说明对于中点为i的回文串还一点都没有匹配，这个时候，就只能老老实实地一个一个匹配了，匹配完成后要更新P的位置和对应的po以及Len[i]。

2.时间复杂度分析

Manacher算法的时间复杂度分析和Z算法类似，因为算法只有遇到还没有匹配的位置时才进行匹配，已经匹配过的位置不再进行匹配，所以对于T字符串中的每一个位置，只进行一次匹配，所以Manacher算法的总体时间复杂度为O(n)，其中n为T字符串的长度，由于T的长度事实上是S的两倍，所以时间复杂度依然是线性的。

下面是算法的实现，注意，为了避免更新P的时候导致越界，我们在字符串T的前增加一个特殊字符，比如说‘$’,所以算法中字符串是从1开始的。

//https://www.cnblogs.com/mini-coconut/p/9074315.html
// 根据自己的理解实现了manacher算法
// 虽然ac了但是代码还不够简洁，还需要进一步精简，待续。。。
#include <iostream>
using namespace std;

int A[2018];
class Solution {
public:
    string longestPalindrome(string s) {
        if(s=="")return "";
        int max_len = 2;
        int max_pos = 2;
        string temp = "$#";
        for(int i = 0;i<s.size();i++)
        {
            temp.append(1,s[i]);
            temp.append(1,'#');
        }
        memset(A,0,sizeof(A));
        A[1] = 1;
        int P = 1;
        int po = 1;
        for(int i = 2;i<temp.size();i++)
        {
            if(i<=P) //i和P的关系
            {
                int j = 2*po-i;
                if(A[j]<P-i) //A[j]和P-i的关系
                {
                    A[i] = A[j];
                }
                else
                {
                    //注意这里flag的初始值是P
                    int flag = P;
                    for(int k = P+1;k<temp.size();k++)
                    {
                        int sym = 2*i-k; //symmetric position for k according to i
                        if(sym<=0||temp[k]!=temp[sym])break;
                        flag = k;
                    }
                    int new_len = flag-i+1;
                    A[i] = new_len;
                    if(2*A[i]-1>max_len)
                    {
                        max_len = 2*A[i]-1;
                        max_pos = i;
                    }
                    if(flag>P)
                    {
                        P = flag;
                        po = i;
                    }
                }
            }
            else
            {
                // 注意这里flag的初始值是i
                int flag = i;
                for(int k = i+1;k<temp.size();k++)
                {
                    int sym = 2*i-k;
                    if(sym<=0||temp[k]!=temp[sym])break;
                    flag = k;
                }
                int new_len = flag-i+1;
                A[i] = new_len;
                if(2*A[i]-1>max_len)
                {
                    max_len = 2*A[i]-1;
                    max_pos = i;
                }
                if(flag>P)
                {
                    P = flag;
                    po = i;
                }
            }
        }
        //for(int i = 0;i<temp.size();i++)
        //    cout<<A[i]<<',';
        //cout<<endl;
        string s1 = temp.substr(max_pos-A[max_pos]+1,2*A[max_pos]-1);
        string ret = "";
        for(int i = 0; i<s1.size();i++)
        {
            if(s1[i]!='#')
            {
                ret.append(1,s1[i]);
            }
        }
        return ret;
    }
};


int main(int argc, const char * argv[]) {
    freopen("input.txt","r",stdin);
    // insert code here...
    int total = 0;
    cin>>total;
    while(total--)
    {
        string s;
        cin>>s;
       // cout<<s<<endl;
        Solution solu;
        cout<<solu.longestPalindrome(s)<<endl;
    }
    
}

相关知识参考链接：https://www.cnblogs.com/mini-coconut/p/9074315.html

ssdut_209

关注

5
点赞
踩
18

收藏

觉得还不错? 一键收藏
0
评论
每日leetcode--（5）最长回文子序列（动态规划及manacher算法的实现和感悟）

给定一个字符串 s，找到 s 中最长的回文子串。你可以假设 s 的最大长度为1000。示例 1：输入: "babad"输出: "bab"注意: "aba"也是一个有效答案。示例 2：输入: "cbbd"输出: "bb"（1）DP 对于字符串str，假设dp[i,j]=1表示str[i...j]是回文子串，那个必定存在dp[i+1,j-1]=1。这样最长回文子串就...
复制链接

扫一扫