【BZOJ3240】【UOJ124】【NOI2013】矩阵游戏

最新推荐文章于 2020-05-18 13:05:43 发布
最新推荐文章于 2020-05-18 13:05:43 发布
阅读量290 收藏
点赞数
分类专栏： 【OJ】BZOJ 【OJ】UOJ 【类型】做题记录 【算法】矩阵乘法 【算法】常数优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_39972971/article/details/79482842
版权

【题目链接】

【思路要点】

  • 直观地来想，本题可以用矩阵乘法优化递推来实现。
  • 但是进制转换并不方便，所以，我们考虑不记录一个方阵的\(2^i\)次方，转而记录一个方阵的\(10^i\)次方，这样就不需要进制转换了。
  • 时间复杂度\(O(|N|+|M|)\)，由于常数很大，实现时可能需要一定的常数优化。

【代码】

#include<bits/stdc++.h>
using namespace std;
const int MAXN = 1000005;
const int P = 1e9 + 7;
template <typename T> void chkmax(T &x, T y) {x = max(x, y); }
template <typename T> void chkmin(T &x, T y) {x = min(x, y); } 
template <typename T> void read(T &x) {
	x = 0; int f = 1;
	char c = getchar();
	for (; !isdigit(c); c = getchar()) if (c == '-') f = -f;
	for (; isdigit(c); c = getchar()) x = x * 1ll * 10 + c - '0';
	x *= f;
}
template <typename T> void write(T x) {
	if (x < 0) x = -x, putchar('-');
	if (x > 9) write(x / 10);
	putchar(x % 10 + '0');
}
template <typename T> void writeln(T x) {
	write(x);
	puts("");
}
int n, m, a, b, c, d;
char s[MAXN], t[MAXN];
int matrix[MAXN][3][3];
int natrix[MAXN][3][3];
int tmp[3][3], tnp[3][3];
int now[3][3], res[3][3];
int Now[1][3], Res[1][3];
int main() {
	scanf("\n%s\n%s", s, t);
	n = strlen(s);
	m = strlen(t);
	reverse(s, s + n);
	reverse(t, t + m);
	for (register int i = 0; i < n; i++)
		if (s[i] == '0') s[i] = '9';
		else {s[i]--; break; }
	for (register int i = 0; i < m; i++)
		if (t[i] == '0') t[i] = '9';
		else {t[i]--; break; }
	read(a), read(b), read(c), read(d);
	memset(now, 0, sizeof(now));
	matrix[0][1][0] = 1;
	matrix[0][1][1] = a;
	matrix[0][2][1] = b;
	matrix[0][2][2] = 1;
	now[0][0] = now[1][1] = now[2][2] = 1;
	for (register int p = 0; p < m; p++) {
		int cnt = (t[p] - '0') % 5;
		while (cnt--) {
			res[0][0] = (1ll * now[0][0] * matrix[p][0][0] + 1ll * now[0][1] * matrix[p][1][0] + 1ll * now[0][2] * matrix[p][2][0]) % P;
			res[0][1] = (1ll * now[0][0] * matrix[p][0][1] + 1ll * now[0][1] * matrix[p][1][1] + 1ll * now[0][2] * matrix[p][2][1]) % P;
			res[0][2] = (1ll * now[0][0] * matrix[p][0][2] + 1ll * now[0][1] * matrix[p][1][2] + 1ll * now[0][2] * matrix[p][2][2]) % P;
			res[1][0] = (1ll * now[1][0] * matrix[p][0][0] + 1ll * now[1][1] * matrix[p][1][0] + 1ll * now[1][2] * matrix[p][2][0]) % P;
			res[1][1] = (1ll * now[1][0] * matrix[p][0][1] + 1ll * now[1][1] * matrix[p][1][1] + 1ll * now[1][2] * matrix[p][2][1]) % P;
			res[1][2] = (1ll * now[1][0] * matrix[p][0][2] + 1ll * now[1][1] * matrix[p][1][2] + 1ll * now[1][2] * matrix[p][2][2]) % P;
			res[2][0] = (1ll * now[2][0] * matrix[p][0][0] + 1ll * now[2][1] * matrix[p][1][0] + 1ll * now[2][2] * matrix[p][2][0]) % P;
			res[2][1] = (1ll * now[2][0] * matrix[p][0][1] + 1ll * now[2][1] * matrix[p][1][1] + 1ll * now[2][2] * matrix[p][2][1]) % P;
			res[2][2] = (1ll * now[2][0] * matrix[p][0][2] + 1ll * now[2][1] * matrix[p][1][2] + 1ll * now[2][2] * matrix[p][2][2]) % P;
			memcpy(now, res, sizeof(res));
		}
		cnt = 4;
		memcpy(tmp, matrix[p], sizeof(matrix[p]));
		while (cnt--) {
			tnp[0][0] = (1ll * tmp[0][0] * matrix[p][0][0] + 1ll * tmp[0][1] * matrix[p][1][0] + 1ll * tmp[0][2] * matrix[p][2][0]) % P;
			tnp[0][1] = (1ll * tmp[0][0] * matrix[p][0][1] + 1ll * tmp[0][1] * matrix[p][1][1] + 1ll * tmp[0][2] * matrix[p][2][1]) % P;
			tnp[0][2] = (1ll * tmp[0][0] * matrix[p][0][2] + 1ll * tmp[0][1] * matrix[p][1][2] + 1ll * tmp[0][2] * matrix[p][2][2]) % P;
			tnp[1][0] = (1ll * tmp[1][0] * matrix[p][0][0] + 1ll * tmp[1][1] * matrix[p][1][0] + 1ll * tmp[1][2] * matrix[p][2][0]) % P;
			tnp[1][1] = (1ll * tmp[1][0] * matrix[p][0][1] + 1ll * tmp[1][1] * matrix[p][1][1] + 1ll * tmp[1][2] * matrix[p][2][1]) % P;
			tnp[1][2] = (1ll * tmp[1][0] * matrix[p][0][2] + 1ll * tmp[1][1] * matrix[p][1][2] + 1ll * tmp[1][2] * matrix[p][2][2]) % P;
			tnp[2][0] = (1ll * tmp[2][0] * matrix[p][0][0] + 1ll * tmp[2][1] * matrix[p][1][0] + 1ll * tmp[2][2] * matrix[p][2][0]) % P;
			tnp[2][1] = (1ll * tmp[2][0] * matrix[p][0][1] + 1ll * tmp[2][1] * matrix[p][1][1] + 1ll * tmp[2][2] * matrix[p][2][1]) % P;
			tnp[2][2] = (1ll * tmp[2][0] * matrix[p][0][2] + 1ll * tmp[2][1] * matrix[p][1][2] + 1ll * tmp[2][2] * matrix[p][2][2]) % P;
			memcpy(tmp, tnp, sizeof(tnp));
		}
		if ((t[p] - '0') / 5) {
			res[0][0] = (1ll * now[0][0] * tmp[0][0] + 1ll * now[0][1] * tmp[1][0] + 1ll * now[0][2] * tmp[2][0]) % P;
			res[0][1] = (1ll * now[0][0] * tmp[0][1] + 1ll * now[0][1] * tmp[1][1] + 1ll * now[0][2] * tmp[2][1]) % P;
			res[0][2] = (1ll * now[0][0] * tmp[0][2] + 1ll * now[0][1] * tmp[1][2] + 1ll * now[0][2] * tmp[2][2]) % P;
			res[1][0] = (1ll * now[1][0] * tmp[0][0] + 1ll * now[1][1] * tmp[1][0] + 1ll * now[1][2] * tmp[2][0]) % P;
			res[1][1] = (1ll * now[1][0] * tmp[0][1] + 1ll * now[1][1] * tmp[1][1] + 1ll * now[1][2] * tmp[2][1]) % P;
			res[1][2] = (1ll * now[1][0] * tmp[0][2] + 1ll * now[1][1] * tmp[1][2] + 1ll * now[1][2] * tmp[2][2]) % P;
			res[2][0] = (1ll * now[2][0] * tmp[0][0] + 1ll * now[2][1] * tmp[1][0] + 1ll * now[2][2] * tmp[2][0]) % P;
			res[2][1] = (1ll * now[2][0] * tmp[0][1] + 1ll * now[2][1] * tmp[1][1] + 1ll * now[2][2] * tmp[2][1]) % P;
			res[2][2] = (1ll * now[2][0] * tmp[0][2] + 1ll * now[2][1] * tmp[1][2] + 1ll * now[2][2] * tmp[2][2]) % P;
			memcpy(now, res, sizeof(res));
		}
		matrix[p + 1][0][0] = (1ll * tmp[0][0] * tmp[0][0] + 1ll * tmp[0][1] * tmp[1][0] + 1ll * tmp[0][2] * tmp[2][0]) % P;
		matrix[p + 1][0][1] = (1ll * tmp[0][0] * tmp[0][1] + 1ll * tmp[0][1] * tmp[1][1] + 1ll * tmp[0][2] * tmp[2][1]) % P;
		matrix[p + 1][0][2] = (1ll * tmp[0][0] * tmp[0][2] + 1ll * tmp[0][1] * tmp[1][2] + 1ll * tmp[0][2] * tmp[2][2]) % P;
		matrix[p + 1][1][0] = (1ll * tmp[1][0] * tmp[0][0] + 1ll * tmp[1][1] * tmp[1][0] + 1ll * tmp[1][2] * tmp[2][0]) % P;
		matrix[p + 1][1][1] = (1ll * tmp[1][0] * tmp[0][1] + 1ll * tmp[1][1] * tmp[1][1] + 1ll * tmp[1][2] * tmp[2][1]) % P;
		matrix[p + 1][1][2] = (1ll * tmp[1][0] * tmp[0][2] + 1ll * tmp[1][1] * tmp[1][2] + 1ll * tmp[1][2] * tmp[2][2]) % P;
		matrix[p + 1][2][0] = (1ll * tmp[2][0] * tmp[0][0] + 1ll * tmp[2][1] * tmp[1][0] + 1ll * tmp[2][2] * tmp[2][0]) % P;
		matrix[p + 1][2][1] = (1ll * tmp[2][0] * tmp[0][1] + 1ll * tmp[2][1] * tmp[1][1] + 1ll * tmp[2][2] * tmp[2][1]) % P;
		matrix[p + 1][2][2] = (1ll * tmp[2][0] * tmp[0][2] + 1ll * tmp[2][1] * tmp[1][2] + 1ll * tmp[2][2] * tmp[2][2]) % P;
	}
	memset(tmp, 0, sizeof(tmp));
	tmp[1][0] = 1;
	tmp[1][1] = c;
	tmp[2][1] = d;
	tmp[2][2] = 1;
	for (register int i = 0; i <= 2; i++)
	for (register int j = 0; j <= 2; j++)
	for (register int k = 0; k <= 2; k++)
		natrix[0][i][j] = (natrix[0][i][j] + now[i][k] * 1ll * tmp[k][j]) % P;
	memset(Now, 0, sizeof(Now));
	Now[0][1] = 1, Now[0][2] = 1;
	for (register int p = 0; p < n; p++) {
		int cnt = (s[p] - '0') % 5;
		while (cnt--) {
			memset(Res, 0, sizeof(Res));
			Res[0][0] = (1ll * Now[0][0] * natrix[p][0][0] + 1ll * Now[0][1] * natrix[p][1][0] + 1ll * Now[0][2] * natrix[p][2][0]) % P;
			Res[0][1] = (1ll * Now[0][0] * natrix[p][0][1] + 1ll * Now[0][1] * natrix[p][1][1] + 1ll * Now[0][2] * natrix[p][2][1]) % P;
			Res[0][2] = (1ll * Now[0][0] * natrix[p][0][2] + 1ll * Now[0][1] * natrix[p][1][2] + 1ll * Now[0][2] * natrix[p][2][2]) % P;
			memcpy(Now, Res, sizeof(Res));
		}
		cnt = 4;
		memcpy(tmp, natrix[p], sizeof(natrix[p]));
		while (cnt--) {
			tnp[0][0] = (1ll * tmp[0][0] * natrix[p][0][0] + 1ll * tmp[0][1] * natrix[p][1][0] + 1ll * tmp[0][2] * natrix[p][2][0]) % P;
			tnp[0][1] = (1ll * tmp[0][0] * natrix[p][0][1] + 1ll * tmp[0][1] * natrix[p][1][1] + 1ll * tmp[0][2] * natrix[p][2][1]) % P;
			tnp[0][2] = (1ll * tmp[0][0] * natrix[p][0][2] + 1ll * tmp[0][1] * natrix[p][1][2] + 1ll * tmp[0][2] * natrix[p][2][2]) % P;
			tnp[1][0] = (1ll * tmp[1][0] * natrix[p][0][0] + 1ll * tmp[1][1] * natrix[p][1][0] + 1ll * tmp[1][2] * natrix[p][2][0]) % P;
			tnp[1][1] = (1ll * tmp[1][0] * natrix[p][0][1] + 1ll * tmp[1][1] * natrix[p][1][1] + 1ll * tmp[1][2] * natrix[p][2][1]) % P;
			tnp[1][2] = (1ll * tmp[1][0] * natrix[p][0][2] + 1ll * tmp[1][1] * natrix[p][1][2] + 1ll * tmp[1][2] * natrix[p][2][2]) % P;
			tnp[2][0] = (1ll * tmp[2][0] * natrix[p][0][0] + 1ll * tmp[2][1] * natrix[p][1][0] + 1ll * tmp[2][2] * natrix[p][2][0]) % P;
			tnp[2][1] = (1ll * tmp[2][0] * natrix[p][0][1] + 1ll * tmp[2][1] * natrix[p][1][1] + 1ll * tmp[2][2] * natrix[p][2][1]) % P;
			tnp[2][2] = (1ll * tmp[2][0] * natrix[p][0][2] + 1ll * tmp[2][1] * natrix[p][1][2] + 1ll * tmp[2][2] * natrix[p][2][2]) % P;
			memcpy(tmp, tnp, sizeof(tnp));
		}
		if ((s[p] - '0') / 5) {
			memset(Res, 0, sizeof(Res));
			Res[0][0] = (1ll * Now[0][0] * tmp[0][0] + 1ll * Now[0][1] * tmp[1][0] + 1ll * Now[0][2] * tmp[2][0]) % P;
			Res[0][1] = (1ll * Now[0][0] * tmp[0][1] + 1ll * Now[0][1] * tmp[1][1] + 1ll * Now[0][2] * tmp[2][1]) % P;
			Res[0][2] = (1ll * Now[0][0] * tmp[0][2] + 1ll * Now[0][1] * tmp[1][2] + 1ll * Now[0][2] * tmp[2][2]) % P;
			memcpy(Now, Res, sizeof(Res));
		}
		natrix[p + 1][0][0] = (1ll * tmp[0][0] * tmp[0][0] + 1ll * tmp[0][1] * tmp[1][0] + 1ll * tmp[0][2] * tmp[2][0]) % P;
		natrix[p + 1][0][1] = (1ll * tmp[0][0] * tmp[0][1] + 1ll * tmp[0][1] * tmp[1][1] + 1ll * tmp[0][2] * tmp[2][1]) % P;
		natrix[p + 1][0][2] = (1ll * tmp[0][0] * tmp[0][2] + 1ll * tmp[0][1] * tmp[1][2] + 1ll * tmp[0][2] * tmp[2][2]) % P;
		natrix[p + 1][1][0] = (1ll * tmp[1][0] * tmp[0][0] + 1ll * tmp[1][1] * tmp[1][0] + 1ll * tmp[1][2] * tmp[2][0]) % P;
		natrix[p + 1][1][1] = (1ll * tmp[1][0] * tmp[0][1] + 1ll * tmp[1][1] * tmp[1][1] + 1ll * tmp[1][2] * tmp[2][1]) % P;
		natrix[p + 1][1][2] = (1ll * tmp[1][0] * tmp[0][2] + 1ll * tmp[1][1] * tmp[1][2] + 1ll * tmp[1][2] * tmp[2][2]) % P;
		natrix[p + 1][2][0] = (1ll * tmp[2][0] * tmp[0][0] + 1ll * tmp[2][1] * tmp[1][0] + 1ll * tmp[2][2] * tmp[2][0]) % P;
		natrix[p + 1][2][1] = (1ll * tmp[2][0] * tmp[0][1] + 1ll * tmp[2][1] * tmp[1][1] + 1ll * tmp[2][2] * tmp[2][1]) % P;
		natrix[p + 1][2][2] = (1ll * tmp[2][0] * tmp[0][2] + 1ll * tmp[2][1] * tmp[1][2] + 1ll * tmp[2][2] * tmp[2][2]) % P;
	}
	memset(Res, 0, sizeof(Res));
	for (register int i = 0; i <= 0; i++)
	for (register int j = 0; j <= 2; j++)
	for (register int k = 0; k <= 2; k++)
		Res[i][j] = (Res[i][j] + Now[i][k] * 1ll * now[k][j]) % P;
	memcpy(Now, Res, sizeof(Res));
	writeln(Now[0][1]);
	return 0;
}

