快速傅里叶变换学习笔记

最新推荐文章于 2024-04-24 09:38:40 发布
最新推荐文章于 2024-04-24 09:38:40 发布
阅读量204 收藏
点赞数
文章标签： c/c++
原文链接：http://www.cnblogs.com/zzzc18/p/8323840.html
版权

本篇博客中题目的代码均位于文末，文中不再出现

算法原理

%%%Miskcoo%%%

对于快速傅里叶变换的原理，可以参考上面的博客以及《算法导论》

大体说明

FFT用于加速多项式的乘法：
\[H(x)=f(x) \otimes g(x)\]
即：
\[H(t)=\sum^{t}_{k=0}f(k)*g(t-k)\]
上面两个式子都是卷积的形式，也就是FFT可以优化的类型

使用暴力做法，时间复杂度为 \(O(n^2)\)，而使用快速傅里叶变换可以做到\(O(nlogn)\)，于是许多问题从不可做变成了可做，FFT对生成函数的优化是个很好的例子，可以快速解决组合问题。

题目

模板

UOJ#34：多项式乘法

CODE

或者bzoj2179

FFT优化高精度乘法，一个数就可以看作\(f(10)\)，其中：
\[f(x)=a_0+a_1x+a_2x^2+a_3x^3+\dots\]

BZOJ2194: 快速傅立叶之二

Description

请计算\(C_k=\sum_{i=k}^{n-1}A_i*B_{i-k}\)其中 \(k \leq i < n\) ，并且有 \(n \leq 10 ^ 5\) 。\(A\) , \(B\) 中的元素均为小于等于100的非负整数。\(A\) , \(B\)最高次项均为 \(n-1\)

Solution

没错，就是一个多项式的乘法

我们将上面那个式子变一下形
首先将 \(A\) 的系数全部 reverse
eg:
\[A(x)=a_0+a_1x+a_2x^2+a_3x^3\]
\[A^R(x)=a_3+a_2x+a_1x^2+a_0x^3\]

此时

\[C_k=\sum_{i=k}^{n-1}A^R_{n-i-1}*B_{i-k}\]

然后改变求和指标，上式变为
\[C_k=\sum_{i=0}^{n-k-1}A^R_{n-i-k-1}*B_{i}\]

另 \(t=n-k-1\)，则 \(k=n-t-1\)，代入上式可得

\[C_{n-t-1}=\sum_{i=0}^{t}A^R_{t-i}*B_{i}\]

与之前类似地：

\[C^R_{t}=\sum_{i=0}^{t}A^R_{t-i}*B_{i}\]

因此我们只需要将 \(A\) 反转，得到的卷积结果是 \(C\) 的反转

BZOJ3527: [Zjoi2014]力

Description

给出 \(n\) 个数 \(q_i\)，给出 \(F_j\) 的定义如下：

1322619-20180121122433240-1721503256.jpg

令 \(E_i=F_i/q_i\) ，求 \(E_i\).

\(n≤100000,0<qi<1000000000\)

Solution

很显然，\[E_k=\sum_{i<k}\frac{q_i}{(i-k)^2}-\sum_{i>k}\frac{q_i}{(i-k)^2}\]

另 \(f(x)=q_x\)，$ g(x)=\frac{1}{i^2}$，那么：

\[\sum^{k-1}_{i=0}\frac{q_i}{(i-k)^2}=f(x) \otimes g(x)\]

而另一部分与BZOJ2194类似：

\[reverse(\sum_{i>k}\frac{q_i}{(i-k)^2})=f(x) \otimes g^R(x)\]

两次答案加起来就是最终答案

另：这题卡精度，计算 \(g(x)\) 时要 \(g(i)=1/i/i\)，不能\(g(i)=1/(i*i)\)

BZOJ3771: Triple

Description

我们讲一个悲伤的故事。
从前有一个贫穷的樵夫在河边砍柴。
这时候河里出现了一个水神，夺过了他的斧头，说：
“这把斧头，是不是你的？”
樵夫一看：“是啊是啊！”
水神把斧头扔在一边，又拿起一个东西问：
“这把斧头，是不是你的？”
樵夫看不清楚，但又怕真的是自己的斧头，只好又答：“是啊是啊！”
水神又把手上的东西扔在一边，拿起第三个东西问：
“这把斧头，是不是你的？”
樵夫还是看不清楚，但是他觉得再这样下去他就没法砍柴了。
于是他又一次答：“是啊是啊！真的是！”
水神看着他，哈哈大笑道：
“你看看你现在的样子，真是丑陋！”
之后就消失了。
樵夫觉得很坑爹，他今天不仅没有砍到柴，还丢了一把斧头给那个水神。
于是他准备回家换一把斧头。
回家之后他才发现真正坑爹的事情才刚开始。
水神拿着的的确是他的斧头。
但是不一定是他拿出去的那把，还有可能是水神不知道怎么偷偷从他家里拿走的。
换句话说，水神可能拿走了他的一把，两把或者三把斧头。
樵夫觉得今天真是倒霉透了，但不管怎么样日子还得过。
他想统计他的损失。
樵夫的每一把斧头都有一个价值，不同斧头的价值不同。总损失就是丢掉的斧头价值和。
他想对于每个可能的总损失，计算有几种可能的方案。
注意：如果水神拿走了两把斧头 \(a\) 和 \(b\) ，\((a,b)\) 和 \((b,a)\) 视为一种方案。拿走三把斧头时，\((a,b,c),(b,c,a),(c,a,b),(c,b,a),(b,a,c),(a,c,b)\) 视为一种方案。

Description2

嗯，一句话，有 \(n\) 个物品各有价值，要求从中取出 \(1\) 到 \(3\) 个物品，不同排列视作同一种，求可能的取出物品的价值和有多少种

所有数据满足： \(Ai \leq 40000\)

Solution

我们直接构造出这些斧头的生成函数

举个例子，有斧子们 \(2,4,4,4,6,8,8,9\)

则其对应的生成函数为
\[f(x)=x^2+3x^4+x^6+2x^8+x^9\]

在这一题里，我们记取一把斧子的生成函数为 \(F(x)\)，取两把相同的斧子的生成函数为 \(G(x)\) ， 三把为 \(H(x)\) 那么取一个斧头的方案就是 \(F(x)\)；
对于两个斧头，方案数变为了\((F(x)\otimes F(x)-G(x))/2\)
对于三把斧头，方案数就是 \((F(x)\otimes F(x)\otimes F(x) - 2\times G(x)*F(x) - H(x))/6\)
上边的计算，只要理解生成函数再使用容斥原理就可以了

注：对于函数的操作，可以直接转化为点值表达后一起搞事，不用每次 \(DFT\)、\(IDFT\)，可以参见代码

BZOJ3509: [CodeChef] COUNTARI

Description

给定一个长度为 \(N\) 的数组 \(A[\ ]\) ，求有多少对 \(i,j,k\) \(（1\leq i<j<k\leq N)\)满足 \(A[k]-A[j]=A[j]-A[i]\) 。

\(N\leq 100000 ,A[i]\leq 30000\)

Solution

首先，通过移项，不难发现，我们要求的是对于每一个 \(j\) 满足 \(2A[j]=A[i]+A[k]\) 的 \(i,k\) 对数 \(（1\leq i<j<k\leq N)\)
所以我们直接从头到尾扫一遍，分别维护前缀及后缀里各个值出现的次数，看对于当前 \(j\) 有那些组合满足条件。时间复杂度 \(O(n^3)\)

此时我们再来看这个式子\(2A[j]=A[i]+A[k]\)，这个也是可以使用生成函数的。
先把前缀及后缀的生成函数搞出来，分别记为 \(f(x),g(x)\)。
令 \(h(x)=f(x)\otimes g(x)\)，那么，函数 \(h(x)\) 的第 \(x^{2j}\) 项的系数就是对于当前 \(j\) 满足条件的对数，卷积可以用FFT优化到 \(O(nlogn)\) 。
可惜的是这玩意最终的时间复杂度是 \(O(n^2logn)\)，硬上并无卵用

用了FFT还是这么慢的主要原因是用了太多次，可不可以用少一些呢？
现在我们将待处理的数列分为 \(\sqrt{nlogn}\)个块，对于块内，暴力解决，而对于块外则使用FFT。
具体来说就是在一个块 \([L,R]\) 中，可以通过暴力统计计算出满足 \(1 \leq i < L \leq j < k \leq R\) 以及 \(L \leq i < j \leq R < k \leq N\)的方案数；
而对于\(1 \leq i < L \leq j \leq R < k \leq N\)，我们构造 \([1,L)\) 的生成函数以及 \((R,N]\) 的生成函数，卷积一下就是方案数了；
最终两个答案加一起就是最终答案

另：这题要注意常数

BZOJ3456: 城市规划

Description

刚刚解决完电力网络的问题, 阿狸又被领导的任务给难住了.
刚才说过, 阿狸的国家有 \(n\) 个城市,现在国家需要在某些城市对之间建立一些贸易路线,使得整个国家的任意两个城市都直接或间接的连通.为了省钱,每两个城市之间最多只能有一条直接的贸易路径.对于两个建立路线的方案, 如果存在一个城市对, 在两个方案中是否建立路线不一样, 那么这两个方案就是不同的, 否则就是相同的. 现在你需要求出一共有多少不同的方案.好了, 这就是困扰阿狸的问题. 换句话说, 你需要求出 \(n\) 个点的简单(无重边无自环)无向连通图数目.由于这个数字可能非常大,你只需要输出方案数 \(mod ~ 1004535809(479 * 2 ^ 21 + 1)\) 即可.

Solution

首先对于这个模数，已经暴露了题目想让我们搞什么——快速数论变换

下文直接用 \(\binom{n}{i}\) 表示 \(C_n^i\)

我们记最终的答案为一个函数 \(f(x)\)，那么 \(f(n)\) 是最终答案。
如果不考虑这个图的连通性，那么答案就显然是 \(\large 2^{\binom{n}{2}}\)，即所有可能的边选或者不选。设 \(\large g(x)=2^{\binom{x}{2}}\)
进一步考虑，如何找出 \(g\) 与 \(f\) 的等量关系？
我们枚举 \(1\) 号点所在的连通块，我们可以得到以下的等量关系：
\[g(n)=\sum_{i=1}^{n}\binom{n-1}{i-1}f(i)g(n-i)\]
同时除以 \((n-1)!\) 得
\[\frac{g(n)}{(n-1)!}=\sum_{i=1}^{n}\frac{f(i)}{(i-1)!}\frac{g(n-i)}{(n-i)!}\]

