【bzoj2342】[Shoi2011]双倍回文

最新推荐文章于 2020-06-18 15:56:16 发布
最新推荐文章于 2020-06-18 15:56:16 发布
阅读量1.8k 收藏
点赞数 3
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/czysjr/article/details/42110695
版权

【题意】

定义 双倍回文 为 一个回文串套一个回文串， 问一个串中的最长双倍回文串。


【题解】

首先manacher扫一遍是必须的，（注意如果把原串每两个字符中间加一个字符那样扫manacher一定要扫够2 * n 啊， 注意边界 s[1] 和 s[2 * n + 1] 都要赋值为'*', 开始因此WA了一次）。

接下来的做法就很多啦，，

下面看看要求的是什么：

显然要枚举每一个 对称轴 x，然后对于每个 x， 要找到一个最大的 y，满足

y - f[y] <= x   &&

y <= x + f[x] / 2

考虑从小到大地枚举 x , 这时候只要把 y 按照 y - f[y] 排序， 就可以单调地加入 y 了！

接下来要做的就是 在当前满足第一个条件的 y 的集合里 找到一个最大的 y ,  使得它 <= x + f[x] / 2。

丢到set里当然就可以了。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#include <set>
#define MAXN 1000005
using namespace std;
int n, p[MAXN], f[MAXN], ans, now, q[MAXN];
char s[MAXN];
set <int> la;
bool cmp(int a, int b){return a - f[a] < b - f[b];}
int main()
{
    scanf("%d", &n);
    scanf("%s", s + 1);
    for(int i = n; i; i --)s[i * 2] = s[i], s[i * 2 - 1] = '*';
    s[0] = '#'; s[2 * n + 1] = '*';
    int k = 0;
    for(int i = 2; i <= 2 * n + 1; i ++){
        if(k + p[k] - 1 < i)p[i] = 1;
        else p[i] = min(p[2 * k - i], k + p[k] - i);
        while(s[i + p[i]] == s[i - p[i]])p[i] ++;
        if(i + p[i] > k + p[k])k = i;  
    }
    for(int i = 1; i <= n; i ++)f[i] = (p[i * 2 + 1] - 1) / 2;
    for(int i = 1; i <= n; i ++)q[i] = i;
    sort(q + 1, q + n + 1, cmp);
    int lala = 1;
    for(int i = 1; i <= n; i ++){
        while(lala <= n && q[lala] - f[q[lala]] <= i)la.insert(q[lala]), lala ++;
        set <int> :: iterator tt = la.upper_bound(i + f[i] / 2);
        if(tt != la.begin())ans = max(ans, (*--tt - i) * 4);
    }cout << ans << endl;
    return 0;
}

考虑我们是要维护一个数列， 每次询问小于等于一个值 的 最大值是多少。

可不可以不开平衡树？


考虑用树状数组， 只可以维护小于一个值的数有多少个， 知道了这个以后二分一下不就可以确定最大值的位置了吗， 或者用类似倍增一样的方法也可以搞上去。

但是复杂度是 n log² n 的。 网上有人说由于某些奇特性质可以做到 n log n， 似乎很玄妙我没有懂。

