fft，ntt总结

一个套路：把式子推成卷积形式，然后用fft或ntt优化求解过程。

fft的扩展性不强，不可以在fft函数里多加骚操作--DeepinC

T1:多项式乘法

板子题

T2：快速傅立叶之二

另一个板子，小技巧：把一个数组反转过来，以符合卷积形式

T3：力

拆式子，把q_j除到左边，然后把大于j的贡献和小于j的贡献分开考虑，对于小于j的，直接用fft统计，对于大于的，先反转再fft

T4：Normal

大神题，考虑把贡献拆成点对，对于两个点i与j，若i能对j作出贡献，则i到j的路径上没有断点，同样删除i到j路径以外的点不影响i与j之间的贡献，则i对j作出贡献的概率为

$frac{1}{dis(i,j)}$则答案即为$sumlimits_{i=1}^{n}sum limits_{j=1}^{n}frac{1}{dis(i,j)}$ 然后这玩意可以用点分治求，合并子树用fft优化

#include<bits/stdc++.h>
#define N 70050
#define LL long long
const int mod=998244353,G1=3,G2=(mod+1)/G1;
#define cri const register int 
using namespace std;
int a[N],b[N];
int n;
int he[N],ne[N],to[N],tot;
int sz[N],alsz,vis[N],rt;
inline void addedge(int x,int y){to[++tot]=y;ne[tot]=he[x];he[x]=tot;}
inline int dfssz(int g,int fa){
    sz[g]=1;int ret=1;
    for(int i=he[g],k;i;i=ne[i]){
        if(to[i]==fa||vis[to[i]])continue;
        k=dfssz(to[i],g);sz[g]+=sz[to[i]];ret=max(ret,k+1);
    }return ret;
}
inline void dfsrt(int g,int fa){
    int hs=0;
    for(int i=he[g];i;i=ne[i]){
        if(to[i]==fa||vis[to[i]])continue;
        dfsrt(to[i],g);hs=max(hs,sz[to[i]]);
    }
    if(sz[g]>(alsz>>1)&&hs<=(alsz>>1))rt=g;
}

inline int dfsdep(int g,int fa,int *a,int d){
    ++a[d];
    for(int i=he[g];i;i=ne[i]){
        if(to[i]==fa||vis[to[i]])continue;
        dfsdep(to[i],g,a,d+1);
    }
}

int r[N];

