Codeforces 827 E. Rusty String(FFT + 字符串 + FFT的一个小优化)

最新推荐文章于 2022-10-28 00:31:20 发布
最新推荐文章于 2022-10-28 00:31:20 发布
阅读量230 收藏 1
点赞数
分类专栏： FFT
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hddddh/article/details/119188890
版权

字符串处理 快速傅里叶变换 周期性检测 算法优化 字符匹配
关键词由CSDN通过智能技术生成

链接：E. Rusty String

题意：

给出一个字符串，只包含三种字符 V, K , ?。? 可以替换为 V 或 K，求字符串可能的周期有哪些。

思路：

  1. 对于该字符串，如果所有的字符往右移动 t 位后都与原来相同 ， 那么它就可以以 t 为周期。所以我们对于每一个字符都计算出右移后与原来形同的步数 ， 也就是所有相同字符之间位置的两两之差，可以用FFT求出 。 如果最后所有字符都可以移动 k 位与原来形同，k就可能是周期。但这里存在问号，可能存在一种情况 S i ≠ S i + 2 t S_i\ne S_{i+2t} Si​​=Si+2t​,但是 S i + t = ? S_{i+t} = ? Si+t​=?,这样就会把 t 当成周期，对于这种情况 2t 不是字符串的周期 ， 所以我们对于不是周期的 t 把它的因子也排除掉就好了。
  2. 我们也可以反着做 ， 如果 S i ≠ S i + t S_{i} \ne S_{i+t} Si​​=Si+t​，那么 t 肯定不是周期 ， 所以我们用 FFT 求出每个字符右移 t 位后与本身不同的所有 t 。其实就是 V 和 K 配对 ， K 和 V 配对。最后把这些 k 的因子也去掉就好了。

代码：

方法1：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e6 + 5;
const int num = 200002;
const double Pi = acos(-1.0);
int r[maxn];
int vis[maxn];
int T, n;
char s[maxn];
int cnt[maxn];
struct Complex{
    double x, y;
    Complex(double xx = 0, double yy = 0) : x(xx), y(yy) {}
    Complex operator+(Complex b){
        return Complex(x + b.x, y + b.y);
    }
    Complex operator-(Complex b){
        return Complex(x - b.x, y - b.y);
    }
    Complex operator*(Complex b){
        return Complex(x * b.x - y * b.y, x * b.y + y * b.x);
    }
};

// 最高n，m次， 0次为常数
Complex a[maxn], b[maxn];
Complex c[maxn];
void fft(Complex *cm, int cnum, int tag){
    for(int i =  0 ; i <= cnum - 1; i ++){
        if (i < r[i]){
            swap(cm[i], cm[r[i]]);
        }
    }
    for (ll mid = 1; mid < cnum; mid <<= 1){
        Complex wk = Complex(cos(2 * Pi / (2 * mid)), tag * sin(2 * Pi / (2 * mid)));
        for (ll j = 0; j < cnum; j += 2 * mid) //枚举 cnum/2*mid个全长段
        {
            Complex w(1, 0);
            for (ll k = 0; k < mid; k++) //每段里面进行fft，不是<=，因为只有一半，不能超出
            {
                Complex buf = w * cm[j + k + mid];
                cm[j + k + mid] = cm[j + k] - buf; //在这一步cm[j + k] = cm[j + k] + buf上，否则cm[j+k]已被更改
                cm[j + k] = cm[j + k] + buf;
                w = w * wk;
            }
        }
    }
}
int fft_init(int n){     //n是最高次幂
    int maxx = 1, bits = 0;
    while ((maxx) <= n) {
        maxx <<= 1;
        bits++;
    }
    for(int i = 0; i <= maxx - 1; i ++){
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (bits - 1)); //求二进制反转结果
    }
    return maxx;
}
void work(char val , int maxx){
    for(int i = 1; i <= n; i ++){
        if(s[i] == val){
            a[n + i].x = 1;
            b[n - i].x = 1;
        }
        if(s[i] == '?'){
            a[n + i].x = 1;
        }
    }
    for(int i = (val == '?') ? 1 : n + 1; i <= 2 * n; i ++){
        a[n + i].x = 1;
    }
    fft(a , maxx , 1);
    fft(b , maxx , 1);
    for(int i = 0; i <= maxx; i ++){
        c[i] = a[i] * b[i];
    }
    fft(c , maxx , -1);
    for(int i = 0; i <= n; i ++){
        cnt[i] += (c[i + 2 * n].x / maxx + 0.5);
    }
    for(int i = 0; i <= maxx; i ++){
        a[i].x = b[i].x = c[i].x = 0;
        a[i].y = b[i].y = c[i].y = 0;
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        scanf("%s",s + 1);
        for(int i = 1; i <= n; i ++){
            vis[i] = 0;
            cnt[i] = 0;
        }
        int maxx = fft_init(4 * n);
        work('V' , maxx);
        work('K' , maxx);
        work('?' , maxx);
        vector<int>ans;
        for(int i = 1; i <= n; i ++){
            if(cnt[i] != n) continue;
            for(int j = i; j <= n; j += i){
                if(cnt[j] != n){
                    cnt[i] = 0;
                    break;
                }
            }
            if(cnt[i] == n) ans.push_back(i);
        }
        printf ("%d\n",ans.size());
        for(int i = 0; i < ans.size(); i ++){
            printf ("%d ",ans[i]);
        }
        printf ("\n");
    }
    return 0;
}

