[NOI Online #3 提高组]魔法值

嘟嘟嘟


这题大体思路比较好想，但是最后的优化非常的妙，我没想出来。


很容易想到用序列\(f_{i-1}\)和邻接矩阵进行矩阵乘法运算得到\(f_i\)，不过这个矩阵乘法的定义有所不同：对于结果\(A(i,j)\)，应该是其中一个矩阵的第\(i\)行和另一个矩阵中的第\(j\)列的每一个元素相乘后的异或和。
因为矩阵有结合律，我们就可以用矩阵快速幂来进行优化，达到\(O(qn^3loga_i)\)的复杂度。


这40分的暴力分很好拿，那怎么能拿到满分呢？
关键在于矩乘虽然是\(O(n^3)\)的，但是\(f_i\)和邻接矩阵相乘是\(O(n^2)\)的，所以我们要想办法尽量多用\(O(n^2)\)代替矩阵快速幂中的\(O(n^3)\)。
但如果朴素的用\(f_i\)和邻接矩阵相乘，单次询问的复杂度就是\(O(n^2a_i)\)的了，显然不行。
所以我们仍要沿用矩阵快速幂的做法，只不过这次我们先预处理出邻接矩阵的\(2^i\)次方矩阵，这样单次询问的复杂度就是\(O(n^2loga_i)\)了，用空间换回了时间。


最终复杂度是\(O(qn^2loga_i)\)。


话说我写这题时把询问离线下来排序，但这样显然并不能降低复杂度：我们记排完序后的两个数据之间的距离为\(d_i\)，那么总时间复杂度就是\(n^3*(\sum_{i=1}^{n-1}logd_i) = n^3 * log\prod_{i=1}^{n-1}d_i\)。最坏情况就是所有\(d_i\)都相等，此时时间复杂度为\(O(n^4log\frac{a_{max}}{n})\)，显然过不了……我当时应该以为总复杂度是\(O(n^3loga_{max})\)吧。

#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<cstring>
#include<cstdlib>
#include<cctype>
#include<vector>
#include<queue>
#include<assert.h>
#include<ctime>
using namespace std;
#define enter puts("") 
#define space putchar(' ')
#define Mem(a, x) memset(a, x, sizeof(a))
#define In inline
#define forE(i, x, y) for(int i = head[x], y; ~i && (y = e[i].to); i = e[i].nxt)
typedef long long ll;
typedef double db;
const int INF = 0x3f3f3f3f;
const db eps = 1e-8;
const int maxn = 105;
const int N = 32;
In ll read()
{
	ll ans = 0;
	char ch = getchar(), las = ' ';
	while(!isdigit(ch)) las = ch, ch = getchar();
	while(isdigit(ch)) ans = (ans << 1) + (ans << 3) + ch - '0', ch = getchar();
	if(las == '-') ans = -ans;
	return ans;
}
In void write(ll x)
{
	if(x < 0) x = -x, putchar('-');
	if(x >= 10) write(x / 10);
	putchar(x % 10 + '0');
}
In void MYFILE()
{
#ifndef mrclr
	freopen("ha.in", "r", stdin);
//	freopen("ac.out", "w", stdout);
#endif
}

int n, m, Q;
ll a[maxn];
struct Mat
{
	int a[maxn][maxn];
	In Mat operator * (const Mat& oth)const
	{
		Mat ret; Mem(ret.a, 0);
		for(int i = 1; i <= n; ++i)
			for(int j = 1; j <= n; ++j)
				for(int k = 1; k <= n; ++k)
					ret.a[i][j] ^= a[i][k] * oth.a[k][j];
		return ret;
	}
}F, E[N + 2];

In Mat quickpow(Mat A, ll b)
{
	Mat ret; Mem(ret.a, 0);
	for(int i = 1; i <= n; ++i) ret.a[i][i] = 1;	
	for(; b; b >>= 1, A = A * A)
		if(b & 1) ret = ret * A;
	return ret;
}

ll b[maxn], tp[maxn];
In void calc(int x)
{
	fill(tp + 1, tp + n + 1, 0);
	for(int i = 1; i <= n; ++i)
		for(int j = 1; j <= n; ++j) tp[i] ^= b[j] * E[x].a[j][i];
	for(int i = 1; i <= n; ++i) b[i] = tp[i];
}
In ll solve(ll x)
{
	for(int i = 1; i <= n; ++i) b[i] = a[i];
	for(int i = 0; i <= N; ++i) 
		if((x >> i) & 1) calc(i);
	return b[1];
}

int main()
{
//	MYFILE();
	n = read(), m = read(), Q = read();
	for(int i = 1; i <= n; ++i) a[i] = read();
	for(int i = 1; i <= m; ++i)
	{
		int x = read(), y = read();
		F.a[y][x] = F.a[x][y] = 1;
	}
	for(int i = 0; i <= N; ++i) E[i] = quickpow(F, (1LL << i));
	for(int i = 1; i <= Q; ++i) write(solve(read())), enter;
	return 0;
}

标签：魔法值,NOI,int,复杂度,矩阵,maxn,Online,const,include
来源： https://blog.51cto.com/u_15234622/2831566