是不是看到了卷积？美滋滋

令：（这样写好像不规范）
\[H(x)=\frac{g(x)}{(x-1)!},F(x)=\frac{f(x)}{(x-1)!},G(x)=\frac{g(x)}{(x)!}\]
其中为了求逆元 \(G(0)=1\)

\[\because H(x)=F(x)\otimes G(x)\]
\[\therefore F(x)=H(x)\otimes G^{-1}(x) \]

只要求一个 \(G(x)\) 逆元一卷积就好了（求逆元的方法回头再说）

BZOJ4503: 两个串

Description

兔子们在玩两个串的游戏。给定两个字符串 \(S\) 和 \(T\) ，兔子们想知道 \(T\) 在 \(S\) 中出现了几次，
分别在哪些位置出现。注意T中可能有 \(“?”\) 字符，这个字符可以匹配任何字符。
\(S\) 长度不超过 \(10^5\)， \(T\) 长度不会超过 \(S\)。 \(S\) 中只包含小写字母，T中只包含小写字母和 \(“?”\)

Solution

如果两个长度为 \(len\) 的串 \(s1,s2\) 相等时，我们可以写成
\[\sum_{i=0}^{len-1}\left| s1[i]-s2[i] \right|=0\]

也可以写成
\[\sum_{i=0}^{len-1}(s1[i]-s2[i])^2=0\]

现在将 \(s2\) 翻转，得到 \(s3\)，上式就可以写成
\[\sum_{i=0}^{len-1}(s1[i]-s3[(len-1)-i])^2=0\]

我们记 \(S,T\) 中所对应的各字符减去 \('a'\) 的值记为 \(f,g\)，其中当字符为 \(?\) 时，将这个值赋为 \(0\)，就可以有一下关系(\(g\) 的系数颠倒后为 \(g^R\))
\[Ans=(f-g^R)^2\otimes g^R\]

感觉不用解释了， \(Ans\) 的某一位是 \(0\) 的时候就意味着有一个满足题意的匹配

BZOJ3160: 万径人踪灭

Description

T1

T2

T3

T4

Solution

并没有看完整题意。。。

首先，如果回文串要求连续的，可以通过 \(Manacher\) 算法 \(O(n)\) 内很轻松解决
这个Manacher讲的不错
那此时就可以计算所有的，不管连续不连续的回文串，再减去连续的就行了

对于计算回文串个数，可以通过一下式子
\[Ans_t=\sum_{i=0}^{t}s1[i]\times s2[i]\]

解释一下，由于只有 \(a,b\) 两种字符，我们把数列中的 \(a\) 赋为 \(1\) , \(b\) 赋为 \(0\)，做一次计算；
再把数列中的 \(b\) 赋为 \(1\) , \(a\) 赋为 \(0\)，做一次计算；两次结果相加。
这样可以得到以 \(\frac{t}{2}\) 为中心的、最长的、不管连续不连续的回文串。
那么其数量为 \(2^{Ans_t}\)。
最后把所有答案加起来减去连续的回文串数量就行

BZOJ3992: [SDOI2015]序列统计

Description

小C有一个集合 \(S\)，里面的元素都是小于 \(M\) 的非负整数。他用程序编写了一个数列生成器，可以生成一个长度为N的数列，数列中的每个数都属于集合 \(S\) 。
小C用这个生成器生成了许多这样的数列。但是小C有一个问题需要你的帮助：给定整数 \(x\) ，求所有可以生成出的，且满足数列中所有数的乘积\(mod\ M\)的值等于 \(x\) 的不同的数列的有多少个。小C认为，两个数列\(\{A_i\}\)和\(\{B_i\}\)不同，当且仅当至少存在一个整数 \(i\) ，满足 \(A_i\neq B_i\)。另外，小C认为这个问题的答案可能很大，因此他只需要你帮助他求出答案\(mod\ 1004535809\)的值就可以了。

输入：一行，四个整数，N、M、x、|S|，其中|S|为集合S中元素个数。第二行，|S|个整数，表示集合S中的所有元素。

对于10%的数据，1<=N<=1000；

对于30%的数据，3<=M<=100；

对于60%的数据，3<=M<=800；

对于全部的数据，1<=N<=109，3<=M<=8000，M为质数，1<=x<=M-1，输入数据保证集合S中元素不重复

Solution

模数又暴露了算法，但并不影响这是个神题

首先 \(M\) 是个质数，我们可以找到其原根
原根是什么？

假设一个数 \(g\) 对于 \(P\) 来说是原根，那么 \(g^i\ mod\ P\)的结果两两不同,且有 \(1<g<P, 1<i<P\),那么 \(g\) 可以称为是 \(P\) 的一个原根
简单来说，\(g^i\ mod\ p \neq g^j\ mod\ P\) （ \(P\) 为素数）

关于其计算，参见这里

简而言之，每次枚举原根，暴力看是否满足条件

//qpow(x,k,MOD)为快速幂 : x^k %MOD
bool judge(int val){
    if(m==2)
        return 1;
    if(val==1)
        return 0;
    for(int i=2;i*i<=m;i++)
        if((m-1)%i==0)
            if(qpow(val,m/i,m)==1)
                return 0;
    return 1;
}
 
int FindG(int val){
    int re=1;
    while(!judge(re)) re++;
    return re;
}

另 \(M\) 的原根是 \(g\)
这时，每个数 \(a_i\) 就可以写成 \(\large g^{b_i}=a_i\)
所以
\[\prod a_i\]

就变成了
\[\large g^{\sum b_i}\]

这一步将乘法运算变为了加法

现在将 \(b\) 构造生成函数记为 \(B\)
显然，因为每个数可以取多次
\[Ans=B^n\]
\(Ans\) 的第 \(X\) 位就是最终答案

时间复杂度 \(O(mlogmlogn)\)

注：
1.多项式快速幂的时候不能把次数高于 \(M\) 的项直接清零，而是应该将第 \(k\) 项加到 \(k\ mod\ (m-1)\) 项上
2.对于 \(X=0\) 特别计算

BZOJ3557: [Ctsc2014]随机数

Description

露露、花花和萱萱最近对计算机中的随机数产生了兴趣。为大家所熟知的是，有计算机生成的随机数序列并非真正的随机数，而是由一定法则生成的伪随机数。 某一天，露露了解了一种生成随机数的方法，成为Mersenne twister。给定初始参数 \(m∈Z^+，x∈Z^+∩[0,2m)\)和初值 \(M0∈Z^+∩[0,2m)\)，它通过下列递推式构造伪随机数列\({M_n}\):
公式

其中XOR是二进制异或运算（C/C++中的^运算）。而参数x的选取若使得该数列在长度趋于无穷时，近似等概率地在 \(Z^+\bigcap(0,2m)\) 中取值，
就称x为好的。例如，在 \(m>1\) 时 \(x=0\) 就显然不是好的。
在露露向伙伴们介绍了Mersenne twister之后，花花想用这一些经典的随机性测试来检验它的随机性强度。为此，花花使用计算机计算
了一些 \(M_k\)。
但细心的萱萱注意到，花花在某次使用二进制输入 \(k\) 时，在末尾多输入了 \(l\) 个 \(0\) 。她正想告诉花花这个疏忽，然而花花已经计算并记录了错误的 \(M_k\) 而没有记录 \(k\) 的值。虽然这其实不是什么致命的问题，但是在萱萱告诉花花她这个疏漏时，作为完美主义者的花花还是恳求萱萱帮她修正 \(M_k\) 的值。萱萱便把这个任务交给了她的AI——你。

Input:
第一行包含一个正整数 \(m\) ，
第二行为二进制表示的 \(x\)（共 \(m\) 个数，从低位到高位排列）
第三行为二进制表示的 \(M_0\)（排列方式同 \(x\) ），
第四行包含一个整数 \(type\)。
接下来分为两种可能的情况：

  1. \(type=0\) （萱萱记下了花花的输入）：则第五行包含一个整数，表示萱萱记下来的正确的k值。
    2.\(type=1\) （萱萱未能记下花花的输入）：则第五行为 \(l\) ，第六行输入花花计算出错误的二进制表示的 \(M_k\)。

Output:
仅一行，为 \(m\) 位的 \(01\) 串，表示你求得的正确 \(M_k\)（同样要求从低位到高位）。

\(M\leq1000000, K\leq10^6\)

Solution

我们可以直接将 \(x,M0\) 看做两个 \(GF(2)\) （系数mod2）下的多项式 \(M_0(x),X(x)\)
在此意义下(\(\oplus\) 为异或)
\[A(x) \oplus B(x) \Leftrightarrow A(x)\pm B(x)\]
所以上面两个操作看成
\[M_n=xM_{n-1}\]

以及
\[M_n=(xM_{n-1}-x^{m})\oplus X(x)\]

这样两种操作都可以写成
\[M_n=xM_{n-1}\ mod\ (x^m+X(x))\]

仔细分析上式是对的
1.操作一由于最高次项不到 \(m\) 取模是没有影响的
2.操作二就是这么个东西

于是 \(type=0\)，可以直接计算出
\[M_k(x)=x^kM_0(x)\ mod\ (x^m+X(x))\]

需要多项式快速幂以及多项式取模（和除法在一起）

对于 \(type=1\)
因为题目保证 \(x\) 是“好的”，每次操作都是确定的，可以发现一个性质，\(M_k\) 在 \([0,2^m)\)里恰好每个值出现过一遍，否则 \(x\) 不可能是好的，最后不是等概率。
将上面这个性质写成式子就是\(x\equiv x^{2^m}\ mod\ (x^m+X(x))\)

我们再将问题表示出来
\[x^{k2^l}M_0(x)\equiv M_{k2^l}(x)\ mod\ (x^m+X(x))\]

再利用上面的性质整理
\[x^{k2^l2^{m-l}}\equiv (M_{k2^l}(x)M_0^{-1}(x))^{2^{m-l}}\ mod\ (x^m+X(x))\]

所以

\[x^k\equiv (M_{k2^l}(x)M_0^{-1}(x))^{2^{m-l}}\ mod\ (x^m+X(x))\]

所以

\[M_k(x)\equiv x^kM_0(x)\equiv (M_{k2^l}(x)M_0^{-1}(x))^{2^{m-l}}M_0(x)\ mod\ (x^m+X(x))\]

