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)}$则答案即为$\sum\limits_{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=,G1=,G2=(mod+)/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]=;int ret=;
     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+);
     }return ret;
 }
 inline void dfsrt(int g,int fa){
     int hs=;
     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>>)&&hs<=(alsz>>))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+);
     }
 }

 int r[N];

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

         ntt(a,l2,);
         for(int j=;j<l2;++j)a[j]=1ll*a[j]*a[j]%mod;
         ntt(a,l2,-);

         const LL iv=qpow(l2,mod-);
         for(int j=;j<=d2+d2;++j)sum[j]-=iv*a[j]%mod;
         for(int j=;j<l2;++j)a[j]=;
     }

     for(int i=;i<=d;++i)sum[i]+=b[i]<<;
     ntt(b,lim,);
     for(int i=;i<lim;++i)b[i]=1ll*b[i]*b[i]%mod;
     ntt(b,lim,-);
     const LL iv=qpow(lim,mod-);
     for(int i=;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[]]=rt;
     }

 }
 int main()
 {
 //    freopen("da.in","r",stdin);
     scanf("%d",&n);
     for(int i=,x,y;i<n;++i){
         scanf("%d%d",&x,&y),++x,++y;
         addedge(x,y),addedge(y,x);
     }
     dfssz(,);alsz=sz[];dfsrt(,);c[++c[]]=rt;
     for(int i=;i<=c[];++i)work(c[i]);
     double ans=;
     for(int i=;i<n;++i)
     {
 //        printf("i:%d sum:%d\n",i,sum[i]);
         ans+=1.0*sum[i]/(i+1.0);
     }
     printf("%.4lf\n",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+二项式反演。首先化式子，$ \binom{m}{k}*\binom{n}{k*s}*\frac{(k*s)!}{x^{k}}*(m-k)^{n-k*s} $就得到了钦定k个的方案数，注意，是钦定，而不是至少。

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

T9：城市规划

次题考察分治fft，分治fft的形式：$f[i]=\sum\limits_{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=,G1=,G2=(mod+)/G1;
 using namespace std;
 int n,f[N],g[N];
 inline int qpow(int d,LL z){
     int ret=;
     for(;z;z>>=,d=1ll*d*d%mod)
         if(z&)ret=1ll*ret*d%mod;
     return ret;
 }
 int inc[N],inv[N];
 inline void init(int n){
     inc[]=inv[]=;
     for(int i=;i<=n;++i)inc[i]=1ll*inc[i-]*i%mod;
     inv[n]=qpow(inc[n],mod-);
     for(int i=n-;i;--i)inv[i]=1ll*inv[i+]*(i+)%mod;
     for(int i=;i<=n;++i)
         g[i]=1ll*qpow(,1ll*i*(i-)>>)*inv[i]%mod;
 }
 inline void ntt(int *a,cri n,cri tag)
 {
     static int r[N],cnt;
     cnt=-;for(int i=n;i;i>>=,++cnt);
     for(int i=;i<n;++i){
         r[i]=(r[i>>]>>)|((i&)<<cnt);
         if(i>r[i])swap(a[i],a[r[i]]);
     }
     for(int i=;i<n;i<<=){
         LL u=qpow(tag==?G1:G2,(mod-)/i/),w=,t;
         for(int j=,I=i<<;j<n;j+=I,w=)
             for(int k=;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\n",l,f[l]);
         if(l){
             f[l]=1ll*f[l]*inc[l-]%mod;
             f[l]=(1ll*g[l]*inc[l]%mod+0ll+mod-f[l])%mod;
             f[l]=1ll*f[l]*inv[l-]%mod;
         }
         return;
     }
     static int ff[N],gg[N];
     const int mid=l+r>>;
     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+;i<=r;++i)ff[i-l]=,gg[i-l]=g[i-l];//gg[r-l]=0;
     ntt(ff,r-l+,);ntt(gg,r-l+,);
     for(int i=;i<r-l+;++i)ff[i]=1ll*ff[i]*gg[i]%mod;
     ntt(ff,r-l+,-);const LL iv=qpow(r-l+,mod-);
     for(int i=mid+;i<=r;++i)(f[i]+=iv*ff[i-l]%mod)%=mod;
     solve(mid+,r);
 }
 int main(){
     scanf("%d",&n);init(n);
     int lim;for(lim=;lim<=n;lim<<=);
     solve(,lim-);
 //    for(int i=1;i<=n;++i)printf("%lld\n",1ll*f[i]*inc[i-1]%mod);
     printf("%lld\n",1ll*f[n]*inc[n-]%mod);
     return ;
 }

板子

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

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

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