伪提答害死人...(出题人赶快出来挨打!!!)

虽说是考场上全看出来是让干嘛了，然而由于太菜以及不会打表所以GG了，只拿了\(39\)...

经测试，截至\(2019.4.18-11:33\)，这份接近10K的代码在洛谷速度rk1，在LOJrk4。

题目大意：

功能对应表：

编号 功能 测试点编号 分值
\(1\_998244353\) 求\(19^x\pmod{998244353}\) \(1-3\) \(4+4+4=12\)
\(1?\) 求\(19^x\pmod{?=1145141}\) \(4\) \(7\)
\(1?+\) 求\(19^x\pmod{?=5211600617818708273}\) \(5\) \(9\)
\(1wa\_998244353\) 求\(19^x\pmod{998244353}\)自然溢出(题目提示) \(6-7\) \(6+7=13\)
\(2p\) 判断质数 \(8-10\) \(4+6+8=18\)
\(2u\) 求\(\mu\) \(11-13\) \(5+6+9=20\)
\(2g/2g?\) 判断原根 \(14-15/16\) \(5+7+9=21\)

为了方便你的阅读，我把测试点编号放在了表格的中间，请你注意这一点。

题目思路：

由于是数论多合一，这个慢慢更qwq。我会尽可能把过程写详细的qwq...

代码什么的等我拿到考场源代码再更吧...懒了懒了qwq...

\(test\ 1-3(1\_998244353)\)

看一下第一个样例不难发现输入前几项是连续正整数，输出是\(19\)的次幂，所以第一个功能就是求\(19^x\)，因为功能上写着\(998244353\)，试一下就会发现确实是在\(\bmod{998244353}\)意义下的结果，所以第一个功能已经明确了。\(test\ 1\)显然直接乘就行，但是看完\(test\ 2,3\)之后会发现，好像不太简单，\(test\ 2\)里面所有输入都是long long级别的数，而\(test\ 3\)里面所有输入都是\(40\)位左右的数，那么考虑到模数是质数，利用费马小定理/欧拉定理，让指数对\(998244352\)取模即可，然后利用秦九韶算法在\(O(len)\)的复杂度内对指数取模，然后跑快速幂即可。

  1. namespace sub1{//1_998244353
  2. 	const int MOD=998244353,MMOD=998244352;
  3. 	char s[50];
  4. 	int n,len;
  5. 	long long zs;
  6. 	long long qpow(long long u,long long v){
  7. 		long long rep=1;
  8. 		while(v>0){
  9. 			if(v&1){
  10. 				rep=rep*u%MOD;
  11. 			}
  12. 			u=u*u%MOD;
  13. 			v>>=1;
  14. 		}
  15. 		return rep;
  16. 	}
  17. 	void solve(){
  18. 		scanf("%d",&n);
  19. 		for(int i=1;i<=n;i++){
  20. 			scanf("%s",s);
  21. 			len=strlen(s);
  22. 			zs=0;
  23. 			for(int j=0;j<len;j++){
  24. 				zs=zs*10+s[j]-'0';
  25. 				zs%=MMOD;
  26. 			}
  27. 			printf("%lld\n",qpow(19,zs));
  28. 		}
  29. 	}
  30. }

\(test\ 4(1?)\)

看一下数据会发现前几项是连续的整数，不过相比前\(3\)个测试点而言，能看得出来模数变小了，显然这个任务的重点在于找到未知的模数。大致看一下输出文件会发现，模数是比较小的数，那么显然可以通过暴力测试的方式得到未知模数。实现起来就是对输出数据求\(\max\)，然后从\(\max+1\)开始试，用第\(11\)行的数据检验(第一个大输入)，然后很快就能得到模数是\(1145141\)，然后采用和\(test\ 1-3\)同样的方式处理即可。

  1. namespace sub2{//1?
  2. 	const int MOD=1145141;
  3. 	const int MMOD=MOD-1;
  4. 	char s[50];
  5. 	int n,len;
  6. 	long long zs;
  7. 	long long qpow(long long u,long long v){
  8. 		long long rep=1;
  9. 		while(v>0){
  10. 			if(v&1){
  11. 				rep=rep*u%MOD;
  12. 			}
  13. 			u=u*u%MOD;
  14. 			v>>=1;
  15. 		}
  16. 		return rep;
  17. 	}
  18. 	void solve(){
  19. 		scanf("%d",&n);
  20. 		for(int i=1;i<=n;i++){
  21. 			scanf("%s",s);
  22. 			len=strlen(s);
  23. 			zs=0;
  24. 			for(int j=0;j<len;j++){
  25. 				zs=zs*10+s[j]-'0';
  26. 				zs%=MMOD;
  27. 			}
  28. 			printf("%lld\n",qpow(19,zs));
  29. 		}
  30. 	}
  31. }

\(test\ 5(1?+)\)

如果采用和\(test\ 4\)相同的思路，会发现模数是\(>5\cdot10^{18}\)的，如此大的模数是不适合用暴力寻找的(事实上用暴力也真的没找到)。所以这个点就需要数论多合一进行珂学计算求模数，求得模数等于\(5211600617818708273\)。

计算过程：

