【luogu P5363】移动金币(博弈论)(DP)(数位DP)(MTT)

移动金币

题目链接:luogu P5363

题目大意

给你一个 1*n 的棋盘,然后一开始有 m 个东西,每次两个人轮流操作,可以选一个东西往左移若干格。
(不能飞出格子,不能越过别的东西)
然后谁不能动就输了,然后问你有多少种初始情况先手必胜。

思路

首先考虑推出什么时候会赢。

你可以把一个点往左移看做是它和它前面的点的距离变小,到它后面点的距离变大,然后你再把 0 0 0 也看做一个点(它不可以移),那如果所有相邻的距离都是 0 0 0 就输了。

然后把一个变小若干,把旁边的变大若干,可以看做是把左边的若干个式子移动到右边,然后全部移动到最右边就输了。

那就是一个阶梯博弈,就是要奇数位的石子个数异或和。
那必胜是非 0 0 0 不好搞考虑求是 0 0 0 的。

然后考虑 DP,就是要把 n − m n-m nm 个石子放到 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=nm,对于它二进制的每一位,要么是在这个位数放了一个式子,要么是从低位的放了若干个进位过来的。
那我们可以直接设 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+vkfi+1,jpk 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} Cj2m+1Ckjm+12m+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+12m+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+1k 的位置。
然后 a a a b b b 的卷积的第 i i i 位结果就是 f i , i − ( m − 1 ) f_{i,i-(m-1)} fi,i(m1) 了。

然后你用任意模数 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;
}

猜你喜欢

转载自blog.csdn.net/weixin_43346722/article/details/121159209