【学习笔记】多项式运算

前置知识

有用的：多项式乘法，别人的博客和别人的博客。

没用的：自适应辛普森，拉格朗日反演，$\text{Half-GCD}$ 和下降幂多项式。

多元多项式乘法

可见于 $\text{EntropyIncreaser}$ 的博客。设第 $i$ 维只用保留 $(n_i-1)$ 次项。

取占位数 $\chi (i)=\lfloor \frac{i}{n_1}\rfloor +\lfloor \frac{i}{n_1{n}_2}\rfloor +\cdots +\lfloor \frac{i}{\prod n_j}\rfloor$，有 $\chi (i+j)-\chi (i)-\chi (j)\in [0,k)$，因此乘 ${\sigma }^{\chi (i)}$ 后对 $({\sigma }^k-1)$ 取模可行。复杂度 $\mathcal{O}(kN\log N)$，其中 $k$ 是变元的数量，而 $N=\prod n_i$ 。

不难发现，这是集合幂级数的推广。$\Delta \chi$ 其实是进位次数，类似 $\text{Kummer}$ 定理。

牛顿迭代

严谨地写，实际上我们是求解方程
$$G(\chi ,x)=0$$

的通解 $\chi =f(x)$ 。在 ${\chi }_0=f_0(x)$ 处，在 $\chi$ 这一维上泰勒展开，得
$$G(\chi ,x)=G({\chi }_0,x)+(\chi -{\chi }_0)\cdot G^{\prime }({\chi }_0,x)+R(\chi )$$

这里的导数 $G^{\prime }$ 都是在 $\chi$ 上的偏导。其中有拉格朗日余项 $R(\chi )=\frac{(\chi -{\chi }_0{)}^2}{2!}{G}^{\prime \prime }[x_0+\gamma (x-x_0)](0<\gamma <1)$ 。此时，设 $f_0(x)\equiv f(x)(\mathrm{mod}{x}^n)$，代入 $\chi =f(x),{\chi }_0=f_0(x)$，再对 $x^{2n}$ 取模得到
$$G(f(x),x)\equiv G(f_0(x),x)+[f(x)-f_0(x)]\cdot G^{\prime }(f_0(x),x)(\mathrm{mod}{x}^{2n})$$

因为 $x^{2n}\mid [f(x)-f_0(x){]}^2\mid R(\chi )$ 。此时解方程 $G(f(x),x)\equiv 0(\mathrm{mod}{x}^{2n})$ 得
$$f(x)\equiv f_0(x)-\frac{G(f_0(x),x)}{G^{\prime }(f(x),x)}(\mathrm{mod}{x}^{2n})$$

只需解出常数 $c$ 使得 $G(c,x)\equiv 0(\mathrm{mod}x)$，然后不断迭代，就能得到对 $x^{2^k}$ 取模的根。

为了避免误解，举个例子，求 $\sqrt{A(x)}$ 。记 $G(f(x),x)=f(x{)}^2-A(x)$，那么 $G^{\prime }(f(x),x)=2f(x)$，因为其原型是 $G(\chi ,x)={\chi }^2-A(x)\Rightarrow \frac{\partial G(\chi ,x)}{\partial \chi }=2\chi$ 。

多点求值

求 $n$ 次多项式 $f(x)$ 的 $k$ 个点值 $f(x_i)(i\in [1,k])$ 。当 $k>n$ 时，将其拆解成 $\lceil \frac{k}{n}\rceil$ 次多点求值，故假定 $n⩾k$ 。

$f(x)\mathrm{mod}(x-x_1)$ 就是 $f(x_1)$ 。那么 $f(x)$ 取模 ${\prod }_{j\in S}(x-x_j)$ 就不会影响 $f(x_j)(j\in S)$ 的取值。

于是分治。对于区间 $l,r$ 可知 $f(x)\mathrm{mod}[{\prod }_{j=l}^r(x-x_j)]$ 的结果，往左递归则继续取模，往右递归也可取模。复杂度 $T(k)=2T(\frac{k}{2})+\mathcal{O}(k\log k)=\mathcal{O}(k{\log }^{2}k)$ 。再考虑到第一步 $f(x)\mathrm{mod}[{\prod }_{j=1}^k(x-x_j)]$ 需要 $\mathcal{O}(n\log n)$ ，总复杂度为
$$\mathcal{O}(n\log n+k{\log }^{2}k)$$

