2018西南交通大学ACM新秀杯决赛题解与总结

 总结：
　　本次比赛是我第一次参加的现场赛，之前只参加过一些网络赛，取得的名次倒还也不算太差。但在这次现场赛中，我却只做出两道题。究其原因：不知为何，相较于网络赛，这次比赛我十分慌张，不能静下来思考，做题时不能专注、集中精神；其次，编译器的不顺手更让我紧张加剧。但这些其实都不该是理由，最主要的理由应该还是我的实力不够，还需要更多的积累、练习。
　　下来之后重新做了比赛时的题目，发现其实赛题难度不大，几乎没有考察算法，如果能冷静下来认真做的话，至少有7道题是没问题的。
　　接下来我们一道一道解决。
　　
Problems
A Key
B 吕元数猜想
C 人类的本质
D A%B problem
E 黑珍珠号的诅咒(The Curse of the Black Pearl)
F 聚魂棺(Dead man’s Chest)
G 喵星网络赛
H N桥问题
I Array

 　　　　　　　　　　　　　　　　　　　Problem A. Key
Time limit: 1000 ms
Memory limit: 256 MB
Input file: standard input
Output file: standard output
庶神有 n 个不同的锁和对应的钥匙。现在他把钥匙打乱了，庶神有一个怪癖，他会把钥匙一个一个插进锁里再拧开。求恰好打开一把锁的情况数。
Input
输入包含多组测试数据，第一行为一个正整数 ? (0≤?≤105) 表示有 T 组测试数据。
对于每组则测试数据，
仅有一行包含一个正整数 ? (1≤?≤107) ，代表有 n 对钥匙和锁。
Output
对于每组测试数据，
输出一行包含一个整数，表示恰好打开一把锁的情况数。答案可能会很大，请将结果对 107+7 取模

 解题思路：
　　此题是一道简单的错排问题。要求恰好打开一把锁的情况数，则先确定打开的锁：总共有n种情况。然后对剩下的n-1把锁进行错排：用f[i]表示i把锁错排的情况数，由递归的思想很容易得f[i]=(i-1)(f[i-1]+f[i-2])。最后的答案就为nf[n-1]。
　　处理细节上将错排数提前预处理即可。

#include 
#include 
#include 
const int BASE=1e7+7,MAXN=1e7;
long long dp[MAXN+5];					//dp[i]：i个数错排的情况数 
int main(void){
	int T;scanf("%d",&T);
	dp[0]=1,dp[1]=0;
	for(int i=2;i<=MAXN;++i)
		dp[i]=((i-1)*(dp[i-1]+dp[i-2]))%BASE;
	int n;
	while(T--){
		scanf("%d",&n);
		printf("%lld\n",(n*dp[n-1])%BASE);
	}
	return 0;
}

 本题小结：
　此题单纯考察了错排，几乎没有变形，之前练习时遇到过同样类型甚至包括更多变形的题目，但是这次现场赛时却没有做出来这道题？？？
　或许是第一次参加现场赛比较慌张的缘故，但也绝对不该丢掉此题。此题同样暴露出了我在 组合数学 方面存在严重问题，需重视。

 
 

 　　　　　　　　　　　　　　　　　　Problem B. 吕元数猜想