cz_xuyixuan
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
[NOI2013] 矩阵游戏 题解
莫莫 dicol 的博客
09-25 252
[NOI2013] 矩阵游戏 [NOI2013] 矩阵游戏 各位我是弱智石锤了。 题目可能不是很难但是有点细节要注意。 首先考虑行和列我们分别来看： 对于列的情况我们只需要前一项即可递推。 对于行的情况我们只需要上一项也可递推。 那么本质上题目就提示我们可以只保留一项进行矩阵快速幂。 不妨设答案矩阵是 [1fm] \left[ \begin{matrix} 1 & f_m \end{matrix} \right] [1​fm​​] 我们考虑首先递推同一行之后再递推列，最后一行单独拿出来处
NOI2013 矩阵游戏 【数论】
Mychael的无声乐章
10-20 293
题目描述 婷婷是个喜欢矩阵的小朋友,有一天她想用电脑生成一个巨大的n行m列的矩阵(你不用担心她如何存储)。她生成的这个矩阵满足一个神奇的性质：若用F[i][j]来表示矩阵中第i行第j列的元素，则F[i][j]满足下面的递推式: F[1][1]=1 F[i,j]=a*F[i][j-1]+b (j!=1) F[i,1]=c*F[i-1][m]+d (i!=1) 递推式
【BZOJ3240】[NOI2013]矩阵游戏
Yu Gi Oh!
08-14 195
题目链接 题目描述 求一个矩阵的第n行m列 递推式 F[1][1]=1F[i,j]=a∗F[i][j−1]+b(j!=1)F[i,1]=c∗F[i−1][m]+d(i!=1)F[1][1]=1F[i,j]=a∗F[i][j−1]+b(j!=1)F[i,1]=c∗F[i−1][m]+d(i!=1) F[1][1]=1\\ F[i,j]=a*F[i][j-1]+b (j!=1)\\ F...
【费马小定理+快速幂+逆元】BZOJ3240-[NOI2013]矩阵游戏
dianchunhui2654的博客
06-26 84
【题目大意】 若用F[i][j]来表示矩阵中第i行第j列的元素，则F[i][j]满足下面的递推式:F[1][1]=1F[i,j]=a*F[i][j-1]+b (j!=1)①F[i,1]=c*F[i-1][m]+d (i!=1)②递推式中a,b,c,d都是给定的常数。求F[n][m]。 【思路】 磨了一个早上，然而UOJ上的额外数据还没有过去..BZOJ上已AC先放上来，后续慢慢磨…...
wangjunrui666#bzoj-problem##3240. [Noi2013]矩阵游戏1
07-25
她生成的这个矩阵满足一个神奇的性质：若用F[i][j]来表示矩阵中第i行第j列的元素，则F[i][j]满足下面的递推式:递推式中a,b,c,d都是给定的常数。由
wangjunrui666#bzoj-problem##3106. [cqoi2013]棋盘游戏1
07-25
比如n=2，白棋子在(1,1)，黑棋子在(2,2)，那么虽然A有两种走法，第二个回合B总能取胜。白色棋子在(r1,c1)，黑色棋子在(r2,c2)（1,
wangjunrui666#bzoj-problem##2370. 单词矩阵1
07-25
第一行一个字母，W表示任务1，N表示任务2若是任务1，第二行是一个优美的单词，否则第二行是一个正整数，表示某个优美的单词的编号，保证该数不超过优美的单词的总数一
wangjunrui666#bzoj-problem##3255. 一个关于序列的游戏1
07-25
第一行一个整数N，表示序列长度 第二行N个数，V1、V2VN，代表每个长度对应的分数 第三行N个数，A1、A2AN，代表初始序列的每个元素
陈立杰历年课件和BZOJ代码
12-04
【陈立杰历年课件和BZOJ代码】是一个集合，包含了知名算法竞赛选手陈立杰（WJMZBMR）在过去的时间里所使用的课件以及他在BZOJ（Best Wrong Judge Online Judge）平台上提交的大部分代码。这个资源对于学习算法、C++...
【BZOJ3435】【UOJ55】【WC2014】紫荆花之恋
cz_xuyixuan的博客
01-13 1283
【题目链接】 BZOJ UOJ 【思路要点】 考虑点\(i\)和点\(j\)路径上任意一点\(k\)，那么$$R_{i}+R_{j}≥Dist(i,j) \Leftrightarrow R_{i}-Dist(i,k)≥Dist(j,k)-R_{j}$$令\(F_{i,k}=R_{i}-Dist(i,k)\)，即\(F_{i,k}≥-F_{j,
【BZOJ3812】【UOJ37】【清华集训2014】主旋律
cz_xuyixuan的博客
02-27 1249
【题目链接】BZOJUOJ【思路要点】我们希望求出使得图强联通的边集数，这等价于求出所有边集数减去使得图不强连通的边集数。首先考虑一种非常暴力的做法，我们枚举最终的图缩点后的情况。那么，剩下的图必须是一个DAG，我们希望求出这张图在是DAG的情况下可行的边集数，并与每一个强连通分量加边方案数相乘，得到答案。后面的这个问题是原问题的一个子问题，递归对对应强联通分量的导出子图求解即可。问题在于求解一张...
【UOJ455】【UER #8】雪灾与外卖
cz_xuyixuan的博客
01-28 1026
【题目链接】 点击打开链接 【思路要点】 首先判断是否无解，以下讨论默认问题有解。 令 ∞\infty∞ 为一个足够大的数，对于送餐员 XiX_iXi​ ，在 Xi−∞X_i-\inftyXi​−∞ 处增加 111 个餐馆，令所有送餐员初始时与其对应的餐馆匹配，即初始时 Ans=N∗∞Ans=N*\inftyAns=N∗∞ 。 从左到右考虑每一个元素，加入当前的考虑集合。 若加入元素为...
【UOJ170】Picks loves segment tree VIII
cz_xuyixuan的博客
01-25 971
【题目链接】 点击打开链接 【前置阅读】 【BZOJ4695】最假女选手 【BZOJ3064】【TYVJ1518】CPU监控【UOJ169】【UR #11】元旦老人与数列 【思路要点】 前置阅读中的前两题中，我们分别对线段树的区间取最大/最小值和线段树的历史最大/最小值进行了研究。本题中，两类问题同时出现，因此我们
【UOJ179】线性规划
cz_xuyixuan的博客
01-12 748
【题目链接】 点击打开链接 【思路要点】 单纯形法模板题，数据很强，错误的实现很可能无法通过Extra Test。 【代码】 #include using namespace std; const int MAXN = 55; const long double eps = 1e-8; const long double I
【UOJ169】【UR #11】元旦老人与数列
cz_xuyixuan的博客
01-25 734
【题目链接】 点击打开链接 【前置阅读】 【BZOJ4355】Play with Sequence 【BZOJ3064】【TYVJ1518】CPU监控 【思路要点】 前置阅读中的两题中，我们分别对线段树的区间取最大/最小值和线段树的历史最大/最小值进行了研究。本题中，两类问题同时出现，因此我们需要将它们整合起来。支持区间取
【UOJ188】【UR #13】Sanrd
cz_xuyixuan的博客
08-10 648
【题目链接】 点击打开链接 【思路要点】 令f(x)f(x)f(x)表示xxx次大的质因子，那么答案即为∑ri=lf(i)∑i=lrf(i)\sum_{i=l}^{r}f(i)，也就是说我们要求的实际上是∑Ni=1f(i)∑i=1Nf(i)\sum_{i=1}^{N}f(i)。 考虑从小到大枚举每一个质因子，最后第二个被枚举到的质因子即为f(x)f(x)f...
【UOJ522】【美团杯2020】版本答案
cz_xuyixuan的博客
05-18 637
题目链接 点击打开链接 题目解法 关于鲭鱼圣者的之间的战斗，有如下观察： (1)(1)(1) 、在任意时刻，双方阵营中没有圣盾的鲭鱼圣者数量不超过 111 (2)(2)(2) 、进攻方的鲭鱼圣者 xxx 进攻后，其余鲭鱼圣者均会重新获得圣盾 (3)(3)(3) 、防守方在被进攻前，或是所有鲭鱼圣者均有圣盾，或是刚刚行动的鲭鱼圣者没有圣盾 因此，我们可以使用四元组 (x,y,s,t)(x,y,s,t)(x,y,s,t) 来描述一个状态，表示： (1)(1)(1) 、当前进攻方剩余鲭鱼圣者的数量为 xxx ，防
【BZOJ5417】【UOJ395】【NOI2018】你的名字
cz_xuyixuan的博客
09-11 624
【题目链接】 BZOJ UOJ 【思路要点】 对 SSS 用后缀自动机建后缀树，并在其 DFSDFSDFS 序上建立主席树。 考虑一个询问 (T,ql,qr)(T,ql,qr)(T,ql,qr) ，从后到前依次考虑其每一个后缀对答案的贡献，显然对于每一个后缀 iii ，存在一个长度 lenlenlen ，当且仅当 j&gt;i+lenj&gt;i+le...
BZOJ JOI 2013-2014春季训练合宿题目解析1
"BZOJ JOI 2013~2014 春季training合宿 系列题解1" 这篇题解涉及到的是一个编程竞赛中的题目，主要运用了哈希算法来解决。哈希算法在计算机科学中是一种高效的数据结构和算法，它能够快速查找、插入和删除元素，其...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值