$\text{2022/1/25 update}$：学了个使用 转置原理 的新方法。

设 $f(x)={\sum }_{i=0}^{n-1}{a}_i{x}^i$ 系数构成列向量 $\mathbf{v}$ 满足 ${\mathbf{v}}_i=a_i$ 。多点求值等价于乘矩阵 $\mathcal{A}$ 满足 ${\mathcal{A}}_{rc}=x_r^c$ 。考虑其转置 ${{\mathcal{A}}^{\mathsf{T}}}_{rc}=x_c^r$ 。此时验算 ${\mathcal{A}}^{\mathsf{T}}\mathbf{v}$ 的第 $r$ 项为 ${\sum }_{i=0}^{n-1}{x}_i^r{a}_i$ 。

对该数列建立生成函数，则 $F(\lambda )={\sum }_{i=1}^n\frac{a_i}{1-x_i\lambda }$，考虑每个 $a_i$ 对 $F(\lambda )$ 各项系数的贡献易得。说老实话，看到这个式子之前我还真不会算。

考虑该转置问题的求解方法：分治，维护分子和分母多项式。分母是固定的 $\prod (1-x_i\lambda )$，可以预先求出来。问题变为，在分治结构上（可将其理解为线段树）求解分子多项式。但是，自变量并不是多项式——自变量应当是 多项式的系数，因为原本的 $\mathcal{A}$ 就是作用于系数的。

用 $f_x$ 表示分子多项式的 系数序列（列向量），用 $g_x$ 表示分母多项式的 卷积矩阵（卷积显然是线性变换，由于分母多项式是已知的，我们可以将其转化为卷积矩阵），记 $l,r$ 为分治结构的左右儿子，则 ${\mathcal{A}}^{\mathsf{T}}\mathbf{v}$ 的解法是 $f_x=g_r{f}_l+g_l{f}_r$ 。

现在，对 ${\mathcal{A}}^{\mathsf{T}}$ 作转置。这一步线性变换则变为
$$f_l=g_r^{\mathsf{T}}{f}_x{f}_r=g_l^{\mathsf{T}}{f}_x$$

这个结果对于熟练者，可以一眼看出。因为矩阵相当于有向图邻接矩阵，转置相当于将有向图边反向；原来有 $g_r$ 条路从 $f_l$ 到 $f_x$，现在就该反着到 $f_l$ 了。

接下来，填个前文的坑——卷积对应的矩阵。我就不列举了，希望大家能用上面的方法，一眼看穿：卷积等价于，从 $i$ 到 $j$ 的路径条数是 $a_{j-i}$ 。所以卷积矩阵的转置，就是 $j\to i$ 路径条数是 $a_{j-i}$，相当于所谓 “减卷积”，下标做减法的卷积。

“减卷积” 可以翻转多项式后做普通卷积，或者沿用转置原理。只需先做 $\text{IDFT}$，作乘法，再做 $\text{DFT}$ 。然而，常数优化 去掉蝴蝶变换 会导致它出问题，所以我不会这么做。

上述的整个过程，就是对 ${\mathcal{A}}^{\mathsf{T}}$ 的转置，也就得到了 $\mathcal{A}$ 。原本 ${\mathcal{A}}^{\mathsf{T}}\mathbf{v}$ 的 $\text{input}$ 是序列 $\{a_0,a_1,\dots ,a_{n-1}\}$，其 $\text{output}$ 是 $f_{\mathrm{root}}$ 的各项系数。那么转置后 $\text{input}$ 变为 $\text{output}$，即 $\{a_0,a_1,\dots ,a_{n-1}\}$ 直接视为 $f_{\mathrm{root}}$ 的各项系数即可。

注意 ${\mathcal{A}}^{\mathsf{T}}\mathbf{v}$ 问题中，求出 $f_{\mathrm{root}}$ 后还除以了最终的分母多项式 $\beta (\lambda )=\prod (1-x_i\lambda )$，转置后就要先跟 $\beta (\lambda {)}^{-1}$ 作 “减卷积”。然后用上面的方法推到叶子节点上。最后叶子节点的值（度数为零的多项式的系数）就是答案。