倍增版

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define lowbit(x) x & (-x)
#define MAXN 1000005
using namespace std;
int n, p[MAXN], f[MAXN], ans, now, q[MAXN], a[MAXN];
char s[MAXN];
void insert(int x){for(; x <= n; x += lowbit(x))a[x] ++;}
int find(int x){int ans = 0; for(; x; x -= lowbit(x))ans += a[x]; return ans;}
int ask(int x){
    int t = 0;
    for(int i = 19; i >= 0; i --)if(t + (1<<i) <= n && a[t + (1<<i)] < x)
        t += (1<<i), x -= a[t];
    return t + 1;    
}
int Ask(int x){return ask(find(x));}
bool cmp(int a, int b){return a - f[a] < b - f[b];}
int main()
{
    scanf("%d", &n);
    scanf("%s", s + 1);
    for(int i = n; i; i --)s[i * 2] = s[i], s[i * 2 - 1] = '*';
    s[0] = '#'; s[2 * n + 1] = '*';
    int k = 0;
    for(int i = 2; i <= 2 * n + 1; i ++){
        if(k + p[k] - 1 < i)p[i] = 1;
        else p[i] = min(p[2 * k - i], k + p[k] - i);
        while(s[i + p[i]] == s[i - p[i]])p[i] ++;
        if(i + p[i] > k + p[k])k = i;  
    }
    for(int i = 1; i <= n; i ++)f[i] = (p[i * 2 + 1] - 1) / 2;
    for(int i = 1; i <= n; i ++)printf("%d ", f[i]);
    for(int i = 1; i <= n; i ++)q[i] = i;
    sort(q + 1, q + n + 1, cmp);
    int lala = 1;
    for(int i = 1; i <= n; i ++){
        while(lala <= n && q[lala] - f[q[lala]] <= i)insert(q[lala ++]);
        ans = max(ans, Ask(i + f[i] / 2) - i);
    }cout << ans * 4 << endl;
    return 0;
}

二分版

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define lowbit(x) x & (-x)
#define MAXN 1000005
using namespace std;
int n, p[MAXN], f[MAXN], ans, now, q[MAXN], a[MAXN];
char s[MAXN];
void insert(int x){for(; x <= n; x += lowbit(x))a[x] ++;}
int find(int x){int ans = 0; for(; x; x -= lowbit(x))ans += a[x]; return ans;}
int Ask(int x){
    int l = find(x), r = x, f = l;
    while(l + 1 < r){
        int mid = l + r >> 1;
        if(find(mid) < f)l = mid + 1;
        else r = mid;
    }if(find(l) == f)return l; return r;
}
bool cmp(int a, int b){return a - f[a] < b - f[b];}
int main()
{
    scanf("%d", &n);
    scanf("%s", s + 1);
    for(int i = n; i; i --)s[i * 2] = s[i], s[i * 2 - 1] = '*';
    s[0] = '#'; s[2 * n + 1] = '*';
    int k = 0;
    for(int i = 2; i <= 2 * n + 1; i ++){
        if(k + p[k] - 1 < i)p[i] = 1;
        else p[i] = min(p[2 * k - i], k + p[k] - i);
        while(s[i + p[i]] == s[i - p[i]])p[i] ++;
        if(i + p[i] > k + p[k])k = i;  
    }
    for(int i = 1; i <= n; i ++)f[i] = (p[i * 2 + 1] - 1) / 2;
    for(int i = 1; i <= n; i ++)q[i] = i;
    sort(q + 1, q + n + 1, cmp);
    int lala = 1;
    for(int i = 1; i <= n; i ++){
        while(lala <= n && q[lala] - f[q[lala]] <= i)insert(q[lala ++]);
        ans = max(ans, Ask(i + f[i] / 2) - i);
    }cout << ans * 4 << endl;
    return 0;
}

嗯， 这样跑出来的确可以比 set 快一点不过 log² 的复杂度还是不太优美啊，，


换一种思路呢？ 再回顾一下要求的东西：

最大的y ， 满足：

y + f[y] >= x &&

y >= x - f[x] / 2

或者等同于：

y - f[y] <= x &&

y <= x + f[x] / 2

刚才一直是在考虑在保证条件 1 的情况下 条件 2 的最大值， 如果来保证条件 2 呢？

鉴于上面两组式子实质是一样的， 这里统一考虑第二组。保证条件2 即 当 y 的上界确定后， 再看第一个条件， 如果从小到大地扫一遍 x， y可以取的值是越来越少的， 而且如果 y 在之前x = i 时 且满足条件 2 的时候不可取， 那么 y 在 x = i + t 且满足条件2 的时候一定也是不可取的（显然）。 于是？ 用一个简单的并查集维护一下就好啦！！