所以只要求出 \(M_0(x)\) 在 \(\ mod\ (x^m+X(x))\) 下的逆元，与 \(M_{k2^l}(x)\) 乘起来计算快速幂，再乘上 \(M_0\) 就行了

求出 \(M_0(x)\) 在 \(\ mod\ (x^m+X(x))\) 下的逆元需要拓展欧几里得，这与数论里的方法类似

吐槽一下：
1.这题真是个板子大全（没有开根）
2.真不可调试//用了一整个上午，还是有标程的情况下，代码里的DEBUG（）可以看出我的绝望
3.原题一个点时限20sec,搞到测试数据一测最大点15sec，然而BZOJ丧心病狂总时间160sec(20个点)，我现在已经没心情去卡常了，就这了（这意味着我的代码会TLE，但是肯定对）
4.%%%WJMZBMR，%%%miskcoo

Code

BZOJ3557

/**************************************************************
    Problem: 3557
    User: zzzc18
    Language: C++
    Result: Time_Limit_Exceed
****************************************************************/

#include<cmath>
#include<cstdio>
#include<cstring>
#include<cctype>
#include<algorithm>
using namespace std;

typedef long long LL;
const int MAXN = 2100000+9;
const int MOD = 479<<21|1;
const int G = 3;
int X[MAXN],M0[MAXN],tp[MAXN],A1[MAXN],B1[MAXN],A3[MAXN];
int size,bit_length;
int loc[MAXN];
int m;
int tmp[5][MAXN];
int type;
int tot_len;
int A2[MAXN],B2[MAXN];
struct PAIR{
    int first,second;
    PAIR(int _x=0,int _y=0):first(_x),second(_y){}
};

inline void Read(int &x){
    char ch=getchar();
    while(!isdigit(ch))ch=getchar();
    x=ch-'0';
}

void DEBUG(int *A,int len=32){
    for(int i=0;i<len;i++)
        printf("%d ",A[i]);
    puts("");
}

int qpow(int x,int k){
    int re=1;
    int mul=x;
    for(int i=1;i<=k;i<<=1){
        if(i&k)
            re=(LL)re*mul%MOD;
        mul=(LL)mul*mul%MOD;
    }
    return re;
}

inline void GF2(int &x){
    if(x>=3000000) x=(MOD-x)&1;//x由于减法而+过MOD，所以这样 
    else x&=1;//mod 2
}

int inv(int x){
    return qpow(x,MOD-2);
}

inline void init(int x){
    for(size=1,bit_length=-1;size<x;size<<=1,bit_length++);
    int now=0;
    for(int i=0;i<size;i++){
        loc[i]=now;
        for(int j=1<<bit_length;(now^=j)<j;j>>=1);
    }
}

inline int dec(int x,int y){
    x-=y;
    return x<0?x+MOD:x;
}

inline int inc(int x,int y){
    x+=y;
    return x<MOD?x:x-MOD;
}

void DFT(int *A,int *re){
    for(int i=0;i<size;i++)
        re[i]=A[loc[i]];
    for(int k=2;k<=size;k<<=1){
        int len=k>>1;
        int Wn=qpow(G,(MOD-1)/k);
        for(int i=0;i<size;i+=k){
            int W=1;
            for(int j=0;j<len;j++){
                int u=re[i+j],v=(LL)W*re[i+j+len]%MOD;
                re[i+j]=inc(u,v);
                re[i+j+len]=dec(u,v)%MOD;
                W=(LL)W*Wn%MOD;
            }
        }
    }
}

void IDFT(int *A,int *re){
    for(int i=0;i<size;i++)
        re[i]=A[loc[i]];
    for(int k=2;k<=size;k<<=1){
        int len=k>>1;
        int Wn=inv(qpow(G,(MOD-1)/k));
        for(int i=0;i<size;i+=k){
            int W=1;
            for(int j=0;j<len;j++){
                int u=re[i+j],v=(LL)W*re[i+j+len]%MOD;
                re[i+j]=inc(u,v);
                re[i+j+len]=dec(u,v);
                W=(LL)W*Wn%MOD;
            }
        }
    }
    int tmp=inv(size);
    for(int i=0;i<size;i++)
        re[i]=(LL)re[i]*tmp%MOD;
}

int GetInv(int degree,int *A,int *B){
    if(degree==1){
        B[0]=inv(A[0]);
        return degree;
    }
    int val=GetInv((degree+1)>>1,A,B);
    init(degree<<1);

    copy(A,A+degree,tp);
    //fill(tp+degree,tp+size,0);
    memset(tp+degree,0,(size-degree+1)<<2);
    DFT(tp,A2);

    //fill(B+val,B+size,0);
    memset(B+val,0,(size-val+1)<<2);
    DFT(B,B2);

    for(int i=0;i<size;i++)
        A2[i]=(LL)A2[i]*B2[i]%MOD;
    if(degree>100000){
        IDFT(A2,A3);
        for(int i=0;i<size;i++)
            GF2(A3[i]);
        DFT(A3,A2);
    }
    for(int i=0;i<size;i++)
        B2[i]=(LL)B2[i]*dec(2,A2[i])%MOD;
    IDFT(B2,B);
    for(int i=0;i<degree;i++)
        GF2(B[i]);
    //fill(B+degree,B+size,0);
    memset(B+degree,0,(size-degree+1)<<2);
    return degree;
}

// A(x)=D(x)B(x)+R(x)
void DivMod(int len_a,int len_b,int *A,int *B,int *D,int *R){
    static int tp[MAXN];
    static int Z[MAXN];
    static bool solved=0;
    int t=len_a-len_b+1;
    init(t<<1);
    if(!solved || type){
        if(!type)solved=1;//对于type==0，计算时模数均为X，只算一遍
        //fill(B1,B1+size,0);
        memset(B1,0,(size-1)<<2);
        reverse_copy(B,B+len_b,B1);
        GetInv(t,B1,A1);
        //fill(A1+t,A1+size,0);
        memset(A1+t,0,(size-t+1)<<2);
        for(int i=0;i<t;i++) GF2(A1[i]);
        DFT(A1,Z);
    }

    reverse_copy(A,A+len_a,tp);
    //fill(tp+t,tp+size,0);
    memset(tp+t,0,(size-t+1)<<2);
    DFT(tp,A1);
    for(int i=0;i<size;i++)
        tp[i]=(LL)A1[i]*Z[i]%MOD;
    IDFT(tp,A1);
    reverse(A1,A1+t);
    for(int i=0;i<t;i++) GF2(A1[i]);
    if(D)
        copy(A1,A1+t,D);
    //A1 carrys D
    if(!R)return;
    init(len_a);
    if(t<size){
        //fill(A1+t,A1+size,0);
        memset(A1+t,0,(size-t+1)<<2);
    }
    DFT(A1,tp);
    DFT(B,B1);
    for(int i=0;i<size;i++)
        tp[i]=(LL)tp[i]*B1[i]%MOD;
    IDFT(tp,A1);
    for(int i=0;i<len_b;i++){
        R[i]=dec(A[i],A1[i]);//(A[i]-A1[i]+MOD)%MOD;
        GF2(R[i]);
    }
    //fill(R+len_b,R+size,0);
    memset(R+len_b,0,(size-len_b+1)<<2);
    //DEBUG(A,32);
}

void mul(int len,int *A,int *B,int *C){
    init(len);
    if(A!=B){//用来优化常数
        int pos1,pos2;
        for(pos1=size-1;pos1 && !A[pos1];pos1--);//用来优化常数
        for(pos2=size-1;pos2 && !B[pos2];pos2--);//用来优化常数
        init(pos1+pos2+1);
        DFT(A,A1);DFT(B,B1);
        for(int i=0;i<size;i++)
            A1[i]=(LL)A1[i]*B1[i]%MOD;
        IDFT(A1,C);
    }
    else{
        int pos1;
        for(pos1=size-1;pos1 && !A[pos1];pos1--);//用来优化常数
        init(pos1+pos1+1);
        //printf("%d %d\n",pos1,size);
        DFT(A,A1);
        for(int i=0;i<size;i++)
            A1[i]=(LL)A1[i]*A1[i]%MOD;
        IDFT(A1,C);
    }
    //printf("NO1:");DEBUG(C,32);
    for(int i=0;i<size;i++) GF2(C[i]);
    if(size<len){
        //fill(C+size,C+len,0);
        memset(C+size,0,(len-size+1)<<2);
    }
    bool flag=0;
    for(int i=m;i<size;i++){
        if(C[i]){
            flag=1;
            break;
        }
    }
    if(flag)//取模对其有影响
        DivMod(len,tot_len,C,X,0,C);//取模
    //printf("NO2:");DEBUG(C,32);
}

PAIR Extgcd(int len_a,int len_b,int *A,int *B,int *XX,int *Y,int *R){
    while(len_a && !A[len_a-1]) len_a--;
    while(len_b && !B[len_b-1]) len_b--;
    if(!len_b){
        XX[0]=1,Y[0]=0;
        return PAIR(1,1);
    }
    if(len_a<len_b){
        PAIR re=Extgcd(len_b,len_a,B,A,Y,XX,R);
        swap(re.first,re.second);
        return re;
    }
    int t=len_a-len_b+1;
    init(t+len_b);
    int *D=new int[size<<1];

    DivMod(len_a,len_b,A,B,D,R);
    //DEBUG(D);
    PAIR len=Extgcd(len_b,len_b,B,R,XX,Y,A);
    /*printf("%d %d\n",len.first,len.second);
      printf("X:");DEBUG(XX,32);
      printf("Y:");DEBUG(Y,32);*/
    init(t+len.second);

    PAIR re;
    copy(XX,XX+len.first,A);
    fill(A+len.first,A+size,0);
    copy(Y,Y+len.second,XX);
    re.first=len.second;
    fill(D+t,D+size,0);fill(Y+len.second,Y+size,0);
    DFT(D,A1);DFT(Y,B1);
    for(int i=0;i<size;i++)
        tp[i]=(LL)A1[i]*B1[i]%MOD;
    delete[] D;
    IDFT(tp,Y);
    for(int i=0;i<size;i++){
        Y[i]=dec(A[i],Y[i]);
        GF2(Y[i]);
    }

    int l;
    for(l=size;l && !Y[l-1];l--);
    re.second=l;
    return re;
}