快速插值

是对拉格朗日插值法的改进。考虑原本的等式
$$f(x)=\sum _{i=1}^n{y}_i\cdot \frac{{\prod }_{j\ne i}(x-x_j)}{{\prod }_{j\ne i}(x_i-x_j)}$$

首先把分母搞定。
$$\prod _{j\ne i}(x_i-x_j)={\left[\prod _{j=1}^n(x-x_j)\right]}^{\prime }{|}_{x=x_i}$$

求出那个多项式，求导，然后 多点求值 得到 $n$ 个位置的取值。现在我们只需要求
$$f(x)=\sum _{i=1}^n\frac{y_i}{g^{\prime }(x_i)}\prod _{j\ne i}(x-x_j)$$

右边那个 $\prod$ 可以用一个前缀与一个后缀拼接而成。于是我们将插值法优化到了
$$\mathcal{O}(n{\log }^{2}n)-\mathcal{O}(n)$$

这个记号的含义是，$\mathcal{O}(n{\log }^{2}n)$ 预处理，然后 $\mathcal{O}(n)$ 查询。

如果我们要求出 $f(x)$ 的多项式形式，就用 $f(x)={\sum }_{i=1}^n\frac{y_i}{g^{\prime }(x_i)}\frac{{\prod }_{j=1}^n(x-x_j)}{x-x_i}$，合并后面的分式可以分治后维护分子分母，复杂度 $\mathcal{O}(n{\log }^{2}n)$ 。

特别地，如果已有点值是 $[0,n)$ 连续点值，显然不需要 多点求值 了，那么至少可以直接做到 $\mathcal{O}(n)$ 算单点值。但是，如果目标是得到别处的连续点值，则存在基于卷积的 $\mathcal{O}(n\log n)$ 做法：
$$f_x=\sum _{i=0}^{n-1}\frac{y_i}{x-i}\cdot \frac{x!}{(x-n)!}\cdot \frac{(-1{)}^{n-i-1}}{i!\cdot (n-i-1)!}=\frac{x!}{(x-n)!}\sum _{i=0}^{n-1}\frac{{\lambda }_i}{x-i}$$

其中与 $x$ 无关的部分写为 ${\lambda }_i$，容易预处理得。

解线性方程组

指 $F_i(x)=G_i(x)+{\sum }_{j=1}^n{P}_{i,j}(x)F_j(x)(\mathrm{mod}{x}^m)$ 一类的方程。当你意识到，形式幂级数的指数只是形式时，你就想到矩阵的所谓下标也只是形式。二者都可作为主元。所以，必定可以写成 元素为矩阵 的多项式 $F(x)=G(x)+P(x)F(x)$ 。

若 $I{x}^0-P(x)$ 存在逆元，用多项式求逆，复杂度 $\mathcal{O}(n^{3}m+n^{2}m\log m)$ 。

当 $[x^0]P(x)=0$ 且 $[x^{\kappa }]G_i(x)=0(\kappa \ne 0)$ 时，即给出的是 $F(x)$ 的线性递推式时，另有一个有趣的做法：递归到某区间，需要计算内部贡献时，内部贡献是线性变换；只需要预处理长度为 $n$ 的左右区间贡献系数。这会是一个多项式，与分治 $\text{NTT}$ 的递推方式相同；在 $[x^0]F(x)=I$ 时，甚至就是 $F(x)$ 的 $[x^0]$ 到 $[x^{n-1}]$ 系数构成的 “子多项式”。

于是时间复杂度 $\mathcal{O}(n^{3}m+n^{2}m\log m)$ 不变。

常数优化

可参考巨佬的博客。这里只摘录（有删改）最常见的求逆操作。

设求解 $f$ 的逆元，$g_0=f^{-1}\mathrm{mod}{x}^n$ 。倍增到 $g=f^{-1}\mathrm{mod}{x}^{2n}$ 满足
$$g=(2g_0-g_0\cdot f\cdot g_0)\mathrm{mod}{x}^{2n}$$

