UOJ#449 喂鸽子

题意：有n个鸽子，你每秒随机喂一只鸽子，每只鸽子吃k次就饱了。求期望多少秒之后全饱了。n <= 50, k <= 1000。

解：有两种做法。一种直接DP的n²k做法在这。我用的是Min-Max容斥 + NTT优化DP。

先Min-Max容斥，由于鸽子是等价的，所以相当于求m只鸽子期望多少秒之后有一只饱了。

讲不清楚...看题解吧。

注意题解中m个盒子的答案为什么放了i + 1个球，这是因为我们把最后一个球拿出来考虑了。所以唯一放满k个球的盒子的贡献是1 / (k - 1)!

 #include <bits/stdc++.h>

 const int MO = ;
 const int N = ;

 int n, K, fac[N], inv[N], invn[N];
 int f[][N], g[][N], A[N * ], B[N * ], r[N * ];

 inline int C(int n, int m) {
     if(n <  || m <  || n < m) return ;
     return 1ll * fac[n] * invn[m] % MO * invn[n - m] % MO;
 }

 inline int qpow(int a, int b) {
     int ans = ;
     while(b) {
         if(b & ) ans = 1ll * ans * a % MO;
         a = 1ll * a * a % MO;
         b = b >> ;
     }
     return ans;
 }

 inline int Inv(int x) {
     return qpow(x, MO - );
 }

 inline void prework(int n) {
     static int R = ;
     if(R == n) return;
     R = n;
     int lm = ;
     while(( << lm) < n) lm++;
     for(int i = ; i < n; i++) {
         r[i] = (r[i >> ] >> ) | ((i & ) << (lm - ));
     }
     return;
 }

 inline void NTT(int *a, int n, int f) {
     prework(n);
     for(int i = ; i < n; i++) {
         if(i < r[i]) {
             std::swap(a[i], a[r[i]]);
         }
     }
     for(int len = ; len < n; len <<= ) {
         int Wn = qpow(, (MO - ) / (len << ));
         if(f == -) Wn = Inv(Wn);
         for(int i = ; i < n; i += (len << )) {
             int w = ;
             for(int j = ; j < len; j++) {
                 int t = 1ll * a[i + len + j] * w % MO;
                 a[i + len + j] = (a[i + j] - t) % MO;
                 a[i + j] = (a[i + j] + t) % MO;
                 w = 1ll * w * Wn % MO;
             }
         }
     }
     if(f == -) {
         int inv = Inv(n);
         for(int i = ; i < n; i++) {
             a[i] = 1ll * a[i] * inv % MO;
         }
     }
     return;
 }

 int main() {

     scanf("%d%d", &n, &K);

     fac[] = inv[] = invn[] = ;
     fac[] = inv[] = invn[] = ;
     for(int i = ; i <= n * K; i++) {
         fac[i] = 1ll * fac[i - ] * i % MO;
         inv[i] = 1ll * inv[MO % i] * (MO - MO / i) % MO;
         invn[i] = 1ll * invn[i - ] * inv[i] % MO;
     }

     int len = ;
     while(len <= n * K) len <<= ;
     g[][] = ;
     memcpy(B, invn, K * sizeof(int));
     NTT(B, len, );
     for(int i = ; i <= n; i++) {
         /*for(int j = 0; j <= i * K; j++) {
             /// g[i][j] f[i][j]
             for(int k = 0; k < K && k <= j; k++) {
                 g[i][j] = (g[i][j] + 1ll * g[i - 1][j - k] * invn[k] % MO) % MO;
                 f[i][j] = (f[i][j] + 1ll * f[i - 1][j - k] * invn[k] % MO) % MO;
             }
             if(j >= K) f[i][j] = (f[i][j] + 1ll * g[i - 1][j - K] * invn[K - 1] % MO) % MO;
         }*/
         memcpy(A, g[i - ], n * K * sizeof(int));
         memset(A + n * K, , (len - n * K) * sizeof(int));
         NTT(A, len, );
         for(int j = ; j < len; j++) {
             A[j] = 1ll * A[j] * B[j] % MO;
         }
         NTT(A, len, -);
         for(int j = ; j <= i * K; j++) {
             g[i][j] = A[j];
         }
         memcpy(A, f[i - ], n * K * sizeof(int));
         memset(A + n * K, , (len - n * K) * sizeof(int));
         NTT(A, len, );
         for(int j = ; j < len; j++) {
             A[j] = 1ll * A[j] * B[j] % MO;
         }
         NTT(A, len, -);
         for(int j = ; j <= i * K; j++) {
             f[i][j] = A[j];
             if(j >= K) {
                 f[i][j] = (f[i][j] + 1ll * g[i - ][j - K] * invn[K - ] % MO) % MO;
             }
         }
     }

     int ans = ;
     for(int i = ; i <= n; i++) {
         int temp = ;
         for(int j = K - ; j <= i * K; j++) {
             temp = (temp + 1ll * fac[j - ] * f[i][j] % MO * qpow(inv[i], j) % MO * j % MO) % MO;
         }
         temp = 1ll * temp * n % MO * inv[i] % MO * C(n, i) % MO;
         if(i & ) {
             ans = (ans + temp) % MO;
         }
         else {
             ans = (ans - temp) % MO;
         }
     }
     printf("%d\n", (ans + MO) % MO);
     return ;
 }

AC代码