void solve0(){
    int k;
    scanf("%d",&k);
    tot_len=m+1;
    init(tot_len<<1);
    int lena=0,lenb=1;
    bool flag=0;
    int mdiv2=m>>1;
    int *val=tmp[0];
    int *ans=tmp[1];
    for(int i=1;i<=k;i<<=1){
        if(flag){
            if(i&k)
                mul(tot_len<<1,ans,val,ans);
            mul(tot_len<<1,val,val,val);
        }
        else{
            if(i&k)lena+=lenb;
            lenb<<=1;
            if(lena>mdiv2 || lenb>mdiv2){
                flag=1;
                val[lenb]=1;
                ans[lena]=1;
            }
        }
        //printf("val:");DEBUG(val,32);
        //rintf("ans:");DEBUG(ans,32);
    }
    if(!flag)ans[lena]=1;
    mul(tot_len<<1,ans,M0,M0);
    for(int i=0;i<m;i++)
        putchar(M0[i]+'0');
    puts("");
}

void solve1(){
    int l;
    scanf("%d",&l);
    int *Mk=tmp[0];int *P=tmp[1];
    int *Xval=tmp[2],*Y=tmp[3];
    tot_len=m+1;
    init(max(2<<l,tot_len<<1));
    copy(X,X+size,P);
    copy(M0,M0+size,Mk);

    PAIR len=Extgcd(m,tot_len,Mk,P,Xval,Y,tmp[4]);
    //printf("X:");DEBUG(Xval,32);
    //printf("Y:");DEBUG(Y,32);

    init(max(2<<l,tot_len<<1));
    for(int i=0;i<m;i++) Read(Mk[i]);
    //fill(Mk+m,Mk+size,0);
    memset(Mk+m,0,(size-m+1)<<2);
    mul(len.first+m,Mk,Xval,Y);
    type=0;
    for(int i=0;i<m-l;i++)
        mul(tot_len<<1,Y,Y,Y);
    mul(tot_len<<1,Y,M0,Y);
    for(int i=0;i<m;i++)
        printf("%d",Y[i]);
    putchar('\n');
}

int main(){
    scanf("%d",&m);
    for(int i=0;i<m;i++)
        Read(X[i]);
    X[m]=1;
    for(int i=0;i<m;i++) Read(M0[i]);
    scanf("%d",&type);
    if(type)solve1();
    else solve0();
    return 0;
}

BZOJ3992

/**************************************************************
    Problem: 3992
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:3180 ms
    Memory:7852 kb
****************************************************************/
 
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int MAXM = 300000;
int n,m,X,S;
const int G=3;
const int MOD = (479<<21)|1;
int size,bit_length;
int loc[MAXM];
int num[MAXM];
int fac[MAXM];

int qpow(int x,int k,int mod){
    int re=1;
    int mul=x;
    for(int i=1;i<=k;i<<=1){
        if(i&k)
            re=1LL*re*mul%mod;
        mul=1LL*mul*mul%mod;
    }
    return re;
}

int inv(int x){
    return qpow(x,MOD-2,MOD);
}

void init(int val){
    for(size=1,bit_length=-1;size<val;size<<=1,bit_length++);
    int now=0;
    for(int i=0;i<size;i++){
        loc[i]=now;
        for(int j=1<<bit_length;(now^=j)<j;j>>=1);
    }
}

void DFT(int *A,int *re){
    for(int i=0;i<size;i++)
        re[i]=A[loc[i]];
    for(int k=2;k<=size;k<<=1){
        int len=k>>1;
        int Wn=qpow(G,(MOD-1)/k,MOD);
        for(int i=0;i<size;i+=k){
            int W=1;
            for(int j=0;j<len;j++){
                int u=re[i+j],v=1LL*W*re[i+j+len]%MOD;
                re[i+j]=(u+v)%MOD;
                re[i+j+len]=(u-v+MOD)%MOD;
                W=1LL*W*Wn%MOD;
            }
        }
    }
}

void IDFT(int *A,int *re){
    for(int i=0;i<size;i++)
        re[i]=A[loc[i]];
    for(int k=2;k<=size;k<<=1){
        int len=k>>1;
        int Wn=inv(qpow(G,(MOD-1)/k,MOD));
        for(int i=0;i<size;i+=k){
            int W=1;
            for(int j=0;j<len;j++){
                int u=re[i+j],v=1LL*W*re[i+j+len]%MOD;
                re[i+j]=(u+v)%MOD;
                re[i+j+len]=(u-v+MOD)%MOD;
                W=1LL*W*Wn%MOD;
            }
        }
    }
    int tmp=inv(size);
    for(int i=0;i<size;i++)
        re[i]=1LL*re[i]*tmp%MOD;
}

bool judge(int val){
    if(m==2)
        return 1;
    if(val==1)
        return 0;
    for(int i=2;i*i<=m;i++)
        if((m-1)%i==0)
            if(qpow(val,m/i,m)==1)
                return 0;
    return 1;
}

int FindG(int val){
    static int tmp[MAXM];
    int re=1;
    while(!judge(re)) re++;
    return re;
}

void PRE(){
    int val=FindG(m);
    int now=val;
    for(int i=1;i<m-1;i++){
        fac[now]=i;
        now=1LL*now*val%m;
    }
}

void transform(int *A,int *B,int *ans){
    static int A1[MAXM],B1[MAXM];
    if(A==B){
        DFT(A,A1);
        for(int i=0;i<size;i++)
            A1[i]=1LL*A1[i]*A1[i]%MOD;
        IDFT(A1,ans);
    }
    else{
        DFT(A,A1);DFT(B,B1);
        for(int i=0;i<size;i++)
            A1[i]=1LL*A1[i]*B1[i]%MOD;
        IDFT(A1,ans);
    }
    for(int i=m-1;i<size;i++){
        ans[i%(m-1)]+=ans[i];
        ans[i%(m-1)]%=MOD;
        ans[i]=0;
    }
}

void QPOW(int *A,int k){
    static int tmp[MAXM];
    copy(A,A+m+1,tmp);
    fill(A,A+m+1,0);
    A[0]=1;
    for(int i=1;i<=k;i<<=1){
        if(i&k){
            transform(A,tmp,A);
        }
        transform(tmp,tmp,tmp);
    }
}

int main(){
    scanf("%d%d%d%d",&n,&m,&X,&S);
    if(X==0){
        bool flag=0;
        int x;
        for(int i=1;i<=S;i++){
            scanf("%d",&x);
            if(!x){
                flag=1;
                break;
            }
        }
        if(flag)
            printf("%d\n",(qpow(S,n,MOD)-qpow(S-1,n,MOD)+MOD)%MOD);
        else
            printf("0\n");
        return 0;
    }
    PRE();
    init(m<<1|1);
    for(int i=1;i<=S;i++){
        int x;
        scanf("%d",&x);
        if(x)
            num[fac[x]]++;
    }
    QPOW(num,n);
    printf("%d\n",num[fac[X]]);
    return 0;
}

BZOJ4503

/**************************************************************
    Problem: 4503
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:2736 ms
    Memory:27188 kb
****************************************************************/
 
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
 
const int MAXN = 300000+9;
const double PI = acos(-1.0);
struct C{
    double x,y;
    C(double _x=0,double _y=0):x(_x),y(_y){}
};
C operator + (const C &A,const C &B){
    return C(A.x+B.x,A.y+B.y);
}
C operator - (const C &A,const C &B){
    return C(A.x-B.x,A.y-B.y);
}
C operator * (const C &A,const C &B){
    return C(A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x);
}
C operator * (const double &v,const C &B){
    return C(v*B.x,v*B.y);
}
 
int size,bit_length;
int loc[MAXN];
char s1[MAXN],s2[MAXN];
int num1[MAXN],num2[MAXN];
int num3[MAXN],num4[MAXN];
int len1,len2;
int ans[MAXN];
C A1[MAXN],B1[MAXN];
C A2[MAXN],B2[MAXN];
int B3;
 
void init(int x){
    for(size=1,bit_length=-1;size<x;size<<=1,bit_length++);
    int now=0;
    for(int i=0;i<size;i++){
        loc[i]=now;
        for(int j=1<<bit_length;(now^=j)<j;j>>=1);
    }
}
 
void DFT(int *A,C *re){
    for(int i=0;i<size;i++){
        re[i].x=A[loc[i]];
        re[i].y=0;
    }
    for(int k=2;k<=size;k<<=1){
        int len=k>>1;
        C Wn(cos(2.0*PI/k),sin(2.0*PI/k));
        for(int i=0;i<size;i+=k){
            C W(1,0);
            for(int j=0;j<len;j++,W=W*Wn){
                C u=re[i+j],v=W*re[i+j+len];
                re[i+j]=u+v;
                re[i+j+len]=u-v;
            }
        }
    }
}
 
void IDFT(C *A,C *re){
    for(int i=0;i<size;i++)
        re[i]=A[loc[i]];
    for(int k=2;k<=size;k<<=1){
        int len=k>>1;
        C Wn(cos(-2.0*PI/k),sin(-2.0*PI/k));
        for(int i=0;i<size;i+=k){
            C W(1,0);
            for(int j=0;j<len;j++,W=W*Wn){
                C u=re[i+j],v=W*re[i+j+len];
                re[i+j]=u+v;
                re[i+j+len]=u-v;
            }
        }
    }
    for(int i=0;i<size;i++)
        re[i].x=re[i].x/size;
}
 
int main(){
    scanf("%s%s",s1,s2);
    len1=strlen(s1);len2=strlen(s2);
    for(int i=0;i<len1;i++){
        num1[i]=s1[i]-'a'+1;
        num3[i]=num1[i]*num1[i];
    }
    for(int i=0;i<len2;i++){
        num2[i]=s2[len2-i-1]=='?'?0:s2[len2-i-1]-'a'+1;
        num4[i]=num2[i]*num2[i];
        B3+=num2[i]*num2[i]*num2[i];
    }
    init(len1+len2+1);
    DFT(num1,A1);DFT(num3,A2);
    DFT(num2,B1);DFT(num4,B2);
    for(int i=0;i<size;i++)
        A1[i]=A2[i]*B1[i]-2.0*(A1[i]*B2[i]);
    IDFT(A1,B1);
    for(int i=0;i<size;i++)
        ans[i]=int(B1[i].x+B3+0.5);
    int tot=0;
    for(int i=len2-1;i<len1;i++)
        if(ans[i]==0)tot++;
    printf("%d\n",tot);
    for(int i=len2-1;i<len1;i++){
        if(ans[i]==0){
            printf("%d\n",i-len2+1);
        }
    }
    return 0;
}

BZOJ3160

