2023.02.20【省选组】模拟 总结

$\text{summary}$

又是写暴力的一天

$\text{T1【USACO 2020 US Open Platinum】 Exercise}$

发现自己连 $dp$ 都不会了
考场暴力都写不出来的原因：不知如何计算各个环长确定的情况下对应排列的数目
因为没有逆元，没法直接排列组合计数。。。
关键在于如果存在环长相同的情况，直接计数不可避免要除掉相同环长数量的阶乘
然而可以 $dp$ 计数，考场想了一会却不会
考虑一个环的代表为这个环上最小的数，那么枚举当前最小值所在环的大小转移，这样就可以避免算重了

这道题又是 $\text{lcm}$ 相关的计数
考虑单独拆开算每个质因子的指数，对某个质因子而言计算 $lcm=p^c$ 的排列数量
改成计算 $p^c|lcm$ 的排列数量，那么环中只要至少存在一个 $p^c$ 倍数的环即可
补集思想，计数不存在一个环长为 $p^c$ 倍数的排列数
若长度为 $i$，这个数目记为 $f_i$，那么 $f_i=i!-\sum_{p^c|j} f_j g_{i-j}$
$g_i$ 表示长度为 $i$ 的排列环长均为 $p^c$ 的倍数的排列数目
于是就可以 $O(n^2) \texttt{ } dp$ 了

$\texttt{warning:}$ 加法运算整个式子的类型默认为第一个对象的类型

$\text{Code}$

$\text{Code}$

#include <bits/stdc++.h> 
#define IN inline
using namespace std;
 
typedef long long LL;
const int N = 7505;
int b[N], n, M, P, C[N][N], bz[N];
 
IN void Add(LL &x, int y){if ((x += y) >= P) x -= P;}
 
int fpow(int x, int y, int p) {
	int s = 1;
	for(; y; y >>= 1, x = (LL)x * x % p) if (y & 1) s = (LL)s * x % p;
	return s;
}
 
LL f[N], g[N], fac[N];
IN int calc(int x) {
	g[0] = 1;
	for(int i = x; i <= n; i += x) {
		g[i] = 0;
		for(int j = x; j <= i; j += x)
			Add(g[i], g[i - j] * C[i - 1][j - 1] % P * fac[j - 1] % P);
	}
	f[0] = 1;
	for(int i = n % x; i <= n; i += x) {
		f[i] = fac[i];
		for(int j = x; j <= i; j += x)
			Add(f[i], P - g[j] * C[i][j] % P * f[i - j] % P);
	}
	return (fac[n] - f[n] + P) % P;
}
 
int main() {
	freopen("exercise.in", "r", stdin);
	freopen("exercise.out", "w", stdout);
	scanf("%d%d", &n, &M), P = M - 1, fac[0] = 1;
	for(int i = 1; i <= n; i++) fac[i] = fac[i - 1] * i % P;
	for(int i = 0; i <= n; i++) C[i][0] = 1;
	for(int i = 1; i <= n; i++)
		for(int j = 1; j <= i; j++) {
			LL z = C[i - 1][j]; Add(z, C[i - 1][j - 1]);
			C[i][j] = z;
		}
	int ans = 1;
	for(int i = 2; i <= n; i++) if (!bz[i]) {
		for(int j = i * i; j <= n; j += i) bz[j] = 1;
		for(int j = i; j <= n; j *= i) ans = (LL)ans * fpow(i, calc(j), M) % M;
	}
	printf("%d\n", ans);
}

$\text{T2 6517. 【GDOI2020模拟03.28】数三数（three)}$

仙姑了。。。

$\text{T3 6568. 【GDOI2020模拟】 迫害 DJ (hakugai)}$

$g$ 在 $p$ 意义下是有个循环节的，且比较短，和斐波那契数列循环节一样
找到这个循环节即可，然后就是套路矩乘了

$\texttt{warning}:$ 函数定义的 $void$ 不能漏，本地编译却可通过

$\text{Code}$

$\text{Code}$

#include <bits/stdc++.h>
#define IN inline
using namespace std;
 
template <typename Tp>
IN void read(Tp &x) {
	x = 0; char ch = getchar(); int f = 0;
	for(; !isdigit(ch); f = (ch == '-' ? 1 : f), ch = getchar());
	for(; isdigit(ch); x = (x<<3)+(x<<1)+(ch^48), ch = getchar());
	if (f) x = ~x + 1;
}
 
typedef long long LL;
LL P, pk[105];
LL gcd(LL x, LL y){return (!y ? x : gcd(y, x % y));}
 
