【FZU】2208 cleaning again【模数质因数以3为众数的三进制NTT】

传送门：【FZU】2208 cleaning again

简要题意：
在长度为$N$的环上，选出$K$个点，同时需要满足这$K$个点两两之间的距离不等于$D$的方案数，方案数对$258280327(2*3^{17}+1)$取模。$1\leq N,D,K\leq 10^5$

题目分析：
首先我们知道如果将所有间隔为D的人建边，我们可以得到$g=gcd(N,D)$个由$N/g$个元素构成的环，而且环与环之间是互不影响的，这是一个很好的性质。这样问题变成了在第$i$环上选出$a_i$个互不相邻的元素，且$\sum_{i=1}^{g} a_i=K$的方案数。

考虑子问题：在一个长度为$X$的环上选出$Y$个互不相邻的元素的方案数。
考虑破环成链，枚举第一个点是否选。
1.第一个点不选
此时考虑将$Y$个点看成隔板，每个隔板左边强制有一个点（因为选的点不能相邻），这样得到的方案数为$C_{X-Y}^Y$。
2.第一个点选
此时我们反过来，使得隔板右边强制有一个点，由于已经选了一个点，且此时第一个点和第二个点不能使用，所以方案数为$C_{X-2-(Y-1)}^{Y-1}$

由于每个环都是一样的，我们不妨构造多项式：

$$A=\sum_{i=0}^{X-1}(C_{X-i}^{i}+C_{X-i-1}^{i-1})\cdot x^i$$

则总的方案数即多项式$A^g$中的第$K$项的系数。

由于所有多项式的阶的和不超过$N$，所以在构造了$A$之后对$A$求一次$FFT$正变换，对每一项用快速幂一下得到自身的$g$次幂，然后在逆变换回来即可。

但是问题还没有结束，因为这个素数并不是我们常用的费马素数，他的质因子$2$只有一个，而$3$却高达$17$个……于是我们只能考虑将$FFT$变成三进制的形式。

• 三进制$FFT$具体变换如下：
  由$A_{k}=A^{[0]}(w_n^{3k})+w_n^{k}\cdot A^{[1]}(w_n^{3k})+w_n^{2k}\cdot A^{[2]}(w_n^{3k})$
  得$~y_{k}=y_{k}^{[0]}+w_n^{k}\cdot y_{k}^{[1]}+w_n^{2k}\cdot y_{k}^{[2]}$
  由$A_{k+(n/3)}=A^{[0]}(w_n^{3k+n})+w_n^{k+(n/3)}\cdot A^{[1]}(w_n^{3k+n})+w_n^{2(k+(n/3))}\cdot A^{[2]}(w_n^{3k+n})$
  得$~y_{k+(n/3)}=y_{k}^{[0]}+w_n^{k+(n/3)}\cdot y_{k}^{[1]}+w_n^{2(k+(n/3))}\cdot y_{k}^{[2]}$
  由$A_{k+(2n/3)}=A^{[0]}(w_n^{3k+2n})+w_n^{k+(2n/3)}\cdot A^{[1]}(w_n^{3k+2n})+w_n^{2(k+(2n/3))}\cdot A^{[2]}(w_n^{3k+2n})$
  得$~y_{k+(2n/3)}=y_{k}^{[0]}+w_n^{k+(2n/3)}\cdot y_{k}^{[1]}+w_n^{2(k+(2n/3))}\cdot y_{k}^{[2]}$

• 蝶形变换和二进制$FFT$一样。

$my~~~code:$

#include <stdio.h>
#include <string.h>
#include <vector>
#include <algorithm>
using namespace std ;

typedef long long LL ;

#define clr( a , x ) memset ( a , x , sizeof a )

const int MAXN = 200005 ;
const int mod = 258280327 ;
const int g = 5 ;

int x1[MAXN] ;
int f[MAXN] , vf[MAXN] ;

int gcd ( int a , int b ) {
    return b ? gcd ( b , a % b ) : a ;
}

int pow_mod ( int x , int n ) {
    int res = 1 ;
    while ( n ) {
        if ( n & 1 ) res = 1LL * res * x % mod ;
        x = 1LL * x * x % mod ;
        n >>= 1 ;
    }
    return res ;
}

void DFT ( int y[] , int n , int rev ) {
    for ( int i = 1 , j , k , t ; i < n ; ++ i ) {
        for ( j = 0 , k = n / 3 , t = i ; k ; k /= 3 , t /= 3 ) {
            j = j * 3 + t % 3 ;
        }
        if ( i < j ) swap ( y[i] , y[j] ) ;
    }
    for ( int s = 3 , ds = 1 ; s <= n ; ds = s , s *= 3 ) {
        LL wn = pow_mod ( g , ( mod - 1 ) / s ) ;
        if ( rev ) wn = pow_mod ( wn , mod - 2 ) ;
        LL t1 = pow_mod ( wn , s / 3 ) ;
        LL t2 = t1 * t1 % mod ;
        for ( int k = 0 ; k < n ; k += s ) {
            LL w = 1 ;
            for ( int i = k , j = i + ds ; i < k + ds ; ++ i , ++ j ) {
                LL X = y[i] ;
                LL Y = w * y[i + ds] % mod ;
                LL Z = w * w % mod * y[j + ds] % mod ;
                y[i] = ( X + Y + Z ) % mod ;
                y[i + ds] = ( X + t1 * Y + t2 * Z ) % mod ;
                y[j + ds] = ( X + t1 * t1 % mod * Y + t2 * t2 % mod * Z ) % mod ;
                w = w * wn % mod ;
            }
        }
    }
}

void NTT ( int x1[] , int n , int m ) {
    DFT ( x1 , n , 0 ) ;
    for ( int i = 0 ; i < n ; ++ i ) {
        x1[i] = pow_mod ( x1[i] , m ) ;
    }
    DFT ( x1 , n , 1 ) ;
    int nv = pow_mod ( n , mod - 2 ) ;
    for ( int i = 0 ; i < n ; ++ i ) {
        x1[i] = 1LL * x1[i] * nv % mod ;
    }
}

int c ( int x , int y ) {
    if ( x < y ) return 0 ;
    return 1LL * f[x] * vf[y] % mod * vf[x - y] % mod ;
}

void process ( int n1 , int n ) {
    x1[0] = 1 ;
    for ( int i = 1 ; i < n1 ; ++ i ) {
        x1[i] = ( c ( n - i , i ) + c ( n - i - 1 , i - 1 ) ) % mod ;
    }
}

void solve () {
    int n , k , d ;
    scanf ( "%d%d%d" , &n , &k , &d ) ;
    int n1 = 1 ;
    while ( n1 <= n + 1 ) n1 *= 3 ;
    int g = gcd ( n , d ) ;
    process ( n1 , n / g ) ;
    NTT ( x1 , n1 , g ) ;
    printf ( "%d\n" , x1[k] ) ;
}

void preprocess () {
    f[0] = vf[0] = 1 ;
    for ( int i = 1 ; i < MAXN ; ++ i ) {
        f[i] = 1LL * f[i - 1] * i % mod ;
        vf[i] = pow_mod ( f[i] , mod - 2 ) ;
    }
}

int main () {
    int T ;
    preprocess () ;
    scanf ( "%d" , &T ) ;
    for ( int i = 1 ; i <= T ; ++ i ) {
        printf ( "Case #%d: " , i ) ;
        solve () ;
    }
    return 0 ;
}