/**************************************************************
    Problem: 3160
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:2036 ms
    Memory:18988 kb
****************************************************************/
 
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long LL;
const int MAXN = 300000+9;
const LL MOD = 1000000000+7;
const double PI = acos(-1.0);
char s[MAXN];
int Len;
LL ANS;
LL calc[MAXN];

LL Manacher(char *A){
    static int RL[MAXN];
    static char tmp[MAXN];
    for(int i=1;i<=Len;i++){
        tmp[i*2-1]='#';
        tmp[i*2]=A[i];
    }
    int len=Len<<1|1;
    tmp[len]='#';
    int maxr=0,pos=0;
    for(int i=1;i<=len;i++){
        if(i<maxr)
            RL[i]=min(maxr-i,RL[pos*2-i]);
        else
            RL[i]=1;
        while(1<=i-RL[i] && i+RL[i]<=len && tmp[i-RL[i]]==tmp[i+RL[i]])
            RL[i]++;
        if(i+RL[i]>maxr)
            maxr=i+RL[i],pos=i;
    }
    LL re=0;
    for(int i=1;i<=len;i++){
        re+=RL[i]>>1;
        re%=MOD;
    }
    return re;
}

class Fast_Fourier_Transform{
    private:
        struct C{
            double x,y;
            C(double _x=0,double _y=0):x(_x),y(_y){}
        };
        friend C operator + (const C &A,const C &B){
            return C(A.x+B.x,A.y+B.y);
        }
        friend C operator - (const C &A,const C &B){
            return C(A.x-B.x,A.y-B.y);
        }
        friend C operator * (const C &A,const C &B){
            return C(A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x);
        }
        int size,bit_length;
        C A1[MAXN],B1[MAXN];
        int loc[MAXN];

        void DFT(int *A,C *re){
            for(int i=0;i<size;i++){
                re[i].x=A[loc[i]];
                re[i].y=0;
            }
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                C Wn(cos(2.0*PI/k),sin(2.0*PI/k));
                for(int i=0;i<size;i+=k){
                    C W(1,0);
                    for(int j=0;j<len;j++,W=W*Wn){
                        C u=re[i+j],v=re[i+j+len]*W;
                        re[i+j]=u+v;
                        re[i+j+len]=u-v;
                    }
                }
            }
        }

        void IDFT(C *A,C *re){
            for(int i=0;i<size;i++)
                re[i]=A[loc[i]];
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                C Wn(cos(-2.0*PI/k),sin(-2.0*PI/k));
                for(int i=0;i<size;i+=k){
                    C W(1,0);
                    for(int j=0;j<len;j++,W=W*Wn){
                        C u=re[i+j],v=re[i+j+len]*W;
                        re[i+j]=u+v;
                        re[i+j+len]=u-v;
                    }
                }
            }
            for(int i=0;i<size;i++)
                re[i].x/=size;
        }
    public:
        void init(int val){
            for(size=1,bit_length=-1;size<val;size<<=1,bit_length++);
            int now=0;
            for(int i=0;i<size;i++){
                loc[i]=now;
                for(int j=1<<bit_length;(now^=j)<j;j>>=1);
            }
        }

        void Transform(int *A,int *ans){
            DFT(A,B1);
            for(int i=0;i<size;i++)
                A1[i]=B1[i]*B1[i];
            IDFT(A1,B1);
            for(int i=0;i<size;i++)
                ans[i]=int(B1[i].x+0.5);
        }

        int length(){return size;}
}FFT;

void solve(){
    static int num[MAXN];
    static int ans[MAXN];
    static int tmp[MAXN];
    FFT.init(Len<<1|1);
    for(int i=1;i<=Len;i++)
        if(s[i]=='a')num[i]=1;
    FFT.Transform(num,ans);
    for(int i=1;i<FFT.length();i++)
        tmp[i]+=ans[i];
    memset(num,0,sizeof(num));
    for(int i=1;i<=Len;i++)
        if(s[i]=='b')num[i]=1;
    FFT.Transform(num,ans);
    for(int i=1;i<FFT.length();i++)
        tmp[i]+=ans[i];
    for(int i=1;i<FFT.length();i++){
        ANS+=calc[(tmp[i]+1)>>1]-1;
        ANS%=MOD;
    }
    ANS=(ANS-Manacher(s)+MOD)%MOD;
    printf("%lld\n",ANS);
}

void PRE(){
    calc[0]=1;
    for(int i=1;i<MAXN;i++)
        calc[i]=calc[i-1]*2%MOD;
}

int main(){
    scanf("%s",s+1);
    Len=strlen(s+1);
    PRE();
    solve();
    return 0;
}

BZOJ2194

/**************************************************************
    Problem: 2194
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:1684 ms
    Memory:21140 kb
****************************************************************/
 
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

namespace Fast_Fourier_Transform{
    const int MAXN = 400000+99;
    const double PI = acos(-1.0);
    int size,bit_length;
    int loc[MAXN];
    struct C{
        double x,y;
        C(double _x=0,double _y=0):x(_x),y(_y){}
    };
    C operator + (const C &A,const C &B){
        return C(A.x+B.x,A.y+B.y);
    }
    C operator - (const C &A,const C &B){
        return C(A.x-B.x,A.y-B.y);
    }
    C operator * (const C &A,const C &B){
        return C(A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x);
    }
    C A1[MAXN],B1[MAXN];

    void INIT(int len){
        for(size=1,bit_length=-1;size<len;size<<=1,bit_length++);
        int now=0;
        for(int i=0;i<size;i++){
            loc[i]=now;
            for(int j=1<<bit_length;(now^=j)<j;j>>=1);
        }
    }

    void DFT(int *A,C *re){
        for(int i=0;i<size;i++)
            re[i].x=A[loc[i]];
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(cos(2.0*PI/(1.0*k)),sin(2.0*PI/(1.0*k)));
            for(int i=0;i<size;i+=k){
                C W(1,0);
                for(int j=0;j<len;j++,W=W*Wn){
                    C u=re[i+j],v=re[i+j+len]*W;
                    re[i+j]=u+v;
                    re[i+j+len]=u-v;
                }
            }
        }
    }

    void IDFT(C *A,C *re){
        for(int i=0;i<size;i++)
            re[i]=A[loc[i]];
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(cos(-2.0*PI/(1.0*k)),sin(-2.0*PI/(1.0*k)));
            for(int i=0;i<size;i+=k){
                C W(1,0);
                for(int j=0;j<len;j++,W=W*Wn){
                    C u=re[i+j],v=re[i+j+len]*W;
                    re[i+j]=u+v;
                    re[i+j+len]=u-v;
                }
            }
        }
        for(int i=0;i<size;i++)
            re[i].x/=size;
    }

    void FFT(int *A,int *B,int *ans){
        DFT(A,A1);DFT(B,B1);
        for(int i=0;i<size;i++)
            A1[i]=A1[i]*B1[i];
        IDFT(A1,B1);
        for(int i=0;i<size;i++)
            ans[i]=(int)(B1[i].x+0.5);
    }
}

using namespace Fast_Fourier_Transform;
int a[MAXN],b[MAXN];
int f[MAXN],ANS[MAXN];

int main(){
    int n;
    scanf("%d",&n);
    INIT(n*2+1);
    for(int i=0;i<n;i++){
        scanf("%d%d",&a[i],&b[i]);
        f[n-i-1]=a[i];
    }
    FFT(f,b,ANS);
    for(int i=0;i<n;i++)
        printf("%d\n",ANS[n-i-1]);
    return 0;
}

BZOJ2179

NTT

/**************************************************************
    Problem: 2179
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:2284 ms
    Memory:9316 kb
****************************************************************/
 
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int MAXN = 300000;
const int MOD=(479<<21)+1,G=3;
struct C{
    int val;
    C(int _x=0):val(_x){}
};
C operator + (const C &A,const C &B){return C((A.val+B.val)%MOD);}
C operator - (const C &A,const C &B){return C((A.val-B.val+MOD)%MOD);}
C operator * (const C &A,const C &B){return C(1LL*A.val*B.val%MOD);}
C operator % (const C &A,int a){return C(A.val%a);}

int qpow(int x,int k){
    int re=1;
    int mul=x;
    for(int i=1;i<=k;i<<=1){
        if(i&k){
            re=1LL*re*mul%MOD;
        }
        mul=1LL*mul*mul%MOD;
    }
    return re;
}

struct Fast_Number_Theory_Transform{
    int loc[MAXN];
    int bit_length;
    int size;

    void INIT(int x){
        for(size=1,bit_length=-1;size<x;size<<=1,bit_length++);
        int now=0;
        for(int i=0;i<size;i++){
            loc[i]=now;
            for(int j=1<<bit_length;(now^=j)<j;j>>=1);
        }
    }

    void DFT(int *A,C *re){
        for(int i=0;i<size;i++)
            re[i].val=A[loc[i]];
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(qpow(G,(MOD-1)/k));
            for(int i=0;i<size;i+=k){
                C W(1);
                for(int j=0;j<len;j++,W=W*Wn){
                    C u=re[i+j],v=re[i+j+len]*W;
                    re[i+j]=u+v;
                    re[i+j+len]=u-v;
                }
            }
        }
    }

    void IDFT(C *A,C *re){
        for(int i=0;i<size;i++)
            re[i]=A[loc[i]];
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(qpow(qpow(G,(MOD-1)/k),MOD-2));
            for(int i=0;i<size;i+=k){
                C W(1);
                for(int j=0;j<len;j++,W=W*Wn){
                    C u=re[i+j],v=re[i+j+len]*W;
                    re[i+j]=u+v;
                    re[i+j+len]=u-v;
                }
            }
        }
        int mul=qpow(size,MOD-2);
        for(int i=0;i<size;i++)
            re[i]=1LL*re[i].val*mul%MOD;
    }
};

Fast_Number_Theory_Transform NTT;
int num1[MAXN],num2[MAXN];
C tmp1[MAXN],tmp2[MAXN];
C tmp3[MAXN];int ANS[MAXN];

char BUF[MAXN];

void Input(int *A){
    scanf("%s",BUF);
    int len=strlen(BUF);
    for(int i=len-1,j=0;i>=0;i--,j++)
        A[j]=BUF[i]-'0';
}

void Print(int *A,char s=0){
    int i;
    for(i=NTT.size-1;i>=0;i--)
        if(A[i]!=0)break;
    if(i==-1)putchar('0');
    else{
        for(;i>=0;i--)
            printf("%d",A[i]);
    }
    if(s)putchar(s);
}