struct Matrix {
	LL s00, s01, s10, s11;
	IN Matrix(LL a0 = 0, LL a1 = 0, LL a2 = 0, LL a3 = 0){s00 = a0, s01 = a1, s10 = a2, s11 = a3;}
	IN Matrix operator * (const Matrix &B) {
		Matrix C;
		C.s00 = (s00 * B.s00 % P + s01 * B.s10 % P) % P;
		C.s01 = (s00 * B.s01 % P + s01 * B.s11 % P) % P;
		C.s10 = (s10 * B.s00 % P + s11 * B.s10 % P) % P;
		C.s11 = (s10 * B.s01 % P + s11 * B.s11 % P) % P;
		return C;
	}
}Z, I, B;
 
IN Matrix fpow(Matrix x, LL y) {
	Matrix s = I;
	for(; y; y >>= 1, x = x * x) if (y & 1) s = s * x;
	return s;
}
 
IN int find(int x) {
	if (x == 2) return 3;
	if (x == 3) return 4;
	if (x == 5) return 10;
	if (x % 5 == 1 || x % 5 == 4) return x - 1;
	return x + 1;
}
IN LL calc(LL p) {
	LL lcm = 1;
	for(LL i = 2; i * i <= p; i++) if (p % i == 0) {
		LL w = 1;
		while (p % i == 0) p /= i, w *= i;
		w /= i, w = w * find(i), lcm = lcm / gcd(lcm, w) * w;
	}
	if (p > 1) p = find(p), lcm = lcm / gcd(lcm, p) * p;
	return lcm;
}
 
int main() {
	freopen("hakugai.in", "r", stdin);
	freopen("hakugai.out", "w", stdout);
	int t; read(t); I = Matrix(1, 0, 0, 1);
	for(; t; --t) {
		int a, b, p, k; LL n; read(a), read(b), read(n), read(k), read(p);
		pk[1] = p;
		for(int i = 2; i <= k; i++) pk[i] = calc(pk[i - 1]);
		for(Matrix ret; k; k--) {
			P = pk[k], Z = Matrix(a % P, b % P, 0, 0), B = Matrix(0, P - 1, 1, 3);
			ret = Z * fpow(B, n), n = ret.s00;
		}
		printf("%lld\n", n);
	}
}

这个循环节的计算规律是真不可背诵的
不过可以随机化，依据生日悖论寻找，$O(\sqrt P)$
具体来说就是猜测最小循环节上界，大致猜个 $12P$
然后在这个范围内随机个 $i$，看算出的 $(F_i,F_{i+1})$ 是否与之前重复
若是，重复的为 $(F_j,F_{j+1})$，那么一定有个循环节 $|i-j|$
期望 $O(\sqrt P)$ 次可以找到

下面是 $P4000$ 斐波那契数列
交了三遍才过呢

$\text{Code}$

$\text{Code}$

#include <bits/stdc++.h>
#define IN inline
using namespace std;
 
typedef long long LL;
typedef unsigned long long ull;
 
LL P;
 
struct Matrix {
	LL s00, s01, s10, s11;
	IN Matrix(LL a0 = 0, LL a1 = 0, LL a2 = 0, LL a3 = 0){s00 = a0, s01 = a1, s10 = a2, s11 = a3;}
	IN Matrix operator * (const Matrix &B) {
		Matrix C;
		C.s00 = (s00 * B.s00 % P + s01 * B.s10 % P) % P;
		C.s01 = (s00 * B.s01 % P + s01 * B.s11 % P) % P;
		C.s10 = (s10 * B.s00 % P + s11 * B.s10 % P) % P;
		C.s11 = (s10 * B.s01 % P + s11 * B.s11 % P) % P;
		return C;
	}
}I, B;
 
const int M = 1 << 18;
struct KSM {
	Matrix f[M + 5], ff[M + 5];
	IN void init(int m) {
		f[0] = ff[0] = I;
		for(int i = 1; i <= m; i++) f[i] = f[i - 1] * B;
		for(int i = 1; i <= m; i++) ff[i] = ff[i - 1] * f[m];
	}
	IN Matrix pow(LL x){return f[x & (M - 1)] * ff[x >> 18];}
}F;
 
const int N = 3e7 + 5;
char str[N];
mt19937_64 rnd(time(0));
 
unordered_map<ull, LL> hs;
 
int main() {
	scanf("%s%d", str, &P), I = Matrix(1, 0, 0, 1), B = Matrix(0, 1, 1, 1), F.init(M);
	LL len = 0;
	while (1) {
		LL x = (rnd() << 28 >> 28); Matrix C = F.pow(x);
		ull val = ((ull)C.s00 << 32) | C.s01;
		if (hs.find(val) != hs.end()){len = abs(x - hs[val]); break;}
		hs[val] = x;
	}
	LL z = 0;
	for(int i = 0; i < strlen(str); i++) z = (z * 10 + (str[i] ^ 48)) % len;
	printf("%lld\n", F.pow(z).s01);
}