虽然系数属于非交换环的情况较少，但确实有（如矩阵）。但是左逆元总是等于右逆元，这是群的性质。

一般做法是，将 $g_0$ 和 $f$ 全部做长度为 $4n$ 的 $\text{FFT}$，乘起来之后逆变换。假定复杂度瓶颈在于 $\text{FFT}$，记为 $3\mathsf{E}(4n)$ 。下面将给出两种更优的做法。

记 $f_0=f\mathrm{mod}{x}^{2n}$，考虑 $g=[g_0-(g_0{f}_0-1)\cdot g_0]\mathrm{mod}{x}^{2n}$，注意到 $(g_0{f}_0-1)$ 只在 $[n,3n)$ 次项处有值，因此可以做长度为 $2n$ 的循环卷积。再计算其与 $g_0$ 的乘积，亦可以用长度为 $2n$ 的循环卷积。

一次长度为 $2n$ 的循环卷积需要 $3\mathsf{E}(2n)$，但 $g_0$ 的正变换被计算了两次，所以实际只有 $5\mathsf{E}(2n)$ 。

再改进：注意到 $(g_0{f}_0-1)\cdot g_0$ 只在 $[n,4n)$ 次项处有值，因此考虑做 长度为 $3n$ 的循环卷积。这听上去需要 $\text{Bluestein}$ 之类的东西？其实只要点值的数量够多即可。

考虑取 $a$ 满足 $a^{2n}\ne 1$，然后求出取模 $(x^{2n}-1)(x^n-a^n)$ 的结果，即在 $\{{\omega }_{2n}^i|i\in [0,2n)\}$ 和 $\{a{\omega }_n^i|i\in [0,n)\}$ 处作点值转换。求值相当于求 $f(x)$ 长为 $2n$ 的 $\text{DFT}$ 数组和 $f(ax)$ 长为 $n$ 的 $\text{DFT}$ 数组，插值则分别 $\text{IDFT}$ 用 $\text{CRT}$ 合并即可。一般取 $a={\omega }_{4n}$ 。

对这个 $\text{CRT}$ 的直观理解：设
$$f(x)=a{x}^n+b{x}^{2n}+c{x}^{3n}$$