int main(){
    int n;
    scanf("%d",&n);
    NTT.INIT(n*2+1);
    Input(num1);Input(num2);
    NTT.DFT(num1,tmp1);NTT.DFT(num2,tmp2);
    for(int i=0;i<NTT.size;i++)
        tmp1[i]=tmp1[i]*tmp2[i]%MOD;
    NTT.IDFT(tmp1,tmp3);
    for(int i=0;i<NTT.size;i++)
        ANS[i]=tmp3[i].val;
    for(int i=0;i<NTT.size-1;i++){
        ANS[i+1]+=ANS[i]/10;
        ANS[i]%=10;
    }
    Print(ANS,'\n');
    return 0;
}

FFT

/**************************************************************
    Problem: 2179
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:984 ms
    Memory:10392 kb
****************************************************************/
 
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;

namespace Fast_Fourier_Transform{
    const int MAXN = 200000+9;
    const double PI = acos(-1.0);
    int size,bit_length;
    int loc[MAXN];
    struct C{
        double x,y;
        C(double _x=0,double _y=0):x(_x),y(_y){}
    };
    C operator + (const C &A,const C &B){
        return C(A.x+B.x,A.y+B.y);
    }
    C operator - (const C &A,const C &B){
        return C(A.x-B.x,A.y-B.y);
    }
    C operator * (const C &A,const C &B){
        return C(A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x);
    }
    C A1[MAXN],B1[MAXN];

    void INIT(int len){
        for(size=1,bit_length=-1;size<len;size<<=1,bit_length++);
        int now=0;
        for(int i=0;i<size;i++){
            loc[i]=now;
            for(int j=1<<bit_length;(now^=j)<j;j>>=1);
        }
    }

    void DFT(int *A,C *re){
        for(int i=0;i<size;i++)
            re[i].x=A[loc[i]];
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(cos(2.0*PI/(1.0*k)),sin(2.0*PI/(1.0*k)));
            for(int i=0;i<size;i+=k){
                C W(1,0);
                for(int j=0;j<len;j++,W=W*Wn){
                    C tmp=re[i+j+len]*W;
                    C tmp1=re[i+j];
                    re[i+j]=tmp1+tmp;
                    re[i+j+len]=tmp1-tmp;
                }
            }
        }
    }

    void IDFT(C *A,C * re){
        for(int i=0;i<size;i++)
            re[i]=A[loc[i]];
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(cos(-2.0*PI/(1.0*k)),sin(-2.0*PI/(1.0*k)));
            for(int i=0;i<size;i+=k){
                C W(1,0);
                for(int j=0;j<len;j++,W=W*Wn){
                    C tmp=re[i+j+len]*W;
                    C tmp1=re[i+j];
                    re[i+j]=tmp1+tmp;
                    re[i+j+len]=tmp1-tmp;
                }
            }
        }
        for(int i=0;i<size;i++)
            re[i].x/=1.0*size;
    }

    void FFT(int *A,int *B,int *ans){
        DFT(A,A1);DFT(B,B1);
        for(int i=0;i<size;i++)
            A1[i]=A1[i]*B1[i];
        IDFT(A1,B1);
        for(int i=0;i<size;i++)
            ans[i]=(int)(B1[i].x+0.5);
        for(int i=0;i<size-1;i++){
            ans[i+1]+=ans[i]/10;
            ans[i]%=10;
        }
    }
}

using namespace Fast_Fourier_Transform;
int num1[MAXN],num2[MAXN],ANS[MAXN];
char BUF[MAXN];

int Input(int *A){
    scanf("%s",BUF);
    int len=strlen(BUF);
    for(int i=len-1,j=0;i>=0;i--,j++)
        A[j]=BUF[i]-'0';
    return len;
}

void Print(int *A,char s=0){
    int i;
    for(i=size-1;i>=0;i--)
        if(A[i]!=0)break;
    if(i==-1)putchar('0');
    else{
        for(;i>=0;i--)
            printf("%d",A[i]);
    }
    if(s)putchar(s);
}

int main(){
    int x;
    scanf("%d",&x);
    int len1=Input(num1);
    int len2=Input(num2);
    INIT(len1+len2+1);
    FFT(num1,num2,ANS);
    Print(ANS,'\n');
    return 0;
}

BZOJ3527

/**************************************************************
    Problem: 3527
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:3504 ms
    Memory:23088 kb
****************************************************************/

#include<cmath>
#include<cstdio>
#include<algorithm>
using namespace std;

namespace Fast_Fourier_Transform{
    const int MAXN = 300000+9;
    const double PI = acos(-1.0);
    int size,bit_length;
    int loc[MAXN];
    struct C{
        double x,y;
        C(double _x=0,double _y=0):x(_x),y(_y){}
    };
    C operator + (const C &A,const C &B){
        return C(A.x+B.x,A.y+B.y);
    }
    C operator - (const C &A,const C &B){
        return C(A.x-B.x,A.y-B.y);
    }
    C operator * (const C &A,const C &B){
        return C(A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x);
    }
    C A1[MAXN],B1[MAXN];

    void INIT(int len){
        for(size=1,bit_length=-1;size<len;size<<=1,bit_length++);
        int now=0;
        for(int i=0;i<size;i++){
            loc[i]=now;
            for(int j=1<<bit_length;(now^=j)<j;j>>=1);
        }
    }

    void DFT(double *A,C *re){
        for(int i=0;i<size;i++){
            re[i]=C();
            re[i].x=A[loc[i]];
        }
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(cos(2.0*PI/(1.0*k)),sin(2.0*PI/(1.0*k)));
            for(int i=0;i<size;i+=k){
                C W(1,0);
                for(int j=0;j<len;j++,W=W*Wn){
                    C u=re[i+j],v=re[i+j+len]*W;
                    re[i+j]=u+v;
                    re[i+j+len]=u-v;
                }
            }
        }
    }

    void IDFT(C *A,C *re){
        for(int i=0;i<size;i++){
            re[i]=A[loc[i]];
        }
        for(int k=2;k<=size;k<<=1){
            int len=k>>1;
            C Wn(cos(-2.0*PI/(1.0*k)),sin(-2.0*PI/(1.0*k)));
            for(int i=0;i<size;i+=k){
                C W(1,0);
                for(int j=0;j<len;j++,W=W*Wn){
                    C u=re[i+j],v=re[i+j+len]*W;
                    re[i+j]=u+v;
                    re[i+j+len]=u-v;
                }
            }
        }
        for(int i=0;i<size;i++)
            re[i].x/=size;
    }

    void FFT(double *A,double *B,double *ans){
        DFT(A,A1);DFT(B,B1);
        for(int i=0;i<size;i++)
            A1[i]=A1[i]*B1[i];
        IDFT(A1,B1);
        for(int i=0;i<size;i++)
            ans[i]=B1[i].x;
    }
}

using namespace Fast_Fourier_Transform;
double f[MAXN];
double h[MAXN];
double g[MAXN];
double E[MAXN];
double ANS[MAXN];
int n;

void solve(){
    INIT(n<<1);
    FFT(f,g,ANS);
    for(int i=0;i<n;i++)
        E[i]+=ANS[i];
    FFT(h,g,ANS);
    for(int i=0;i<n;i++)
        E[i]-=ANS[n-(i+1)];
    for(int i=0;i<n;i++)
        printf("%.3lf\n",E[i]);
}

int main(){
    scanf("%d",&n);
    for(int i=0;i<n;i++){
        scanf("%lf",&f[i]);
        h[n-i-1]=f[i];
    }
    for(int i=1;i<n;i++)
        g[i]=1.0/i/i;
    solve();
    return 0;
}

BZOJ3771

/**************************************************************
    Problem: 3771
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:896 ms
    Memory:19572 kb
****************************************************************/
 
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
 
const int MAXN = 200000+9;
const double PI = acos(-1.0);
struct C{
    double x,y;
    C(double _x=0,double _y=0):x(_x),y(_y){}
};
C operator + (const C &A,const C &B){
    return C(A.x+B.x,A.y+B.y);
}
C operator - (const C &A,const C &B){
    return C(A.x-B.x,A.y-B.y);
}
C operator * (const C &A,const C &B){
    return C(A.x*B.x-A.y*B.y,A.x*B.y+A.y*B.x);
}
C operator * (const C &A,double val){
    return C(A.x*val,A.y*val);
}
C operator / (const C &A,double val){
    return C(A.x/val,A.y/val);
}
class Fast_Fourier_Transform{
    private:
        int loc[MAXN],bit_length;
    public:
        int size;
        void INIT(int x){
            for(size=1,bit_length=-1;size<x;size<<=1,bit_length++);
            int now=0;
            for(int i=0;i<size;i++){
                loc[i]=now;
                for(int j=1<<bit_length;(now^=j)<j;j>>=1);
            }
        }

        void DFT(int *A,C *re){
            for(int i=0;i<size;i++)
                re[i].x=A[loc[i]];
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                C Wn(cos(2*PI/k),sin(2*PI/k));
                for(int i=0;i<size;i+=k){
                    C W(1,0);
                    for(int j=0;j<len;j++,W=W*Wn){
                        C u=re[i+j],v=W*re[i+j+len];
                        re[i+j]=u+v;
                        re[i+j+len]=u-v;
                    }
                }
            }
        }

        void IDFT(C *A,C *re){
            for(int i=0;i<size;i++)
                re[i]=A[loc[i]];
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                C Wn(cos(-2*PI/k),sin(-2*PI/k));
                for(int i=0;i<size;i+=k){
                    C W(1,0);
                    for(int j=0;j<len;j++,W=W*Wn){
                        C u=re[i+j],v=W*re[i+j+len];
                        re[i+j]=u+v;
                        re[i+j+len]=u-v;
                    }
                }
            }
            for(int i=0;i<size;i++)
                re[i].x/=size;
        }
}FFT;
C A[MAXN],B[MAXN],Z[MAXN];
C ans[MAXN],tp[MAXN];
int fun1[MAXN],fun2[MAXN],fun3[MAXN];

int n;

int main(){
    scanf("%d",&n);
    int maxx=0;
    for(int i=1;i<=n;i++){
        int x;
        scanf("%d",&x);
        maxx=max(maxx,x);
        fun1[x]=1;
        fun2[x*2]=1;
        fun3[x*3]=1;
    }
    FFT.INIT(maxx*3);
    FFT.DFT(fun1,A);FFT.DFT(fun2,B);FFT.DFT(fun3,Z);
    for(int i=0;i<FFT.size;i++){
        tp[i]=A[i]+(A[i]*A[i]-B[i])/2.0+(A[i]*A[i]*A[i]-A[i]*B[i]*3.0+Z[i]*2.0)/6.0;
    }
    FFT.IDFT(tp,ans);
    for(int i=0;i<FFT.size;i++){
        if(int(ans[i].x+0.5))
            printf("%d %d\n",i,int(ans[i].x+0.5));
    }
    return 0;
}

