2017.3.23考试

总述：

这场考试的题是数据结构的使用，最近学过线段树，二叉树排序树，平衡树以及伸展树。然后一看到题没怎么想就第一反应打版去了，没注意这棵树在这题里有什么实际的作用。手下很熟练地就写了splay和avl（因为最近写顺手了），然而事实上这几道题都不是这样做的，在遇到题目的时候应该先经过深思熟虑，而不是一走上来就想这道题是不是原题，是不是可以用xxx算法xxx数据结构上去套，每一种算法和数据结构都为一类具有共同特点的题目类型所服务的，可以完成一部分的需求（比如解题需要的某个数据），但并不一定直接就能出答案，而且个人觉得应该先理解题意，毕竟我总是臆想一些莫名的条件，所以做题还是要冷静。

第一题完全是傻，明明可以直接用线段树维护一个差值，然后向上更新就行，但是还是生拉硬拽地把splay给写上去了，写完之后又写wa了差值的更新，还暴力了一波差值，然后T掉。

第二题也可以用线段树做，暴力合并都是可以的，我，写了，树套树，线段树+splay，真的是厉害了，而且还在结构体里面疯一样地塞字符串，当时写了几个数据都过了，就觉得应该没什么，然后也没有自细地去算时间，所以T了，但是答案是对的我还是挺欣慰，T的真相是我没有只保存前11个，而是全部保存了，嗯然后gg了。

第三题我第一反应就是一道矩形树裸题，维护最小值和最大值就可以了，然后数组应该开到16*N*N，嗯于是我只开了16*N，特别尴尬，一直RE。后面改了数组之后，发现此题还有一个更坑的地方，1<=N<=250，而询问次数高达1000000，这很显然有很多重复的，再开一个数组记忆答案才可以过，嗯我没开然后每次都搜去了，TLE。

题目：

问题 A(2856): 原子核研究

时间限制: 1 Sec  内存限制: 128 MB

题目描述

最近物理学家正在研究一些新的原子，称为X族。他们发现该族中的元素非常相近，但是其质量都不相同。质量越接近的越容易相互转化。现在，物理学家已经发明了一种设备，可以对X族的元素来进行以下三种操作：
1.generate M 产生质量为M的一个元素，如果已经存在，则该操作不产生作用。
2.romove M 销掉质量为M的元素，如果不存在质量为M的元素，则该操作不产生作用。
3.query 查询X族中质量最接近的两种元素的质量差的绝对值。如果此时X族中的元素个数小于2，则输出-1.
现在，请你写一个程序来模拟该设备的操作。

输入

输入包含多组测试数据，第一行一个整数t，表示测试数据的组数。对于每一组数据，第一行是一个整数n，表示有n条指令。接下来n行，每行表示一条指令，如上所述。M是一个正整数，不超过100000.

输出

输出：对于每组测试数据，对于其中的每一个查询操作，都要输出一个结果。注意：每一组测试数据后要输出一个空行。

样例输入

1
12
generate 1
remove 2
generate 1
query
generate 7
query
generate 10
query
generate 5
query
remove 7
query

样例输出

-1
6
3
2
4

