移动金币
题目链接：luogu P5363
题目大意
给你一个 1*n 的棋盘，然后一开始有 m 个东西，每次两个人轮流操作，可以选一个东西往左移若干格。
（不能飞出格子，不能越过别的东西）
然后谁不能动就输了，然后问你有多少种初始情况先手必胜。
思路
首先考虑推出什么时候会赢。
你可以把一个点往左移看做是它和它前面的点的距离变小，到它后面点的距离变大，然后你再把 0 0 0 也看做一个点（它不可以移），那如果所有相邻的距离都是 0 0 0 就输了。
然后把一个变小若干，把旁边的变大若干，可以看做是把左边的若干个式子移动到右边，然后全部移动到最右边就输了。
那就是一个阶梯博弈，就是要奇数位的石子个数异或和。
那必胜是非 0 0 0 不好搞考虑求是 0 0 0 的。
然后考虑 DP，就是要把 n − m n-m n−m 个石子放到 m + 1 m+1 m+1 堆里面且偶数堆异或和是 0 0 0。
首先是暴力枚举每一堆放多少个石子状态时到第 i i i 堆一共用了多少式子当前异或值是多少， m n 3 mn^3 mn3。
然后考虑异或，就每位每位搞，就每次看一位，看有多少堆里面放了。
设 f i , j f_{i,j} fi,j 为当前处理到第 i i i 位，然后已经有了 j j j 的石子，然后枚举放多少个， n m log n nm\log n nmlogn。
然后发现你对于 N = n − m N=n-m N=n−m，对于它二进制的每一位，要么是在这个位数放了一个式子，要么是从低位的放了若干个进位过来的。
那我们可以直接设 f i , j f_{i,j} fi,j 为处理到第 i i i 位，当前为还有 j j j 次可以选。
然后因为如果 j > m + 1 j>m+1 j>m+1 就直接无解（无论如何都放不完），所以 j j j 是 m m m 级别的， m 2 log n m^2\log n m2logn。
具体转移大概就是： f i , 2 j + v − k ← f i + 1 , j ∗ p k f_{i,2j+v-k}\leftarrow f_{i+1,j}*p_k fi,2j+v−k←fi+1,j∗pk（ v v v 是 N N N 这一位是 1 1 1 还是 0 0 0， p k p_k pk 是 k k k 个分给 m + 1 m+1 m+1 堆，偶数堆有偶数个的方案数）
p k p_k pk 可以预处理，就直接暴力枚举给偶数堆的个数 j j j，直接 C j ⌊ m + 1 2 ⌋ ⋅ C k − j m + 1 − ⌊ m + 1 2 ⌋ C_j^{\left\lfloor\frac{m+1}{2}\right\rfloor}\cdot C_{k-j}^{m+1-\left\lfloor\frac{m+1}{2}\right\rfloor} Cj⌊2m+1⌋⋅Ck−jm+1−⌊2m+1⌋
（ m + 1 − ⌊ m + 1 2 ⌋ = ⌊ m + 2 2 ⌋ m+1-\left\lfloor\frac{m+1}{2}\right\rfloor=\left\lfloor\frac{m+2}{2}\right\rfloor m+1−⌊2m+1⌋=⌊2m+2⌋）
然后其实就可以了。
但是还不够（至少在对于某题来讲）
然后你发现转移的式子它其实可以看做是卷起来。
把 f i + 1 , j f_{i+1,j} fi+1,j 放到 a 2 j + v a_{2j+v} a2j+v 的位置， p k p_k pk 放到 b m + 1 − k b_{m+1-k} bm+1−k 的位置。
然后 a a a 和 b b b 的卷积的第 i i i 位结果就是 f i , i − ( m − 1 ) f_{i,i-(m-1)} fi,i−(m−1) 了。
然后你用任意模数 NTT 搞即可，这里用了 MTT 的方法。
然后复杂度就是 m log m log n m\log m\log n mlogmlogn 了。
代码
普通版（ m 2 log n m^2\log n m2logn）
#include<cstdio>
#define ll long long
#define mo 1000000009
using namespace std;
int n, m;
ll jc[61], inv[61], p[61];
ll f[21][61];
ll C(int n, int m) {
if (n < m) return 0;
if (m < 0) return 0;
return jc[n] * inv[m] % mo * inv[n - m] % mo;
}
ll ksm(ll x, ll y) {
ll re = 1;
while (y) {
if (y & 1) re = re * x % mo;
x = x * x % mo;
y >>= 1;
}
return re;
}
void init() {
jc[0] = 1;
for (int i = 1; i <= m + 1; i++) jc[i] = jc[i - 1] * i % mo;
inv[m + 1] = ksm(jc[m + 1], mo - 2);
for (int i = m; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mo;
int on = (m + 1) / 2, jn = (m + 2) / 2;
for (int k = 0; k <= m + 1; k++) {
for (int i = 0; i <= on; i += 2) {
p[k] = (p[k] + C(on, i) * C(jn, k - i) % mo) % mo;
}
}
}
int main() {
scanf("%d %d", &n, &m);
init();
f[20][0] = 1; int need = n - m;
for (int i = 19; i >= 0; i--) {
int hv = (need >> i) & 1;
for (int j = 0; j <= m + 1; j++)
for (int k = 0; k <= m + 1; k++) {
int to = 2 * j + hv - k;
if (to < 0 || to > m + 1) continue;
f[i][to] = (f[i][to] + f[i + 1][j] * p[k] % mo) % mo;
}
}
ll ans = 1;
for (int i = n - m + 1; i <= n; i++) ans = ans * i % mo;
ans = ans * inv[m];
printf("%lld", (ans - f[0][0] + mo) % mo);
return 0;
}
MTT版（ m log m log n m\log m\log n mlogmlogn）
#include<cmath>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define lim 32000
#define ll long long
#define mo 1000000009
using namespace std;
struct complex {
double x, y;
complex (double xx = 0, double yy = 0) {
x = xx; y = yy;
}
};
int n, m;
ll jc[61], inv[61], p[61];
ll f[21][61], ans[201], a[201], b[201];
double Pi = acos(-1.0);
complex operator +(complex x, complex y) {
return (complex){
x.x + y.x, x.y + y.y};
}
complex operator -(complex x, complex y) {
return (complex){
x.x - y.x, x.y - y.y};
}
complex operator *(complex x, complex y) {
return (complex){
x.x * y.x - x.y * y.y, x.x * y.y + x.y * y.x};
}
ll C(int n, int m) {
if (n < m) return 0;
if (m < 0) return 0;
return jc[n] * inv[m] % mo * inv[n - m] % mo;
}
ll ksm(ll x, ll y) {
ll re = 1;
while (y) {
if (y & 1) re = re * x % mo;
x = x * x % mo;
y >>= 1;
}
return re;
}
void init() {
jc[0] = 1;
for (int i = 1; i <= m + 1; i++) jc[i] = jc[i - 1] * i % mo;
inv[m + 1] = ksm(jc[m + 1], mo - 2);
for (int i = m; i >= 0; i--) inv[i] = inv[i + 1] * (i + 1) % mo;
int on = (m + 1) / 2, jn = (m + 2) / 2;
for (int k = 0; k <= m + 1; k++) {
for (int i = 0; i <= on; i += 2) {
p[k] = (p[k] + C(on, i) * C(jn, k - i) % mo) % mo;
}
}
}
struct MTT_work {
complex p1[201 << 2], p2[201 << 2], q[201 << 2];
int limit, l_size, an[201 << 2];
void FFT(complex *now, int op) {
for (int i = 0; i < limit; i++)
if (i < an[i]) swap(now[i], now[an[i]]);
for (int mid = 1; mid < limit; mid <<= 1) {
complex Wn(cos(Pi / mid), op * sin(Pi / mid));
for (int R = (mid << 1), j = 0; j < limit; j += R) {
complex w(1, 0);
for (int k = 0; k < mid; k++, w = w * Wn) {
complex x = now[j + k], y = w * now[j + mid + k];
now[j + k] = x + y; now[j + mid + k] = x - y;
}
}
}
}
void mul(int n, ll *x, int m, ll *y) {
limit = 1; l_size = 0;
while (limit <= n + m) {
limit <<= 1; l_size++;
}
for (int i = 0; i < limit; i++) p1[i] = p2[i] = q[i] = (complex){
0, 0};
for (int i = 0; i <= n; i++)
p1[i] = (complex){
x[i] / lim, x[i] % lim}, p2[i] = (complex){
x[i] / lim, -x[i] % lim};
for (int i = 0; i <= m; i++)
q[i] = (complex){
y[i] / lim, y[i] % lim};
for (int i = 0; i < limit; i++)
an[i] = (an[i >> 1] >> 1) | ((i & 1) << (l_size - 1));
FFT(p1, 1); FFT(p2, 1); FFT(q, 1);
for (int i = 0; i < limit; i++) q[i].x /= limit, q[i].y /= limit;
for (int i = 0; i < limit; i++) p1[i] = p1[i] * q[i], p2[i] = p2[i] * q[i];
FFT(p1, -1); FFT(p2, -1);
for (int i = 0; i <= n + m; i++) {
ll a1b1 = (ll)floor((p1[i].x + p2[i].x) / 2 + 0.5) % mo;
ll a1b2 = (ll)floor((p1[i].y + p2[i].y) / 2 + 0.5) % mo;
ll a2b1 = ((ll)floor(p1[i].y + 0.5) - a1b2) % mo;
ll a2b2 = ((ll)floor(p2[i].x + 0.5) - a1b1) % mo;
ans[i] = (a1b1 * lim * lim + (a1b2 + a2b1) * lim + a2b2) % mo;
ans[i] = (ans[i] + mo) % mo;
}
}
}MTT;
int main() {
scanf("%d %d", &n, &m);
init();
f[20][0] = 1; int need = n - m;
for (int i = 19; i >= 0; i--) {
int hv = (need >> i) & 1;
// for (int j = 0; j <= m + 1; j++)
// for (int k = 0; k <= m + 1; k++) {
// int to = 2 * j + hv - k;
// if (to < 0 || to > m + 1) continue;
// f[i][to] = (f[i][to] + f[i + 1][j] * p[k] % mo) % mo;
// }
memset(a, 0, sizeof(a)); memset(b, 0, sizeof(b));
for (int j = 0; j <= m + 1; j++)//两倍加上进位
a[2 * j + hv] = f[i + 1][j];
for (int j = 0; j <= m + 1; j++)//反过来全部右移 m+1
b[m + 1 - j] = p[j];
MTT.mul((m + 1) * 2 + hv, a, m + 1, b);
for (int j = m + 1; j <= m + 1 + m + 1; j++)
f[i][j - (m + 1)] = ans[j];//因为 b 右移了所以要移回来 m+1 位
}
ll answ = 1;
for (int i = n - m + 1; i <= n; i++) answ = answ * i % mo;
answ = answ * inv[m];
printf("%lld", (answ - f[0][0] + mo) % mo);
return 0;
}