FJUT3703 这还是一道数论题（二分 + hash + manacher 或者 STL + hash 或者 后缀数组 + hash）题解

Problem Description

最后来个字符串签个到吧，这题其实并不难，所需的算法比较基础，甚至你们最近还上过课。

为了降低难度，免得所有人爆零。这里给几个提示的关键字 ：字符串，回文，二分，哈希. 注意要对奇偶回文分开二分

这样还不会做，说明基础有所欠缺。

给你一个字符串A和一个字符串B,请你求一个满足以下要求的所有字符串中，最长的字符串C的长度：

1. C必须同时是A和B的子串，即A和B中都必须存在一个子区间和C长得一样

2. C必须是一个回文，即正过来读和反过来读都一样

Input

多组数据，请处理到EOF

每组数据包含，两行，每行都是仅由小写字符构成的字符串，代表A和B。

对于30%的数据。

保证|A|,|B|<=1000，且单个文件的字符总数小于10000

对于100%的数据

保证|A|,|B|<=100000，且单个文件的字符总数小于2e6

其中70%的数据答案为奇数哦

因为没有处理掉字符串尾巴上多余的'\r',所以为了防止读到'\r' 推荐使用scanf("%s");

链接

思路：

更新2.0：

旺神nb。发现A了之后就能看所有人代码了

终于找到Hash的O(n)找公共子串的方法了，直接用unordered_map储存所有满足长度的回文子串。unordered_map查询接近常数级，就是O（1），插入反正比map快，所以总体就是O（n）级。

然后就从7000ms瞬间降到1400ms

代码2.0我没有预处理成全奇回文，而是直接分类奇偶二分。显然我们可以优化一下，奇偶遍历存在与否时可以直接两步两步走，因为奇偶的回文中心刚好交错。然后我们假如先二分奇数，得到一个长度R，那么我二分偶数回文半径至少R / 2 + 1，否则没有意义。我们直接用unordered_map储存s串的回文答案，然后O（n）判断p中有没有，如果怕Hash冲突，可以再验算一边是否一样。

然后我发现时限变成4000ms了...7s的代码卡掉了...只能用2.0的代码过...

这道题后缀数组也能做，JQtxdy +

----------------代码1.0分割线（已T）----------------------------

按照旺神的思路来。

我是把串先按照Manacher处理成只有奇数回文，然后找到最大回文串R，显然最终答案只可能是R，R-2，R-4....那么我直接二分这个最终长度。然后用hash找是否存在这个长度的公共子串，但是我只会Hash的O（nlogn + m）写法啊。在T了几发之后发现题目时限又开大了，8000ms用7400ms擦过，旺神nb。

代码2.0：

#include<cmath>
#include<set>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include <iostream>
#include<algorithm>
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn =  + ;
const ull seed = ;
const int INF = 0x3f3f3f3f;
const int MOD = ;
char s[maxn], p[maxn], snew1[maxn];
int pos[maxn], num[maxn];
ull hs[maxn], hp[maxn], fac[maxn], q[maxn];
inline ull getHashP(int l, int r){
    return hp[r] - (l == ?  : hp[l - ]) * fac[r - l + ];
}
inline ull getHashS(int l, int r){
    return hs[r] - (l == ?  : hs[l - ]) * fac[r - l + ];
}
int lens, lenp, lenSnew;
int init(int len){
    int cnt = ;
    snew1[cnt] = '$';
    for(int i = ; i < len; i++){
        snew1[++cnt] = '#';
        snew1[++cnt] = s[i];
    }
    snew1[++cnt] = '#';
    snew1[++cnt] = '\0';
    return cnt;
}
int Manacher(){
    int cnt = init(lens);
    lenSnew = cnt;
    int id = , ans = -;
    for(int i = ; i < cnt; i++){
        if(pos[id] + id > i){
            pos[i] = min(pos[ * id - i], pos[id] + id - i);
        }
        else pos[i] = ;
        while(snew1[i - pos[i]] == snew1[i + pos[i]])
            pos[i]++;
        if(id + pos[id] < i + pos[i])
            id = i;
        ans = max(ans,pos[i] - );
    }
    return ans; //长度
}
bool mid(int l, int r, ull aim){
    while(l <= r){
        int m = (l + r) >> ;
        if(q[m] >= aim){
            if(q[m] == aim) return true;
            r = m - ;
        }
        else l = m + ;

    }
    return false;
}
unordered_map<ull, int> mp;
//$#a#a#a#0
bool checkJi(int len){
    mp.clear();
    for(int i = ; i + len -  < lenSnew; i += ){   //s
        if(pos[i] -  >= len){
            int R = len / ;
            int position = i /  - ;   //实际位置
            mp[getHashS(position - R, position + R)] = ;
        }
    }
    for(int i = ; i + len -  < lenp; i++){
        ull aim = getHashP(i, i + len - );
        if(mp.count(aim)) return true;
    }
    return false;
}
//$#c#a#a#a#a#0
bool checkOu(int len){
    mp.clear();
    for(int i = ; i + len -  < lenSnew; i += ){   //s
        if(pos[i] -  >= len){
            int R = len / ;
            int position = i /  - ;   //实际位置
            mp[getHashS(position - R + , position + R)] = ;
        }
    }
    for(int i = ; i + len -  < lenp; i++){
        ull aim = getHashP(i, i + len - );
        if(mp.count(aim)) return true;
    }
    return false;
}
int main(){
    fac[] = ;
    for(int i = ; i < ; i++)
        fac[i] = fac[i - ] * seed;
    while(scanf("%s%s", s, p) != EOF){
        lens = lenp = ;
        hs[] = hp[] = ;
        for(int i = ; s[i] != '\0'; i++){  //hash
            if(i == ) hs[i] = s[i];
            else hs[i] = hs[i - ] * seed + s[i];
            lens++;
        }
        for(int i = ; p[i] != '\0'; i++){
            if(i == ) hp[i] = p[i];
            else hp[i] = hp[i - ] * seed + p[i];
            lenp++;
        }

        int R = Manacher(); //马拉车返回s最大长度
        int l, r, ans = ;
        l = , r = R / ;
        while(l <= r){  //偶
            int m = (l + r) >> ;
            if(checkOu(m * )){
                l = m + ;
                ans = m * ;
            }
            else r = m - ;
        }
        l = ans / , r = R / ;
        while(l <= r){  //奇
            int m = (l + r) >> ;
            if(checkJi(m *  + )){
                l = m + ;
                ans = max(m *  + , ans);
            }
            else r = m - ;
        }
        printf("%d\n", ans);
    }
    return ;
}

