动态规划——最长回文子串

1 问题描述

给出一个字符串S，求S的最长回文子串的长度。

2 状态转移思路

令dp[i][j]表示S[i]至S[j]所表示的子串是否是回文子串，是则为1，不是则为0。这样根据S[i]是否等于S[j]，可以把转移情况分为两类：

1. 若S[i]==S[j]，那么只要S[i+1]至S[j-1]是回文子串，S[i]至S[j]就是回文子串；反之则不是。
2. 若S[i]!=S[j]，那么S[i]至S[j]一定不是回文子串。

由此可以写出状态转移方程：

边界：dp[i][i]=1，dp[i][i+1]=(S[i]==S[i+1]) ? 1 : 0。

此外，还需注意的是：如果按照i和j从小到大的顺序来枚举子串的两个端点，然后更新dp[i][j]，会无法保证dp[i+1][j-1]已经被计算过，从而无法得到正确的dp[i][j]。解决的办法是：按照子串的长度和子串的初始位置进行枚举（因为考虑到边界情况表示的是长度为1和2的子串，且每次转移时都对子串的长度减了2）。

代码（可以达到O(n^2)的时间复杂度）

#include <cstdio>
#include <cstring>
const int MAXN=1010;
char S[MAXN];
int dp[MAXN][MAXN];
int main(){
    gets(S);
    int len = strlen(S),ans=1;
    memset(dp,0,sizeof(dp));  // 初始化dp数组
    for(int i=0;i<len;i++){  // 边界
        dp[i][i]=1;
        if(i<len-1){
            if(S[i]==S[i+1]){
                dp[i][i+1] = 1;
                ans=2;  // 初始化时注意当前最长回文子串的长度
            }
        }
    }
    // 状态转移方程
    for(int L=3;L<=len;L++){  // 枚举子串的长度
        for(int i=0;i+L-1<len;i++){  // 枚举子串的起始端点
            int j=i+L-1;  // 子串的右端点
            if(S[i]==S[j] && dp[i+1][j-1]==1){
                dp[i][j] = 1;
                ans = L;  // 更新最长回文子串长度
            }
        }
    }
    printf("%d\n",ans);
    return 0;
}

3 除了动态规划方法以外，用hash解决，能降低时间复杂度

 hash+二分的思路

这里的二分是对回文子串的长度大小进行二分

该算法的复杂度是O(nlogn)

#include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long LL;
const LL MOD = 1e9+7;  //  MOD为计算hash值时的模数
const LL P = 1e7+19;  // P为计算hash值时的进制数
const LL MAXN = 2e5+10;  // 字符串的最大长度
// powP[i]存放P^i%MOD, H1和H2分别存放str和rstr的hash值
LL powP[MAXN],H1[MAXN],H2[MAXN];
// init函数初始化为powP函数
void init() {
    powP[0] = 1;
    for(int i=1; i<MAXN; i++) {
        powP[i] = (powP[i-1]*P)%MOD;
    }
}
// calH函数计算字符串str的hash值
void calH(LL H[],string &str) {
    H[0] = str[0];  // H[0]单独处理
    for(int i=1; i<str.length(); i++)
        H[i] = (H[i-1]*P+str[i])%MOD;
}
// calSingleSubH计算H[i...j]
int calSingleSubH(LL H[],int i,int j) {
    if(i==0)
        return H[j];
    return ((H[j]-H[i-1]*powP[j-i+1])%MOD+MOD)%MOD;
}
// 对称点为i，字符串长len，在[left,right]里二分回文半径
// 寻找最后一个满足  hashL==hashR  的回文半径
// 等价于寻找第一个满足条件  hashL!=hashR  的回文半径，然后减1即可
// isEven当求奇回文时为0，当求偶回文时为1
int binarySearch(int left,int right,int len,int i,int isEven) {
    while(left<right) {
        int mid = (left+right)/2;
        // 左半子串hash值H1[H1L...H1R]，右半子串值H2[H2L...H2R]
        int H1L = i - mid + isEven,H1R = i;
        int H2L = len - left - (i+mid),H2R = len-left-(i+isEven);
        int hashL = calSingleSubH(H1,H1L,H1R);
        int hashR = calSingleSubH(H2,H2L,H2R);
        if(hashL!=hashR)
            right=mid;  // hash值不等，说明回文半径<=mid
        else
            left = mid + 1;  // hash值相等，说明回文半径>mid
    }
    return left-1;  // 返回最大回文半径
}
int main() {
    init();
    string str;
    getline(cin,str);
    calH(H1,str);
    reverse(str.begin(),str.end());  // 将字符串反转
    calH(H2, str);
    int ans = 0;
    // 奇回文
    for(int i=0; i<str.length(); i++) {
        // 二分上界为分界点i的左右长度的较小值加1
        int maxLen = min(i,(int)str.length()-1-i)+1;
        int k = binarySearch(0,maxLen,str.length(),i,0);
        ans = max(ans,k*2+1);
    }
    // 偶回文
    for(int i=0; i<str.length(); i++) {
        // 二分上界为分界点i的左右长度的较小值加1（注意左长为i+1）
        int maxLen = min(i+1,(int)str.length()-1-i)+1;
        int k = binarySearch(0,maxLen,str.length(),i,1);
        ans = max(ans,k*2);
    }
    printf("%d\n",ans);
    return 0;
}