@codechef - BIKE@ Chef and Bike

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

输入 n(n ≤ 22) 个点，m(m ≤ 8000) 个边。每个边连接着点 (si, ei)，有两个长度 fi, ri。

问对于每个点 k，有多少条路径（不一定是简单路径）由 t (t ≤ 10^9) 条边组成，从 k 开始，并且以 k 结束；并且路径上所有边 f 的和 mod n 为 x；并且路径上所有边 r 的和 mod (n − 1) 为 y。

对于每一个 (x, y) 都要计算。

方案数 mod 1163962801 输出。

input

输入的第一行包含三个整数 n、m 和 t。n, m, t 的含义如上，注意 n 是点数，也是模数。如果重复经过同一条边，需要计算两次。

之后的 m 行里，每一行表示一条边。其中第 i 行包含四个整数，分别代表 si, ei, fi, ri。含义如上。

可能有重边自环。

output

输出被分为 n 个部分。其中第 k 个部分 (1 ≤ k ≤ n) 包含 n 行，而每一行包含 n − 1 个整数。

第 k 个输出部分的第 i 行的第 j 个数应当表示从点 k 出发，走过 t 条边之后回到点 k，路径上所有边 f 的和 mod n 为 i；并且路径上所有边 r 的和 mod (n − 1) 为 j。

输出的所有数字都应当对 1163962801 取模。

sample input

3 6 6

1 2 0 0

2 1 1 1

1 3 1 2

3 1 2 1

2 3 5 5

3 2 10 10

sample output

1 5

0 10

1 5

1 5

0 10

1 5

1 8

0 10

1 2

@solution@

首先观察到 n 的范围很小，t 的范围很大，并且可以经过重复的边。不难想到使用矩阵加速。

一个很 naive 的想法是，我们对于矩阵的每一个位置 (i, j) 记录 n*(n-1) 个二元组 (x, y)，表示从 i 到 j 路径上所有边 f 的和 mod n 为 x，r 的和 mod (n − 1) 为 y 的方案数。

这样做矩阵乘法 \(C = A*B\) 的时候，\(C(i, j) = \sum A(i, k)*B(k, j)\) 实际上就是 \(C(i, j, (x+p) \mod n, (y+q) \mod (n-1)) = \sum(A(i, k, x, y) * B(k, j, p, q))\)。

要做 \(O(n^3)\) 次乘法，每次乘法 \(O(n^4)\)。时间复杂度 \(O(n^7*log k)\)。虽然 n 很小但还是太慢了。

观察我们乘法的转移形式，不难发现它是一个循环卷积的形式，可以使用 fft 优化。

优化过后每次乘法只需要 \(O(n^2*log n)\) 的时间，时间复杂度降为 \(O(n^5*log n*log k)\)。

但是注意到模数不是 998244353 而是 1163962801，所以这里的 fft 必须要使用一些常数较大的技巧来避免溢出。

所以实际运行时效果远不如 \(O(n^5*log n*log k)\) 那么优秀。

考虑我们平常使用多项式作快速幂，是将其转为点值形式，使用点值做快速幂。这个地方是否也可以运用这一方法呢。

对于长度为 n 的循环卷积，无法将其长度拓展为 2 的幂，所以无法使用一般的 fft。

但是，代入 n 次单位根很多性质依然可以满足。或者说，除了不能使用分治进行 fft，其他性质都可以满足。

注意到这个地方的 n 很小，我们可以直接暴力 \(O(n^2)\) 求值，暴力 \(O(n^2)\) 还原。

观察模数 mod = 1163962801。想一想为什么可以使用 p = 998244353 进行数论变换，因为 p-1 恰好是 2^23 的倍数，所以它有 2^x(x ≤ 23) 次单位根。

对 mod - 1 进行质因数分解，它等于 \(2^4*3^2*5^2*7*11*13*17*19\)。我们发现它是 1~22 所有数字的公倍数，因此它有 1~22 次单位根。

最后一个问题，这个地方是一个二维的卷积形式。

因此，我们求值时是代入一个二元组 \((w_n^i, w_{n-1}^j)\)，一共有 n*(n-1) 对二元组要求值。