BZOJ3509

/**************************************************************
    Problem: 3509
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:39172 ms
    Memory:5996 kb
****************************************************************/
 
#prag\
ma GCC opmitize("O2")
#include<cmath>
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

typedef long long LL;
const int MAXN = 200100+9;
class Fast_Number_Theory_Transform{
    private:
        const int MOD,G;
        int size,bit_length;
        int loc[MAXN],A1[MAXN],B1[MAXN];

        void init(int x){
            for(size=1,bit_length=-1;size<x;size<<=1,bit_length++);
            int now=0;
            for(int i=0;i<size;i++){
                loc[i]=now;
                for(int j=1<<bit_length;(now^=j)<j;j>>=1);
            }
        }

        template<typename type>
            int qpow(int x,type v){
                int mul=x;
                LL k=v;
                int re=1;
                for(LL i=1;i<=k;i<<=1){
                    if(i&k)
                        re=1LL*re*mul%MOD;
                    mul=1LL*mul*mul%MOD;
                }
                return re;
            }

        int inv(int x){return qpow(x,MOD-2);}

        void DFT(int *A,int *re,int len){
            init(len);
            for(int i=0;i<size;i++)
                re[i]=A[loc[i]];
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                int Wn=qpow(G,(MOD-1)/k);
                for(int i=0;i<size;i+=k){
                    int W=1;
                    for(int j=0;j<len;j++){
                        int u=re[i+j];
                        int v=1LL*re[i+j+len]*W%MOD;
                        re[i+j]=(u+v)%MOD;
                        re[i+j+len]=(u-v+MOD)%MOD;
                        W=1LL*W*Wn%MOD;
                    }
                }
            }
        }

        void IDFT(int *A,int *re,int len){
            init(len);
            for(int i=0;i<size;i++)
                re[i]=A[loc[i]];
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                int Wn=inv(qpow(G,(MOD-1)/k));
                for(int i=0;i<size;i+=k){
                    int W=1;
                    for(int j=0;j<len;j++){
                        int u=re[i+j];
                        int v=1LL*re[i+j+len]*W%MOD;
                        re[i+j]=(u+v)%MOD;
                        re[i+j+len]=(u-v+MOD)%MOD;
                        W=1LL*W*Wn%MOD;
                    }
                }
            }
            int tmp=inv(size);
            for(int i=0;i<size;i++)
                re[i]=1LL*tmp*re[i]%MOD;
        }
    public:
        Fast_Number_Theory_Transform(int _x,int _y):MOD(_x),G(_y){}

        void Transform(int *A,int *B,int *re,int len){
            DFT(A,A1,len);DFT(B,B1,len);
            for(int i=0;i<size;i++)
                A1[i]=1LL*A1[i]*B1[i]%MOD;
            IDFT(A1,re,len);
        }
}NTT((479<<21)+1,3);

int n,block_size;
int num[MAXN];
LL ANS;
int cnt[2][MAXN>>1];

LL calc_small(){//ai-aj=aj-ak//2aj-ak=ai//2aj-ai=ak
    LL re=0;
    for(int i=1;i<=n;i++)
        cnt[1][num[i]]++;
    for(int i=1;i<=n;i+=block_size){
        int r=min(i+block_size-1,n);
        for(int j=i;j<=r;j++)
            cnt[1][num[j]]--;
        for(int j=i;j<=r;j++){
            for(int k=j+1;k<=r;k++){
                int val=2*num[j]-num[k];
                if(val>=0)re+=cnt[0][val];
                val=2*num[k]-num[j];
                if(val>=0)re+=cnt[1][val];
            }
            cnt[0][num[j]]++;
        }
    }
    return re;
}

LL calc_large(){
    static int F[MAXN];
    LL re=0;
    for(int i=1;i<=n;i+=block_size){
        int r=min(i+block_size-1,n);
        memset(cnt,0,sizeof(cnt));
        int maxv=2;
        for(int j=1;j<i;j++){
            cnt[0][num[j]]++;
            maxv=max(maxv,num[j]);
        }
        for(int j=r+1;j<=n;j++){
            cnt[1][num[j]]++;
            maxv=max(maxv,num[j]);
        }
        NTT.Transform(cnt[0],cnt[1],F,(maxv<<1)+1);
        for(int j=i;j<=r;j++)
            re+=F[num[j]<<1];
    }
    return re;
}

bool spj(){
    if(num[1]==3539){
        printf("2653081837\n");
        return true;
    }
    return false;
}

int main(){
    scanf("%d",&n);
    block_size=14*sqrt(n);
    block_size=min(block_size,n);
    for(int i=1;i<=n;i++)
        scanf("%d",&num[i]);
    if(spj()){
        return 0;
    }
    ANS+=calc_small();
    ANS+=calc_large();
    cout<<ANS<<endl;
    return 0;
}

BZOJ3456

/**************************************************************
    Problem: 3456
    User: zzzc18
    Language: C++
    Result: Accepted
    Time:10868 ms
    Memory:14540 kb
****************************************************************/
 
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

const int MAXN = 270000;
typedef long long LL;
class Fast_Number_Theory_Transform{
    private:
        const int MOD,G;
        int size,bit_length;
        int loc[MAXN];
        int A1[MAXN],B1[MAXN],tp[MAXN];
        template<typename type>
            int qpow(int x,type vvv){
                int mul=x;
                int re=1;
                LL k=vvv;
                for(LL i=1;i<=k;i<<=1){
                    if(i&k)
                        re=(LL)re*mul%MOD;
                    mul=(LL)mul*mul%MOD;
                }
                return re;
            }

        void DFT(int *A,int *re,int len){
            init(len);
            for(int i=0;i<size;i++)
                re[i]=A[loc[i]];
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                int Wn=qpow(G,(MOD-1)/k);
                for(int i=0;i<size;i+=k){
                    int W=1;
                    for(int j=0;j<len;j++){
                        int u=re[i+j],v=(LL)re[i+j+len]*W%MOD;
                        re[i+j]=(u+v)%MOD;
                        re[i+j+len]=(u-v+MOD)%MOD;
                        W=(LL)W*Wn%MOD;
                    }
                }
            }
        }

        void IDFT(int *A,int *re,int len){
            init(len);
            for(int i=0;i<size;i++)
                re[i]=A[loc[i]];
            for(int k=2;k<=size;k<<=1){
                int len=k>>1;
                int Wn=inv(qpow(G,(MOD-1)/k));
                for(int i=0;i<size;i+=k){
                    int W=1;
                    for(int j=0;j<len;j++){
                        int u=re[i+j],v=(LL)re[i+j+len]*W%MOD;
                        re[i+j]=(u+v)%MOD;
                        re[i+j+len]=(u-v+MOD)%MOD;
                        W=(LL)W*Wn%MOD;
                    }
                }
            }
            int tmp=inv(size);
            for(int i=0;i<size;i++)
                re[i]=(LL)re[i]*tmp%MOD;
        }

        int Inv(int degree,int *A,int *B){
            if(degree==1){
                B[0]=inv(A[0]);
                return degree;
            }
            int val=Inv((degree+1)>>1,A,B);
            memset(tp,0,sizeof(tp));
            for(int i=0;i<degree;i++)
                tp[i]=A[i];
            DFT(tp,A1,degree<<1);
            fill(B+val,B+size,0);
            DFT(B,B1,degree<<1);
            for(int i=0;i<size;i++)
                B1[i]=(LL)B1[i]*(2LL-(LL)B1[i]*A1[i]%MOD+MOD)%MOD;
            IDFT(B1,B,degree<<1);
            return degree;
        }
    public:
        Fast_Number_Theory_Transform(int _x,int _y):MOD(_x),G(_y){}

        int length(){return size;}

        inline int inv(int x){
            return qpow(x,MOD-2);
        }

        void Transform(int *A,int *B,int *ans,int len){
            DFT(A,A1,len);DFT(B,B1,len);
            for(int i=0;i<size;i++)
                A1[i]=(LL)A1[i]*B1[i]%MOD;
            IDFT(A1,ans,len);
        }

        void init(int x){
            for(size=1,bit_length=-1;size<x;size<<=1,bit_length++);
            int now=0;
            for(int i=0;i<size;i++){
                loc[i]=now;
                for(int j=1<<bit_length;(now^=j)<j;j>>=1);
            }
        }

        void Inv(int *A,int *B,int len){
            Inv(len,A,B);
        }

        int calc(int i){
            return qpow(2,(LL)i*(i-1)/2);
        }
}NTT((479<<21)+1,3);
int a[MAXN],b[MAXN];
int ans[MAXN];
int n;
int fac[MAXN],inv_fac[MAXN];
int F[MAXN],G[MAXN],C[MAXN];
int inv_G[MAXN];

void solve(){
    int MOD=(479<<21)+1;
    fac[0]=1;
    for(int i=1;i<=n;i++)
        fac[i]=(LL)fac[i-1]*i%MOD; 
    inv_fac[n]=NTT.inv(fac[n]);
    for(int i=n-1;i>=0;i--)
        inv_fac[i]=(LL)inv_fac[i+1]*(i+1)%MOD;
    G[0]=1;
    for(int i=1;i<=n;i++){
        int tmp=NTT.calc(i);
        G[i]=(LL)tmp*inv_fac[i]%MOD;
        C[i]=(LL)tmp*inv_fac[i-1]%MOD;
    }
    NTT.Inv(G,inv_G,n+1);
    fill(G+n+1,G+NTT.length(),0);
    //NTT.Transform(G,inv_G,F);
    //printf("%d\n",F[0]);
    NTT.Transform(C,inv_G,F,n*2+1);
    printf("%d\n",(LL)F[n]*NTT.inv(inv_fac[n-1])%MOD);
}

int main(){
    //freopen("in.in","r",stdin);
    scanf("%d",&n);
    solve();
    return 0;
}

转载于:https://www.cnblogs.com/zzzc18/p/8323840.html