inline int qpow(int d,int z)
{
    int ret=1;
    for(;z;z>>=1,d=1ll*d*d%mod)
        if(z&1)ret=1ll*ret*d%mod;
    return ret;
}
inline void ntt(int *a,cri n,cri tag){
    int cnt=-2;for(int i=n;i;i>>=1,++cnt);
    for(int i=0;i<n;++i){
        r[i]=(r[i>>1]>>1)|((i&1)<<cnt);
        if(r[i]>i)swap(a[i],a[r[i]]);
    }
    for(int i=1;i<n;i<<=1){
        LL u=qpow(tag==1?G1:G2,(mod-1)/i/2),w=1,t;
        for(int j=0,I=i<<1;j<n;j+=I,w=1)
            for(int k=0;k<i;++k,w=w*u%mod)
                t=a[j+k+i]*w%mod,a[j+k+i]=(a[j+k]-t+mod)%mod,(a[j+k]+=t)%=mod;
    }
}
int c[N];int sum[N];
inline void work(int g)
{
    int d=dfssz(g,0)-1,lim=1;
    vis[g]=1;if(sz[g]==1)return;
    for(lim=1;lim<=d+d;lim<<=1);
    for(register int i=0;i<lim;++i)a[i]=b[i]=0;
    for(int i=he[g],d2,l2;i;i=ne[i]){
        if(vis[to[i]])continue;dfsdep(to[i],g,a,1);
        for(d2=1;a[d2];++d2)b[d2]+=a[d2];--d2;
        for(l2=1;l2<=d2+d2;l2<<=1);
        
        ntt(a,l2,1);
        for(int j=0;j<l2;++j)a[j]=1ll*a[j]*a[j]%mod;
        ntt(a,l2,-1);

        const LL iv=qpow(l2,mod-2);
        for(int j=0;j<=d2+d2;++j)sum[j]-=iv*a[j]%mod;
        for(int j=0;j<l2;++j)a[j]=0;
    }
    
    for(int i=0;i<=d;++i)sum[i]+=b[i]<<1;
    ntt(b,lim,1);
    for(int i=0;i<lim;++i)b[i]=1ll*b[i]*b[i]%mod;
    ntt(b,lim,-1);
    const LL iv=qpow(lim,mod-2);
    for(int i=0;i<=d+d;++i)sum[i]+=iv*b[i]%mod;
    
    
    for(int i=he[g];i;i=ne[i]){
        if(vis[to[i]])continue;
        alsz=sz[to[i]],dfsrt(to[i],g),c[++c[0]]=rt;
    }
    
}
int main()
{
//    freopen("da.in","r",stdin);
    scanf("%d",&n);
    for(int i=1,x,y;i<n;++i){
        scanf("%d%d",&x,&y),++x,++y;
        addedge(x,y),addedge(y,x);
    }
    dfssz(1,0);alsz=sz[1];dfsrt(1,0);c[++c[0]]=rt;
    for(int i=1;i<=c[0];++i)work(c[i]);
    double ans=0;
    for(int i=1;i<n;++i)
    {
//        printf("i:%d sum:%d
",i,sum[i]);
        ans+=1.0*sum[i]/(i+1.0);
    }
    printf("%.4lf
",ans+n);
}

T5：万径人踪灭

字符串与fft的结合，考虑以每个点为中心，用总共的减去连续的。发现只要求出以每个点为中心的对称的点对有多少个即可，对于中心mid，若l与r关于mid对称，

则mid=（l+r）>>1,然后这个东西就可以卷积了。对a和b分别卷积，就能求出以每个点为中心的对称的点对的个数,求连续的个数可以manacher也可以hash+二分

T6：序列统计

考察原根的用法。利用原根把乘法转化为加法，即将1～p-1中的每个数都表示为原根的k次方，原数相乘=新数相加，然后就可以ntt了

T7：求和

fft与斯特林数结合，个人感觉难想的点其实在于把j的枚举范围从i直接升到n，这样其实是去掉j对i的限制，同时不影响答案。

T8：染色

fft+二项式反演。首先化式子，$ inom{m}{k}*inom{n}{k*s}*frac{(k*s)!}{x^{k}}*(m-k)^{n-k*s} $就得到了钦定k个的方案数，注意，是钦定，而不是至少。

然后利用二项式反演的至少形式，化成卷积式，就可以fft了。

T9：城市规划

次题考察分治fft，分治fft的形式：$f[i]=sumlimits_{j=1}^{i}g[j]*f[i-j]$

#include<bits/stdc++.h>
#define cri const register int 
#define N 270050
#define LL long long
const int mod=1004535809,G1=3,G2=(mod+1)/G1;
using namespace std;
int n,f[N],g[N];
inline int qpow(int d,LL z){
    int ret=1;
    for(;z;z>>=1,d=1ll*d*d%mod)
        if(z&1)ret=1ll*ret*d%mod;
    return ret;
}
int inc[N],inv[N];
inline void init(int n){
    inc[0]=inv[0]=1;
    for(int i=1;i<=n;++i)inc[i]=1ll*inc[i-1]*i%mod;
    inv[n]=qpow(inc[n],mod-2);
    for(int i=n-1;i;--i)inv[i]=1ll*inv[i+1]*(i+1)%mod;
    for(int i=1;i<=n;++i)
        g[i]=1ll*qpow(2,1ll*i*(i-1)>>1)*inv[i]%mod;
}
inline void ntt(int *a,cri n,cri tag)
{
    static int r[N],cnt;
    cnt=-2;for(int i=n;i;i>>=1,++cnt);
    for(int i=0;i<n;++i){
        r[i]=(r[i>>1]>>1)|((i&1)<<cnt);
        if(i>r[i])swap(a[i],a[r[i]]);
    }
    for(int i=1;i<n;i<<=1){
        LL u=qpow(tag==1?G1:G2,(mod-1)/i/2),w=1,t;
        for(int j=0,I=i<<1;j<n;j+=I,w=1)
            for(int k=0;k<i;++k,(w*=u)%=mod)
                t=w*a[j+k+i]%mod,a[j+k+i]=(a[j+k]-t+mod)%mod,(a[j+k]+=t)%=mod;
    }
}
inline void solve(int l,int r){
    if(l>n)return;
    if(l==r){//printf("f[%d]=%d
",l,f[l]);
        if(l){
            f[l]=1ll*f[l]*inc[l-1]%mod;
            f[l]=(1ll*g[l]*inc[l]%mod+0ll+mod-f[l])%mod;
            f[l]=1ll*f[l]*inv[l-1]%mod;
        }
        return;
    }
    static int ff[N],gg[N];
    const int mid=l+r>>1;
    solve(l,mid);
    
    for(int i=l;i<=mid;++i)ff[i-l]=f[i],gg[i-l]=g[i-l];
    for(int i=mid+1;i<=r;++i)ff[i-l]=0,gg[i-l]=g[i-l];//gg[r-l]=0;
    ntt(ff,r-l+1,1);ntt(gg,r-l+1,1);
    for(int i=0;i<r-l+1;++i)ff[i]=1ll*ff[i]*gg[i]%mod;
    ntt(ff,r-l+1,-1);const LL iv=qpow(r-l+1,mod-2);
    for(int i=mid+1;i<=r;++i)(f[i]+=iv*ff[i-l]%mod)%=mod;
    solve(mid+1,r);
}
int main(){
    scanf("%d",&n);init(n);
    int lim;for(lim=1;lim<=n;lim<<=1);
    solve(0,lim-1);
//    for(int i=1;i<=n;++i)printf("%lld
",1ll*f[i]*inc[i-1]%mod);
    printf("%lld
",1ll*f[n]*inc[n-1]%mod);
    return 0;
}

然而这题化式子好像也挺难的。。。

考虑用总共的减去不合法的。设f[i]为答案数组，g[i]为i个点随意组合的方案数，则g[i]=2^n*(n-1)/2

考虑最后一个点加在了哪个联通块里面：$f[i]=g[i]-sumlimits_{j=1}^{i-1}inom{i-1}{j}g[i-j]*f[j]$就可以卷积了。