分治FFT

前言

好像是一个不是很烦的算法
然后和分治套NTT不同

题目

模板题
已知$g_i$
求每个$f_i$
$$f_i=\sum _{j=1}^i{f}_{i-j}{g}_j$$

一般解法

直接求是$\Theta (n^2)$的
用FFT直接求是$\Theta (n^{2}logn)$的
不是很优
考虑分治
对所有位置建立二叉树
考虑其的后序遍历
访问到每个节点时，若其是其父亲的左儿子，那么对父亲的右儿子进行贡献
直接FFT转移即可
共有$logn$层，每层长度为$n$，FFT的复杂度有一个$log$
总复杂度$\Theta (nlo{g}^{2}n)$

代码

#include
#include
#include
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))
#define rg register
typedef long long LL;
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 void mind(T&a,const T b){a=a<b?a:b;}
template <typename T> inline void 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 T gcd(const T a,const T b){if(!b)return a;return gcd(b,a%b);}
template <typename T> inline T lcm(const T a,const T b){return a/gcd(a,b)*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> inline 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 LL mod=998244353,maxn=262146;
inline int Md(const int x){return x>=mod?x-mod:x;}
inline LL pow(LL x,LL y)
{
    rg LL res=1;
    for(;y;y>>=1,x=x*x%mod)if(y&1)res=res*x%mod;
    return res;
}
int n,f[maxn],g[maxn];
int lenth,Reverse[maxn];
int W[maxn],F[maxn];
inline void init(const int x)
{
    rg int tim=0;lenth=1;
    while(lenth<x)lenth<<=1,tim++;
    for(rg int i=0;i<lenth;i++)Reverse[i]=(Reverse[i>>1]>>1)|((i&1)<<(tim-1));
}
inline void NTT(int*A,const int fla)
{
    for(rg int i=0;i<lenth;i++)if(i<Reverse[i])swap(A[i],A[Reverse[i]]);
    for(rg int i=1;i<lenth;i<<=1)
    {
        const int w=fla==-1?F[i]:W[i];
        for(rg int j=0;j<lenth;j+=(i<<1))
        {
            int K=1;
            for(rg int k=0;k<i;k++,K=(LL)K*w%mod)
            {
                const int x=A[j+k],y=(LL)A[j+k+i]*K%mod;
                A[j+k]=Md(x+y);
                A[j+k+i]=Md(mod+x-y);
            }
        }
    }
    if(fla==-1)
    {
    	const int inv=pow(lenth,mod-2);
    	for(rg int i=0;i<lenth;i++)A[i]=(LL)A[i]*inv%mod;
    }
}
int A[maxn],B[maxn];
void calc(const int ll,const int rr,const bool sign)
{
    if(ll+1!=rr)
    {
        const int mid=(ll+rr)>>1; 
        calc(ll,mid,1);
        calc(mid,rr,0);
    }
    if(sign)
    {
        const int Lth=rr-ll,R=rr+Lth;
        init(Lth<<1);
        memcpy(A,f+ll,sizeof(int)*Lth);
        memset(A+Lth,0,sizeof(int)*Lth);
        memcpy(B,g,sizeof(int)*(Lth<<1));
        NTT(A,1),NTT(B,1);
        for(rg int i=0;i<lenth;i++)A[i]=(LL)A[i]*B[i]%mod;
        NTT(A,-1);
        for(rg int i=rr;i<R;i++)f[i]=Md(f[i]+A[Lth+i-rr]);
    }
}
int main()
{
    read(n),n--;
    init(n);
    for(rg int i=1;i<=n;i++)read(g[i]);
    for(rg int i=1;i<262144;i<<=1)
    {
        W[i]=pow(3,(mod-1)/i/2);
        F[i]=pow(W[i],mod-2);
    }
    f[0]=1;
    calc(0,lenth,0);
    for(rg int i=0;i<=n;i++)print(f[i]),putchar(' ');
    return flush(),0;
}

多项式求逆解法

我们观察式子：
$$f_i=\sum _{j=1}^i{f}_{i-j}{g}_j$$
我们可以换个写法（$f_0$即常数项）
$$f(x)\ast g(x)+f_0=f(x)(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
然后移项
$$f(x)=f_0(1-g(x){)}^{-1}(\mathrm{m}\mathrm{o}\mathrm{d}{x}^n)$$
多项式求逆即可
复杂度$\mathcal{O}(nlogn)$，代码就不贴了

总结

好用&清真