复杂度 n log n

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define MAXN 1000005
using namespace std;
int n, p[MAXN], f[MAXN], ans, now, fat[MAXN];
char s[MAXN];
int find(int x){return fat[x] == x ? x : fat[x] = find(fat[x]);}
int main()
{
    scanf("%d", &n);
    scanf("%s", s + 1);
    for(int i = n; i; i --)s[i * 2] = s[i], s[i * 2 - 1] = '*';
    s[0] = '#'; s[2 * n + 1] = '*';
    int k = 0;
    for(int i = 2; i <= 2 * n + 1; i ++){
        if(k + p[k] - 1 < i)p[i] = 1;
        else p[i] = min(p[2 * k - i], k + p[k] - i);
        while(s[i + p[i]] == s[i - p[i]])p[i] ++;
        if(i + p[i] > k + p[k])k = i;  
    }
    for(int i = 1; i <= n; i ++)f[i] = (p[i * 2 + 1] - 1) / 2;
    for(int i = 1; i <= n; i ++)fat[i] = i;
    for(int i = 1; i <= n; i ++){
        for(now = find(i - f[i] / 2); now + f[now] < i; now = fat[now])
            fat[now] = find(now + 1);    
        ans = max(ans, i - now);
    }
    cout << ans * 4<<endl;
    return 0;
}


最后， status里那些 100ms -- 的是怎么做到的呢？

n² 暴力 加一个最优性剪枝 ！！ 就可以做到 100ms 一下了。

不过这个是很容易出数据卡掉的， 所有的字母都一样就好了。

不过这不失为一个骗分的很好方法啊。

#include <iostream>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <cstring>
#define MAXN 1000005
using namespace std;
int n, p[MAXN], f[MAXN], ans;
char s[MAXN];
int main()
{
    scanf("%d", &n);
    scanf("%s", s + 1);
    for(int i = n; i; i --)s[i * 2] = s[i], s[i * 2 - 1] = '*';
    s[0] = '#'; s[2 * n + 1] = '*';
    int k = 0;
    for(int i = 2; i <= 2 * n + 1; i ++){
        if(k + p[k] - 1 < i)p[i] = 1;
        else p[i] = min(p[2 * k - i], k + p[k] - i);
        while(s[i + p[i]] == s[i - p[i]])p[i] ++;
        if(i + p[i] > k + p[k])k = i;  
    }
    for(int i = 1; i <= n; i ++)f[i] = (p[i * 2 + 1] - 1) / 2;
    for(int i = 1; i <= n; i ++)
        for(int j = f[i] / 2; j && j * 4 > ans; j --)
            if(f[i - j] >= j && f[i + j] >= j)ans = max(ans, j * 4);
    cout << ans << endl;
    return 0;
}

大致跑出来的时间对比：
                算法ProblemResultMemoryTimeCode_Length
暴力剪枝2342Accepted10060 kb92 ms936 B
并查集2342Accepted13968 kb112 ms1111 B
树状数组+二分2342Accepted17872 kb408 ms1614 B
树状数组+倍增2342Accepted17872 kb556 ms1543 B
set2342Accepted25588 kb972 ms1293 B


【技巧总结】

虽然是一道很水的题， 但是感觉思维的过程还是很值得借鉴的。

一般在做一道题的时候， 如果思维的深度不够的话 会想到一些 用稍微复杂一些的东西来维护的方法， 时间复杂度与编程复杂度皆较高（不考虑用STL水过去）；反之， 越深入地思考到问题的本质越能发现一些简单高效的精妙方法， 令人大呼机智。

另外， 一些基础的东西要形成模块， 这样在遇到 一类问题的时候都可以很快地 调用起它， 不然很多看似学会了的东西仍 无法自主应用到做题中。

还有一点是在做题的时候的反方向思考。 这道题最后的并查集方法如果 式子列的和上面方法一样的话就要从 大的往小的扫（当然把式子反过来列也可以解决这个问题）， 为什么必须反过来呢？ 因为并查集实现的是把集合合并， 或者说是把可选的变得越来越少， 在第一组式子的第一个式子中 只有当 x 越来越小， y 的可行解才会越来越少， 这时候才可以维护。 这便又回到了 对算法的深入理解上面，比如并查集， bzoj 1015 就是很显然的要反向处理， 因为这样才可以让联通块越来越少。

