多项式运算学习

前言

之前零零碎碎的学了一些多项式的操作（模意义下即NTT）
现在打算还是仔细的学习一下吧，顺带自己推一波式子
然后把板子写一下

多项式乘法

见FFT
朴素的还是挺方便的
当然在一些情况下可以进行优化（暂时咕咕咕）

分治FFT&分治套FFT

这两个东西本质上只是思路，所以没什么好封装的
分治FFT
分治套FFT(这个是猎人杀的题解，里面有讲到分治套FFT)

模意义&循环卷积

一般多项式都有一个操作，模$x^n$，即次数大于等于$n$的项都要舍去
注意这里要和循环卷积分开来，循环卷积是把所有指数大于等于$n$的项系数都加到次数模$n$的相应项里

多项式求逆

给定一个多项式$A(x)$，求模$x^n$意义下的逆元$A^{-1}(x)$满足
$$A(x)A^{-1}(x)\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
我们发现：
若$n=1$，我们可以$\mathcal{O}(logn)$求出常数项的逆元
若$n̸=1$，我们考虑递归解决这个问题
设我们要求的为$B(x)$，即$$A(x)B(x)\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
已经递归求得$B_0(x)$，即$$A(x)B_0(x)\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{\lceil \frac{n}{2}\rceil })$$
容易发现$$A(x)B(x)\equiv 1(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{\lceil \frac{n}{2}\rceil })$$
相减得$$A(x)(B(x)-B_0(x))\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{\lceil \frac{n}{2}\rceil })$$
我们发现，如果$A(x)\mathrm{m}\mathrm{o}\mathrm{d}{x}^{\lceil \frac{n}{2}\rceil }=0$，显然$B_0(x)=0$，我们的期望结果是$B(x)=0$，那么$B(x)=B_0(x)$
如果$A(x)\mathrm{m}\mathrm{o}\mathrm{d}{x}^{\lceil \frac{n}{2}\rceil }̸=0$，那么右边一项在模意义下为$0$
所以，得出如下式子
$$B(x)-B_0(x)\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{\lceil \frac{n}{2}\rceil })$$
两边平方
$$B^2(x)-2B(x)B_0(x)+B_0^2(x)\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
我们发现，所有次数小于$n$的项至少由一边的一个次数小于$\lceil \frac{n}{2}\rceil$的项乘得，所以可以将模数改为$x^n$
我们将等式两边同时乘上$A(x)$
得到$$B(x)-2B_0(x)+A(x)B_0^2(x)\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
移项得$$B(x)\equiv 2B_0(x)-A(x)B_0^2(x)(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
合并得$$B(x)\equiv B_0(x)(2-A(x)B_0(x))(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
复杂度$T(n)=T(\frac{n}{2})+\mathcal{O}(nlogn)=O(nlogn)$
小提示：在具体代码实现的时候可以不用封装的多项式乘法，而只在开始和结束分别做DFT/IDFT即可，中间的运算用每个点值进行运算来解决，能够大大减少常数

多项式除法/取模

给定一个长度为$n$的多项式$A(x)$，给定一个长度为$m(m\le n)$的多项式$B(x)$
求两个多项式$D(x),R(x)$满足$$A(x)=D(x)B(x)+R(x)$$
并且$Lent{h}_{R(x)}<m$（定义$Lent{h}_{F(x)}$为多项式$F(x)$的长度）
容易发现，$Lent{h}_{D(x)}$$\le n-m+1$
注意这里没有模意义下，所以答案是唯一的
传统的除法复杂度是$\mathcal{O}(nm)$的，并不优秀
我们发现问题在$R(x)$上，我们想办法消除影响
有一个很好的思路是：选择一个合适的$x^a$使得在这个模意义下的$D(x)$不受影响，而$R(x)$被模掉，这样就可以直接套用多项式求逆了
我们发现$Lent{h}_{R(x)}+Lent{h}_{D(x)}\le n$
那么我们想办法把$Lent{h}_{R(x)}$的那一部分进行系数翻转
定义对于一个多项式在次数$n$下的翻转：
$$F^{R_n}(x)=F(\frac{1}{x})x^{n-1}=\sum _{i=0}^{n-1}{a}_{n-1-i}{x}^i$$
（我们发现对于$F(x)\Rightarrow F^{R_a}(x)$需要乘上$x^{a-1}$）
对于式子$$A(x)=D(x)B(x)+R(x)$$
我们将$\frac{1}{x}$带入（这样等式显然依然成立），得到$$A(\frac{1}{x})=D(\frac{1}{x})B(\frac{1}{x})+R(\frac{1}{x})$$
等式两边同乘$x^{n-1}$，得到$$A^{R_n}(x)=D^{R_{n-m+1}}(x)B^{R_m}(x)+x^{n-m}{R}^{R_m}(x)$$
我们发现我们发现这个式子只有最后一项的$x$次数均$\ge n-m$，其余项的$x$次数均$<n-m$，所以我们把这个式子转到模$x^{n-m}$意义下即可，得到$$A^{R_n}(x)\equiv D^{R_{n-m+1}}(x)B^{R_m}(x)(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{n-m})$$
我们用多项式求逆$\mathcal{O}(nlogn)$求$D(x)$，得到$D(x)$后可以直接用多项式乘法和减法求出$R(x)$
复杂度$\mathcal{O}(nlogn)$

多项式微分

由于$x^n(n\in \mathbb{N})$的一阶导数为$n\ast x^{n-1}$
所以直接做即可
复杂度$\mathcal{O}(n)$

多项式积分

根据微分的式子积回来即可，写板子的话常数项默认为$0$吧
需要预处理逆元
复杂度$\mathcal{O}(n)$

多项式牛顿迭代法（思路）

假设我们现在有一个函数$g(x)$要求，求$f(x)$满足$$g(f(x))\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
多项式牛顿迭代法需要确定初始近似值，即前$1$位
这$1$位的值也就是常数项需要单独讨论
假设当前的近似值为$f_0(x)$，其确定位数为$n$
我们现在要求$f(x)$，其确定位数为$2n$
已知条件：$$f_0(x)\equiv f(x)(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
$$g(f_0(x))\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
我们将$g(f(x))$在$f_0(x)$上泰勒展开并代入$f(x)$
$$\begin{array}{rl}g(f(x))& =\sum _{i=0}^{\infty }\frac{g^{(i)}(f_0(x))\ast (f(x)-f_0(x){)}^i}{i!}\\ & =\frac{g(f_0(x))}{0!}+\frac{g^{\prime }(f_0(x))(f(x)-f_0(x))}{1!}+\frac{g^{\prime \prime }(f_0(x))(f(x)-f_0(x){)}^2}{2!}\cdot \cdot \cdot \end{array}$$
注意：由于我们这里求的是f(x)，所以求导是对f(x)求导而不是对x求导
我们发现，由于$f(x)-f_0(x)\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$，而我们求的$g(f(x))$是在模$x^{2n}$意义下的，所以所有$i\ge 2$的项都是无用的
所以得到$$g(f(x))\equiv g(f_0(x))+g^{\prime }(f_0(x))(f(x)-f_0(x))(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{2n})$$
将$g(f(x))\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{2n})$带入并移项得$$f(x)\equiv f_0(x)-\frac{g(f_0(x))}{g^{\prime }(f_0(x))}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^{2n})$$
如果求导后的结果计算很方便，那么就可以迭代求值

多项式开根

承接牛顿迭代的思路
对于一个多项式$f(x)$，这里$g(f(x))=f^2(x)-A(x)$
即$$f^2(x)\equiv A(x)(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
我们代入迭代的式子（提示：$x^2$的导数为$2x$）
$$\begin{array}{rl}f(x)& \equiv f_0(x)-\frac{g(f_0(x))}{g^{\prime }(f_0(x))}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)\\ & \equiv f_0(x)-\frac{f_0^2(x)-A(x)}{2f_0(x)}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)\\ & \equiv \frac{1}{2}(f_0(x)+\frac{A(x)}{f_0(x)})(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)\end{array}$$
然后常数项需要在模意义下开根（所以如果常数项不是这个模数下的二次剩余那么这个多项式将无法开根，一般题目会说明保证常数项是模意义下的二次剩余，二次剩余博客传送门），当然如果保证常数项为$1$，那么结果也为$1$