用线段树解，初始按数据的数值建树，用一个P数组保存分配到单点的位置，每次插入新数值直接访问到最下的叶子节点（有点像zkw树的思路），然后向上更新到根节点，删除也是从叶子节点开始访问，向上更新。ans是当前的最小差值，lc是当前小值，rc是当前大值，答案在根节点。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
using namespace std;
const int Max=100005;
struct node{
	int l,r,lc,rc,ans;
}Tr[Max*4];
int T,N,cnt;
int P[Max];
bool flag[Max];
int min(int a,int b){return a<b?a:b;}
void getint(int &num){
    char c;int flag=1;num=0;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;
    while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}
    num*=flag;
}
void build(int i,int l,int r){
	Tr[i].l=l,Tr[i].r=r;
	Tr[i].ans=Tr[i].lc=Tr[i].rc=Max;
	if(l==r){P[++cnt]=i;return ;}
	int mid=(l+r)>>1;
	build(i<<1,l,mid);
	build(i<<1|1,mid+1,r);
}
void change(int val){
	for( int pos=P[val]>>1; pos>0; pos>>=1){
		Tr[pos].ans=min(Tr[pos<<1].ans,Tr[pos<<1|1].ans);
		if(Tr[pos<<1].rc!=Max&&Tr[pos<<1|1].lc!=Max)
			Tr[pos].ans=min(Tr[pos].ans,Tr[pos<<1|1].lc-Tr[pos<<1].rc);
		Tr[pos].lc=Tr[pos<<1].lc;
		Tr[pos].rc=Tr[pos<<1|1].rc;
		if(Tr[pos].lc!=Max&&Tr[pos].rc!=Max&&Tr[pos].lc!=Tr[pos].rc)
			Tr[pos].ans=min(Tr[pos].ans,Tr[pos].rc-Tr[pos].lc);
		if(Tr[pos].lc==Max)
			Tr[pos].lc=Tr[pos].rc;
		if(Tr[pos].rc==Max)
			Tr[pos].rc=Tr[pos].lc;
	}
}
void insert(int val){
	Tr[P[val]].lc=Tr[P[val]].rc=val;
	change(val);
}
void dele(int val){
	Tr[P[val]].lc=Tr[P[val]].rc=Max;
	change(val);
}
int main(){
	getint(T);
	char ord[10];
	int x,in;
	while(T--){
		getint(N);
		in=cnt=0;
		memset(flag,0,sizeof(flag));
		build(1,1,Max);
		for(int i=1; i<=N; ++i){
			scanf("%s",ord);
			if(ord[0]=='g'){
				getint(x);
				if(!flag[x]){
					flag[x]=1;
					insert(x);
					++in;
				}
			}
			else if(ord[0]=='r'){
				getint(x);
				if(flag[x]){
					flag[x]=0;
					dele(x);
					--in;
				}
			}
			else {
				if(in<2)puts("-1");
				else printf("%d\n",Tr[1].ans);
			}
		}
		putchar(10);
	}
	return 0;
}

问题 B(2368): 球星

时间限制: 10 Sec  内存限制: 128 MB

题目描述

给出球星们的能力值、年份、名字，有很多个查询，每个查询给出一个年份的范围，求出这个范围里能力值从高到低排列的前11名球员，如果能力值相同则按年份从低到高排，如果年份仍然相同，则按名字的字典序排。如果不足11个球员，就用XXX代替输出凑够11行。

输入

输入数据：
第一行包含1个整数N（1<=N<=50000）,表示球星的总数，接下来N行，每行描述了1个球星（year,name,ability）。0<=year<=1000000000,name不超过15个字母，0<=ability<=1000000000.
假设没有两个人的名字相同。接下来有一个整数R，表示有R个查询。接下来R行，每行描述了一个产寻，每个查询包含2个整数（x,y）,表示从第x年到第y年。（0<=x<=y<=1000000000）

输出

输出数据：对于每组数据，按上面描述的顺序输出最靠前的11个球员的名字，每个球员占一行。如果不足11行，则用XXX代替，凑够11行。每组数据后都有一个空行。

样例输入

5
1 a 1
2 b 2
2 c 6
5 e 50
5 d 50
2
1 2
5 5

样例输出

c
b
a
XXX
XXX
XXX
XXX
XXX
XXX
XXX
XXX

d
e
XXX
XXX
XXX
XXX
XXX
XXX
XXX
XXX
XXX