我们已知的是
$$\{\begin{array}{l}f(x)\mathrm{mod}(x^{2n}-1)=b+(a+c)x^n\\ f({\omega }_{4n}x)\mathrm{mod}(x^n-1)={\omega }_{4}a+{\omega }_4^{2}b+{\omega }_4^{3}c\end{array}$$

还原出 $a$ 是容易的，毕竟 ${\omega }_4^3=-{\omega }_4$ 。这样的复杂度是 $3\mathsf{E}(2n)+3\mathsf{E}(n)$ 。

半在线卷积

所谓半在线：要做卷积的东西在动态增长。

• 最简单情形：求 $G(x)$ 使得 $[x^n]G(x)={\omega }_n[x^n]F(x)G(x)$ 。

$\text{cdq}$ 分治即可。不妨设 $n=2^k$，则只需先算出前 $2^{k-1}$ 项，然后与 $F(x)$ 的前 $2^k$ 项作卷积，贡献到右侧。

注意到这样的 $F(x)G(x)$ 只在 $[0,3\times 2^{k-1})$ 项有值，故可以做 $2^k$ 长度的循环卷积，这样只会污染前半部分的值。

又注意到我们总是对 $F(x)$ 长为 $2^k$ 的前缀做 $2^k$ 长度的循环卷积，故可以预处理这些结果。这样应该是相当快的，至少 $\text{cmdblock}$ 说这样实现 $\exp$ 比牛顿迭代快多了。

具体实现的时候，甚至可以避免递归（但我不清楚是否有常数上的优化）。

• 更在线的情形：令 $f_n={⨁}_{i=0}^{n-1}{g}_i$，求 $[x^n]G(x)={\omega }_n[x^n]F(x)G(x)$ 的解。

因为 $F(x)$ 未给定，当分治区间左端点 $l=0$ 时，$F(x)$ 的前 $2^k$ 项还没算出来。只能做 $F(x)$ 前 $2^{k-1}$ 项的卷积。

其后，可以认为 $F(x),G(x)$ 的项数同步增长，每次都将新增项的贡献加入即可（如同 最简单情形 中 $G(x)$ 的新求出项去乘 $F(x)$ 的前缀，$F(x)$ 的新求出项也要去乘 $G(x)$ 的前缀）。

• 最真实的半在线卷积：给定 $F(x)$，求 $[x^n]G(x)={\omega }_n[x^n]F(x)G(x{)}^2$ 。

当 $G(x)$ 多求出一项后，$G(x{)}^2$ 并不能 $\mathcal{O}(1)$ 增长。与上面 更在线的情况 形成对比（前缀异或和 $\mathcal{O}(1)$ 即得）。

因此我们要同步计算 $G(x{)}^2$，也是半在线卷积。

• 更快速的半在线卷积。

若 $\mathtt{cdq}$ 分治时，分成 $\log n$ 个块，则递归层数是 ${\log }_{\log n}n=\frac{\log n}{\log \log n}$ 。每层的 $\text{FFT}$ 总复杂度还是 $\mathcal{O}(n\log n)$，而卷积需要块之间两两暴力乘法，复杂度 $\mathcal{O}(\frac{n}{\log n}\cdot {\log }^{2}n)=\mathcal{O}(n\log n)$，因此总复杂度 $\mathcal{O}(\frac{n\log n}{\log \log n})$ 。

代码实现

不是很全面，但应该比较好用了。

const int MOD = 998244353, LOGMOD = 30;
inline void modAddUp(int &x, const int &y){
	if((x += y) >= MOD) x -= MOD; // faster?
}
inline llong qkpow(llong b, int q){
	llong a = 1;
	for(; q; q>>=1,b=b*b%MOD) if(q&1) a = a*b%MOD;
	return a;
}
const int MAXN = 800005;
int g[LOGMOD], inv[MAXN];
inline void prepareNtt(const int &n){
	rep0(i,(inv[1]=1)<<1,1<<n) inv[i] = int(
		llong(MOD-MOD/i)*inv[MOD%i]%MOD);
	int p = MOD-1, x = 0;
	while(!(p&1)) p >>= 1, ++ x;
	for(g[x]=int(qkpow(3,p)); x; --x)
		g[x-1] = int(llong(g[x])*g[x]%MOD);
}
void ntt(int a[], int n){
	for(int w=1<<n>>1,x=n; x; w>>=1,--x)
	for(int *p=a; p!=a+(1<<n); p+=(w<<1))
	for(int *i=p,*j=p+w,v=1; i!=p+w; ++i,++j,v=int(llong(v)*g[x]%MOD)){
		const llong t = llong((*i)+MOD-(*j))*v%MOD;
		modAddUp(*i,*j), *j = int(t);
	}
}
void dntt(int a[], int n){
	for(int w=1,x=1; x<=n; w<<=1,++x)
	for(int *p=a; p!=a+(1<<n); p+=(w<<1))
	for(int *i=p,*j=p+w,v=1; i!=p+w; ++i,++j,v=int(llong(v)*g[x]%MOD)){
		const int t = int(llong(*j)*v%MOD);
		modAddUp(*j=*i,MOD-t), modAddUp(*i,t);
	}
	std::reverse(a+1,a+(1<<n));
	const int inv2n = MOD-((MOD-1)>>n);
	for(int *i=a; i!=a+(1<<n); ++i)
		*i = int(llong(*i)*inv2n%MOD);
}
inline int getNttLen(int n){
	return 32-__builtin_clz(n);
}
inline void array_mul(int a[], const int b[], int n){
	for(; n; --n,++a,++b) *a = int(llong(*a)*(*b)%MOD);
}
int tmp[MAXN]; // be careful
void getInv(const int a[], int n, int f[]){
	f[0] = int(qkpow(a[0],MOD-2)), f[1] = 0;
	for(int len=1; len<=n; ++len){
		memcpy(tmp,a,(1<<len)<<2);
		memset(tmp+(1<<len),0,(1<<len)<<2);
		memset(f+(1<<len),0,(1<<len)<<2);
		ntt(tmp,len+1), ntt(f,len+1);
		rep0(i,0,2<<len) f[i] = int((2-llong(
			f[i])*tmp[i]%MOD+MOD)*f[i]%MOD);
		dntt(f,len+1); // get inversion
		memset(f+(1<<len),0,(1<<len)<<2);
	}
}
void getLn(const int a[], int n, int ln[]){
	getInv(a,n,ln); ntt(ln,n+1);
	rep0(i,1,1<<n) tmp[i-1] = int(llong(i)*a[i]%MOD);
	memset(tmp+(1<<n),0,(1<<n)<<2), tmp[(1<<n)-1] = 0;
	ntt(tmp,n+1); array_mul(tmp,ln,2<<n);
	dntt(tmp,n+1); ln[0] = 0; rep0(i,1,1<<n)
		ln[i] = int(llong(inv[i])*tmp[i-1]%MOD);
}
int tmp2[MAXN]; // need more buffer
void getExp(const int a[], int n, int exp[]){
	exp[0] = 1, exp[1] = 0; rep(len,1,n){
		getLn(exp,len,tmp2); tmp2[0] = tmp2[0] ? tmp2[0]-1 : MOD-1;
		rep0(i,0,1<<len) tmp2[i] = (MOD+a[i]-tmp2[i])%MOD;
		memset(tmp2+(1<<len),0,(1<<len)<<2);
		memset(exp+(1<<len),0,(1<<len)<<2);
		ntt(tmp2,len+1), ntt(exp,len+1), array_mul(exp,tmp2,2<<len);
		dntt(exp,len+1), memset(exp+(1<<len),0,(1<<len)<<2);
	}
}

还有基于 $\mathtt{vector}$ 的多点求值以及多项式求逆（含常数优化）实现。但不得不说，确实慢。

#include 
#include  // Almighty XJX yyds!!
#include  // Who can tell me why I'm so weak!
#include  // rainybunny root of the evil.
#include 
#include 
using llong = long long;
# define rep(i,a,b) for(int i=(a); i<=(b); ++i)
# define drep(i,a,b) for(int i=(a); i>=(b); --i)
# define rep0(i,a,b) for(int i=(a); i!=(b); ++i)
inline int readint(){
    int a = 0, c = getchar(), f = 1;
    for(; !isdigit(c); c=getchar()) if(c == '-') f = -f;
    for(; isdigit(c); c=getchar()) a = a*10+(c^48);
    return a*f;
}

const int MOD = 998244353, LOGMOD = 24;
inline llong qkpow(llong b, int q){
    llong a = 1;
    for(; q; q>>=1,b=b*b%MOD) if(q&1) a = a*b%MOD;
    return a;
}
inline void modAddUp(int& x, const int& y){
    if((x += y) >= MOD) x -= MOD;
}

const int MAXN = 1<<17;
struct Poly : std::vector<int>{
    static int g[LOGMOD];
    static void prepare(){
        int p = MOD-1, x = 0;
        while(!(p&1)) p >>= 1, ++ x;
        for(g[x]=int(qkpow(3,p)); x; --x)
            g[x-1] = int(llong(g[x])*g[x]%MOD);
    }
    static void ntt(Poly& a, const int& n){
        for(int w=1<<n>>1,x=n; x; w>>=1,--x){
            static int v[MAXN]; v[0] = 1; // pre-compute
            rep0(i,1,w) v[i] = int(llong(g[x])*v[i-1]%MOD);
            for(auto p=a.begin(); p!=a.end(); p+=(w<<1)){
                const int* nowv = v;
                for(auto i=p,j=p+w; i!=p+w; ++i,++j,++nowv){
                    llong t = llong((*i)-(*j)+MOD)*(*nowv)%MOD;
                    modAddUp(*i,*j); *j = int(t);
                }
            }
        }
    }
    static void dntt(Poly& a, const int& n){
        for(int w=1,x=1; x<=n; w<<=1,++x){
            static int v[MAXN]; v[0] = 1; // pre-compute
            rep0(i,1,w) v[i] = int(llong(g[x])*v[i-1]%MOD);
            for(auto p=a.begin(); p!=a.end(); p+=(w<<1)){
                const int* nowv = v;
                for(auto i=p,j=p+w; i!=p+w; ++i,++j,++nowv){
                    int t = int(llong(*j)*(*nowv)%MOD);
                    modAddUp(*j=*i,MOD-t); modAddUp(*i,t);
                }
            }
        }
        std::reverse(a.begin()+1,a.end());
        const llong inv2n = MOD-((MOD-1)>>n);
        rep0(i,0,1<<n) a[i] = int(a[i]*inv2n%MOD);
    }
    inline void trim(){ while(back() == 0) pop_back(); }
    template < class Itr > // mostly Poly::iterator
    inline static void array_mul(Itr a, Itr b, int n){
        for(; n; ++a,++b,--n) *a = int(llong(*a)*(*b)%MOD);
    }
    template < class IntegerType >
    inline static int nttLen(const IntegerType& n){
        if(n == 0) return 0; // 2^0 > 0
        return 32-__builtin_clz(unsigned(n));
    }
    Poly operator * (const Poly& b) const{
        const int n = nttLen(size()+b.size()-2);
        Poly c = *this; c.resize(1<<n,0); ntt(c,n);
        Poly d = b; d.resize(1<<n,0); ntt(d,n);
        array_mul(c.begin(),d.begin(),1<<n); dntt(c,n);
        c.resize(size()+b.size()-1); return c;
    }
    /** @note @p a shall be of length 1 << @p n */
    static Poly inv(const Poly& a, const int& len){
        Poly b; b.resize(1<<len,0); b[0] = 1;
        rep0(n,0,len){ // log2 of current length
            Poly tmp; tmp.resize(2<<n);
            rep0(i,0,2<<n) tmp[i] = a[i];
            Poly tmpb; tmpb.resize(2<<n,0);
            rep0(i,0,1<<n) tmpb[i] = b[i];
            ntt(tmp,n+1), ntt(tmpb,n+1);
            array_mul(tmp.begin(),tmpb.begin(),2<<n);
            dntt(tmp,n+1); rep0(i,0,1<<n) tmp[i] = 0;
            ntt(tmp,n+1); // (g0*f0-1) to multiply g0
            array_mul(tmp.begin(),tmpb.begin(),2<<n);
            dntt(tmp,n+1); rep0(i,1<<n,2<<n)
                if(tmp[i]) b[i] = MOD-tmp[i];
        }
        return b; // exactly that length
    }
};
int Poly::g[LOGMOD]; // actually global
Poly minus_convolution(const Poly& a, const Poly& b){
    Poly c = b; std::reverse(c.begin(),c.end());
    c = c*a; const int shift = int(b.size())-1;
    rep0(i,shift,int(c.size())) c[i-shift] = c[i];
    c.resize(c.size()-shift); return c;
}

Poly mom[MAXN<<1], ans[MAXN<<1];
int a[MAXN], b[MAXN];
int main(){
    Poly::prepare();
    int n = readint()+1, m = readint();
    rep0(i,0,n) a[i] = readint();
    rep0(i,0,m) b[i] = readint();
    if(n < m) n = m; // be bigger
    const int ass = Poly::nttLen(n-1);
    n = 1<<ass; // won't change the answer
    rep0(i,0,n){
        if(!b[i]){
            mom[i^n].resize(1,1);
            continue; // short
        }
        mom[i^n].resize(2); mom[i^n][0] = 1;
        mom[i^n][1] = MOD-b[i];
    }
    drep(i,n-1,1) mom[i] = mom[i<<1]*mom[i<<1|1];
    ans[1].resize(n); // set to be f_{root}
    rep0(i,0,n) ans[1][i] = a[i];
    mom[1].resize(1<<ass,0); // it's Okay
    Poly beta = Poly::inv(mom[1],ass);
    ans[1] = minus_convolution(ans[1],beta);
    for(int i=1,siz=n<<1; i!=n; ++i){
        if((i&-i) == i) siz >>= 1; // shrink
        ans[i].resize(siz); // how long is needed
        ans[i<<1] = minus_convolution(ans[i],mom[i<<1|1]);
        ans[i<<1|1] = minus_convolution(ans[i],mom[i<<1]);
    }
    rep0(i,0,m) printf("%d\n",ans[i^n][0]);
    return 0;
}