对输入文件中的所有指数排序，找除了\(0-9\)以外的相差最小的两个指数，发现最小相差为\(2\)，两个指数分别是\(264708066,264708068\)(对应输入文件中的\(7146\)行和\(9371\)行)，则对应的答案在\(7143,9368\)两行，分别为\(1996649514996338529,1589589654696467295\)，于是有\(1996649514996338529\times361\equiv1589589654696467295\)，设模数为\(p\)，则\(1996649514996338529\times361-1589589654696467295=kp(k\in\mathbb{N_+})\)，用python算出来应该是\(719200885258981741674=kp(k\in\mathbb{N_+})\)，然后进行因数分解，有\(\left\{\begin{array}{lcl}719200885258981741674 &=& 1 \times 719200885258981741674 \\ &=& 2 \times 359600442629490870837 \\ &=& 3 \times 239733628419660580558 \\ &=& 6 \times 119866814209830290279 \\ &=& 23 \times 31269603706912249638 \\ &=& 46 \times 15634801853456124819 \\ &=& 69 \times 10423201235637416546 \\ &=& 138 \times 5211600617818708273 \\\end{array}\right.\) ，然后代入检验得模数是\(5211600617818708273\)。

  1. namespace sub3{//1?+
  2. 	const long long MOD=5211600617818708273LL;
  3. 	int n;
  4. 	int zs;
  5. 	long long plu(long long u,long long v){
  6. 		return (long long)(((ull)u+(ull)v)%MOD);
  7. 	}
  8. 	long long mul(long long u,long long v){
  9. 		long long rep=0;
  10. 		while(v>0){
  11. 			if(v&1){
  12. 				rep=plu(rep,u);
  13. 			}
  14. 			u=plu(u,u);
  15. 			v>>=1;
  16. 		}
  17. 		return rep;
  18. 	}
  19. 	long long qpow(long long u,int v){
  20. 		long long rep=1;
  21. 		while(v>0){
  22. 			if(v&1){
  23. 				rep=mul(rep,u);
  24. 			}
  25. 			u=mul(u,u);
  26. 			v>>=1;
  27. 		}
  28. 		return rep;
  29. 	}
  30. 	void solve(){
  31. 		scanf("%d",&n);
  32. 		for(int i=1;i<=n;i++){
  33. 			scanf("%d",&zs);
  34. 			printf("%lld\n",qpow(19,zs));
  35. 		}
  36. 	}
  37. }

\(test\ 6-7(1wa\_998244353)\)

根据题目的提示，应该用到自然溢出(不然你当提示白给你了)，然而考试的时候无论如何也没猜到出题人怎么自然溢出的。不过\(test\ 6\)可以骗到，因为是连续的，所以每次\(\times19\)，然后对\(998244353\)取模即可。对于\(test\ 7\)，只需要找到其中的循环节即可，然后采取类似欧拉定理的方式对指数进行处理，至于结果，打表输出就好了。

  1. namespace sub4{//1wa_998244353
  2. 	int n,len;
  3. 	int ans[101000]={};
  4. 	long long zs;
  5. 	void solve(){
  6. 		for(int i=0,rep=1;i<1e5+1000;i++){
  7. 			ans[i]=rep;
  8. 			rep=rep*19%998244353;
  9. 		}
  10. 		scanf("%d",&n);
  11. 		for(int i=1;i<=n;i++){
  12. 			scanf("%lld",&zs);
  13. 			zs=zs>55244?(55245+((zs-55245)%45699)):zs;
  14. 			printf("%d\n",ans[(int)zs]);
  15. 		}
  16. 	}
  17. }

\(test\ 8-10(2p)\)

当首位变成\(2\)的时候就意味着要换任务了(不然你又当题目提示白给你了)，一开始看到数据是毫无头绪的，不过看着看着发现两个数似乎代表区间端点(毕竟输出长度在那儿放着呢)，然后看到\(2-10\)的输出是\(pp.p.p...\)，然后瞬间就想到可能就是判断质数(背质数表:2,3,5,7,...)，仔细看一下输出会发现，越往后\(p\)的分布越稀疏，确认过眼神就是判断质数了。\(test\ 8\)判断的是\(1-10^6\)，\(test\ 9\)是\(999999000001-10^{12}\)，\(test\ 10\)是\(999999999999000001-10^{18}\)。虽说长度都是\(10^6\)，但是这难度显然不同啊。

对于\(test\ 8\)，线性筛就足够了。

对于\(test\ 9\)，不难发现如果其中的某个数为合数，则在\(10^6\)范围内一定存在一个它的质因子，借此可以利用\(test\ 8\)的线性筛筛出\(10^6\)范围内的质数，然后用这些质数去筛\(test\ 9\)区间内的数。

对于\(test\ 10\)，可以考虑直接跑\(Miller-Rabin\)检验，只用\(2,3\)跑正确性就没问题，速度也可以接受。

  1. namespace sub5{//2p
  2. 	int n;
  3. 	long long l,r;
  4. 	long long mul(long long u,long long v,long long MOD){
  5. 		long long w=(long long)(1.0L*u*v/(1.0L*MOD)),rep=u*v-w*MOD;
  6. 		rep-=MOD;
  7. 		while(rep<0){
  8. 			rep+=MOD;
  9. 		}
  10. 		return rep;
  11. 	}
  12. 	long long qpow(long long u,long long v,long long MOD){
  13. 		long long rep=1;
  14. 		while(v>0){
  15. 			if(v&1){
  16. 				rep=mul(rep,u,MOD);
  17. 			}
  18. 			u=mul(u,u,MOD);
  19. 			v>>=1;
  20. 		}
  21. 		return rep;
  22. 	}
  23. 	bool mr(long long u){
  24. 		if(u==1){
  25. 			return 0;
  26. 		}
  27. 		int tplist[20]={2,3,5,7,61,24251,19260817};
  28. 		long long v=u-1,rep,nxt;int rrep=0;
  29. 		while(!(v&1)){
  30. 			v>>=1;++rrep;
  31. 		}
  32. 		for(int i=0;i<2;i++){
  33. 			if(u==tplist[i]){
  34. 				return 1;
  35. 			}
  36. 			if(u%tplist[i]==0){
  37. 				return 0;
  38. 			}
  39. 			rep=qpow(tplist[i],v,u);
  40. 			for(int j=1;j<=rrep;j++){
  41. 				nxt=mul(rep,rep,u);
  42. 				if(nxt==1&&rep!=1&&rep!=u-1){
  43. 					return 0;
  44. 				}
  45. 				rep=nxt;
  46. 			}
  47. 			if(rep!=1){
  48. 				return 0;
  49. 			}
  50. 		}
  51. 		return 1;
  52. 	}
  53. 	void solve(){
  54. 		printf("pp.p.p...\np.p...\npp.p.p...p.p..\n");
  55. 		scanf("%d",&n);
  56. 		scanf("%d",&n);
  57. 		scanf("%d",&n);
  58. 		scanf("%d",&n);
  59. 		scanf("%d",&n);
  60. 		scanf("%d",&n);
  61. 		scanf("%d",&n);
  62. 		scanf("%lld%lld",&l,&r);
  63. 		if(r<=1e6){
  64. 			pre();
  65. 			for(int i=2;i<=1e6;i++){
  66. 				notpr[i]?putchar('.'):putchar('p');
  67. 			}
  68. 			putchar('\n');
  69. 		}
  70. 		else if(r<=1e12){
  71. 			bool vis[1000010]={};
  72. 			const long long MIN=999998999999LL;
  73. 			pre();
  74. 			int st;
  75. 			for(int i=1;i<=cntpr;i++){
  76. 				st=(int)((MIN/pr[i])*pr[i]+pr[i]-MIN);
  77. 				for(;st<=1e6+1;st+=pr[i]){
  78. 					vis[st]=1;
  79. 				}
  80. 			}
  81. 			for(int i=1;i<=1e6+1;i++){
  82. 				vis[i]?putchar('.'):putchar('p');
  83. 			}
  84. 		}
  85. 		else{
  86. 			for(long long i=999999999999000000LL;i<=1000000000000000000LL;i++){
  87. 				mr(i)?putchar('p'):putchar('.');
  88. 			}
  89. 		}
  90. 	}
  91. }

\(test\ 11-13(2u)\)

有了\(2p\)，那自然可以想到后面又是求什么东西的，看一下数据你会发现，出题人偷懒了，就改了个字母，其他和\(8-10\)完全一样。那看一下输出吧，发现只有\(+-0\)，那这不就显然了，就是\(\mu\)啊。

和前面\(2p\)一样，\(test\ 11\)直接线性筛就行了。

对于\(test\ 12\)，我们可以参考\(test\ 9\)的思路，一方面判断有没有平方因子，另一方面记录不同的质因子个数，由于可能存在\(>10^6\)的质因子，我们记录每个数在筛过之后的值，初值为本身，被一个质数筛过后值除以当前质数，如果最后值\(>1\)就说明还有\(>10^6\)的质因子，那么不同的质因子个数\(+1\)即可，最后根据是否为质数以及不同的质因子个数求出\(\mu\)值即可。

对于\(test\ 13\)，如果跑\(Pollard-Rho\)，很不幸...这玩意肯定T飞了。那么考虑参考\(test\ 12\)的思路，先筛\(10^6\)以内的质数，用这些质数筛区间里的数，那么考虑对于剩下的未分解完全的数，这些数没有\(10^6\)以内的质因数，数的大小又不超过\(10^{18}\)，所以只有三种可能的形式\(p_1,p_1p_2,p_1^2\)，质数可以用\(Miller-Rabin\)测试，平方可以开根测试，用排除法确定两质因子乘积形式。

  1. namespace sub6{//2u
  2. 	int n;
  3. 	long long l,r;
  4. 	long long mul(long long u,long long v,long long MOD){
  5. 		long long w=(long long)(1.0L*u*v/(1.0L*MOD)),rep=u*v-w*MOD;
  6. 		rep-=MOD;
  7. 		while(rep<0){
  8. 			rep+=MOD;
  9. 		}
  10. 		return rep;
  11. 	}
  12. 	long long qpow(long long u,long long v,long long MOD){
  13. 		long long rep=1;
  14. 		while(v>0){
  15. 			if(v&1){
  16. 				rep=mul(rep,u,MOD);
  17. 			}
  18. 			u=mul(u,u,MOD);
  19. 			v>>=1;
  20. 		}
  21. 		return rep;
  22. 	}
  23. 	bool mr(long long u){
  24. 		if(u==1){
  25. 			return 0;
  26. 		}
  27. 		int tplist[20]={2,3,5,7,61,24251,19260817};
  28. 		long long v=u-1,rep,nxt;int rrep=0;
  29. 		while(!(v&1)){
  30. 			v>>=1;++rrep;
  31. 		}
  32. 		for(int i=0;i<2;i++){
  33. 			if(u==tplist[i]){
  34. 				return 1;
  35. 			}
  36. 			if(u%tplist[i]==0){
  37. 				return 0;
  38. 			}
  39. 			rep=qpow(tplist[i],v,u);
  40. 			for(int j=1;j<=rrep;j++){
  41. 				nxt=mul(rep,rep,u);
  42. 				if(nxt==1&&rep!=1&&rep!=u-1){
  43. 					return 0;
  44. 				}
  45. 				rep=nxt;
  46. 			}
  47. 			if(rep!=1){
  48. 				return 0;
  49. 			}
  50. 		}
  51. 		return 1;
  52. 	}
  53. 	void solve(){
  54. 		printf("--0-+-00+\n-+-00+\n--0-+-00+-0-++\n");
  55. 		scanf("%d",&n);
  56. 		scanf("%d",&n);
  57. 		scanf("%d",&n);
  58. 		scanf("%d",&n);
  59. 		scanf("%d",&n);
  60. 		scanf("%d",&n);
  61. 		scanf("%d",&n);
  62. 		scanf("%lld%lld",&l,&r);
  63. 		if(r<=1e6){
  64. 			pre();
  65. 			for(int i=2;i<=1e6;i++){
  66. 				if(mu[i]<0){
  67. 					putchar('-');
  68. 				}
  69. 				else if(mu[i]>0){
  70. 					putchar('+');
  71. 				}
  72. 				else{
  73. 					putchar('0');
  74. 				}
  75. 			}
  76. 			putchar('\n');
  77. 		}
  78. 		else if(r<=1e12){
  79. 			bool sqvis[1000010]={};
  80. 			const long long MIN=999998999999LL;
  81. 			pre();
  82. 			for(int i=1;i<=1e6+1;i++){
  83. 				num[i]=MIN+i;
  84. 			}
  85. 			int st;long long sq;
  86. 			for(int i=1;i<=cntpr;i++){
  87. 				sq=1LL*pr[i]*pr[i];
  88. 				st=(int)((MIN/pr[i])*pr[i]+pr[i]-MIN);
  89. 				for(;st<=1e6+1;st+=pr[i]){
  90. 					++mucnt[st];
  91. 					num[st]/=pr[i];
  92. 					if(!sqvis[st]){
  93. 						if((MIN+st)%sq==0){
  94. 							sqvis[st]=1;
  95. 						}
  96. 					}
  97. 				}
  98. 			}
  99. 			for(int i=1;i<=1e6+1;i++){
  100. 				if(num[i]>1){
  101. 					++mucnt[i];
  102. 				}
  103. 				if(sqvis[i]){
  104. 					putchar('0');
  105. 				}
  106. 				else if(mucnt[i]&1){
  107. 					putchar('-');
  108. 				}
  109. 				else{
  110. 					putchar('+');
  111. 				}
  112. 			}
  113. 		}
  114. 		else{
  115. 			bool sqvis[1000010]={};
  116. 			const long long MIN=999999999998999999LL;
  117. 			pre();
  118. 			for(int i=1;i<=1e6+1;i++){
  119. 				num[i]=MIN+i;
  120. 			}
  121. 			int st;long long sq;
  122. 			for(int i=1;i<=cntpr;i++){
  123. 				sq=1LL*pr[i]*pr[i];
  124. 				st=(int)((MIN/pr[i])*pr[i]+pr[i]-MIN);
  125. 				for(;st<=1e6+1;st+=pr[i]){
  126. 					++mucnt[st];
  127. 					num[st]/=pr[i];
  128. 					if(!sqvis[st]){
  129. 						if((MIN+st)%sq==0){
  130. 							sqvis[st]=1;
  131. 						}
  132. 					}
  133. 				}
  134. 			}
  135. 			for(int i=1;i<=1e6+1;i++){
  136. 				if(num[i]>1){
  137. 					if(mr(num[i])){
  138. 						++mucnt[i];
  139. 					}
  140. 					else{
  141. 						long long rep=(long long)sqrt(num[i]);
  142. 						if(rep*rep==num[i]){
  143. 							sqvis[i]=1;
  144. 						}
  145. 						else{
  146. 							mucnt[i]+=2;
  147. 						}
  148. 					}
  149. 				}
  150. 				if(sqvis[i]){
  151. 					putchar('0');
  152. 				}
  153. 				else if(mucnt[i]&1){
  154. 					putchar('-');
  155. 				}
  156. 				else{
  157. 					putchar('+');
  158. 				}
  159. 			}
  160. 		}
  161. 	}
  162. }

\(test\ 14-16(2g/2g?)\)

看到\(test\ 14\)，不用想，这肯定又是让求啥东西了，分布还十分鬼畜，重点是除了区间还又多给了一个数，然后发现是\(998244353\)，再想想这是\(g\)啊，\(3\)还是\(g\)，那不用多想了吧，原根跑不掉了。既然实锤是原根了，那问题来了，原根咋判断啊???在这直接讲结论了(因为其他的我也不会)，对于有原根的数\(p\)，设\(\varphi(p)=p_1^{a_1}p_2^{a_2}\cdots p_k^{a_k}\)，其原根\(g\)满足\(\forall i\in[1,k],g^{\frac{\varphi(p)}{p_i}}\neq1\pmod{p}\)。所以对于\(test\ 14\)暴力检验即可。

对于\(test\ 15\)，发现要求\(13123111\)的所有原根，范围\(10^7\)，然后\(\varphi(13123111)=13123110=2\times3\times5\times7\times11\times13\times19\times23\)，每个数检验\(8\)次，一次\(\log\)复杂度，显然会T啊...那怎么办...考虑到原根的性质，对于质数模数\(p\)，\(g^0,g^1,\cdots,g^{p-2}\)在\(\bmod{\ p}\)意义下分别为\(1,2,\cdots,p-1\)，对于异于\(g\)的原根\(g'\)一定可以被表示为\(g'=g^k(k\in\mathbb{N_+})\)，那么显然\(0,k,2k,\cdots,(p-2)k\)在\(\bmod{\ p-1}\)意义下分别对应\(0,1,\cdots,p-2\)(毕竟都是原根...)，所以\(\gcd(k,p-1)=1\)。由此，我们根据输出文件得到\(6\)是最小的原根，所以只需要求所有数在模\(13123111\)意义下以\(6\)为原根的指标，所有指标与\(\varphi(p)=p-1\)互质的数都是原根，互质用类似埃筛的方式实现即可。

  1. namespace sub7{//2g
  2. 	bool vis[13123123]={};int I[13123123]={};
  3. 	long long qpow(long long u,int v,int MOD){
  4. 		long long rep=1;
  5. 		while(v>0){
  6. 			if(v&1){
  7. 				rep=rep*u%MOD;
  8. 			}
  9. 			u=u*u%MOD;
  10. 			v>>=1;
  11. 		}
  12. 		return rep;
  13. 	}
  14. 	bool check(int u){
  15. 		if(qpow(u,998244352/2,998244353)==1){
  16. 			return 0;
  17. 		}
  18. 		if(qpow(u,998244352/7,998244353)==1){
  19. 			return 0;
  20. 		}
  21. 		if(qpow(u,998244352/17,998244353)==1){
  22. 			return 0;
  23. 		}
  24. 		return 1;
  25. 	}
  26. 	void solve(){
  27. 		printf(".g\n.g.gg...g\n");
  28. 		int n;
  29. 		scanf("%d",&n);
  30. 		if(n==3){
  31. 			for(int i=2;i<=13123111;i+=2){
  32. 				vis[i]|=1;
  33. 			}
  34. 			for(int i=3;i<=13123111;i+=3){
  35. 				vis[i]|=1;
  36. 			}
  37. 			for(int i=5;i<=13123111;i+=5){
  38. 				vis[i]|=1;
  39. 			}
  40. 			for(int i=7;i<=13123111;i+=7){
  41. 				vis[i]|=1;
  42. 			}
  43. 			for(int i=11;i<=13123111;i+=11){
  44. 				vis[i]|=1;
  45. 			}
  46. 			for(int i=13;i<=13123111;i+=13){
  47. 				vis[i]|=1;
  48. 			}
  49. 			for(int i=19;i<=13123111;i+=19){
  50. 				vis[i]|=1;
  51. 			}
  52. 			for(int i=23;i<=13123111;i+=23){
  53. 				vis[i]|=1;
  54. 			}
  55. 			for(int i=6,j=1;;i=(int)(6LL*i%13123111),++j){
  56. 				if(I[i]){
  57. 					break;
  58. 				}
  59. 				I[i]=j;
  60. 			}
  61. 			for(int i=1;i<13123111;i++){
  62. 				vis[I[i]]?putchar('.'):putchar('g');
  63. 			}
  64. 			putchar('\n');
  65. 		}
  66. 		else{
  67. 			for(int j=2;j<=400000;j++){
  68. 				if(check(j)){
  69. 					putchar('g');
  70. 				}
  71. 				else{
  72. 					putchar('.');
  73. 				}
  74. 			}
  75. 			putchar('\n');
  76. 			for(int j=104857601;j<=105257600;j++){
  77. 				if(check(j)){
  78. 					putchar('g');
  79. 				}
  80. 				else{
  81. 					putchar('.');
  82. 				}
  83. 			}
  84. 			putchar('\n');
  85. 		}
  86. 	}
  87. }

对于\(16\)，重点在于求模数，提示是一个\(10^9\sim2\cdot10^9\)之间的质数，然后暴力枚举，用Miller-Rabin检验质数，检验原根只考虑\(g^{\frac{\varphi(p)}{2}}\)是否满足条件，取前\(25\)个原根检验，用\(531.9s\)就可以得到唯一解，求得未知的质数为\(1515343657\)。

  1. namespace sub8{//2g?
  2. 	long long qpow(long long u,int v,int MOD){
  3. 		long long rep=1;
  4. 		while(v>0){
  5. 			if(v&1){
  6. 				rep=rep*u%MOD;
  7. 			}
  8. 			u=u*u%MOD;
  9. 			v>>=1;
  10. 		}
  11. 		return rep;
  12. 	}
  13. 	bool check(int u){//1515343656=2*2*2*3*4003*15773
  14. 		if(qpow(u,1515343656/2,1515343657)==1){
  15. 			return 0;
  16. 		}
  17. 		if(qpow(u,1515343656/3,1515343657)==1){
  18. 			return 0;
  19. 		}
  20. 		if(qpow(u,1515343656/4003,1515343657)==1){
  21. 			return 0;
  22. 		}
  23. 		if(qpow(u,1515343656/15773,1515343657)==1){
  24. 			return 0;
  25. 		}
  26. 		return 1;
  27. 	}
  28. 	void solve(){
  29. 		printf(".g\n.g.gg...g\n");
  30. 		for(int j=233333333;j<=234133333;j++){
  31. 			if(check(j)){
  32. 				putchar('g');
  33. 			}
  34. 			else{
  35. 				putchar('.');
  36. 			}
  37. 		}
  38. 		putchar('\n');
  39. 	}
  40. }

求模数代码：

  1. #include<bits/stdc++.h>
  3. using namespace std;
  5. long long qpow(long long u,long long v,long long MOD){
  6. 	long long rep=1;
  7. 	while(v>0){
  8. 		if(v&1){
  9. 			rep=(rep*u)%MOD;
  10. 		}
  11. 		u=(u*u)%MOD;
  12. 		v>>=1;
  13. 	}
  14. 	return rep;
  15. }
  17. bool mr(long long u){
  18. 	if(u==1){
  19. 		return 0;
  20. 	}
  21. 	int tplist[20]={2,3,5,7,61,24251,19260817};
  22. 	long long v=u-1,rep,nxt;int rrep=0;
  23. 	while(!(v&1)){
  24. 		v>>=1;++rrep;
  25. 	}
  26. 	for(int i=0;i<7;i++){
  27. 		if(u==tplist[i]){
  28. 			return 1;
  29. 		}
  30. 		if(u%tplist[i]==0){
  31. 			return 0;
  32. 		}
  33. 		rep=qpow(tplist[i],v,u);
  34. 		for(int j=1;j<=rrep;j++){
  35. 			nxt=rep*rep%u;
  36. 			if(nxt==1&&rep!=1&&rep!=u-1){
  37. 				return 0;
  38. 			}
  39. 			rep=nxt;
  40. 		}
  41. 		if(rep!=1){
  42. 			return 0;
  43. 		}
  44. 	}
  45. 	return 1;
  46. }
  48. bool ccheck(int u,int p,int MOD){
  49. 	return qpow(u,p,MOD)!=1;
  50. }
  52. bool check(int u,int p){
  53. 	return ccheck(u,(p-1)/2,p);
  54. }
  55. int main(){
  56. 	for(int i=1e9+1;i<=2e9;i+=2){//1515343657
  57. 		if(!mr(i)){
  58. 			continue;
  59. 		}
  60. 		if(!check(233333336,i)){
  61. 			continue;
  62. 		}
  63. 		if(!check(233333337,i)){
  64. 			continue;
  65. 		}
  66. 		if(!check(233333338,i)){
  67. 			continue;
  68. 		}
  69. 		if(!check(233333341,i)){
  70. 			continue;
  71. 		}
  72. 		if(!check(233333342,i)){
  73. 			continue;
  74. 		}
  75. 		if(!check(233333344,i)){
  76. 			continue;
  77. 		}
  78. 		if(!check(233333348,i)){
  79. 			continue;
  80. 		}
  81. 		if(!check(233333351,i)){
  82. 			continue;
  83. 		}
  84. 		if(!check(233333352,i)){
  85. 			continue;
  86. 		}
  87. 		if(!check(233333355,i)){
  88. 			continue;
  89. 		}
  90. 		if(!check(233333357,i)){
  91. 			continue;
  92. 		}
  93. 		if(!check(233333358,i)){
  94. 			continue;
  95. 		}
  96. 		if(!check(233333365,i)){
  97. 			continue;
  98. 		}
  99. 		if(!check(233333366,i)){
  100. 			continue;
  101. 		}
  102. 		if(!check(233333369,i)){
  103. 			continue;
  104. 		}
  105. 		if(!check(233333376,i)){
  106. 			continue;
  107. 		}
  108. 		if(!check(233333377,i)){
  109. 			continue;
  110. 		}
  111. 		if(!check(233333380,i)){
  112. 			continue;
  113. 		}
  114. 		if(!check(233333381,i)){
  115. 			continue;
  116. 		}
  117. 		if(!check(233333385,i)){
  118. 			continue;
  119. 		}
  120. 		if(!check(233333389,i)){
  121. 			continue;
  122. 		}
  123. 		if(!check(233333392,i)){
  124. 			continue;
  125. 		}
  126. 		if(!check(233333394,i)){
  127. 			continue;
  128. 		}
  129. 		if(!check(233333397,i)){
  130. 			continue;
  131. 		}
  132. 		if(!check(233333401,i)){
  133. 			continue;
  134. 		}
  135. 		printf("%d\n",i);
  136. 	}
  137. 	return 0;
  138. }

坑终于填完了qwq...

完整AC代码：

  1. #include<cstdio>//T3 2S 512M
  2. #include<iostream>
  3. #include<cstring>
  4. #include<string>
  5. #include<cmath>
  6. #include<algorithm>
  7. #include<cstdlib>
  8. #include<map>
  9. #define ull unsigned long long
  11. using namespace std;
  13. char op[20];
  15. bool notpr[1000010];
  17. int pr[1000010],cntpr,mu[1000010],mucnt[1000010];
  19. long long num[1000010];
  21. void pre(){
  22. 	notpr[0]=notpr[1]=1;
  23. 	for(int i=2;i<=1000000;i++){
  24. 		if(!notpr[i]){
  25. 			pr[++cntpr]=i;
  26. 			mu[i]=-1;
  27. 		}
  28. 		for(int j=1;j<=cntpr&&i*pr[j]<=1e6;j++){
  29. 			notpr[i*pr[j]]=1;
  30. 			if(i%pr[j]==0){
  31. 				break;
  32. 			}
  33. 			mu[i*pr[j]]=-mu[i];
  34. 		}
  35. 	}
  36. }
  38. namespace sub1{//1_998244353
  39. 	const int MOD=998244353,MMOD=998244352;
  40. 	char s[50];
  41. 	int n,len;
  42. 	long long zs;
  43. 	long long qpow(long long u,long long v){
  44. 		long long rep=1;
  45. 		while(v>0){
  46. 			if(v&1){
  47. 				rep=rep*u%MOD;
  48. 			}
  49. 			u=u*u%MOD;
  50. 			v>>=1;
  51. 		}
  52. 		return rep;
  53. 	}
  54. 	void solve(){
  55. 		scanf("%d",&n);
  56. 		for(int i=1;i<=n;i++){
  57. 			scanf("%s",s);
  58. 			len=(int)strlen(s);
  59. 			zs=0;
  60. 			for(int j=0;j<len;j++){
  61. 				zs=zs*10+s[j]-'0';
  62. 				zs%=MMOD;
  63. 			}
  64. 			printf("%lld\n",qpow(19,zs));
  65. 		}
  66. 	}
  67. }
  69. namespace sub2{//1?
  70. 	const int MOD=1145141;
  71. 	const int MMOD=MOD-1;
  72. 	char s[50];
  73. 	int n,len;
  74. 	long long zs;
  75. 	long long qpow(long long u,long long v){
  76. 		long long rep=1;
  77. 		while(v>0){
  78. 			if(v&1){
  79. 				rep=rep*u%MOD;
  80. 			}
  81. 			u=u*u%MOD;
  82. 			v>>=1;
  83. 		}
  84. 		return rep;
  85. 	}
  86. 	void solve(){
  87. 		scanf("%d",&n);
  88. 		for(int i=1;i<=n;i++){
  89. 			scanf("%s",s);
  90. 			len=(int)strlen(s);
  91. 			zs=0;
  92. 			for(int j=0;j<len;j++){
  93. 				zs=zs*10+s[j]-'0';
  94. 				zs%=MMOD;
  95. 			}
  96. 			printf("%lld\n",qpow(19,zs));
  97. 		}
  98. 	}
  99. }
  101. namespace sub3{//1?+
  102. 	const long long MOD=5211600617818708273LL;
  103. 	int n;
  104. 	int zs;
  105. 	long long plu(long long u,long long v){
  106. 		return (long long)(((ull)u+(ull)v)%MOD);
  107. 	}
  108. 	long long mul(long long u,long long v){
  109. 		long long rep=0;
  110. 		while(v>0){
  111. 			if(v&1){
  112. 				rep=plu(rep,u);
  113. 			}
  114. 			u=plu(u,u);
  115. 			v>>=1;
  116. 		}
  117. 		return rep;
  118. 	}
  119. 	long long qpow(long long u,int v){
  120. 		long long rep=1;
  121. 		while(v>0){
  122. 			if(v&1){
  123. 				rep=mul(rep,u);
  124. 			}
  125. 			u=mul(u,u);
  126. 			v>>=1;
  127. 		}
  128. 		return rep;
  129. 	}
  130. 	void solve(){
  131. 		scanf("%d",&n);
  132. 		for(int i=1;i<=n;i++){
  133. 			scanf("%d",&zs);
  134. 			printf("%lld\n",qpow(19,zs));
  135. 		}
  136. 	}
  137. }
  139. namespace sub4{//1wa_998244353
  140. 	int n,len;
  141. 	int ans[101000]={};
  142. 	long long zs;
  143. 	void solve(){
  144. 		for(int i=0,rep=1;i<1e5+1000;i++){
  145. 			ans[i]=rep;
  146. 			rep=rep*19%998244353;
  147. 		}
  148. 		scanf("%d",&n);
  149. 		for(int i=1;i<=n;i++){
  150. 			scanf("%lld",&zs);
  151. 			zs=zs>55244?(55245+((zs-55245)%45699)):zs;
  152. 			printf("%d\n",ans[(int)zs]);
  153. 		}
  154. 	}
  155. }
  157. namespace sub5{//2p
  158. 	int n;
  159. 	long long l,r;
  160. 	long long mul(long long u,long long v,long long MOD){
  161. 		long long w=(long long)(1.0L*u*v/(1.0L*MOD)),rep=u*v-w*MOD;
  162. 		rep-=MOD;
  163. 		while(rep<0){
  164. 			rep+=MOD;
  165. 		}
  166. 		return rep;
  167. 	}
  168. 	long long qpow(long long u,long long v,long long MOD){
  169. 		long long rep=1;
  170. 		while(v>0){
  171. 			if(v&1){
  172. 				rep=mul(rep,u,MOD);
  173. 			}
  174. 			u=mul(u,u,MOD);
  175. 			v>>=1;
  176. 		}
  177. 		return rep;
  178. 	}
  179. 	bool mr(long long u){
  180. 		if(u==1){
  181. 			return 0;
  182. 		}
  183. 		int tplist[20]={2,3,5,7,61,24251,19260817};
  184. 		long long v=u-1,rep,nxt;int rrep=0;
  185. 		while(!(v&1)){
  186. 			v>>=1;++rrep;
  187. 		}
  188. 		for(int i=0;i<2;i++){
  189. 			if(u==tplist[i]){
  190. 				return 1;
  191. 			}
  192. 			if(u%tplist[i]==0){
  193. 				return 0;
  194. 			}
  195. 			rep=qpow(tplist[i],v,u);
  196. 			for(int j=1;j<=rrep;j++){
  197. 				nxt=mul(rep,rep,u);
  198. 				if(nxt==1&&rep!=1&&rep!=u-1){
  199. 					return 0;
  200. 				}
  201. 				rep=nxt;
  202. 			}
  203. 			if(rep!=1){
  204. 				return 0;
  205. 			}
  206. 		}
  207. 		return 1;
  208. 	}
  209. 	void solve(){
  210. 		printf("pp.p.p...\np.p...\npp.p.p...p.p..\n");
  211. 		scanf("%d",&n);
  212. 		scanf("%d",&n);
  213. 		scanf("%d",&n);
  214. 		scanf("%d",&n);
  215. 		scanf("%d",&n);
  216. 		scanf("%d",&n);
  217. 		scanf("%d",&n);
  218. 		scanf("%lld%lld",&l,&r);
  219. 		if(r<=1e6){
  220. 			pre();
  221. 			for(int i=2;i<=1e6;i++){
  222. 				notpr[i]?putchar('.'):putchar('p');
  223. 			}
  224. 			putchar('\n');
  225. 		}
  226. 		else if(r<=1e12){
  227. 			bool vis[1000010]={};
  228. 			const long long MIN=999998999999LL;
  229. 			pre();
  230. 			int st;
  231. 			for(int i=1;i<=cntpr;i++){
  232. 				st=(int)((MIN/pr[i])*pr[i]+pr[i]-MIN);
  233. 				for(;st<=1e6+1;st+=pr[i]){
  234. 					vis[st]=1;
  235. 				}
  236. 			}
  237. 			for(int i=1;i<=1e6+1;i++){
  238. 				vis[i]?putchar('.'):putchar('p');
  239. 			}
  240. 		}
  241. 		else{
  242. 			for(long long i=999999999999000000LL;i<=1000000000000000000LL;i++){
  243. 				mr(i)?putchar('p'):putchar('.');
  244. 			}
  245. 		}
  246. 	}
  247. }
  249. namespace sub6{//2u
  250. 	int n;
  251. 	long long l,r;
  252. 	long long mul(long long u,long long v,long long MOD){
  253. 		long long w=(long long)(1.0L*u*v/(1.0L*MOD)),rep=u*v-w*MOD;
  254. 		rep-=MOD;
  255. 		while(rep<0){
  256. 			rep+=MOD;
  257. 		}
  258. 		return rep;
  259. 	}
  260. 	long long qpow(long long u,long long v,long long MOD){
  261. 		long long rep=1;
  262. 		while(v>0){
  263. 			if(v&1){
  264. 				rep=mul(rep,u,MOD);
  265. 			}
  266. 			u=mul(u,u,MOD);
  267. 			v>>=1;
  268. 		}
  269. 		return rep;
  270. 	}
  271. 	bool mr(long long u){
  272. 		if(u==1){
  273. 			return 0;
  274. 		}
  275. 		int tplist[20]={2,3,5,7,61,24251,19260817};
  276. 		long long v=u-1,rep,nxt;int rrep=0;
  277. 		while(!(v&1)){
  278. 			v>>=1;++rrep;
  279. 		}
  280. 		for(int i=0;i<2;i++){
  281. 			if(u==tplist[i]){
  282. 				return 1;
  283. 			}
  284. 			if(u%tplist[i]==0){
  285. 				return 0;
  286. 			}
  287. 			rep=qpow(tplist[i],v,u);
  288. 			for(int j=1;j<=rrep;j++){
  289. 				nxt=mul(rep,rep,u);
  290. 				if(nxt==1&&rep!=1&&rep!=u-1){
  291. 					return 0;
  292. 				}
  293. 				rep=nxt;
  294. 			}
  295. 			if(rep!=1){
  296. 				return 0;
  297. 			}
  298. 		}
  299. 		return 1;
  300. 	}
  301. 	void solve(){
  302. 		printf("--0-+-00+\n-+-00+\n--0-+-00+-0-++\n");
  303. 		scanf("%d",&n);
  304. 		scanf("%d",&n);
  305. 		scanf("%d",&n);
  306. 		scanf("%d",&n);
  307. 		scanf("%d",&n);
  308. 		scanf("%d",&n);
  309. 		scanf("%d",&n);
  310. 		scanf("%lld%lld",&l,&r);
  311. 		if(r<=1e6){
  312. 			pre();
  313. 			for(int i=2;i<=1e6;i++){
  314. 				if(mu[i]<0){
  315. 					putchar('-');
  316. 				}
  317. 				else if(mu[i]>0){
  318. 					putchar('+');
  319. 				}
  320. 				else{
  321. 					putchar('0');
  322. 				}
  323. 			}
  324. 			putchar('\n');
  325. 		}
  326. 		else if(r<=1e12){
  327. 			bool sqvis[1000010]={};
  328. 			const long long MIN=999998999999LL;
  329. 			pre();
  330. 			for(int i=1;i<=1e6+1;i++){
  331. 				num[i]=MIN+i;
  332. 			}
  333. 			int st;long long sq;
  334. 			for(int i=1;i<=cntpr;i++){
  335. 				sq=1LL*pr[i]*pr[i];
  336. 				st=(int)((MIN/pr[i])*pr[i]+pr[i]-MIN);
  337. 				for(;st<=1e6+1;st+=pr[i]){
  338. 					++mucnt[st];
  339. 					num[st]/=pr[i];
  340. 					if(!sqvis[st]){
  341. 						if((MIN+st)%sq==0){
  342. 							sqvis[st]=1;
  343. 						}
  344. 					}
  345. 				}
  346. 			}
  347. 			for(int i=1;i<=1e6+1;i++){
  348. 				if(num[i]>1){
  349. 					++mucnt[i];
  350. 				}
  351. 				if(sqvis[i]){
  352. 					putchar('0');
  353. 				}
  354. 				else if(mucnt[i]&1){
  355. 					putchar('-');
  356. 				}
  357. 				else{
  358. 					putchar('+');
  359. 				}
  360. 			}
  361. 		}
  362. 		else{
  363. 			bool sqvis[1000010]={};
  364. 			const long long MIN=999999999998999999LL;
  365. 			pre();
  366. 			for(int i=1;i<=1e6+1;i++){
  367. 				num[i]=MIN+i;
  368. 			}
  369. 			int st;long long sq;
  370. 			for(int i=1;i<=cntpr;i++){
  371. 				sq=1LL*pr[i]*pr[i];
  372. 				st=(int)((MIN/pr[i])*pr[i]+pr[i]-MIN);
  373. 				for(;st<=1e6+1;st+=pr[i]){
  374. 					++mucnt[st];
  375. 					num[st]/=pr[i];
  376. 					if(!sqvis[st]){
  377. 						if((MIN+st)%sq==0){
  378. 							sqvis[st]=1;
  379. 						}
  380. 					}
  381. 				}
  382. 			}
  383. 			for(int i=1;i<=1e6+1;i++){
  384. 				if(num[i]>1){
  385. 					if(mr(num[i])){
  386. 						++mucnt[i];
  387. 					}
  388. 					else{
  389. 						long long rep=(long long)sqrt(num[i]);
  390. 						if(rep*rep==num[i]){
  391. 							sqvis[i]=1;
  392. 						}
  393. 						else{
  394. 							mucnt[i]+=2;
  395. 						}
  396. 					}
  397. 				}
  398. 				if(sqvis[i]){
  399. 					putchar('0');
  400. 				}
  401. 				else if(mucnt[i]&1){
  402. 					putchar('-');
  403. 				}
  404. 				else{
  405. 					putchar('+');
  406. 				}
  407. 			}
  408. 		}
  409. 	}
  410. }
  412. namespace sub7{//2g
  413. 	bool vis[13123123]={};int I[13123123]={};
  414. 	long long qpow(long long u,int v,int MOD){
  415. 		long long rep=1;
  416. 		while(v>0){
  417. 			if(v&1){
  418. 				rep=rep*u%MOD;
  419. 			}
  420. 			u=u*u%MOD;
  421. 			v>>=1;
  422. 		}
  423. 		return rep;
  424. 	}
  425. 	bool check(int u){
  426. 		if(qpow(u,998244352/2,998244353)==1){
  427. 			return 0;
  428. 		}
  429. 		if(qpow(u,998244352/7,998244353)==1){
  430. 			return 0;
  431. 		}
  432. 		if(qpow(u,998244352/17,998244353)==1){
  433. 			return 0;
  434. 		}
  435. 		return 1;
  436. 	}
  437. 	void solve(){
  438. 		printf(".g\n.g.gg...g\n");
  439. 		int n;
  440. 		scanf("%d",&n);
  441. 		if(n==3){
  442. 			for(int i=2;i<=13123111;i+=2){
  443. 				vis[i]|=1;
  444. 			}
  445. 			for(int i=3;i<=13123111;i+=3){
  446. 				vis[i]|=1;
  447. 			}
  448. 			for(int i=5;i<=13123111;i+=5){
  449. 				vis[i]|=1;
  450. 			}
  451. 			for(int i=7;i<=13123111;i+=7){
  452. 				vis[i]|=1;
  453. 			}
  454. 			for(int i=11;i<=13123111;i+=11){
  455. 				vis[i]|=1;
  456. 			}
  457. 			for(int i=13;i<=13123111;i+=13){
  458. 				vis[i]|=1;
  459. 			}
  460. 			for(int i=19;i<=13123111;i+=19){
  461. 				vis[i]|=1;
  462. 			}
  463. 			for(int i=23;i<=13123111;i+=23){
  464. 				vis[i]|=1;
  465. 			}
  466. 			for(int i=6,j=1;;i=(int)(6LL*i%13123111),++j){
  467. 				if(I[i]){
  468. 					break;
  469. 				}
  470. 				I[i]=j;
  471. 			}
  472. 			for(int i=1;i<13123111;i++){
  473. 				vis[I[i]]?putchar('.'):putchar('g');
  474. 			}
  475. 			putchar('\n');
  476. 		}
  477. 		else{
  478. 			for(int j=2;j<=400000;j++){
  479. 				if(check(j)){
  480. 					putchar('g');
  481. 				}
  482. 				else{
  483. 					putchar('.');
  484. 				}
  485. 			}
  486. 			putchar('\n');
  487. 			for(int j=104857601;j<=105257600;j++){
  488. 				if(check(j)){
  489. 					putchar('g');
  490. 				}
  491. 				else{
  492. 					putchar('.');
  493. 				}
  494. 			}
  495. 			putchar('\n');
  496. 		}
  497. 	}
  498. }
  500. namespace sub8{//2g?
  501. 	long long qpow(long long u,int v,int MOD){
  502. 		long long rep=1;
  503. 		while(v>0){
  504. 			if(v&1){
  505. 				rep=rep*u%MOD;
  506. 			}
  507. 			u=u*u%MOD;
  508. 			v>>=1;
  509. 		}
  510. 		return rep;
  511. 	}
  512. 	bool check(int u){//1515343656=2*2*2*3*4003*15773
  513. 		if(qpow(u,1515343656/2,1515343657)==1){
  514. 			return 0;
  515. 		}
  516. 		if(qpow(u,1515343656/3,1515343657)==1){
  517. 			return 0;
  518. 		}
  519. 		if(qpow(u,1515343656/4003,1515343657)==1){
  520. 			return 0;
  521. 		}
  522. 		if(qpow(u,1515343656/15773,1515343657)==1){
  523. 			return 0;
  524. 		}
  525. 		return 1;
  526. 	}
  527. 	void solve(){
  528. 		printf(".g\n.g.gg...g\n");
  529. 		for(int j=233333333;j<=234133333;j++){
  530. 			if(check(j)){
  531. 				putchar('g');
  532. 			}
  533. 			else{
  534. 				putchar('.');
  535. 			}
  536. 		}
  537. 		putchar('\n');
  538. 	}
  539. }
  541. int main(){
  542. 	scanf("%s",op);
  543. 	if(op[0]=='1'){
  544. 		if(op[1]=='_'){//1_998244353
  545. 			sub1::solve();
  546. 		}
  547. 		else if(op[1]=='?'){
  548. 			if(op[2]=='+'){//1?+
  549. 				sub3::solve();
  550. 			}
  551. 			else{//1?
  552. 				sub2::solve();
  553. 			}
  554. 		}
  555. 		else{//1wa_998244353
  556. 			sub4::solve();
  557. 		}
  558. 	}
  559. 	else{
  560. 		if(op[1]=='p'){//2p
  561. 			sub5::solve();
  562. 		}
  563. 		else if(op[1]=='u'){//2u
  564. 			sub6::solve();
  565. 		}
  566. 		else{
  567. 			if(op[2]=='?'){//2g?
  568. 				sub8::solve();
  569. 			}
  570. 			else{//2g
  571. 				sub7::solve();
  572. 			}
  573. 		}
  574. 	}
  575. 	return 0;
  576. }

Luogu P5285 / LOJ3050 【[十二省联考2019]骗分过样例】的更多相关文章

  1. Luogu P5285 [十二省联考2019]骗分过样例

    Preface ZJOI一轮被麻将劝退的老年选手看到这题就两眼放光,省选也有乱搞题? 然后狂肝了3~4天终于打完了,期间还补了一堆姿势 由于我压缩技术比较菜,所以用的都是非打表算法,所以一共写了5K- ...

  2. Luogu5285 [十二省联考2019] 骗分过样例

    题目分析: 观察前3个点,$361=19*19$,所以可以发现实际上就是快速幂,然后模数猜测是$998244353$,因为功能编号里面有这个数字,用费马小定理处理一下. $pts:12$ 观察第4个点 ...

  3. [十二省联考2019]骗分过样例 luoguP5285 loj#3050

    不解释(因为蒟蒻太弱了,肝了一晚受不了了...现在省选退役,这有可能就是我做的最后一题了... #include<bits/stdc++.h> using namespace std; # ...

  4. [十二省联考2019]异或粽子 01trie

    [十二省联考2019]异或粽子 01trie 链接 luogu 思路 首先求前k大的(xo[i]^xo[j])(i<j). 考场上只想到01trie,不怎么会写可持久,就写了n个01trie,和 ...

  5. [十二省联考2019]字符串问题——后缀自动机+parent树优化建图+拓扑序DP+倍增

    题目链接: [十二省联考2019]字符串问题 首先考虑最暴力的做法就是对于每个$B$串存一下它是哪些$A$串的前缀,然后按每组支配关系连边,做一遍拓扑序DP即可. 但即使忽略判断前缀的时间,光是连边的 ...

  6. [十二省联考2019]异或粽子——可持久化trie树+堆

    题目链接: [十二省联考2019]异或粽子 求前$k$大异或区间,可以发现$k$比较小,我们考虑找出每个区间. 为了快速得到一个区间的异或和,将原序列做前缀异或和. 对于每个点作为右端点时,我们维护出 ...

  7. 【BZOJ5495】[十二省联考2019]异或粽子（主席树，贪心）

    [BZOJ5495][十二省联考2019]异或粽子(主席树,贪心) 题面 BZOJ 洛谷 题解 这不是送分题吗... 转异或前缀和,构建可持久化\(Trie\). 然后拿一个堆维护每次的最大值,每次如 ...

  8. 【BZOJ5496】[十二省联考2019]字符串问题（后缀树）

    [BZOJ5496][十二省联考2019]字符串问题(后缀树) 题面 BZOJ 洛谷 题解 首先显然可以把具有支配关系的串从\(A\)到\(B\)连一条有向边,如果\(B_i\)是\(A_j\)的前缀 ...

  9. 【BZOJ5498】[十二省联考2019]皮配（动态规划）

    [BZOJ5498][十二省联考2019]皮配(动态规划) 题面 BZOJ 洛谷 题解 先考虑暴力\(dp\),设\(f[i][j][k]\)表示前\(i\)所学校,有\(j\)人在某个阵营,有\(k ...

随机推荐

  1. java web 常见异常及解决办法

    javax.servlet.ServletException: javax/servlet/jsp/SkipPageException 重启tomcat, javax.servlet.ServletE ...

  2. Windows激活

    最近重新安装了一下系统,我的系统是Windows10.这就出现了一个问题,如果是Windows7系统的话,可以使用网上的破解工具进行破解操作,使之成为永久破解版.但是Windows10系统,网上对于它 ...

  3. ios不触发事件也能播放音频

    ios不触发事件也能播放音频. 首先界面初始化预加载一个没有声音的音频,代码如下: html: js: $(function(){ $("#start_audio")[0].pla ...

  4. Oracle pivot行转列函数案例

    with temp as( select '湖北省' province,'武汉市' city,'第一' ranking from dual union all select '湖北省' provinc ...

  5. spring IOC源码分析（ApplicationContext）

    在上一篇文章中,我们以BeanFactory这条主线进行IOC的源码解析的,这里,将以ApplicationContext这条线进行分析.先看使用方法: @Test public void testA ...

  6. Docker安装部署redis

    借鉴博客:https://my.oschina.net/u/3489495/blog/1825335 待续... >>>>>>>>>docker安 ...

  7. day 7-4 互斥锁与队列

    一. 基本定义 互斥锁(英语:英语:Mutual exclusion,缩写 Mutex)是一种用于多线程编程中,防止两条线程同时对同一公共资源(比如全局变量)进行读写的机制.该目的通过将代码切片成一个 ...

  8. 阿里巴巴 Java开发手册1.4.0

    <阿里巴巴Java开发手册1.4.0>下载地址: 下载地址:https://102.alibaba.com/downloadFile.do?file=1528269849853/Java_ ...

  9. Jmeter安装与使用（压测）

    一.介绍 Apache JMeter是100%纯JAVA桌面应用程序,被设计为用于测试客户端/服务端结构的软件(例如web应用程序).它可以用来测试静态和动态资源的性能,例如:静态文件,Java Se ...

  10. python数据结构与算法第七天【链表】

    1.链表的定义 如图: 注意: (1)线性表包括顺序表和链表 (2)顺序表是将元素顺序地存放在一块连续的存储区里 (3)链表是将元素存放在通过链构造的存储快中 2. 单向链表的实现 #!/usr/bi ...