FFT，NTT 专题

学习傅里叶的基本性质及其代码，可以参考大神理解

还有 ACdream 的博客

贴一下NTT的模板：

using namespace std;
typedef long long ll;
 
int n;
const ll MOD=;
const int N = ;
const int g=;
int len;
ll A[N];
long long a[N],b[N],wn[];
long long q_pow(long long x,long long y,long long P)
{
    long long ans=;
    while(y>)
    {
        if(y&)ans=ans*x%P;
        x=x*x%P;
        y>>=;
    }
    return ans;
}
void init()
{
    for(int i=;i<;i++)
    {
        int t=<<i;
        wn[i]=q_pow(g,(MOD-)/t,MOD);
    }
}
///雷德算法，2^M=len，将第i位的数与“i的二进制反转之后的位”的数交换
void rader(long long F[],int len)
{
    int j=len/;///模拟二进制反转进位的的位置
    for(int i=;i<len-;i++)
    {
        if(i<j)swap(F[i],F[j]);///该出手时就出手
        int k=len/;
        while(j>=k)
        {
            j-=k;
            k>>=;
        }
        if(j<k)j+=k;
    }
}
void NTT(long long F[],int len,int t)
{
    int id=;
    rader(F,len);
    for(int h=;h<=len;h<<=)
    {
        id++;
        for(int j=;j<len;j+=h)
        {
            long long E=;
            for(int k=j;k<j+h/;k++)
            {
                long long u=F[k];
                long long v=(E*F[k+h/])%MOD;
                F[k]=(u+v)%MOD;
                F[k+h/]=((u-v)%MOD+MOD)%MOD;
                E=(E*wn[id])%MOD;
            }
        }
    }
    if(t==-)
    {
        for(int i=;i<len/;i++)swap(F[i],F[len-i]);
        long long ni=q_pow(len,MOD-,MOD);
        for(int i=;i<len;i++)F[i]=(F[i]%MOD*ni)%MOD;
    }
}
 
void work()///卷积，点乘，插值
{
    NTT(a,len,);
    NTT(b,len,);
    for(int i=;i<len;i++)
        a[i]=(a[i]*b[i])%MOD;
    NTT(a,len,-);
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif
    init();
    int T_T;
    scanf("%d",&T_T);
    for(int kase=;kase<=T_T;kase++)
    {
        sc(n);
        len=;
        while(len<=*n)
            len<<=;
　　　　/**
　　　　　　　这部分就是你对公式的变形并把他转化为卷积形式，分别存在a[],b[]里
　　　　*/
　　　　work();
　　}
　　return 0;
}

对于傅里叶运用的要点，要认真对待对下面卷积公式的理解

训练：

传送门：hdu 5829 Rikka with Subset

题意：给你一个数组A[]，然后计算F[k],F[k]指A[]所有子集中，先对每个子集前k大的数的和，然后再对把所以子集所求值求和

思路：因为我也是初学，所以我找的一个大神的博客学习的http://blog.csdn.net/cqu_hyx/article/details/52194696

对于其中的几点，我做一点补充：

1. f[k]计算的是第k大的数对答案的贡献，而比他大的数的贡献没有计算；不过只需要累加分f[1]..f[k-1]就是前k大的数的和了
2. 对比以上卷积公式，我们得到的是   a[i]=2^n-i/i!   ,  b[i]=A[i]*(i-1)! ;如果我们b[0]=A[1]*0！，那么我们reverse一下，b[i]=b[n-i]了；在我们推导的f[k]公式里，f[k]是与a[i]*b[i+k]相关的，且i最大为（n-k），经过我们对b数组reverse，f[k]是与a[i]*b[(n-k)-i]相关的，这刚好和上面的卷积公式一致，所以我们可以放心ntt了。
3. 由卷积公式可知，y[n-k]是a[i]*b[(n-k)-i]的卷积结果，而这个结果存在a[]里；并且f[k]也等于a[i]*b[(n-k)-i]的卷积，所以f[k]与y[n-k]即a[n-k]相关