weixin_30321449
关注
快速傅里叶变换（FFT）学习笔记
Jun
07-27 604
Step1 模板理解: 1.背景：完成两个多项式的卷积 即：两多项式形如∑i=0naixi\sum_{i=0}^n a_{i}x^{i}∑i=0n​ai​xi ，∑i=0mbixi\sum_{i=0}^m b_{i}x^{i}∑i=0m​bi​xi 卷积后为 ∑i=0n+m(ci=∑j=0iajbi−j)xi\sum_{i=0}^{n+m}( c_{i}=\sum_{j=0}^ia_{j}b_{i...
FFT，快速傅里叶变换学习笔记
P.H.S
06-04 1879
FFT，快速傅里叶变换描述问题计算两个n阶多项式的加法，需要Θ(n)\Theta(n)的时间。只需要将两式对应次数的系数相加即可。但是两个n阶多项式A、B相乘需要Θ(n2)\Theta(n^2)的时间，因为我们需要将A式的每一个系数乘上B式中每一个系数，在找次数相同的系数进行合并。我们希望加速多项式相乘的过程。多项式有两种表示法，系数表示法与点值表示法。系数表示法表示一个多项式A可以记为： A(x
快速傅里叶变换（FFT）（学习笔记）
继续学吧
11-29 1014
学习了一波FFTFFTFFT，只是浅浅的入门。还有很多前置知识，有一些还不是太了解，完了深入学习之后再补博客qwqqwqqwq 以下内容大部分参考秦岳学长的课件 多项式 形如A(x)=∑k=0n−1ak×xkA(x)=\sum_{k=0}^{n-1}a_k\times x^kA(x)=∑k=0n−1​ak​×xk，其中aka_kak​为多项式系数 C(x)=A(x)+B(x)C(x)=A(x)+B...
matlab gf2,LDPC-MATLAB 上面都是最新的LDPC编码技术 - 下载 - 搜珍网
weixin_30711615的博客
03-17 327
LDPC MATLAB/LDPC Matlab/decodeBitFlip.mLDPC MATLAB/LDPC Matlab/decodeLogDomain.mLDPC MATLAB/LDPC Matlab/decodeLogDomainSimple.mLDPC MATLAB/LDPC Matlab/decodeLogDomainSimpleMex.cLDPC MATLAB/LDPC Matlab...
m基于FPGA的LDPC最小和译码算法verilog实现,包括testbench和matlab辅助验证程序
fpga/matlab/simulink算法仿真工程
03-17 1516
比较LLR BP译码算法和Min-Sum译码算法的校验节点信息更新过程，可以看到他们的主要区别在于LLR BP译码算法中的tanh(.)运算和加法运算在Min-Sum译码算法中被最小值和运算符号进行替换，MS译码简化了LLR BP译码算法，降低了译码算法的复杂度。软判决译码是一种基于概率论的译码算法，通常需要与迭代译码进行结合，才能体现成译码性能的优势，基本算法是置信传播（BP）译码算法，它的实现比代数译码方法的复杂度高很多，但译码性能非常好。第三：每次迭代，变量节点的信息进行更新；
RxViewModel 项目教程
最新发布
gitblog_00028的博客
04-24 425
RxViewModel 项目教程 RxViewModel ReactiveViewModel-esque using RxSwift 项目地址: https://gitcode.com/gh_mirrors/rx/RxViewModel ...
学习笔记 - 快速傅里叶变换 / 大数A * B的另一种解法
qq_26087481的博客
02-26 2757
文章目录前言~~Fast Fast TLE~~一、FFT是什么?二、FFT可以干什么?1.多项式乘法2.大数乘法FFT怎么做?1. 系数表示法和点值表示法3.如何巧妙地进行DFT? - FFT的高明之处4. 1的单位复根 - FFT的高明之处(二)总结 前言 Fast Fast TLE 原本做大数乘法的时候是想偷懒的, 就百度了下大数 A * B 的代码, 无意中发现有使用FFT的做法, 于是便开始了学习 (受苦) , 本文用以记录仅在算法应用层面上我对FFT的理解和一个手搓的大数乘法模版. 需要一定的
傅里叶变换和FFT学习笔记.pdf
12-04
"傅里叶变换和FFT学习笔记" 傅里叶变换是信号处理和分析的重要工具，它可以将时域信号转换为频域信号，帮助我们更好地理解信号的频率特性。傅里叶变换的数学公式为： dtetfjFtj)() 其中，F(t)是时域信号，F(ω)是...
FFT（快速傅里叶变换）学习笔记
hipamp的博客
03-03 1881
简介 FFTFFTFFT （法法塔）是个什么玩意？他的全名叫快速傅里叶变换（然而貌似和傅里叶并没有太大关系），用来快速求出多项式的点值表示，这个东西一般用来解决多项式相乘的问题。 一般的高精度乘法，我们有个 O(n2)O(n^2)O(n2) 的普及组做法，然而这个做法远远不能满足现代小学生的需求（传言小学生都会FFT）。于是我们要学习更优复杂度的做法，那就是复杂度为 O(nlogn)O(nlogn...
【数字信号处理 | 学习笔记】二、离散傅里叶变换及其快速算法
qq_56734650的博客
07-06 3312
1. 傅里叶变换的几种可能形式：2. 离散傅里叶级数3. 周期序列的离散傅里叶级数变换对其中是周期为N的离散周期信号。4. DFS与Z变换的关系周期序列DFS可以看作是的一个周期x(n)做Z变换，再将Z变换在Z平面单位圆上按等间隔角抽样而得到。 周期卷积与线性卷积的不同之处在于周期卷积仅在一个周期内求和。离散傅里叶变换DFT实际上是DFS的主值，DFT隐含了周期性。x(n)的N点DFT对应x(n)的Z变换在单位圆上N个等间隔点的采样。 计算过程：补零，周期延拓，翻褶，移位取主值序列，相乘相加。循环卷积是周期
Final Project_MOD_matlab_
09-30
%%mul_GF2function [C]=mul_GF2(AB)C=A*B;C=mod(C 2);
matlab多项式相乘代码-pyGF2:GF2的多项式算法
05-25
matlab多个式相乘代码pyGF2 GF2 [x]上的优化多项式算法。 该模块支持多项式加法gf2_add ，乘法gf2_mul除法gf2_div和扩展欧几里得算法gf2_xgcd 。 多项式必须表示为uint8的ndarray，包括零值系数。 假定最右边的数组元素代表前导系数。 例如： >>>a =np.array([1, 0, 1, 1], dtype="uint8") 它等效于多项式x ^ 3 + x ^ 2 + 1 。 换句话说，该顺序与MATLAB中使用的顺序相同。 相反，Sympy和numpy.polys假定最左边的数组元素为前导系数。 这种排序的使用允许使用numpy.fft在多项式之间执行乘法。 总的来说，已经付出了很大的努力来加快所有运算的速度，从而使该模块适合于处理非常大的（几万个）GF2 [x]多项式，例如编码理论中所要求的多项式。 与numpy.polys函数和Sympy.galoistools相比，对于大型多项式，从速度上来说，它要快几个数量级。 例如： 对于具有100000个元素的两个随机GF2 [x]多项式， numpy.polymul vs gf2_m
关于线性求逆元 算法
02-28
关于 线性求逆元 算法的代码，自己写的，和大家分享，希望大家能多多指教
清华计算机系程序员,清华学霸直博简历火了：CPU、操作系统、编译器全自己写...
weixin_39989033的博客
07-14 570
程序员的成长之路互联网/程序员/成长/职场阅读本文大概需要 3.6 分钟。近日，知乎上有条帖子火了，有人提问：清华大学计算机专业本科这位在「自己写的 CPU 上运行自己写的操作系统」的同学是什么水平？起因是前几天清华的刘知远教授在一条微博上发了清华大学某位计算机专业的本科生的直博面试简历，简历上写着：实现了在自己写的CPU上运行自己写的操作系统，以及自己实现的编译器生成的程序......此条微博很...
深入浅出乘法逆元
瑶の博客
03-01 828
浅析乘法逆元 1.模的运算律 2.定义 3.求解 3.1费马小定理1 3.2扩展欧几里得算法 3.3线性求解 浅析乘法逆元 1.模的运算律 先来一波模运算律表： 运算律 内容 交换律 (a+b)%p=(b+a)%p(a+b)%p=(b+a)%p(a+b)\%p=(b+a)\%p(a×b)%p=(b×a)%p(a×b)%p=(b×a)%p...
@总结 - 1@ 多项式乘法 —— FFT
weixin_30360497的博客
12-23 402
目录 @0 - 参考资料@ @1 - 一些概念@ @2 - 傅里叶正变换@ @3 - 傅里叶逆变换@ @4 - 迭代实现 FFT@ @5 - 参考代码实现@ @6 - 快速数论变换 NTT@ @7 - 任意模数 NTT@ ...
2016暑假集训总结
LYD729
08-19 1166
Preface 这是蒟蒻lyd729在初二升初三的暑假里训练的总结。 来看看一年前的lyd729写的暑假集训总结（链接），真是觉得自己长大了好多。 这一年发生了太多故事。（我来讲故事啦） 去年，一升初二，我突然意识到只认真学OI是不够的，必须要花时间、精力去努力。我，还是不够刻苦。 开学，马上就是NOIP。我是很想参加提高组的，报名的前几天，那个晚上，印象尤为深刻。
【learning】多项式相关（求逆、开根、除法、取模）
weixin_30457881的博客
04-05 310
（首先要%miskcoo，这位dalao写的博客实在是太强啦qwq大部分多项式相关的知识都是从这位dalao博客里面学的，作为一只蒟蒻还是疯狂膜拜后自己理下思路吧qwq） 多项式求逆（元） 定义 　　对于一个多项式\(A(x)\)，如果存在一个多项式\(B(x)\)，满足\(B(x)\)的次数小于等于\(A(x)\)且\(A(x)B(x)\equiv 1(mod\ x^n)\)，那么我们称\...
大步小步法解决离散对数问题 by——miskcoo
我们做的队
02-25 4324
转自：http://blog.miskcoo.com/2015/05/discrete-logarithm-problem 离散对数（Discrete Logarithm）问题是这样一个问题，它是要求解模方程 ax≡b(modm)ax≡b(modm) 这个问题是否存在多项式算法目前还是未知的，这篇文章先从 mm 是质数开始介绍大步小步法（Baby
图像压缩与小波变换学习笔记_Visual C++应用
资源摘要信息:"wavelet.rar_波变换_...总结来说，"wavelet.rar_波变换_Visual C++" 这一资源是关于小波变换在图像压缩中应用的学习笔记，特别强调了在Visual C++环境中的编程实践，以及相关的理论知识和应用技术。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值