多项式ln

复合函数求导法则：
设$f(x)=g(h(x))$
则$f^{\prime }(x)=g^{\prime }(h(x))h^{\prime }(x)$
我们现在有一个多项式$A(x)$
要求$ln(A(x))$
$$\begin{array}{rl}ln(A(x))& =\int l{n}^{\prime }(A(x))\\ & =\int \frac{A^{\prime }(x)}{A(x)}\end{array}$$
注意：这里的ln都是对于每个x取确定值的，所以是对x求导
用上面的微分和积分，这些都是$\mathcal{O}(n)$的，求逆$\mathcal{O}(nlogn)$，总复杂度$\mathcal{O}(nlogn)$
同开根一样，常数项也需要在模意义下进行$ln$
一般写法默认$A(x)$常数项为$1$，计算出的$f(x)$的常数项为$0$

多项式exp

求$$e^{A(x)}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
化多项式牛顿迭代经典式
设$$f(x)\equiv e^{A(x)}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
两边求ln
$$ln(f(x))\equiv A(x)(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
$$ln(f(x))-A(x)\equiv 0(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
代入式子$$\begin{array}{rl}f(x)& \equiv f_0(x)-\frac{g(f_0(x))}{g^{\prime }(f_0(x))}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)\\ & \equiv f_0(x)-\frac{ln(f_0(x))-A(x)}{\frac{1}{f_0(x)}}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)\\ & \equiv f_0(x)(1-ln(f_0(x))+A(x))(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)\end{array}$$
同上，常数项需要单独计算exp
一般写法默认$A(x)$常数项为$0$，计算出的$f(x)$的常数项为$1$
复杂度$\mathcal{O}(nlogn)$