/**************************************************************
    Problem:hdu 5829 Rikka with Subset
    User: youmi
    Language: C++
    Result: Accepted
    Time:2605MS
    Memory:11804K
****************************************************************/
//#pragma comment(linker, "/STACK:1024000000,1024000000")
//#include<bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <cmath>
#include <queue>
#include <deque>
#include <string>
#include <vector>
#define zeros(a) memset(a,0,sizeof(a))
#define ones(a) memset(a,-1,sizeof(a))
#define sc(a) scanf("%d",&a)
#define sc2(a,b) scanf("%d%d",&a,&b)
#define sc3(a,b,c) scanf("%d%d%d",&a,&b,&c)
#define scs(a) scanf("%s",a)
#define sclld(a) scanf("%I64d",&a)
#define pt(a) printf("%d\n",a)
#define ptlld(a) printf("%I64d\n",a)
#define rep(i,from,to) for(int i=from;i<=to;i++)
#define irep(i,to,from) for(int i=to;i>=from;i--)
#define Max(a,b) ((a)>(b)?(a):(b))
#define Min(a,b) ((a)<(b)?(a):(b))
#define lson (step<<1)
#define rson (lson+1)
#define eps 1e-6
#define oo 0x3fffffff
#define TEST cout<<"*************************"<<endl
const double pi=*atan(1.0);
 
using namespace std;
typedef long long ll;
 
int n;
const ll MOD=;
const int N = ;
const int g=;
int len;
ll inv2;
ll A[N];
ll inv[N],fac[N],f[N],bit[N];
long long a[N],b[N],wn[];
long long q_pow(long long x,long long y,long long P)
{
    long long ans=;
    while(y>)
    {
        if(y&)ans=ans*x%P;
        x=x*x%P;
        y>>=;
    }
    return ans;
}
void init()
{
    for(int i=;i<;i++)
    {
        int t=<<i;
        wn[i]=q_pow(g,(MOD-)/t,MOD);
    }
    inv[]=inv[]=;
    rep(i,,1e5)
        inv[i]=(inv[i-]*q_pow(i,MOD-,MOD))%MOD;
    fac[]=fac[]=;
    rep(i,,1e5)
        fac[i]=(fac[i-]*i)%MOD;
    bit[]=;
    rep(i,,1e5)
        bit[i]=bit[i-]*%MOD;
    inv2=q_pow(,MOD-,MOD);
}
///雷德算法，2^M=len，将第i位的数与“i的二进制反转之后的位”的数交换
void rader(long long F[],int len)
{
    int j=len/;///模拟二进制反转进位的的位置
    for(int i=;i<len-;i++)
    {
        if(i<j)swap(F[i],F[j]);///该出手时就出手
        int k=len/;
        while(j>=k)
        {
            j-=k;
            k>>=;
        }
        if(j<k)j+=k;
    }
}
void NTT(long long F[],int len,int t)
{
    int id=;
    rader(F,len);
    for(int h=;h<=len;h<<=)
    {
        id++;
        for(int j=;j<len;j+=h)
        {
            long long E=;
            for(int k=j;k<j+h/;k++)
            {
                long long u=F[k];
                long long v=(E*F[k+h/])%MOD;
                F[k]=(u+v)%MOD;
                F[k+h/]=((u-v)%MOD+MOD)%MOD;
                E=(E*wn[id])%MOD;
            }
        }
    }
    if(t==-)
    {
        for(int i=;i<len/;i++)swap(F[i],F[len-i]);
        long long ni=q_pow(len,MOD-,MOD);
        for(int i=;i<len;i++)F[i]=(F[i]%MOD*ni)%MOD;
    }
}
 
void work()///卷积，点乘，插值
{
    NTT(a,len,);
    NTT(b,len,);
    for(int i=;i<len;i++)
        a[i]=(a[i]*b[i])%MOD;
    NTT(a,len,-);
}
int main()
{
    #ifndef ONLINE_JUDGE
    freopen("in.txt","r",stdin);
    #endif
    init();
    int T_T;
    scanf("%d",&T_T);
    for(int kase=;kase<=T_T;kase++)
    {
        sc(n);
        len=;
        while(len<=*n)
            len<<=;
        rep(i,,n)
            sclld(A[i]);
        sort(A+,A++n,greater<ll>());
        zeros(a);zeros(b);
        rep(i,,n-)
            a[i]=(bit[n-i]*inv[i])%MOD;
        rep(i,,n-)
            b[i]=(A[i+]*fac[i])%MOD;
        reverse(b,b+n);
        work();
        ll r=inv2;
        f[]=;
        rep(i,,n)
        {
            f[i]=a[n-i]*inv[i-]%MOD*r%MOD;
            r=r*inv2%MOD;
            f[i]=(f[i]+f[i-])%MOD;
            printf("%I64d ",f[i]);
        }
        puts("");
    }
}