方法二：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e6 + 5;
const int num = 200002;
const double Pi = acos(-1.0);
int r[maxn];
int vis[maxn];
int T, n;
char s[maxn];
int cnt[maxn];
struct Complex{
    double x, y;
    Complex(double xx = 0, double yy = 0) : x(xx), y(yy) {}
    Complex operator+(Complex b){
        return Complex(x + b.x, y + b.y);
    }
    Complex operator-(Complex b){
        return Complex(x - b.x, y - b.y);
    }
    Complex operator*(Complex b){
        return Complex(x * b.x - y * b.y, x * b.y + y * b.x);
    }
};

// 最高n，m次， 0次为常数
Complex a[maxn], b[maxn];
Complex c[maxn];
void fft(Complex *cm, int cnum, int tag){
    for(int i =  0 ; i <= cnum - 1; i ++){
        if (i < r[i]){
            swap(cm[i], cm[r[i]]);
        }
    }
    for (ll mid = 1; mid < cnum; mid <<= 1){
        Complex wk = Complex(cos(2 * Pi / (2 * mid)), tag * sin(2 * Pi / (2 * mid)));
        for (ll j = 0; j < cnum; j += 2 * mid) //枚举 cnum/2*mid个全长段
        {
            Complex w(1, 0);
            for (ll k = 0; k < mid; k++) //每段里面进行fft，不是<=，因为只有一半，不能超出
            {
                Complex buf = w * cm[j + k + mid];
                cm[j + k + mid] = cm[j + k] - buf; //在这一步cm[j + k] = cm[j + k] + buf上，否则cm[j+k]已被更改
                cm[j + k] = cm[j + k] + buf;
                w = w * wk;
            }
        }
    }
}
int fft_init(int n){     //n是最高次幂
    int maxx = 1, bits = 0;
    while ((maxx) <= n) {
        maxx <<= 1;
        bits++;
    }
    for(int i = 0; i <= maxx - 1; i ++){
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (bits - 1)); //求二进制反转结果
    }
    return maxx;
}
void work(char val1 , char val2 , int maxx){
    for(int i = 1; i <= n; i ++){
        if(s[i] == val1){
            a[n + i].x = 1;
        }
        if(s[i] == val2){
            b[n - i].x = 1;
        }
    }
    fft(a , maxx , 1);
    fft(b , maxx , 1);
    for(int i = 0; i <= maxx; i ++){
        c[i] = a[i] * b[i];
    }
    fft(c , maxx , -1);
    for(int i = 0; i <= n; i ++){
        cnt[i] += (c[i + 2 * n].x / maxx + 0.5);
    }
    for(int i = 0; i <= maxx; i ++){
        a[i].x = b[i].x = c[i].x = 0;
        a[i].y = b[i].y = c[i].y = 0;
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        scanf("%s",s + 1);
        for(int i = 1; i <= n; i ++){
            vis[i] = 0;
            cnt[i] = 0;
        }
        int maxx = fft_init(3 * n);
        work('K' , 'V' ,maxx);
        work('V' , 'K' ,maxx);

        vector<int>ans;
        for(int i = 1; i <= n; i ++){
            if(cnt[i]) continue;
            for(int j = i; j <= n; j += i){
                if(cnt[j]){
                    cnt[i] = 1;
                    break;
                }
            }
            if(!cnt[i]) ans.push_back(i);
        }
        printf ("%d\n",ans.size());
        for(int i = 0; i < ans.size(); i ++){
            printf ("%d ",ans[i]);
        }
        printf ("\n");
    }
    return 0;
}