多项式k次幂

快速幂：由于每次要IDFT回来保证长度，所以复杂度为$\mathcal{O}(nlognlogk)$
提出最低次数项的次数及$x$（设为$a{x}^b$），再进行ln和exp即可
$$f^k(x)=a^k{x}^{kb}exp(k\ast ln(\frac{f(x)}{a{x}^b}))$$
复杂度$\mathcal{O}(nlogn)$

封装代码

贴出封装的代码，所有功能都能很方便的调用
这是loj150挑战多项式的ac代码

#include<cstdio>
#include<cctype>
#include<cstring>
#include<cstdlib>
#include<vector>
namespace fast_IO
{
    const int IN_LEN=10000000,OUT_LEN=10000000;
    char ibuf[IN_LEN],obuf[OUT_LEN],*ih=ibuf+IN_LEN,*oh=obuf,*lastin=ibuf+IN_LEN,*lastout=obuf+OUT_LEN-1;
    inline char getchar_(){return (ih==lastin)&&(lastin=(ih=ibuf)+fread(ibuf,1,IN_LEN,stdin),ih==lastin)?EOF:*ih++;}
    inline void putchar_(const char x){if(oh==lastout)fwrite(obuf,1,oh-obuf,stdout),oh=obuf;*oh++=x;}
    inline void flush(){fwrite(obuf,1,oh-obuf,stdout);}
}
using namespace fast_IO;
#define getchar() getchar_()
#define putchar(x) putchar_((x))
typedef long long ll;
#define rg register
template <typename T> inline T max(const T a,const T b){return a>b?a:b;}
template <typename T> inline T min(const T a,const T b){return a<b?a:b;}
template <typename T> inline T mind(T&a,const T b){a=a<b?a:b;}
template <typename T> inline T maxd(T&a,const T b){a=a>b?a:b;}
template <typename T> inline T abs(const T a){return a>0?a:-a;}
template <typename T> inline void swap(T&a,T&b){T c=a;a=b;b=c;}
template <typename T> inline void swap(T*a,T*b){T c=a;a=b;b=c;}
template <typename T> inline T gcd(const T a,const T b){if(!b)return a;return gcd(b,a%b);}
template <typename T> inline T square(const T x){return x*x;};
template <typename T> inline void read(T&x)
{
    char cu=getchar();x=0;bool fla=0;
    while(!isdigit(cu)){if(cu=='-')fla=1;cu=getchar();}
    while(isdigit(cu))x=x*10+cu-'0',cu=getchar();
    if(fla)x=-x;  
}
template <typename T> void printe(const T x)
{
    if(x>=10)printe(x/10);
    putchar(x%10+'0');
}
template <typename T> inline void print(const T x)
{
    if(x<0)putchar('-'),printe(-x);
    else printe(x);
}
const int maxn=2097152,mod=998244353;
inline int Md(const int x){return x>=mod?x-mod:x;}
template<typename T>
inline int pow(int x,T y)
{
    rg int res=1;x%=mod;
    for(;y;y>>=1,x=(ll)x*x%mod)if(y&1)res=(ll)res*x%mod;
    return res;
}
namespace Poly///namespace of Poly
{
int W_[maxn],ha[maxn],hb[maxn],Inv[maxn];
inline void init(const int x)
{
    rg int tim=0,lenth=1;
    while(lenth<x)lenth<<=1,tim++;
    for(rg int i=1;i<lenth;i<<=1)
    {
    	const int WW=pow(3,(mod-1)/(i*2));
    	W_[i]=1;
    	for(rg int j=i+1,k=i<<1;j<k;j++)W_[j]=(ll)W_[j-1]*WW%mod;
    }
    Inv[0]=Inv[1]=1;
    for(rg int i=2;i<x;i++)Inv[i]=(ll)(mod-mod/i)*Inv[mod%i]%mod;
}
int L;
inline void DFT(int*A)//prepare:init L 
{
    for(rg int i=0,j=0;i<L;i++)
    {
        if(i>j)swap(A[i],A[j]);
        for(rg int k=L>>1;(j^=k)<k;k>>=1);
    }
    for(rg int i=1;i<L;i<<=1)
        for(rg int j=0,J=i<<1;j<L;j+=J)
            for(rg int k=0;k<i;k++)
            {
                const int x=A[j+k],y=(ll)A[j+k+i]*W_[i+k]%mod;
                A[j+k]=Md(x+y),A[j+k+i]=Md(mod+x-y);
            }
}
void IDFT(int*A)
{
    for(rg int i=1;i<L-i;i++)swap(A[i],A[L-i]);
    DFT(A);
}
inline int Quadratic_residue(const int a)
{
    if(a==0)return 0;
    int b=(rand()<<14^rand())%mod;
    while(pow(b,(mod-1)>>1)!=mod-1)b=(rand()<<14^rand())%mod;
    int s=mod-1,t=0,x,inv=pow(a,mod-2),f=1;
    while(!(s&1))s>>=1,t++,f<<=1;
    t--,x=pow(a,(s+1)>>1),f>>=1;
    while(t)
    {
        f>>=1;
        if(pow((int)((ll)inv*x%mod*x%mod),f)!=1)x=(ll)x*pow(b,s)%mod;
        t--,s<<=1;
    }
    return min(x,mod-x);
}
struct poly
{
    std::vector<int>A;
    poly(){A.resize(0);}
    poly(const int x){A.resize(1),A[0]=x;}
    inline int&operator[](const int x){return A[x];}
    inline int operator[](const int x)const{return A[x];}
    inline void clear(){A.clear();}
    inline unsigned int size()const{return A.size();}
    inline void resize(const unsigned int x){A.resize(x);}
    void RE(const int x)
    {
        A.resize(x);
        for(rg int i=0;i<x;i++)A[i]=0; 
    }
    void readin(const int MAX)
    {
        A.resize(MAX);
        for(rg int i=0;i<MAX;i++)read(A[i]);
    }
    void putout()const
    {
        for(rg unsigned int i=0;i<A.size();i++)print(A[i]),putchar(' ');
    }
    inline poly operator +(const poly b)const
    {
        poly RES;
        RES.resize(max(size(),b.size()));
        for(rg unsigned int i=0;i<RES.size();i++)RES[i]=Md((i<size()?A[i]:0)+(i<b.size()?b[i]:0));
        return RES;
    }
    inline poly operator -(const poly b)const
    {
        poly RES;
        RES.resize(max(size(),b.size()));
        for(rg unsigned int i=0;i<RES.size();i++)RES[i]=Md((i<size()?A[i]:0)+mod-(i<b.size()?b[i]:0));
        return RES;
    }
    inline poly operator *(const int b)const
    {
        poly RES=*this;
        for(rg unsigned int i=0;i<RES.size();i++)RES[i]=(ll)RES[i]*b%mod;
        return RES;
    }
    inline poly operator /(const int b)const
    {
        poly RES=(*this)*pow(b,mod-2);
    	return RES;
    }
    inline poly operator *(const poly b)const
    {
        const int RES=A.size()+b.size()-1;
        L=1;while(L<RES)L<<=1;
        poly c;c.A.resize(RES);
        memset(ha,0,L<<2);
        memset(hb,0,L<<2);
        for(rg unsigned int i=0;i<A.size();i++)ha[i]=A[i];
        for(rg unsigned int i=0;i<b.A.size();i++)hb[i]=b.A[i];
        DFT(ha),DFT(hb);
        for(rg int i=0;i<L;i++)ha[i]=(ll)ha[i]*hb[i]%mod;
        IDFT(ha);
        const int inv=pow(L,mod-2);
        for(rg int i=0;i<RES;i++)c.A[i]=(ll)ha[i]*inv%mod;
        return c;
    }
    inline poly inv()const
    {
        poly C;
        if(A.size()==1){C=*this;C[0]=pow(C[0],mod-2);return C;}
        C.resize((A.size()+1)>>1);
        for(rg unsigned int i=0;i<C.size();i++)C[i]=A[i];
        C=C.inv();
        L=1;while(L<(int)size()*2-1)L<<=1;
        for(rg unsigned int i=0;i<A.size();i++)ha[i]=A[i];
        for(rg unsigned int i=0;i<C.size();i++)hb[i]=C[i];
        memset(ha+A.size(),0,(L-A.size())<<2);
        memset(hb+C.size(),0,(L-C.size())<<2);
        DFT(ha),DFT(hb);
        for(rg int i=0;i<L;i++)ha[i]=(ll)(2-(ll)hb[i]*ha[i]%mod+mod)*hb[i]%mod;
        IDFT(ha);
        const int inv=pow(L,mod-2);
        C.resize(size());
        for(rg unsigned int i=0;i<size();i++)C[i]=(ll)ha[i]*inv%mod;
        return C;
    }
/*    inline poly inv()const
    {
        poly C;
        if(A.size()==1){C=*this;C[0]=pow(C[0],mod-2);return C;}
        C.resize((A.size()+1)>>1);
        for(rg unsigned int i=0;i<C.size();i++)C[i]=A[i];
        C=C.inv();
        poly D=(poly)2-*this*C;
        D.resize(size());
        D=D*C;
        D.resize(size());
        return D;
    }*///大常数版本 
    inline void Reverse(const int n)
    {
    	A.resize(n);
    	for(rg int i=0,j=n-1;i<j;i++,j--)swap(A[i],A[j]);
    }
    inline poly operator /(const poly B)const
    {
    	if(size()<B.size())return 0;
        poly a=*this,b=B;a.Reverse(size()),b.Reverse(B.size());
        b.resize(size()-B.size()+1);
        b=b.inv();
        b=b*a;
        b.Reverse(size()-B.size()+1);
        return b;
    }
    inline poly operator %(const poly B)const
    {
        poly C=(*this)-(*this)/B*B;C.resize(B.size()-1);
        return C;
    }
    inline poly diff()const
    {
        poly C;C.resize(size()-1);
        for(rg unsigned int i=1;i<size();i++)C[i-1]=(ll)A[i]*i%mod;
        return C;
    }
    inline poly inte()const
    {
        poly C;C.resize(size()+1);
        for(rg unsigned int i=0;i<size();i++)C[i+1]=(ll)A[i]*Inv[i+1]%mod;
        C[0]=0;
        return C;
    }
    inline poly ln()const
    {
        poly C=(diff()*inv()).inte();C.resize(size());
        return C;
    }
    inline poly exp()const
    {
        poly C;
        if(size()==1){C=*this;C[0]=1;return C;}
        C.resize((size()+1)>>1);
        for(rg unsigned int i=0;i<C.size();i++)C[i]=A[i];
        C=C.exp();C.resize(size());
        poly D=(poly)1-C.ln()+*this;
        D=D*C;
        D.resize(size());
        return D;
    }
    inline poly sqrt()const
    {
        poly C;
        if(size()==1)
        {
            C=*this;C[0]=Quadratic_residue(C[0]);
            return C;
        }
        C.resize((size()+1)>>1);
        for(rg unsigned int i=0;i<C.size();i++)C[i]=A[i];
        C=C.sqrt();C.resize(size());
        C=(C+*this*C.inv())*(int)499122177;
        C.resize(size());
        return C;
    }
    inline poly operator >>(const unsigned int x)const
    {
    	poly C;if(size()<x){C.resize(0);return C;}
        C.resize(size()-x);
    	for(rg unsigned int i=0;i<C.size();i++)C[i]=A[i+x];
    	return C;
    }
    inline poly operator <<(const unsigned int x)const
    {
    	poly C;C.RE(size()+x);
    	for(rg unsigned int i=0;i<size();i++)C[i+x]=A[i];
    	return C;
    }
    inline poly Pow(const unsigned int x)const
    {
    	for(rg unsigned int i=0;i<size();i++)
            if(A[i])
            {
                poly C=((((*this/A[i])>>i).ln()*x).exp()*pow(A[i],x))<<(min(i*x,size()));
                C.resize(size());
                return C;
            }
    	return *this;
    }
    inline void cheng(const poly&B)
    {
        for(rg unsigned int i=0;i<size();i++)A[i]=(ll)A[i]*B[i]%mod; 
    }
    inline void jia(const poly&B)
    {
        for(rg unsigned int i=0;i<size();i++)A[i]=Md(A[i]+B[i]); 
    }
    inline void dft()
    {
        memset(ha,0,L<<2);
        for(rg unsigned int i=0;i<A.size();i++)ha[i]=A[i];
        DFT(ha);
        resize(L);
        for(rg int i=0;i<L;i++)A[i]=ha[i];
    }
    inline void idft()
    {
        memset(ha,0,L<<2);
        for(rg unsigned int i=0;i<A.size();i++)ha[i]=A[i];
        IDFT(ha);
        const int inv=pow(L,mod-2);
        for(rg int i=0;i<L;i++)A[i]=(ll)ha[i]*inv%mod;
        while(size()&&!A[size()-1])A.pop_back();
    }
};
void fz(const int root,const int l,const int r,std::vector<int>&v,std::vector<poly>&A)
{
    if(l==r)
    {
        A[root].resize(2);
        A[root][0]=(mod-v[l])%mod;
        A[root][1]=1;
        return;
    }
    const int mid=(l+r)>>1;
    fz(root<<1,l,mid,v,A),fz(root<<1|1,mid+1,r,v,A);
    A[root]=A[root<<1]*A[root<<1|1];
}
void calc(const int root,const int l,const int r,std::vector<int>&v,std::vector<poly>&A,std::vector<poly>&B)
{
    if(l==r)
    {
        v[l]=B[root][0];
        return;
    }
    const int mid=(l+r)>>1;
    B[root<<1]=B[root]%A[root<<1];
    B[root<<1|1]=B[root]%A[root<<1|1];
    calc(root<<1,l,mid,v,A,B),calc(root<<1|1,mid+1,r,v,A,B);
}
void multi_point_evaluation(const poly a,std::vector<int>&v)
{
    std::vector<poly>A,B;A.resize(maxn),B.resize(maxn);
    fz(1,0,v.size()-1,v,A);
    B[1]=a%A[1];
    calc(1,0,v.size()-1,v,A,B);
}
void fz2(const int root,const int l,const int r,std::vector<int>&y,std::vector<poly>&A,std::vector<poly>&B)
{
    if(l==r)
    {
        B[root].resize(1),B[root][0]=y[l];
        return;
    }
    const int mid=(l+r)>>1;
    fz2(root<<1,l,mid,y,A,B),fz2(root<<1|1,mid+1,r,y,A,B);
    B[root]=B[root<<1]*A[root<<1|1]+B[root<<1|1]*A[root<<1];
}
poly interpolation(std::vector<int>&x,std::vector<int>&y)
{
    std::vector<poly>A,B;A.resize(maxn),B.resize(maxn);
	fz(1,0,x.size()-1,x,A);
	multi_point_evaluation(A[1].diff(),x);
	for(rg unsigned int i=0;i<x.size();i++)y[i]=(ll)y[i]*pow(x[i],mod-2)%mod;
    fz2(1,0,x.size()-1,y,A,B);
    return B[1];
}
}///namespace of Poly
Poly::poly a;
int n,m;
int main()
{
    Poly::init(maxn);///namespace of Poly
    read(n),n++,read(m);
	a.readin(n);
	a=(((Poly::poly){2-a[0]}+a-a.sqrt().inv().inte().exp()).ln()+(Poly::poly)1).Pow(m).diff();
	a.resize(n-1);
	a.putout();
	return flush(),0;
}

update by 2019.2.24： 优化了NTT函数，减小了一半的常数

总结

要注意求导对什么求，否则会推错
很多算法基于牛顿迭代
对于求导积分会损失常数项，所以要单独求
自己写一遍博客才知道很多式子的细节所在
还被迫学了二次剩余