同样是线段树，结构体中需要维护当前区间内11个球星的名字。按照年份建树，二分查找[l,r]在树中的最左边位置和最右边位置，然后每次合并的时候就暴力合并。注意最先找到的11个不能保证是答案，一定要找完整个区间，即使排序也不行，因为既然是按年份建树，那么ab值将成为第二关键字而非第一关键字，所以会wa的。还有，合并的时候注意细节。后来重做的时候一直都在报超时，检查很久都没有检查出来是什么原因，最后才发现，是因为我在查找最值的时候，当区间为包含关系时，更改全局变量后忘记了return导致递归继续而超时，这个问题已经不是第一次，感觉以后可能写代码的时候要慢一点，打漏这种东西真的很难找。

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<climits>
#define son1 (i<<2)-2
#define son2 (i<<2)-1
#define son3 (i<<2)
#define son4 (i<<2)+1
using namespace std;
const int Max=250;
const int MaxM=Max*Max*16;
struct node{
	int x1,y1,x2,y2;
	int xm,nm;
}Tr[MaxM];
int N,K,B,XM,NM;
int map[Max+5][Max+5];
int Ans[Max+5][Max+5];
void getint(int &num){
    char c;int flag=1;num=0;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;
    while(c>='0'&&c<='9'){num=num*10+c-48;c=getchar();}
    num*=flag;
}
int min(int a,int b){return a<b?a:b;}
int max(int a,int b){return a<b?b:a;}
void pushup(int i){
	Tr[i].nm=min(min(Tr[son1].nm,Tr[son2].nm),min(Tr[son3].nm,Tr[son4].nm));
	Tr[i].xm=max(max(Tr[son1].xm,Tr[son2].xm),max(Tr[son3].xm,Tr[son4].xm));
}
void build(int i,int x1,int y1,int x2,int y2){
	Tr[i].x1=x1,Tr[i].y1=y1;
	Tr[i].x2=x2,Tr[i].y2=y2;
	if(x1==x2&&y1==y2){
		Tr[i].nm=Tr[i].xm=map[x1][y1];
		return ;
	}
	int midx=(x1+x2)>>1,midy=(y1+y2)>>1;
	if(x1==x2){
		build(son1,x1,y1,x1,midy);
		build(son2,x1,midy+1,x1,y2);
		Tr[son3].nm=Tr[son4].nm=0x3f3f3f3f;
	}
	else if(y1==y2){
		build(son1,x1,y1,midx,y1);
		build(son3,midx+1,y1,x2,y1);
		Tr[son2].nm=Tr[son4].nm=0x3f3f3f3f;
	}
	else {
		build(son1,x1,y1,midx,midy);
		build(son2,x1,midy+1,midx,y2);
		build(son3,midx+1,y1,x2,midy);
		build(son4,midx+1,midy+1,x2,y2);
	}
	pushup(i);
}
void find_tr(int i,int x1,int y1,int x2,int y2){
	if(Tr[i].x2<x1||Tr[i].y2<y1)return ;
	if(Tr[i].x1>x2||Tr[i].y1>y2)return ;
	if(x1<=Tr[i].x1&&y1<=Tr[i].y1&&x2>=Tr[i].x2&&y2>=Tr[i].y2){
		XM=max(XM,Tr[i].xm);
		NM=min(NM,Tr[i].nm);
		return ;
	}
	find_tr(son1,x1,y1,x2,y2);
	find_tr(son2,x1,y1,x2,y2);
	find_tr(son3,x1,y1,x2,y2);
	find_tr(son4,x1,y1,x2,y2);
}
int main(){
	getint(N),getint(K),getint(B);
	for(int i=1; i<=N; ++i)
		for(int j=1; j<=N; ++j)
			getint(map[i][j]);
	build(1,1,1,N,N);
	int x,y;
	while(B--){
		getint(x),getint(y);
		NM=0x3f3f3f3f,XM=0;
		if(!Ans[x][y]){
			find_tr(1,x,y,x+K-1,y+K-1);
			Ans[x][y]=XM-NM;
		}
		printf("%d\n",Ans[x][y]);
	}
}