再做一些题以后 我要把每个简单算法或数据结构都进行一个系统的总结。

czysjr
关注
[SHOI2011]双倍回文
C202044zxy的博客
02-06 172
一、题目 点此看题 二、解法 可以先建出回文自动机，这道题我们需要维护一个transtranstrans指针，表示不超过该回文串12\frac{1}{2}21​的最长回文后缀。 建自动机的时候，我们先判断该点的长度是否不大于222，是的话transtranstrans就是failfailfail，否则先拿到父亲的transtranstrans，然后看能不能再两边加，还有加之后的长度的两倍不能大于该...
【BZOJ】2342: [Shoi2011]双倍回文-manacher&set
远行客
12-09 210
一维排序，一维二分
[Shoi2011]双倍回文
dilei7762的博客
11-25 168
Description Input 输入分为两行，第一行为一个整数，表示字符串的长度，第二行有个连续的小写的英文字符，表示字符串的内容。 Output 输出文件只有一行，即：输入数据中字符串的最长双倍回文子串的长度，如果双倍回文子串不存在，则输出0。 Sample Input 16 ggabaabaabaaball Sa...
bzoj2342【SHOI2011】双倍回文
AaronPolaris
05-25 3300
manacher+set
BZOJ 2565 最长双回文串 Hash+二分
世界
02-24 2304
题目大意：给定一个字符串，求一个最长的子串，该字串可以分解为两个回文子串 傻逼的我又忘了Manacher怎么写了= = 无奈Hash+二分吧 首先将字符串用分隔符倍增，然后求出以每个点为中心的最长回文半径 然后考虑两个回文串怎么合并成一个 我们发现图中以i为中心的回文串和以j为中心的回文串合并后长度恰好为(j-i)*2 能合并的前提是以两个点为中心的回文串有交点 那么对于每个j
[回文树][BZOJ2160][国家集训队]拉拉队排练
EZ_TJY的博客
01-25 1865
Description 艾利斯顿商学院篮球队要参加一年一度的市篮球比赛了。拉拉队是篮球比赛的一个看点，好的拉拉队往往能帮助球队增加士气，赢得最终的比赛。所以作为拉拉队队长的楚雨荨同学知道，帮助篮球队训练好拉拉队有多么的重要。拉拉队的选拔工作已经结束，在雨荨和校长的挑选下，nnn位集优秀的身材、舞技于一体的美女从众多报名的女生中脱颖而出。这些女生将随着篮球队的小伙子们一起，和对手抗衡，为艾利斯顿篮...
BZOJ 5384 有趣的字符串题（区间本质不同回文串数量）
Freopen的博客
06-18 1600
题意： 多次求区间本质不同回文串数量。 我们知道区间本质不同子串个数是SAM+LCT+BIT。 所以区间本质不同回文串个数就是PAM+SegmentTree+BIT。 为什么可以搏一搏LCT变线段树呢？ 因为PAM同时有着组合border的离谱性质。 套用区间本质不同子串个数的做法。 那么我们需要离线后移动右端点RRR，然后更新一系列PAM上的节点的最后一次出现的时间并且在BIT上维护关于[L,R][L,R][L,R]内的本质不同回文串个数。 考虑PAM上一条链，满足每个祖先都是后代的回文后缀，也就一定是b
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
03-17
CTSC 2011 无穷图的桥(BZOJ 2307) 题解.ppt
2342: [Shoi2011]双倍回文
Tgotp的博客
02-26 305
并查集 + manacher看到回文串很容易想到了马拉车首先发现双倍回文既然是4得倍数，那么其中心一定是添加得符号。同样，他的一半得中心也一样是添加得符号。考虑枚举双倍回文中心。先处理出他的回文串长度，因为其左右对称，那么只用考虑他的左边最长回文串长度。很容易知道只要满足p[j] &gt;= i - j 即可保证左边就可以满足j为双倍回文中四分之一的点。并且因为双倍回文中心是不断递增，那么一个j不...
BZOJ2342 Shoi2011 双倍回文 【Manacher】
Dream_maker的博客
06-25 345
BZOJ2342 Shoi2011 双倍回文 Description Input 输入分为两行，第一行为一个整数，表示字符串的长度，第二行有个连续的小写的英文字符，表示字符串的内容。 Output 输出文件只有一行，即：输入数据中字符串的最长双倍回文子串的长度，如果双倍回文子串不存在，则输出0。 Sample Input 16 ggabaabaabaaball ...
bzoj2342（双倍回文）
zhhx2001的博客
08-10 523
本来需要set，并查集等数据结构优化来着，被我暴力水过了。。。 双倍回文，反正肯定要跑一遍manacher 对于每一个#位置，在i-p【i】/2~i之间枚举找到一个最小的i，使得i+p【i】>i,就是说，在它左边属于回文范围内找到一个最长的回文，保证要挨着i，因为在i的回文p【i】范围内，所以右边和左边对称，光处理左边即可 #include #include #include
bzoj2342 [Shoi2011]双倍回文 （回文树）
nbl97
09-10 206
题意： 在字符串s中寻找一个最长字串，这个子串必须是回文串并且这个字串的前半部分也是回文串。这个最长字串长度是4的倍数。 分析： 对于结点u，它的fail结点就是一个最长回文后缀，再fail一下，就又是一个短了一些的回文后缀，以此类推。对于u，我们只需要一直往上fail，看有没有一个fail结点长度是u的一半，有的话就找到了一个。 将这个过程反向过来，建立一个fail的树，从根节点dfs一...
BZOJ2342: [Shoi2011]双倍回文【Manacher】
yywyzdzr
05-07 1387
题意： 记字符串A。A反转过来是B。在给定的一个字符串里找到最长的形如ABAB的子串。这个子串称为双倍回文。   考虑用Manacher算法。（不会的自行google即可呃） 首先每个字符之间加一个分隔符#。然后跑一遍Manacher得到p数组。 拿字符串abbaabba举例子。如图。 然后我们从小到大开始枚举中心点i。 因为从i往右扩展的最远的地方是r=i+p[i]-1。那么我
回文树(回文自动机) - BZOJ 3676 回文串
weixin_33816300的博客
08-19 102
  BZOJ 3676 回文串 Problem's Link:  http://www.lydsy.com/JudgeOnline/problem.php?id=3676   Mean:  略 analyse: 由于构造完回文自动机后，len[i]表示第i个回文串的长度，cnt[i]表示第i个回文串出现的次数，只需两者相...
[BZOJ2342][Shoi2011]双倍回文（manacher）
zyf2000
12-19 856
题目描述传送门题解这道题非常有趣的是，要将一个字符串劈开两次都是回文串。 实际上manacher了之后对于每一个大中心暴力找小中心就可以了，因为只有26个字符暴力是无法卡掉的。不过如果时间复杂度科学的话貌似可以写平衡树或者可持久化线段树之类的东西。代码#include<iostream> #include<cstring> #include<cstdio> using namespace std;
bzoj.org俄罗斯方块
最新发布
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。其中包括了很多有趣的游戏算法问题，比如Puzzle，Tetris等。 而bzoj.org俄罗斯方块就是在该平台上的一个经典的俄罗斯方块游戏。在该游戏中，玩家需要控制方块不断向下移动，直到方块落到底部或者与其他方块重叠。游戏过程中，玩家可以通过旋转和移动方块来调整方块的位置，使其能够合理地落下。当一行方块被填满时，该行会被清除，并获得相应的分数。 bzoj.org俄罗斯方块不仅仅是一款游戏，更是一个很好的算法练习平台，你可以通过该游戏来学习和研究游戏算法问题。
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值