方法二的一点优化：
由于我们在FFT的时候是把匹配串的幂次当成负数，达到系数减法的效果，这样把所有的幂次整体右移一个 n ，这样最大幂次会达到 3 * n 。但我们只要把匹配串翻转一下，最后得到的值减去 n + 1可以达到算差值的效果 ， 这样最大幂次只有 2 * n + 1。快了不少。

代码：

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 5e6 + 5;
const int num = 200002;
const double Pi = acos(-1.0);
int r[maxn];
int vis[maxn];
int T, n;
char s[maxn],t[maxn];
int cnt[maxn];
struct Complex{
    double x, y;
    Complex(double xx = 0, double yy = 0) : x(xx), y(yy) {}
    Complex operator+(Complex b){
        return Complex(x + b.x, y + b.y);
    }
    Complex operator-(Complex b){
        return Complex(x - b.x, y - b.y);
    }
    Complex operator*(Complex b){
        return Complex(x * b.x - y * b.y, x * b.y + y * b.x);
    }
};

// 最高n，m次， 0次为常数
Complex a[maxn], b[maxn];
Complex c[maxn];
void fft(Complex *cm, int cnum, int tag){
    for(int i =  0 ; i <= cnum - 1; i ++){
        if (i < r[i]){
            swap(cm[i], cm[r[i]]);
        }
    }
    for (ll mid = 1; mid < cnum; mid <<= 1){
        Complex wk = Complex(cos(2 * Pi / (2 * mid)), tag * sin(2 * Pi / (2 * mid)));
        for (ll j = 0; j < cnum; j += 2 * mid) //枚举 cnum/2*mid个全长段
        {
            Complex w(1, 0);
            for (ll k = 0; k < mid; k++) //每段里面进行fft，不是<=，因为只有一半，不能超出
            {
                Complex buf = w * cm[j + k + mid];
                cm[j + k + mid] = cm[j + k] - buf; //在这一步cm[j + k] = cm[j + k] + buf上，否则cm[j+k]已被更改
                cm[j + k] = cm[j + k] + buf;
                w = w * wk;
            }
        }
    }
}
int fft_init(int n){     //n是最高次幂
    int maxx = 1, bits = 0;
    while ((maxx) <= n) {
        maxx <<= 1;
        bits++;
    }
    for(int i = 0; i <= maxx - 1; i ++){
        r[i] = (r[i >> 1] >> 1) | ((i & 1) << (bits - 1)); //求二进制反转结果
    }
    return maxx;
}
void work(char val1 , char val2 , int maxx){
    for(int i = 1; i <= n; i ++){
        if(s[i] == val1){
            a[i].x = 1;
        }
        if(t[i] == val2){
            b[i].x = 1;
        }
    }
    fft(a , maxx , 1);
    fft(b , maxx , 1);
    for(int i = 0; i <= maxx; i ++){
        c[i] = a[i] * b[i];
    }
    fft(c , maxx , -1);
    for(int i = 0; i <= n; i ++){
        cnt[i] += (c[i + n + 1].x / maxx + 0.5);
    }
    for(int i = 0; i <= maxx; i ++){
        a[i].x = b[i].x = c[i].x = 0;
        a[i].y = b[i].y = c[i].y = 0;
    }
}
int main(){
    int T;
    scanf("%d",&T);
    while(T--){
        scanf("%d",&n);
        scanf("%s",s + 1);
        for(int i = 1; i <= n; i ++){
            t[i] = s[n - i + 1];
        }
        for(int i = 1; i <= n; i ++){
            vis[i] = 0;
            cnt[i] = 0;
        }
        int maxx = fft_init(2 * n + 1);
        work('K' , 'V' ,maxx);
        work('V' , 'K' ,maxx);

        vector<int>ans;
        for(int i = 1; i <= n; i ++){
            if(cnt[i]) continue;
            for(int j = i; j <= n; j += i){
                if(cnt[j]){
                    cnt[i] = 1;
                    break;
                }
            }
            if(!cnt[i]) ans.push_back(i);
        }
        printf ("%d\n",ans.size());
        for(int i = 0; i < ans.size(); i ++){
            printf ("%d ",ans[i]);
        }
        printf ("\n");
    }
    return 0;
}
stduy_ing
关注
专栏目录
codeforces 6E. Exposition(RMQ + 二分)
哇咔咔
05-24 659
E. Exposition time limit per test 1.5 seconds memory limit per test 64 megabytes input standard input output standard output There are several days left before the fiftieth birthd
2018.11.09 codeforces487E. Tourists（tarjan+树链剖分）
苟为蒟蒻又何妨
11-09 1210
传送门 先把边双连通分量用圆方树一样的方法缩点，然后把新建的树树剖维护。 注意对于边双连通分量需要维护动态最小值，可以用multisetmultisetmultiset。 代码： #include&lt;bits/stdc++.h&gt; #define lc (p&lt;&lt;1) #define rc (p&lt;&lt;1|1) #define mid (T[p].l+T[p].r&gt;...
Codeforces 827E Rusty String
banglei0443的博客
07-13 180
一万年没有写过题解了...这题idea是不错 题意 给你一个只由V/K/?组成的字符串，问这个字符串的循环长度可以是多少，其中？表示既可以是V也可以是K。将所有可能的循环长度都输出。 想法 如果没有?，那就是next数组判断。而之所以可以用next数组判断，是因为假设循环长度为\(d\)，那么将字符串向右滑动\(d\)位之后重合的部分一定完全相同。基于这个理论，这道题也可以这么想。 假设...
CodeForces 827 E.Rusty String（FFT）
ZSQ
01-14 903
Description 给出一个只由′V′′V′'V',′K′′K′'K',′?′′?′'?'组成的字符串，′?′′?′'?'可以变成′V′′V′'V'或′K′′K′'K'，问该字符串可能的循环节 Input 第一行输入一整数TTT表示用例组数，每组用例首先输入一整数nnn表示字符串长度，之后输入一个长度为nnn的字符串(1≤n≤5⋅105)(1≤n≤5⋅105)(1\le n\le 5\c...
codeforces 827E
Irving0323的博客
02-08 152
循环周期 NTT
Codeforces Round #423 (Div. 1, rated, based on VK Cup Finals) E. Rusty String（fft）
bibibibi的博客
07-22 368
题目链接：http://codeforces.com/contest/827/problem/E 对于一个答案d，一定满足如果，如果s[i]!='?'&&s[j]!='?'&&i%d==j%d，则s[i]=s[j]，我们可以用fft的方式，对V和K分别处理，对K的顺序进行反转，然后，如果卷积出来的下标，就是所有差为i的情况下，有多少个位置不匹配。然后将所有的倍数更新到结果数组中，即可得出
E. Rusty String
weixin_30251829的博客
07-17 103
E. Rusty String time limit per test 3 seconds memory limit per test 512 megabytes input standard input output standard output Grigory loves strings. Recently he found a metal st...
Codeforces D1/D2. Prefix-Suffix Palindrome (字符串hash) /详解
01-03
D1. Prefix-Suffix Palindrome (Easy version) D2. Prefix-Suffix Palindrome (Hard version) 题意： ...很显然，这是一个O（n^2）时间复杂度的算法，那么还有哪里可以优化呢？其实关于求回文串palindrom
Codeforces 721 C. Journey（拓扑排序+DP）
01-03
因为是有向无环图，所以我们可以在拓扑排序的时候进行dp，循环n个点，复杂度On^2，然后多开一个pre[i][j]记录经过i点时的前一个点。 由于开了两个5000*5000的数组，所以得用int，如果用long long会MLE。 代码如下： ...
codeforces 1453 D. Checkpoints (构造+期望)
henuzxy
12-08 534
构造题目，需要想到一种构造方法，这个题目其实可以想到两种构造，用全为1进行构造，如1111这种，但她的期望公式是f[n] = 2*n，因为n最大是2000，所以显然不行，然后就是全为0进行构造，因为开头是1，所以就是后面补0来进行构造。 考虑 f1 = 2;f2 = 6;f3 = 14,可以看出规律是f[n] = f[n-1]*2,根据这个规律就可以解决这道题目了，因为第一个位置必须是1，结合上面也可以看出，无论怎么构造，期望一定是偶数。可以得到代码如下： #include <bits/stdc++.
Codeforces 827E Rusty String - 快速傅里叶变换 - 暴力
adx33526的博客
08-21 159
Grigory loves strings. Recently he found a metal strip on a loft. The strip had lengthnand consisted of letters "V" and "K". Unfortunately, rust has eaten some of the letters so tha...
Codeforces Round #827 (Div. 4)-C. Stripes
weixin_52490191的博客
10-14 370
Codeforces Round #827 (Div. 4)-C. Stripes
Codeforces Round #827 (Div. 4)A~G（模拟，暴力，前缀最大值，二分，二进制）
zy98zy998的博客
10-14 577
Codeforces Round #827 (Div. 4)A~G（模拟，暴力，前缀最大值，二分，二进制）
Codeforces Round #827 (Div. 4)——A-G
Mango.
10-17 364
Codeforces Round #827 (Div. 4)——A-G
CF 827E - Rusty String FFT 字符串 循环节
c6376315qqso的专栏
09-20 268
题意： 给你一个字符串，只含'V', 'K', '?'，其中'?’可能是任意这两个字符之一，问可能的循环节？（循环节不用整除N，只要满足s[i] = s[i + k]） 题解： 找循环节，就是找所有公共前后缀长度。 现在有'?’ ，属于模糊匹配， 只能用FFT。 等于0的话就可以匹配，拆开是，做三次FFT即可。 （貌似不用做三次，别人都是做一次，我的做法常数比较大，贴一个别人的博客： ...
【CF827E】Rusty String 调和级数+FFT
aodanchui1057的博客
01-29 175
【CF827E】Rusty String 题意：给你一个01串，其中部分字符是'?'，?可以是0或1，求所有可能的d，满足存在一种可能得到的01串，在向右移动d格后与自己相同。 $n\le 5\times 10^5$ 题解：我们先枚举d，那么一个串符合条件当且仅当：$\forall i \in [0,d), a_i=a_{i+d}=a_{i+2d}=...$，我们可以用fft来判断...
Codeforces Round #827 (Div. 4) G. Orray 解题报告
qq_45554473的博客
10-28 702
Codeforces Round #827 (Div. 4) G. Orray 解题报告
CodeForces 827E Round$423 Div1E Solution:暴力的正确姿势
辣鸡葫芦娃
07-23 468
题意：给出一个字符串s(len 题解：正解是FFT，但是弱弱我看了一整天刚刚看得懂理论，代码还没看得懂呢。只好暴力过了这个题。 类似于素数筛的方法。假设找到了一个length是循环节，那么显然length的倍数也是循环节。完全类似于素数筛。 注意：既然都暴力了，那么像memset这种操作就不要memset(can,false,.sizeof(can))这种暴力的操作了，清空需要的部分就可以了
Codeforces Round #827 (Div. 4) 题解记录
万伏小太阳
10-14 459
观察可以发现，第一个数肯定是a数组中最大的那个数，那么接下来就找和前面或最大的数，可以遍历一遍没有用过的数，找到最大的那个，由于最多有31位，所以最多遍历31次或的结果就是最大的,遍历31次之后，剩下就可以随便输出了。如果有一整行或者一整列为同一个字母，说明肯定是最后一次画的。桶计数，暴力找,两个数互质，gcd为1。大的，如果有，则无法构造。字符串都是有一个a的，可以发现如果。的字符放在第一个，这样肯定。字符大，我们就可以让S的。预处理，前缀和，二分。
codeforces round #792 (div. 1 + div. 2)
最新发布
06-06
2) 是 Codeforces 竞赛平台上的一场比赛，包括两个级别：div. 1 和 div. 2。这场比赛通常会有多个问题需要参赛者解决，每个问题都有不同的难度等级。参赛者需要在规定的时间内提交他们的解决方案，然后等待评测结果...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值