Time limit: 1000 ms
Memory limit: 128 MB
Input file: standard input
Output file: standard output
给定两个正整数 A 和 B
要求找出所有的整数对 (C, D)
满足 ?≤?≤?, ?≤?≤? 且 AB+BA≤CD+?? (分数运算，并非整除)
Input
输入包含多组测试数据，
第一行为一个正整数 ? (0≤?≤20) 表示有 T 组测试数据。
对于每组则测试数据，
仅有一行包含两个整数 ? (0 Output
对于每组测试数据，
第一行包含一个整数 X 表示所求整数对的数量，
接下来 X 行，每行包含一个所求整数对 (C,D)
将答案按 C 的大小从小到大进行排序后输出，若 C 大小相等，则 C 相等的整数对按 C 的大小从小到大排序。如 (3,4)<(3,5) , (3,4)>(2,4)

 解题思路：
　　由题设条件易得，C<=D和D<=C是一组对称的结果，所以我们假设C<=D。
　　仔细观察便能得到不等式两端有着相同的形式：f(x)=x+1/x。
　　根据A/B<=C/D<=1<=D/C<=B/A，因此有f(D/C)=f(C/D)<=f(A/B)=f(B/A)，当且仅当A/B=C/D，即A=C,B=D时等号成立。
　　再由不等式得等号成立所以A=C，B=D。再加上D<=C的情况即为全部答案。

#include 
int main(void){
	int T,a,b;scanf("%d",&T);
	while(T--){
		scanf("%d%d",&a,&b);
		if(a==b) printf("1\n%d %d\n",a,a);
		else printf("2\n%d %d\n%d %d\n",a,b,b,a);
	}
	return 0;
}

 本题小结：
　本题是这次比赛唯二做出的题中的一道，并且实际做题时思路也没有上述那么严谨，更多的是偏向于猜测：同样假设C<=D，得到了A/B<=C/D<=1<=D/C<=B/A。
　再看给出的不等式，移项有：B/A-D/C<=C/D-A/B。可以看出右式中两个数都小于等于1，左式两个数都大于等于1，则要想使不等号成立，需两大于1的数的差值小于两小于1的数的差值，显然缩小左式的值较右式更为困难，因此猜测不等号最多只有等号成立。
　这道“难得”做对的题还是猜对的，让我在比赛时又受了次打击。

 
 

 　　　　　　　　　　　　　　　　　　　　　Problem C. 人类的本质
Time limit: 1000 ms
Memory limit: 256 MB
Input file: standard input
Output file: standard output
众所周知，在某些比赛交流群里，总是能完美地体现人类的本质，这是漫长的看算法做算法题生涯中为数不多的乐趣之一。这本来无可厚非，但是在 SWJTU 比赛交流群里，这种行为严重影响了群主的日常生活，他不得不停下他的家长会来答疑，当他发现群成员并没有问题而只是一些复读消息时，他生气了。于是群里出现了复读禁言机器人。
复读禁言机器人总是禁言最后一条复读消息的发送者。有些成员发现了这个现象但还是打算皮一下，所以他们在发出消息的一段时间后又撤回了他们的消息。复读禁言机器人并不是时时刻刻在线的（因为机器人也是有妹子的），所以在机器人禁言的总是目前屏幕上剩下的消息中，最后一条复读消息的发送者。
已经被禁言的成员是不会再复读并且不能再被禁言的。数据保证每次操作的合理性。
Input
输入只包含一组测试数据，
第一行为一个正整数 n 和 q (1≤?≤?≤105) ，表示 n 个人参与复读，今天有 k 次操作（有些成员可能不遵循复读基本法，他们复读了不止一次）。
接下来有 q 行，每行包含一个整数 ? (1≤?≤?) 和一个字符串 s ( s 仅包含小写字母且长度不超过 10 ）表示操作种类和执行操作的群成员的名字。
?=0 表示群成员 s 撤回了他最近的一条复读消息。
?=1 表示群成员 s 复读了一条消息。
?=2 表示禁言机器人 s 禁言了一个成员。
Output
输出包含若干行，
每行包含一个字符串，表示对于每次 ?=2 时，被禁言成员的名字。

 解题思路：
　　很容易想到用栈记录复读序列，同时“撤回一次”表示抵消一次禁言，那么“禁言一次”就可以表示抵消无穷次禁言。注意将成员的名字用整数表示。

#include 
#include 
#include 
#include 

 本题小结：
　代码AC不了，但实在找不到问题。

 
 

 　　　　　　　　　　　　　　　　　　　　Problem D. A%B problem
Time limit: 1000 ms
Memory limit: 128 MB
Input file: standard input
Output file: standard output
这道题是众所周知的真·签到题 A+B Problem 的进阶版，只不过加变成了取模。听起来挺简单的，那来做做吧！
Input
输入包含多组测试数据，第一行为一个正整数 ? (1≤?≤2333) 表示有 T 组测试数据。
对于每组则测试数据，
仅有一行包含两个整数 ? (1≤?≤10233) 和 ? (1≤?≤2×109)。
Output
对于每组测试数据，
输出一行包含一个整数，即 A 除以 B 的余数。

 解题思路：纯模板题。

#include 
#include 
#include 
using namespace std;
const int L=300;  
string s1,s2;
int sub(int *a,int *b,int La,int Lb)  
{  
    if(La=0;i--)  
            if(a[i]>b[i]) break;  
            else if(a[i]=0;i--)  
        if(a[i]) return i+1;//返回差的位数  
    return 0;//返回差的位数  
  
}  
string div(string n1,string n2,int nn)//n1,n2是字符串表示的被除数，除数,nn是选择返回商还是余数  
{  
    string s,v;//s存商,v存余数  
     int a[L],b[L],r[L],La=n1.size(),Lb=n2.size(),i,tp=La;//a，b是整形数组表示被除数，除数，tp保存被除数的长度  
     fill(a,a+L,0);fill(b,b+L,0);fill(r,r+L,0);//数组元素都置为0  
     for(i=La-1;i>=0;i--) a[La-1-i]=n1[i]-'0';  
     for(i=Lb-1;i>=0;i--) b[Lb-1-i]=n2[i]-'0';  
     if(La=0;i--)//将除数扩大10^t倍  
        if(i>=t) b[i]=b[i-t];  
        else b[i]=0;  
     Lb=La;  
     for(int j=0;j<=t;j++)  
     {  
         int temp;  
         while((temp=sub(a,b+j,La,Lb-j))>=0)//如果被除数比除数大继续减  
         {  
             La=temp;  
             r[t-j]++;  
         }  
     }  
     for(i=0;i=0) s+=r[i--]+'0';  
     //cout<  
     while(i>=0) v+=a[i--]+'0';  
     if(v.empty()) v="0";  
     //cout<>T;
	while(T--){
		cin>>s1>>s2;
		cout<

 本题小结：
　本题提醒我比赛一定要记得带模板。

 
 

 　　　　　　　　　　　　　　　　　　　Problem E. 黑珍珠号的诅咒(The Curse of the Black Pearl)
Time limit: 1000 ms
Memory limit: 128 MB
Input file: standard input
Output file: standard output
故事发生在传说中海盗最活跃的 加勒比海(Caribbean Sea)。这片神秘的海域位于北美洲东南部，那里碧海蓝天，阳光明媚，海面水晶般清澈透明。
玩世不恭的 Jack Sparrow (Oh, I mean, Captain Jack Sparrow …) 是活跃在加勒比海上的年轻海盗，拥有令人闻风丧胆的 “黑珍珠号”(Black Pearl) 海盗船。对他来说，最惬意的生活莫过于驾驶着 “黑珍珠号” 在加勒比海上游荡，自由自在地打劫过往船只。但不幸的是，他遭到了自己的大副 Barbossa 的背叛，不仅自己珍爱的 “黑珍珠号” 被 Barbossa 偷走，自己也被遗弃在荒岛独自等死。
与此同时，抢劫了 “黑珍珠号” 的 Barbossa 变得更加猖狂，在加勒比海上横行霸道，一时成为整个加勒比海的霸主。但 Barbossa 和他的船员们却因掠取了 “阿兹特克金币”(Aztec Gold) 而遭到了邪恶的诅咒：成为无法满足一切欲望的骷髅，他们渴得要死却渴不死，他们饿得要死却饿不死，他们感不到海风拂面、他们触不到浪花拍打……
终于， Barbossa 得知，只有将 882 枚散落在世界各地的 “阿兹特克金币” 集齐，才能够消除诅咒，于是他派遣 Marty 去四处搜集散落的金币。
一天， Marty 在集市上看到了 n 枚闪闪发光的金币， Marty 并不知道这是不是可以解除他们诅咒的金币，所以 Marty 打算买一些回去碰碰运气。
这些金币被串成了一串，每枚金币都有各自的价格。众所周知， Marty 是一个丢三落四的家伙，他并不能带着散装的金币回去。也就是说，如果他打算购买金币的话，就只能买连续的、连成一串的若干枚。而在那个时候，扫码转账等移动支付还并没有普及开来，所以 Marty 只能用口袋里无数个价值为 a 的钱币，去换取疑似的 “阿兹特克金币” 。
在 Marty 打算交钱的时候，得知店主并没有零钱找给他。由于 Marty 还是一个极其小气的人，如果没有找零， Marty 是不可能用高价值的钱币去换取小价格金币的，即使那些金币有可能是去除诅咒的关键。这就表示， Marty 买的某串金币价格的总和必定是 k 的倍数。
The 14th ACM-ICPC Southwest Jiaotong University Programming Contest Freshman Cup
Southwest Jiaotong University, Sunday December 9, 2018
Page 10 of 18
但 Marty 的数学能力也很差……他并不知道他能否找到某串合适的金币，所以他把这个问题交给了你……
Input
输入包含多组测试数据，第一行为一个正整数 ? (1≤?≤10) 表示有 T 组测试数据。
对于每组测试数据，
第一行包含两个正整数 ? (1≤?≤105) 和 ? (1≤?≤5×104) ，表示集市有 n 枚金币, Marty 有无数个价值为 k 的钱币。
第二行包含 n 个正整数 ?? (0≤??≤109) ，表示那 n 个连在一起的金币各自的价格。
Output
对于每组测试数据，
输出一行包含一个字符串表示结果，如果 Marty 可以买到某串金币，则输出 “YES” (不包含引号)；否则输出 “NO” (不包含引号)。

 解题思路：
　　本题可以看做判断序列中是否存在和为k的倍数的子串，直接暴力求解的话O(n^2)可能会超时，因此可使用分治的策略。
　　将一个序列分为左右两部分，一个序列符合要求代表左串(1)、右串(2)或者从序列中间跨过左右两边的子串(3)符合要求。降低复杂度主要考虑对(3)的处理，由于只需要判断子串的和是否为k的倍数，即为(3)中左半边的和加上右半边的和为k的倍数，即对左半边每个和值查找在右半边中是否存在对应的值满足条件，因此我们可以考虑用STL中的红黑树来实现，复杂度f(n)=O(nlogn)。
　　写出时间复杂度的递推公式：
　　　T(n)=2T(n/2)+O(nlogn)，由主定理得：T(n)=O(nlogn)。
　　　（需要注意的是，虽然理论值如此，但是实际中STL的运行速度很慢）

#include 
#include 
#include 
#include 
#include 
#include 
using namespace std;
int n,k,a[100005];				//a[i]从1到n储存	
int sum[100005];				//从1到i的子串和(mod k)
set s;
bool Can(int i,int j){
	if(i==j) return a[i]%k==0;
	else if(j-i==1) return (a[i]+a[j])%k==0;
	int mid=(i+j)/2;s.clear();
	for(int p=mid+1;p<=j;++p)
		s.insert((sum[p]-sum[mid]+k)%k);
	for(int p=mid,x;p>=i;--p){
		x=(sum[mid]-sum[p-1]+k)%k;
		if(s.find(k-x)!=s.end())
			return true;
	}
	return Can(i,mid)||Can(mid+1,j);
}
int main(void){
	int T;scanf("%d",&T);
	while(T--){
		scanf("%d%d",&n,&k);
		bool flag=false;
		for(int i=1;i<=n;++i){
			scanf("%d",&a[i]);
			if(a[i]==0) --i,--n;
			else if(a[i]%k==0) flag=true;
			else a[i]%=k;
		}
		if(n==0){
			puts("NO");continue;
		}
		for(int i=1;i<=n;++i){
			sum[i]=(sum[i-1]+a[i])%k;
			if(sum[i]==0){
				flag=true;
				break;
			}
		}
		if(flag==true||Can(1,n))
			puts("YES");
		else puts("NO");
	}
	return 0;
}

 本题小结：
　本题稍微考察了一点分治的算法，难度不大。实际上本题数据量不算大，比赛时用了O(n^2)的暴力方法加上一定的剪枝也过了。

 
 

 
 　　　　　　　　　　　　　　　　　　　　Problem F. 聚魂棺(Dead man’s Chest)
Time limit: 1000 ms
Memory limit: 128 MB
Input file: standard input
Output file: standard output
Davy Jones 曾是英俊的北海海盗王，驾驶着 “飞翔的荷兰人号” (the Flying Dutchman) 在海上驰骋。和其他海盗一样， Davy Jones 也有着对冒险的热衷，有着对大海的痴狂，如果没有遇到那个她，他会和 Jack , Barbossa 一样，杀人，防火，抢劫，在 Tortugar 一手拿着朗姆酒瓶，一手拿着枪开怀地大笑……
但他偏偏遇到了，他遇到了那个她，海神 Calypso 。从此 Jones 像着了魔一样深深爱上了 Calypso 。也许 Calypso 只是玩弄，也许是真的也喜欢上了 Jones ， Calypso 提出让 Jones 帮忙，替她照顾那些在海上死去的亡灵，将他们引渡到阴间。这个任务要在海上航行十年，才能有上岸的一天，与爱人 Calypso 相见。
为了深爱的人， Jones 答应了：他不再逍遥四海，不再烧杀掳掠，他放下杀戮、放弃自由，为了爱人他放弃了海盗的尊严。从此，纵情高歌他不参与，纷繁世俗与他无关，有的只是一个人，一条船，做一个引渡者，带着亡魂来往于阴间与人世。为了爱情，海盗也变得靠谱了起来。就这样，一天，两天、一年，又一年……十年虽长，但 Jones 不急，为了自己的深爱的人，他可以等，他认为这所有的一切是值得的……
然而十年终了，当 Jones 上岸来到他与 Calypso 相约的地方时，等待他的，却只有一席空地…… Jones 委屈，愤怒，不解，失望……黄昏将至，即将到来的又是一个漫长的十年。 Jones 的内心太过痛苦，他想结束这一切，他将自己的心脏挖出，连同情书一起锁进箱子里，藏在遥远的地方，他想发誓忘记 Calypso ，但他做不到…… 他放弃了作为引渡者的工作，并在大海上肆意杀戮，以掩盖自己心里的痛苦……
被他抓到的水手，只有两条路: 要么丧身大海，没有了引渡人，那就只能永远的做海上亡魂；要么成为 “飞翔的荷兰人号” 船员，在船上服役 100 年，届时，必定思想麻木、肉体腐败，船员的一部分也将成为船体的一部分。
一天，船员 系带王 Bill 因一个新来的家伙而和船长 Jones 赌博起来。赌的方法是扑克。不同于我们平常 13 种数字牌的扑克 {A,2,3,…,10,J,Q,K} ，这种扑克一共有 n 种数字 {1,2,3,…,n} 。
为了简化问题，我们约定每个人只能出 “对子” (即两张数字一样的牌) 和 “顺子” (即三张数字相连的牌) 。
现已知 Bill 的所有牌，请问他最多可以出牌几次。
Input
输入包含多组测试数据，第一行为一个正整数 ? (1≤?≤10) 表示有 T 组测试数据。
对于每组测试数据，
第一行包含一个正整数 ? (1≤?≤105) 表示扑克有几种数字。
接下来一行包含 n 个正整数 ?? (0≤??≤109)，表示 Bill 有 ?? 张数字为的 i 的扑克。
Output
对于每组测试数据，
输出一行包含一个字符串表示结果，如果 Marty 可以买到某串金币，则输出 “YES” (不包含引号)；否则输出 “NO” (不包含引号)。

 解题思路：
　　本题可运用贪心的思想。将出“对子”称为操作1，“顺子”为操作2。不难发现，除了11211这种情况外，优先操作1必定不会有亏损。因此当某种牌的数量大于2时，优先进行操作2，这样最后我们能得到一个最大值为2的序列。
　　然后我们便要排除11211此种情况。我们又能想到当出现“11*”此种情况时，优先操作2也必定不会有亏损，且对后续操作无后效性。这样我们便得到了贪心的策略：先对所有数量大于2的牌进行操作1，得到一个数量最大为2的序列，然后对序列顺序处理，出现“11*”执行操作2，其余执行操作1。

#include 
#include 
long long ans;
int a[100005],N;
int main(void){
	int T;scanf("%d",&T);
	while(T--){
		scanf("%d",&N);
		ans=0;
		for(int i=0;i

 本题小结：
　比赛中看到本题我首先想到的是用dp，但是却找不到合适的状态，因此放弃了。比赛结束后突然想到本题好像可以贪心，于是尝试了一下，但是我才疏学浅，没有想到如何用数学方法严格地证明贪心的结论，以后有空会再尽力尝试一下。

 
 

 　　　　　　　　　　　　　　　　　　Problem G. 喵星网络赛
Time limit: 1000 ms
Memory limit: 256 MB
Input file: standard input
Output file: standard output
在遥远的喵星文明中，一天被划分为 n 小时。
因此，喵星被划分为 n 个时区， 相邻时区的时差为 1 小时。也就是说，当第 1 个时区的时间为 1:00 时，第 2 个时区的时间就为 2:00 ， …… ， 第 n 个时区的时间为 n:00 。
对于每个时区的喵星人来说，他们只会在当地的 2 点到 F 点之间活动（即从 S:00 开始， F:00 结束）。
喵星打算举办一场时长 1 小时的程序设计网络赛，从整点开始，已知第 i 个时区有 ?? 只喵星人，请问什么时候开始，能够参加比赛的喵星人的数量最多？ 输出答案为第 1 个时区的当地时间。
Input
输入包含多组测试数据，第一行为一个正整数 ? (1≤?≤30) 表示有 T 组测试数据。
对于每组则测试数据，
第一行为一个正整数 ? (2≤?≤105) ，代表喵星一天有 n 个小时，被划分为 n 个时区；
第二行有 n 个数， 第 i 个数为 ?? (1≤??≤104) ，代表第 i 个时区有 ?? 只喵星人。
第三行输出两个整数 S 和 F (1≤?≤?≤?) ， 代表每个时区喵星人的活动时间。
Output
对于每个测试数据,
输出一行包含一个整数，表示在第 1 时区下，使能够参加比赛的喵星人数最多的比赛开始的整点时间。
0:00 用 n:00 表示。

 解题思路：
　　本题可先将每个时区的时间都转换为第1个时区的时间，转换公式为：第i个时区的t点等于第一个时区的(t-i+n)%n+1点。然后将每个时区的活动时间转换为第一个时区的时间，得到S[i]和F[i]，便容易看出此题是一个区间叠加类的问题。
　　因为活动时间的区间都是连续的，所以可用f[i]表示从S[i]开始活动的总人数。令φ=S-F-1,则f[i]=sum(a[i],a[i+φ])，S>F。当f[i]最大时对应的S[i]即为答案。
　　当S=F时，去答案为1。
　　处理sum时，可用一维数组sum[i]表示从第1个时区到第i个时区的人数和，节省时间空间。
　　复杂度O(N)。

#include 
#include 
#include 
int a[100005],f[100005];
int	S,F,n,sum[100005];
int main(void){
	int T;scanf("%d",&T);
	while(T--){
		scanf("%d",&n);
		for(int i=1;i<=n;++i) scanf("%d",&a[i]),sum[i]=sum[i-1]+a[i];
		scanf("%d%d",&S,&F);
		if(S==F) puts("1");
		else{
			int t=F-S-1;
			for(int i=1;i<=n;++i)
				if(i+t<=n) f[i]=sum[i+t]-sum[i-1];
				else
					f[i]=sum[(i+t+n-1)%n+1]+sum[n]-sum[i-1];
			int p,m=0;
			for(int i=1;i<=n;++i)
				if(f[i]>m) p=i,m=f[i];				
			printf("%d\n",(S-p+n)%n+1);			
		}
	}
	return 0;
}

 本题小结：
　本题若说难度，主要就是题目读起来比较绕，比赛时读着读着就晕了，根本没有好好思考过。不过本题理解了之后做并不复杂。

 
 

 　　　　　　　　　　　　　　　　　　　Problem H. N桥问题
Time limit: 1000 ms
Memory limit: 128 MB
Input file: standard input
Output file: standard output
X 开车来到了一条河边，河上有 n 座互相平行的桥。 X 想按照指定的顺序通过所有的桥仅一次，但是又不想让陆上的车辙印交叉（过第一个桥前的车辙不算）。假设陆地平坦，面积无限大，车的大小和形状不计。 X 想知道对于给定的过桥顺序，他能否达成这样的目标。
Input
输入包含多组测试数据，第一行为一个正整数 ? (1≤?≤10) 表示有 T 组测试数据。
对于每组则测试数据，
第一行包含一个正整数 ? (1≤?≤106) 表示桥的数量，
第二行包含 n 个互不相同的整数 ?? (1≤??≤?), 表示第 i 个桥需要第 ?? 个通过。
数据保证所有 n 的和不超过 106。
Output
对于每个测试数据，
输出一行表示答案，如果 X 能按照这样的次序通过，输出 “Yes” (不包含引号)，否则输出 “No” (不包含引号)。
 解题思路：
　　咳咳，，，，，还没做出来。

 
 

  　　　　　　　　　　　　　　　　　　Problem I. Array
Time limit: 1000 ms
Memory limit: 128 MB
Input file: standard input
Output file: standard output
一个数列 A ，长度为 n ，编号从左至右为 1…n ，为了满足某种特定的规律， ?? 不超过 k ，且大于 1 。
现在有两种操作。
1、代表将整个数列的值加 1 ，即 ?? = ??%?+1 。
2、查询区间 [?,?] 中值为 X 的个数。
Input
输入包含多组测试数据，第一行为一个正整数 ? (1≤?≤5) 表示有 T 组测试数据。
对于每组则测试数据，
第一行三个数 ? (1≤?≤105), ? (1≤?≤20) 和 ? (1≤?≤105) ，代表数组长度，值的上限和询问的次数。
第二行包含 n 个数代表 ?? 的值。
接下来有 q 行有 q 次操作。
1 代表 操作1 。
2 l r x 代表 操作2 。
Output
对于每次询问输出所求值。

 解题思路：
　　本题考察内容也较为简单，主要考察计算数组中某一区间某数的个数。为了节省时间和空间可用一个二维数组sum[i][k]表示从i到N区间中k的个数。对任一区间[i,j]，num(k)=sum[i][k]-sum[j+1][k]。k最大为20，因此复杂度O(N)。
　　需要注意的地方是对操作1的记录：只需要记录操作1的次数t，最后查询时的原始值为(x-t+k-1)%k+1。

#include 
#include 
#include 
#include 
#include 
using namespace std;
int k,q,N,a[100005];
int sum[100005][21];		//sum[i][j]= <从0到i数组中j的个数> 
int main(void){
	int T;scanf("%d",&T);
	while(T--){
		scanf("%d%d%d",&N,&k,&q);
		for(int i=0;i<=k;++i) sum[N][i]=0;
		for(int i=0;i=0;--i)
			for(int j=1;j<=k;++j)
				if(a[i]!=j)	sum[i][j]=sum[i+1][j];
				else sum[i][j]=sum[i+1][j]+1;
		
		int num=0;			//操作1的次数
		for(int i=0,op;i

 本题小结：
　本题没有什么难点，思路也很自然。但是在比赛时不知道为什么，处理sum数组时用了顺序处理：复杂度O(N^2)？？？所以妥妥的TLE。可能果真是太紧张了，做题时完全没有进行思考。需要好好反思。