最后逆变换还原时，插值 \((w_n^{-i}, w_{n-1}^{-j})\) 即可。直观理解起来不难。

时间复杂度为 \(O(n^5*log k)\)。

@accepted code@

#include<cstdio>
const int G = 46;
const int MAXN = 22 + 5;
const int MAXM = 10000 + 5;
const int MOD = 1163962801;
inline int add(int x, int y) {return (1LL*x + 1LL*y)%MOD;}
inline int mul(int x, int y) {return 1LL*x*y%MOD;}
int pow_mod(int b, int p) {
	int ret = 1;
	while( p ) {
		if( p & 1 ) ret = mul(ret, b);
		b = mul(b, b);
		p >>= 1;
	}
	return ret;
}
struct matrix{
	int m[MAXN][MAXN], r, c;
	friend matrix operator * (const matrix &A, const matrix &B) {
		matrix C; C.r = A.r, C.c = B.c;
		for(int i=0;i<C.r;i++)
			for(int j=0;j<C.c;j++) {
				C.m[i][j] = 0;
				for(int k=0;k<A.c;k++) {
					C.m[i][j] = add(C.m[i][j], mul(A.m[i][k], B.m[k][j]));
				}
			}
		return C;
	}
};
matrix mpow(matrix A, int p) {
	matrix ret; ret.r = ret.c = A.r;
	for(int i=0;i<A.r;i++)
		for(int j=0;j<A.c;j++)
			ret.m[i][j] = (i == j);
	while( p ) {
		if( p & 1 ) ret = ret * A;
		A = A * A;
		p >>= 1;
	}
	return ret;
}
void func(int a[], int n) {
	a[0] = 1, a[1] = pow_mod(G, (MOD - 1)/n);
	for(int i=2;i<n;i++) a[i] = mul(a[i - 1], a[1]);
}
int wx[MAXN], wy[MAXN];
int u[MAXM], v[MAXM], x[MAXM], y[MAXM];
int t, n, m;
matrix get_matrix(int i, int j) {
	matrix A; A.r = A.c = n;
	for(int k=0;k<A.r;k++)
		for(int l=0;l<A.c;l++)
			A.m[k][l] = 0;
	for(int k=1;k<=m;k++)
		A.m[u[k]][v[k]] = add(A.m[u[k]][v[k]], mul(pow_mod(wx[i], x[k]), pow_mod(wy[j], y[k])));
	return A;
}
int f[MAXN][MAXN][MAXN];
int ans[MAXN][MAXN];
void func2(int i) {
	for(int j=0;j<n;j++)
		for(int k=0;k<n-1;k++)
			ans[j][k] = 0;
	for(int j=0;j<n;j++)
		for(int k=0;k<n-1;k++)
			for(int p=0;p<n;p++)
				for(int q=0;q<n-1;q++) {
					ans[j][k] = add(ans[j][k], mul(f[i][p][q], mul(pow_mod(wx[j], n-p), pow_mod(wy[k], (n-1)-q))));
				}
	int inv = pow_mod(n*(n - 1), MOD - 2);
	for(int j=0;j<n;j++)
		for(int k=0;k<n-1;k++)
			printf("%d%c", mul(ans[j][k], inv), (k + 1 == n - 1) ? '\n' : ' ');
}
int main() {
	scanf("%d%d%d", &n, &m, &t);
	for(int i=1;i<=m;i++) {
		scanf("%d%d%d%d", &u[i], &v[i], &x[i], &y[i]);
		u[i]--, v[i]--, x[i] %= n, y[i] %= (n-1);
	}
	func(wx, n), func(wy, n - 1);
	for(int i=0;i<n;i++)
		for(int j=0;j<n-1;j++) {
			matrix M = mpow(get_matrix(i, j), t);
			for(int k=0;k<n;k++)
				f[k][i][j] = M.m[k][k];
		}
	for(int i=0;i<n;i++)
		func2(i);
}

@details@

这道题的模数，加法刚好溢出 int。

我就说为什么它会出现负数……

2017 冬令营的老题了……