代码：

#include<cmath>
#include<set>
#include<queue>
#include<cstdio>
#include<vector>
#include<cstring>
#include <iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const int maxn =  + ;
const ull seed = ;
const int INF = 0x3f3f3f3f;
const int MOD = ;
char s[maxn], p[maxn], snew1[maxn], snew2[maxn];
int pos[maxn], num[maxn];
ull hs[maxn], hp[maxn], fac[maxn], q[maxn];
inline ull getHashP(int l, int r){
    return hp[r] - (l == ?  : hp[l - ]) * fac[r - l + ];
}
inline ull getHashS(int l, int r){
    return hs[r] - (l == ?  : hs[l - ]) * fac[r - l + ];
}
int lens, lenp, lenSnew;
int init(int len){
    int cnt = ;
    snew1[cnt] = '$';
    for(int i = ; i < len; i++){
        snew1[++cnt] = '#';
        snew1[++cnt] = s[i];
    }
    snew1[++cnt] = '#';
    snew1[++cnt] = '\0';
    return cnt;
}
int Manacher(){
    int cnt = init(lens);
    lenSnew = cnt;
    int id = , ans = -;
    for(int i = ; i < cnt; i++){
        if(pos[id] + id > i){
            pos[i] = min(pos[ * id - i], pos[id] + id - i);
        }
        else pos[i] = ;
        while(snew1[i - pos[i]] == snew1[i + pos[i]])
            pos[i]++;
        if(id + pos[id] < i + pos[i])
            id = i;
        ans = max(ans,pos[i] - );
    }
    return ans; //长度
}
bool mid(int l, int r, ull aim){
    while(l <= r){
        int m = (l + r) >> ;
        if(q[m] >= aim){
            if(q[m] == aim) return true;
            r = m - ;
        }
        else l = m + ;

    }
    return false;
}
bool check(int len){
    int tol = ;
    for(int i = ; i + len -  < lenp; i++){    //p子串
        q[tol++] = getHashP(i, i + len - );
    }
    sort(q, q + tol);
    for(int i = ; i < lenSnew; i += ){  //找s
        if(pos[i] -  >= len){
            int R = len / ;
            int position = i /  - ;   //实际位置
            ull aim = getHashS(position - R, position + R);
            if(mid(, tol - , aim)){
                return true;
            }

        }
    }
    return false;
}
int main(){
    fac[] = ;
    for(int i = ; i < maxn; i++)
        fac[i] = fac[i - ] * seed;
    while(scanf("%s%s", snew1, snew2) != EOF){
        lens = , lenp = ;

        //改成全奇回文
        s[lens++] = '';
        for(int i = ; snew1[i] != '\0'; i++){
            s[lens++] = snew1[i];
            s[lens++] = '';
        }
        p[lenp++] = '';
        for(int i = ; snew2[i] != '\0'; i++){
            p[lenp++] = snew2[i];
            p[lenp++] = '';
        }

        hs[] = hp[] = ;
        for(int i = ; i < lens; i++){  //hash
            if(i == ) hs[i] = s[i];
            else hs[i] = hs[i - ] * seed + s[i];
        }
        for(int i = ; i < lenp; i++){
            if(i == ) hp[i] = p[i];
            else hp[i] = hp[i - ] * seed + p[i];
        }

        int cnt = lenSnew;
        int L = , R = Manacher(); //马拉车返回最大长度
        int l = , r = R / ; //R = 2 * r + 1
        int ans = ;
        while(l <= r){
            int m = (l + r) >> ;
            if(check( * m + )){
                ans =  * m + ;
                l = m + ;
            }
            else{
                r = m - ;
            }
        }
        printf("%d\n", ans / );
    }
    return ;
}