Beyond the Void » Treap http://www.byvoid.com/blog Tue, 29 Jun 2010 08:44:46 +0000 en hourly 1 http://wordpress.org/?v=3.0 NOI 2009 二叉查找树 http://www.byvoid.com/blog/noi-2009-treapmod/ http://www.byvoid.com/blog/noi-2009-treapmod/#comments Tue, 12 Jan 2010 12:38:55 +0000 BYVoid http://www.byvoid.com/blog/?p=1763 问题简述

有一棵Treap，每个节点有一个互不相同的数据值和权值，以及一个访问频度。一个节点的访问代价为它的访问频度乘以它在树中的深度，整棵树的访问代价定义为所有节点的访问代价之和。节点的权值可以修改为任意实数，每修改一个节点的权值的代价为K。任务是修改一些节点的权值，使得整棵树的访问代价与修改代价之和最小。

问题建模

首先离散化所有节点的权值，对所有节点按照数据值排序后线性存储。定义S[i,j]为(排序后)第i个节点到第j个节点的访问频度之和。

解法 动态规划

算法描述

定义Weight[i]为状态转移方程为第i个节点离散化后的权值，F[i,j,w]表示从第i个节点到第j个节点组成一棵子树的最小代价，子树根节点的权值≥w。状态转移方程为

clip_image002

边界条件为clip_image004，目标函数为clip_image006。

算法分析

对于一个状态F[i,j,w]，我们要枚举从节点[i..j]组成的这棵子树的根节点k，其左子树为[i..k-1]，右子树为[k+1..j]。

如果根节点k的权值Weight[k]≥w，那么节点k的权值无需修改即可直接作为该子树的根节点。总代价为左子树的代价F[i,k-1, Weight[k]]，加上右子树的代价F[k+1,j, Weight[k]]，以及整个子树的访问频度之和。

另外一种情况，修改节点k的权值，使之不小于w。由于我们已经离散化了权值，修改后的权值不应是整数，以免和已有重复。假设节点k修改后的权值为w加上一个很小的小数，其左右子树根节点的权值都不应小于节点k修改后的权值。我们约定如果根和子节点都必须大于w的话，则子节点的权值比根节点略大，且大于w。于是这种情况的总代价为左子树的代价F[i,k-1, w]，加上右子树的代价F[k+1,j, w]，加上修改权值的代价K，以及整个子树的访问频度之和。

复杂度分析

状态数为O(N3)，每次转移需要以O(N)的时间枚举k，所以时间复杂度为O(N4)。在实际测试中通过了所以测试点，得到100分。

参考程序
?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

/* 
 * Problem: NOI2009 treapmod
 * Author: Guo Jiabao
 * Time: 2009.9.24 14:50
 * State: Solved
 * Memo: 动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
 
typedef long long big;
 
const int MAXN = 72;
const big INF = ~0ULL>>1;
 
struct node
{
	int val,wei,freq;
}P[MAXN];
 
int N,K;
big sf[MAXN],F[MAXN][MAXN][MAXN],Ans=INF;
 
void init()
{
	int i;
	freopen("treapmod.in","r",stdin);
	freopen("treapmod.out","w",stdout);
	scanf("%d%d",&N,&K);
	for (i=1;i<=N;i++)
		scanf("%d",&P[i].val);
	for (i=1;i<=N;i++)
		scanf("%d",&P[i].wei);
	for (i=1;i<=N;i++)
		scanf("%d",&P[i].freq);
	memset(F,-1,sizeof(F));
}
 
inline int cmp1(const void *a,const void *b)
{
	return ((node *)a) -> wei - ((node *)b) -> wei;
}
 
inline int cmp2(const void *a,const void *b)
{
	return ((node *)a) -> val - ((node *)b) -> val;
}
 
inline big sum(int i,int j)
{
	return sf[j] - sf[i-1];
}
 
big dp(int i,int j,int w)
{
	if (i>j)
		return 0;
	if (F[i][j][w] == -1)
	{
		int a;
		big t,rs=INF;
		for (a=i;a<=j;a++)
		{
			t = dp(i,a-1,w) + dp(a+1,j,w) + sum(i,j) + K;
			if (t < rs)
				rs = t;
			if (P[a].wei >= w)
			{
				t = dp(i,a-1,P[a].wei) + dp(a+1,j,P[a].wei) + sum(i,j);
				if (t < rs)
					rs = t;
			}
		}
		F[i][j][w] = rs;
	}
	return F[i][j][w];
}
 
void solve()
{
	int i;
	qsort(P+1,N,sizeof(P[0]),cmp1);
	for (i=1;i<=N;i++)
		P[i].wei = i;
	qsort(P+1,N,sizeof(P[0]),cmp2);
	for (i=1;i<=N;i++)
	{
		P[i].val = i;
		sf[i] = sf[i-1] + P[i].freq;
	}
	for (i=0;i<=1;i++)
	{
		big t = dp(1,N,i);
		if (t < Ans)
			Ans = t;
	}
}
 
int main()
{
	init();
	solve();
	cout << Ans << endl;
	return 0;
}

Maybe you like

]]> http://www.byvoid.com/blog/noi-2009-treapmod/feed/ 4 NOI 2001 解题报告 http://www.byvoid.com/blog/noi-2001-solution/ http://www.byvoid.com/blog/noi-2001-solution/#comments Sat, 21 Mar 2009 09:31:06 +0000 BYVoid http://www.byvoid.com/blog/?p=982 NOI2001的题目是[反正切函数的应用][聪明的打字员][陨石的秘密][食物链][炮兵阵地][方程的解数]。

其中[反正切函数的应用][聪明的打字员]较为简单，[陨石的秘密][食物链][炮兵阵地][方程的解数]稍有难度。

[反正切函数的应用]是一个求函数最值的问题，要配合数学知识解决。[聪明的打字员]是广度优先搜索问题。[陨石的秘密]是一个树形动态规划的问题，需要仔细思考。[食物链]用到了并差集。[  炮兵阵地]是个不易看出的动态规划问题。[方程的解数]是搜索问题，需要用哈希表来优化。

[反正切函数的应用]

根据题中公式，可以推出 a=(b*c-1)/(b+c)。由此得出c=(a*b+1)/(b-a)。因为b,c均为正整数，所以b>a。

我们要求b+c最小，设函数y=f(x)，自变量x为b的取值，但不限于正整数。则有

  • f(x) = (a*x+1)/(x-a) + x = a + ((1+a^2)/(x-a)) + x

对f(x)求导，得导数

  • f’(x)=1-(1+a^2)/(x-a)^2

f’(x)=0 得出 x = a+(a^2+1)^0.5 或 x = a-(a^2+1)^0.5，由于x>0，取 x = a+(a^2+1)^0.5。

且x > a+(a^2+1)^0.5时，f’(x)>0，x < a+(a^2+1)^0.5时，f’(x)<0，所以当x = a+(a^2+1)^0.5时，f(x)取得最小值。

由于b和c都是正整数，只需在x一边寻找距离x最近的整数b,c，b+c即要求的最小值。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

/*
 * Problem: NOI2001 arctan
 * Author: Guo Jiabao
 * Time: 2009.3.21 14:18
 * State: Solved
 * Memo: 函数最值问题
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
using namespace std;
int a,b,c,Ans=0x7FFFFFFF;
int main()
{
	freopen("arctan.in","r",stdin);
	freopen("arctan.out","w",stdout);
	scanf("%d",&a);
	double t=ceil(a+sqrt((double)a*a+1));
	for (;;t--)
	{
		b=(int)(t+0.1);
		long long q=a;
		q=q*b+1;
		if (q%(b-a)==0)
		{
			c=q/(b-a);
			Ans=b+c;
			break;
		}
	}
	printf("%d\n",Ans);
	return 0;
}

[聪明的打字员]

简单的广搜题，对于每个状态，直接按照规则扩展6状态，开一个哈希表判重，直到搜索到结果为止。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

/*
 * Problem: NOI2001 clever
 * Author: Guo Jiabao
 * Time: 2009.3.17 13:37
 * State: Solved
 * Memo: BFS
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int LIM=1000000;
using namespace std;
struct state
{
	int s,step,pos;
};
bool used[LIM][7];
int S,T;
int Q_size,Q_head,Q_tail;
state Q[LIM];
state start;
void init()
{
	freopen("clever.in","r",stdin);
	freopen("clever.out","w",stdout);
	scanf("%d%d",&S,&T);
	start.s=S;
	start.pos=1;
	start.step=0;
	Q_head=-1;Q_tail=0;Q_size=0;
}
void Answer(int ans)
{
	printf("%d\n",ans);
	exit(0);
}
void Q_ins(state p)
{
	if (used[p.s][p.pos]) return;
	used[p.s][p.pos]=true;
	if (p.s==T) Answer(p.step);
	Q_size++;
	if (++Q_head==LIM) Q_head=0;
	Q[Q_head]=p;
}
state Q_pop()
{
	state r=Q[Q_tail];
	Q_size--;
	if (++Q_tail==LIM) Q_tail=0;
	return r;
}
void BFS()
{
	state u,v;
	int pos[7],su,sv,tim,p,i;
	Q_ins(start);
	while (Q_size)
	{
		u=Q_pop();
		su=sv=u.s;
		p=u.pos;
		tim=LIM;
		for (i=1;i<=p;i++)
			tim/=10;
		for (i=6;i>=1;i--)
		{
			pos[i]=sv%10;
			sv/=10;
		}
		if (p>1) //swap0
		{
			sv=su;
			sv-=100000*pos[1] + tim*pos[p];
			sv+=tim*pos[1] + 100000*pos[p];
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (p<6) //swap1
		{
			sv=su;
			sv-=pos[6] + tim*pos[p];
			sv+=tim*pos[6] + pos[p];
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (pos[p]!=9) //up
		{
			sv=su;
			sv+=tim;
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (pos[p]!=0) //down
		{
			sv=su;
			sv-=tim;
			v.pos=u.pos;
			v.step=u.step+1;
			v.s=sv;
			Q_ins(v);
		}
		if (p>1) //left
		{
			v.s=u.s;
			v.pos=u.pos-1;
			v.step=u.step+1;
			Q_ins(v);
		}
		if (p<6) //right
		{
			v.s=u.s;
			v.pos=u.pos+1;
			v.step=u.step+1;
			Q_ins(v);
		}
	}
}
int main()
{
	init();
	BFS();
	return 0;
}

[陨石的秘密]

容易看出是动态规划，但是状态转移方程容易考虑不周全。

题目中样例的8种方案为

{[]()} {()[]} {}[()] [()]{} []{()} {()}[] (){[]} {[]}()

可以看出每个SS表达式都可以看成由几个小的SS组成，组成方式可能是嵌套或者连接。如果是嵌套（包括仅1层），我们把这个嵌套体看作一个整体部分，称为一个组。则每个SS表达式都是由几个组连接而成了。

设定 F[p1,p2,p3,d]为深度不超过d，包含p1个{}，p2个[],p3个()的SS表达式的可能组成的方案数。S[p1,p2,p3,d]为深度不超过d，包含p1个{}，p2个[],p3个()的一个组的可能组成的方案数。

则状态转移方程为

S[p1,p2,p3,d]=
{
	0 (p1==p2==p3==0)
	F[p1-1,p2,p3,d-1] (p1>=1)
	F[p1,p2-1,p3,d-1] (p1==0 && p2>=1)
	F[p1,p2,p3-1,d-1] (p1==0 && p2==0 && p3>=1)
}

F[p1,p2,p3,d]=Σ(S[x1,x2,x3,d]*F[p1-x1,p2-x2,p3-x3,d]) (0<=x1<=p1,0<=x2<=p2,0<=x3<=p3且x1,x2,x3不同时为0)

初始条件

  • F[0,0,0,i]=1 (0<=i<=D)

最终的结果就是

  • F[L1,L2,L3,D]-F[L1,L2,L3,D-1]
?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68

/* 
 * Problem: NOI2001 secret
 * Author: Guo Jiabao
 * Time: 2009.3.18 13:54
 * State: Solved
 * Memo: 动态规划
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXL=11,MAXD=31,MOD=11380;
using namespace std;
int L1,L2,L3,D,Ans;
int F[MAXL][MAXL][MAXL][MAXD];
int single(int p1,int p2,int p3,int d);
int dp(int p1,int p2,int p3,int d);
void init()
{
	freopen("secret.in","r",stdin);
	freopen("secret.out","w",stdout);
	scanf("%d%d%d%d",&L1,&L2,&L3,&D);
	int p1,p2,p3,d;
	for (d=0;d<=D;d++)
	{
		for (p1=0;p1<=L1;p1++)
			for (p2=0;p2<=L2;p2++)
				for (p3=0;p3<=L3;p3++)
					F[p1][p2][p3][d]=-1;
		F[0][0][0][d]=1;
	}
}
int single(int p1,int p2,int p3,int d)
{
	if (p1>=1)
		return dp(p1-1,p2,p3,d-1);
	else if (p1==0 && p2>=1)
		return dp(p1,p2-1,p3,d-1);
	else
		return dp(p1,p2,p3-1,d-1);
}
int dp(int p1,int p2,int p3,int d)
{
	if (d<0) return 0;
	if (F[p1][p2][p3][d]==-1)
	{
		int x1,x2,x3,y1,y2,y3;
		F[p1][p2][p3][d]=0;
		for (x1=0;x1<=p1;x1++)
			for (x2=0;x2<=p2;x2++)
				for (x3=0;x3<=p3;x3++)
				{
					y1=p1-x1;y2=p2-x2;y3=p3-x3;
					if (x1+x2+x3==0) continue;
					F[p1][p2][p3][d]+=single(x1,x2,x3,d)*dp(y1,y2,y3,d)%MOD;
					F[p1][p2][p3][d]%=MOD;
				}
	}
	return F[p1][p2][p3][d];
}
int main()
{
	init();
	Ans=(dp(L1,L2,L3,D)-dp(L1,L2,L3,D-1)+MOD)%MOD;
	printf("%d\n",Ans);
	return 0;
}

[食物链]

这道题真是个并差集的典型应用问题。由于判断真假总是根据前面得到的关系，在某时关系不是完全的，所以不能直接判断a,b究竟是哪个物种，但是可以知道部分的关系。

很显然，合法的关系都是三角形环，如果a,b同属于一个环内，那么它们的关系是可以直接判断的。如果不属于同一环，因为不与前面矛盾，就认 为是正确的，然后把a,b所在的两个环合并。建立一个并差集，表示每个生物所属的物种类型。对于物种i，定义prev[i]为可以吃掉i的物种类 型，next[i]为i可以吃掉的物种类型。初始时，每个物种i对应一个单独的类型，并且引入两个虚节点prev[i]和next[i]，可分别为一个单 独的类型。

合并两个环时，对于D=1，a与b为同一物种，分别把(a,b),(prev[a],prev[b]),(next[a],next[b])依次合并。

对于D=2，a可以吃掉b，则分别把(next[a],b),(a,prev[b]),(prev[a],next[b])依次合并。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

/* 
 * Problem: NOI2001
 * Author: Guo Jiabao
 * Time: 2009.3.13 13:28
 * State: Solved
 * Memo: 并差集 等价类判断
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=50001;
struct UFS
{
	int f[MAXN*3];
	int getroot(int a)
	{
		int t,r=a;
		while (f[r]!=r) r=f[r];
		while (f[a]!=a) {t=f[a];f[a]=r;a=t;}
		return r;
	}
	bool judge(int a,int b){return getroot(a)==getroot(b);}
	void merge(int a,int b){f[getroot(b)]=getroot(a);}
}U;
using namespace std;
int N,M,Fake;
int prev[MAXN*3],next[MAXN*3];
void init()
{
	int i,p,n;
	freopen("eat.in","r",stdin);
	freopen("eat.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		p=N+i;n=p+N;
		U.f[i]=i;U.f[p]=p;U.f[n]=n;
		prev[i]=p;next[i]=n;prev[n]=i;
		next[n]=p;prev[p]=n;next[p]=i;
	}
}
bool relation(int d,int a,int b)
{
	if (d==1)
	{
		if (U.judge(a,b))
			return true;
		if (U.judge(prev[a],b) || U.judge(next[a],b))
			return false;
		U.merge(a,b);
		U.merge(prev[a],prev[b]);
		U.merge(next[a],next[b]);
	}
	else
	{
		if (U.judge(next[a],b))
			return true;
		if (U.judge(a,b) || U.judge(prev[a],b))
			return false;
		U.merge(next[a],b);
		U.merge(a,prev[b]);
		U.merge(prev[a],next[b]);
	}
	return true;
}
void solve()
{
	int i,d,a,b;
	for (i=1;i<=M;i++)
	{
		scanf("%d%d%d",&d,&a,&b);
		if (a>N || b>N || (d==2 && a==b) ||!relation(d,a,b))
			Fake++;
	}
}
int main()
{
	init();
	solve();
	printf("%d\n",Fake);
	return 0;
}

[炮兵阵地]

较难看出的动态规划问题。注意到数据范围N≤100；M≤10，发现每行的宽度都不大，所以可以考虑把一行看成一个状态，表示该行的布置方案。每行的布置方案可以预先处理出，由数学知识可以算出，每行最多的布置方案数也不过60个而已。

状态设定

F[i,a,b]为前i行，第i行的方案为A[a]，第i-1行的方案为A[b]的最大炮兵数。

状态转移方程

  • F[i,a,b]=Max{ F[i-1,b,c] + P[a] }

其中c为i-2行的布置方案，a,b,c应保证互不冲突，即放置方案中炮兵都在平地上，且不会互相攻击到。

目标结果

  • Ans=Max{F[N,a,b]}
?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

/* 
 * Problem: NOI2001 cannon
 * Author: Guo Jiabao
 * Time: 2009.3.20 17:54
 * State: Solved
 * Memo: 动态规划 位表示状态
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=101,MAXM=11,MAXA=61;
using namespace std;
int N,M,Ans,AC;
bool used[MAXN];
int F[MAXN][MAXA][MAXA];
int A[MAXA],C[MAXA],Pla[MAXN];
void init()
{
	int i,j;
	char c;
	freopen("cannon.in","r",stdin);
	freopen("cannon.out","w",stdout);
	scanf("%d%d",&N,&M);
	for (i=1;i<=N;i++)
	{
		do c=getchar(); while(c==10 || c==13);
		ungetc(c,stdin);
		Pla[i]=0;
		for (j=1;j<=M;j++)
			if ((c=getchar())=='H')
				Pla[i]+=1<<(j-1);
	}
}
inline int Max(int a,int b)
{
	return a>b?a:b;
}
void dynamic()
{
	int i,j,k,l,x,y,z,p,q;
	for (i=2,j=1;j<=AC;j++)
	{
		x=A[j];
		p=C[j];
		if ((x&Pla[1])==0)
		for (k=1;k<=AC;k++)
		{
			y=A[k];
			q=C[k];
			if ((y&Pla[i])==0 && (x&y)==0)
				F[i][k][j]=p+q;
			if (F[i][j][k] > Ans)
				Ans = F[i][j][k];
		}
	}
	for (i=3;i<=N;i++)
	{
		for (j=1;j<=AC;j++)
		{
			x=A[j];	p=C[j];
			if ((x&Pla[i])==0)
				for (k=1;k<=AC;k++)
				{
					y=A[k];
					if ((y&Pla[i-1])==0 && (x&y)==0)
						for (l=1;l<=AC;l++)
						{
							z=A[l];
							if ((z&Pla[i-2])==0 && ((y|z)&x)==0)
								F[i][j][k]=Max(F[i][j][k],F[i-1][k][l] + p);
						}
					if (F[i][j][k] > Ans)
						Ans = F[i][j][k];
				}
		}
	}
}
void arrange(int p)
{
	if (p>M)
	{
		int r=0,c=0;
		for (int i=1;i<=M;i++)
			if (used[i])
			{
				c++;
				r+=1<<(i-1);
			}
		AC++;
		A[AC]=r;
		C[AC]=c;
		return ;
	}
	used[p]=true;
	arrange(p+3);
	used[p]=false;
	arrange(p+1);
}
void solve()
{
	arrange(1);
	dynamic();
}
int main()
{
	init();
	solve();
	printf("%d\n",Ans);
	return 0;
}

[方程的解数]

经典的搜索问题，方法是搜索每个x的所有可能值[1,M]，判断符合条件的解的个数。但是对于N=6，搜索量高达11390625000000，显然会超时。

我们不妨把等式变形，对于N项，把后N/2项移到等式右边，则移过去的项的k值全部取相反数。对于左边剩下的N/2项，搜索x的所有可能 值，计算左边式子的值，并插入到哈希表中。然后再对于右边的N-2项，搜索x的所有可能值，计算左边式子的值，然后再哈希表中查找与之相等的值的个数，加 到结果上。

插入到哈希表时先把绝对值Mod一个大质数，我选的是4000037，然后挂链解决冲突。为了提高效率，在哈希表的每个位置上我都建立了一个Treap，这样解决冲突时就能更快得找到了。

做这道题起初我试图直接用一个Treap存储所有的算式可能值，但是这样做会超时。通过使用哈希表，使数据平均分布了许多。哈希表和平衡树，或者Trie树混合使用不失为一种解决冲突优秀的方法。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151

/* 
 * Problem: NOI2001 equation1
 * Author: Guo Jiabao
 * Time: 2009.3.21 16:15
 * State: Solved
 * Memo: 搜索 + Hash +Treap判重
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
const int MAXN=7,MAXM=151,MAXP=7,MOD=4000037;
const bool LEFT=true,RIGHT=false;
using namespace std;
struct TTreap
{
	struct Treap_node
	{
		Treap_node *left,*right;
		int value,weight,fix;
		Treap_node(int v):value(v),weight(1)
		{
			left=right=0;
			fix=rand();
		}
	};
	Treap_node *root;
	TTreap():root(0){}
	inline void rotate_left(Treap_node *&p)
	{
		Treap_node *q=p->right;
		p->right=q->left;
		q->left=p;
		p=q;
	}
	inline void rotate_right(Treap_node *&p)
	{
		Treap_node *q=p->left;
		p->left=q->right;
		q->right=p;
		p=q;
	}
	void insert(Treap_node *&p,int value)
	{
		if (!p)
			p=new Treap_node(value);
		else if (value == p->value)
			p->weight++;
		else if (value < p->value)
		{
			insert(p->left,value);
			if (p->left->fix < p->fix)
				rotate_right(p);
		}
		else
		{
			insert(p->right,value);
			if (p->right->fix < p->fix)
				rotate_left(p);
		}
	}
	int find(Treap_node *p,int value)
	{
		if (!p)
			return 0;
		else if (value == p->value)
			return p->weight;
		else if (value < p->value)
			return find(p->left,value);
		else
			return find(p->right,value);
	}
};
struct item
{
	int k,p,x;
}I[MAXN];
int N,LIM,Mid,Ans;
int POW[MAXM][MAXP];
TTreap Hash[MOD];
bool L;
void init()
{
	freopen("equation1.in","r",stdin);
	freopen("equation1.out","w",stdout);
	scanf("%d%d",&N,&LIM);
	Mid=N/2;
	for (int i=1;i<=N;i++)
	{
		scanf("%d%d",&I[i].k,&I[i].p);
		if (i>Mid)
			I[i].k=-I[i].k;
	}
	srand(9112);
}
inline int power(int x,int p)
{
	if (!POW[x][p])
	{
		POW[x][p]=1;
		for (int i=1;i<=p;i++)
			POW[x][p]*=x;
	}
	return POW[x][p];
}
int compute(int a,int b)
{
	int rs=0,i;
	for (i=a;i<=b;i++)
		rs+=power(I[i].x,I[i].p)*I[i].k;
	return rs;
}
inline int Abs(int a) {return a<0?-a:a;}
void search(int e)
{
	int i,H;
	if (L && e>Mid )
	{
		i=compute(1,Mid);
		H=Abs(i)%MOD;
		Hash[H].insert(Hash[H].root,i);
	}
	else if (!L && e>N)
	{
		i=compute(Mid+1,N);
		H=Abs(i)%MOD;
		int a=Hash[H].find(Hash[H].root,i);
		Ans+=a;
	}
	else
		for (i=1;i<=LIM;i++)
		{
			I[e].x=i;
			search(e+1);
		}
}
void solve()
{
	L=LEFT;
	search(1);
	L=RIGHT;
	search(Mid+1);
}
int main()
{
	init();
	solve();
	printf("%d\n",Ans);
	return 0;
}

反正切函数的应用

Image:Arctan.gif

输入文件

输入文件中只有一个正整数a ，其中1<=a<=60000 。

输出文件

输出文件中只有一个整数，为b + c的值。
输入样例

1

输出样例

5

聪明的打字员

阿兰是某机密部门的打字员，她现在接到一个任务：需要在一天之内输入几百个长度固定为6的密码。当然，她希望输入的过程中敲击键盘的总次数越少越好。

不幸的是，出于保密的需要，该部门用于输入密码的键盘是特殊设计的，键盘上没有数字键，而只有以下六个键：Swap0, Swap1, Up, Down, Left, Right，为了说明这6个键的作用，我们先定义录入区的6个位置的编号，从左至右依次为1，2，3，4，5，6。下面列出每个键的作用：

  • Swap0：按Swap0，光标位置不变，将光标所在位置的数字与录入区的1号位置的数字（左起第一个数字）交换。如果光标已经处在录入区的1号位置，则按Swap0键之后，录入区的数字不变；
  • Swap1：按Swap1，光标位置不变，将光标所在位置的数字与录入区的6号位置的数字（左起第六个数字）交换。如果光标已经处在录入区的6号位置，则按Swap1键之后，录入区的数字不变；
  • Up：按Up，光标位置不变，将光标所在位置的数字加1（除非该数字是9）。例如，如果光标所在位置的数字为2，按Up之后，该处的数字变为3；如果该处数字为9，则按Up之后，数字不变，光标位置也不变；
  • Down：按Down，光标位置不变，将光标所在位置的数字减1（除非该数字是0），如果该处数字为0，则按Down之后，数字不变，光标位置也不变；
  • Left：按Left，光标左移一个位置，如果光标已经在录入区的1号位置（左起第一个位置）上，则光标不动；
  • Right：按Right，光标右移一个位置，如果光标已经在录入区的6号位置（左起第六个位置）上，则光标不动。

当然，为了使这样的键盘发挥作用，每次录入密码之前，录入区总会随机出现一个长度为6的初始密码，而且光标固定出现在1号位置上。当巧妙地使用上述六个特殊键之后，可以得到目标密码，这时光标允许停在任何一个位置。 现在，阿兰需要你的帮助，编写一个程序，求出录入一个密码需要的最少的击键次数。

输入文件

文件仅一行，含有两个长度为6的数，前者为初始密码，后者为目标密码，两个密码之间用一个空格隔开。

输出文件

文件仅一行，含有一个正整数，为最少需要的击键次数。

输入样例

123456 654321

输出样例

11

样例说明：

初始密码是123456，光标停在数字1上。对应上述最少击键次数的击键序列为：

Image:Clever.gif

最少的击键次数为11。

陨石的秘密

公元11380年，一颗巨大的陨石坠落在南极。于是，灾难降临了，地球上出现了一系列反常的现象。当人们焦急万分的时候，一支中国科学家组成的南极考察队赶到了出事地点。经过一番侦察，科学家们发现陨石上刻有若干行密文，每一行都包含5个整数：

1 1 1 1 6
0 0 6 3 57
8 0 11 3 2845

著名的科学家SS发现，这些密文实际上是一种复杂运算的结果。为了便于大家理解这种运算，他定义了一种SS表达式：

  1. SS表达式是仅由‘{’，‘}’，‘[’，‘]’，‘（’，‘）’组成的字符串。
  2. 一个空串是SS表达式。
  3. 如果A是SS表达式，且A中不含字符‘{’，‘}’，‘[’，‘]’，则(A)是SS表达式。
  4. 如果A是SS表达式，且A中不含字符‘{’，‘}’，则[A]是SS表达式。
  5. 如果A是SS表达式，则{A}是SS表达式。
  6. 如果A和B都是SS表达式，则AB也是SS表达式。

例如

  • ()(())[]
  • {()[()]}
  • {{[[(())]]}}

都是SS表达式。

而

  • ()([])()
  • [()

不是SS表达式。

一个SS表达式E的深度D(E)定义如下：

例如(){()}[]的深度为2。

密文中的复杂运算是这样进行的：

设密文中每行前4个数依次为L1，L2，L3，D，求出所有深度为D，含有L1对{}，L2对[]，L3对()的SS串的个数，并用这个数对当前的年份11380求余数，这个余数就是密文中每行的第5个数，我们称之为“神秘数”。

密文中某些行的第五个数已经模糊不清，而这些数字正是揭开陨石秘密的钥匙。现在科学家们聘请你来计算这个神秘数。

输入文件

共一行，4个整数L1，L2，L3，D。相邻两个数之间用一个空格分隔。（0≤L1≤10，0≤L2≤10，0≤L3≤10，0≤D≤30）

输出文件

共一行，包含一个整数，即神秘数。

输入样例

1 1 1 2

输出样例

8

食物链

动物王国中有三类动物A,B,C，这三类动物的食物链构成了有趣的环形。A吃B， B吃C，C吃A。

现有N个动物，以1－N编号。每个动物都是A,B,C中的一种，但是我们并不知道它到底是哪一种。

有人用两种说法对这N个动物所构成的食物链关系进行描述：

  • 第一种说法是“1 X Y”，表示X和Y是同类。
  • 第二种说法是“2 X Y”，表示X吃Y。

此人对N个动物，用上述两种说法，一句接一句地说出K句话，这K句话有的是真的，有的是假的。当一句话满足下列三条之一时，这句话就是假话，否则就是真话。

  1. 当前的话与前面的某些真的话冲突，就是假话；
  2. 当前的话中X或Y比N大，就是假话；
  3. 当前的话表示X吃X，就是假话。

你的任务是根据给定的N（1<=N<=50,000）和K句话（0<=K<=100,000），输出假话的总数。

输入文件

第一行是两个整数N和K，以一个空格分隔。

以下K行每行是三个正整数 D，X，Y，两数之间用一个空格隔开，其中D表示说法的种类。

  • 若D=1，则表示X和Y是同类。
  • 若D=2，则表示X吃Y。

输出文件

只有一个整数，表示假话的数目。

输入样例

输入文件

100 7
1 101 1
2 1 2
2 2 3
2 3 3
1 1 3
2 3 1
1 5 5

输出样例

3

样例说明

对7句话的分析

  • 1 101 1 假话
  • 2 1 2 真话
  • 2 2 3 真话
  • 2 3 3 假话
  • 1 1 3 假话
  • 2 3 1 真话
  • 1 5 5 真话

炮兵阵地

司令部的将军们打算在N*M的网格地图上部署他们的炮兵部队。一个N*M的地图由N行M列组成，地图的每一格可能是山地（用“H” 表示），也可能是平原（用“P”表示），如下图。在每一格平原地形上最多可以布置一支炮兵部队（山地上不能够部署炮兵部队）；一支炮兵部队在地图上的攻击 范围如图中黑色区域所示：

如果在地图中的灰色所标识的平原上部署一支炮兵部队，则图中的黑色的网格表示它能够攻击到的区域：沿横向左右各两格，沿纵向上下各两格。图上其它白色网格均攻击不到。从图上可见炮兵的攻击范围不受地形的影响。

现在，将军们规划如何部署炮兵部队，在防止误伤的前提下（保证任何两支炮兵部队之间不能互相攻击，即任何一支炮兵部队都不在其他支炮兵部队的攻击范围内），在整个地图区域内最多能够摆放多少我军的炮兵部队。

Image:Cannon.gif

输入文件

文件的第一行包含两个由空格分割开的正整数，分别表示N和M；

接下来的N行，每一行含有连续的M个字符（‘P’或者‘H’），中间没有空格。按顺序表示地图中每一行的数据。N≤100；M≤10。

输出文件

文件仅在第一行包含一个整数K，表示最多能摆放的炮兵部队的数量。

输入样例

5 4
PHPP
PPHH
PPPP
PHPP
PHHP

输出样例

6

方程的解数

问题描述

已知一个n元高次方程：

Image:Equation1.gif

其中：x1, x2, …,xn是未知数，k1,k2,…,kn是系数，p1,p2,…pn是指数。且方程中的所有数均为整数。

假设未知数1≤ xi ≤M, i=1,,,n，求这个方程的整数解的个数。

输入文件

文件的第1行包含一个整数n。第2行包含一个整数M。第3行到第n+2行，每行包含两个整数，分别表示ki和pi。两个整数之间用一个空格隔开。第3行的数据对应i=1，第n+2行的数据对应i=n。
输出文件

文件仅一行，包含一个整数，表示方程的整数解的个数。

输入样例

3
150
1 2
-1 2
1 2

输出样例

178

约束条件

1<=n<=6；1<=M<=150；

Image:Equation2.gif

方程的整数解的个数小于2^31。

★本题中，指数Pi(i=1,2,……,n)均为正整数。

Maybe you like

]]> http://www.byvoid.com/blog/noi-2001-solution/feed/ 3 Dynamic Rankings 动态排名系统 (zju 2112) http://www.byvoid.com/blog/zju-2112/ http://www.byvoid.com/blog/zju-2112/#comments Mon, 09 Feb 2009 11:59:33 +0000 BYVoid http://www.byvoid.com/blog/?p=853 解决这个和问题，需要用到“树套树”。建立一棵线段树，维护N的节点的所有区间，每个线段树节点上有一个平衡树，用来维护当前区间内所有数的动态排名。很显然，每个线段树节点上的平衡树，都是这个线段树节点的两个子节点的平衡树的合并。由于我们无法实现高效的平衡树合并，只好用这种以空间换时间的方法。

对于每个修改操作，只需先在线段树找出单位区间[i,i]上平衡树中的唯一节点，就是A[i]的原值，然后把线段树从根到该节点路径上所有节点的平衡树中都删除掉A[i]的原值，然后插入新值j。

查询操作为比较特殊，因为给定的区间[i,j]可能对应线段树中若干个区间的并，所以首先找出这对应的q区间的平衡树T[1],T[2],T[3],…,T[q]，找出其中的最大值Max和最小值Min，然后在[Min,Max]之间二分答案。对于给定的答案r，判断是符合要求，否则按照单调性缩小二分区间。

如何求给定的r值的总排名，由于r可能不在某些甚至所有的q个平衡树中，所以有时求r的排名是没有意义的，换而我们可以求r在所有平衡树中后继的最小值MinSucc的排名。对于第i个平衡树，要求r在T[i]中的后继(不大于r的最小值)的排名S[i]，MinSucc的排名就是k1=Σ{S[i]-1} + 1。但是相同的MinSucc的值可能会有多个，所以MinSucc的排名实际上是属于一个区间的，应在所有的平衡树中找出MinSucc一共的个数Count，MinSucc的最大排名就是k2=k1+Count-1。如果k属于[k1,k2]，那么结果就是MinSucc。如果k2<k，则应向增大的方向二分答案，否则向减小的方向二分答案。

代码很长，最后一句话，细节决定成败！

感谢slxg，正如你所说的，我写错了。现在错误已经修正。看来zju的数据还是不够强大，原来有点错的也能AC。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353

/* 
 * Problem: Zju2112 dynrank
 * Author: Guo Jiabao
 * Time: 2009.2.9 14:14
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
 
using namespace std;
 
struct treap_node
{
	treap_node *left,*right;
	int v,fix,size,weight;
	inline int lsize() {return left ?left ->size:0;}
	inline int rsize() {return right?right->size:0;}
};
 
struct sgt_node
{
	sgt_node *left,*right;
	int a,b;
	treap_node *treap;
};
 
const int MAXN=50001,MAXM=10001,INF=0x7FFFFFFF/2;
const int MAXTN=(MAXN+MAXM)*16,MAXSN=MAXN*2;
treap_node TS[MAXTN];
sgt_node SS[MAXSN];
int D,N,M,TC,SC,Tcnt;
sgt_node *sgt_root;
treap_node *T[MAXN];
 
inline treap_node* new_treap_node(int v)
{
	TS[++TC].v=v;
	TS[TC].left=TS[TC].right=0;
	TS[TC].size=TS[TC].weight=1;
	TS[TC].fix=rand();
	return &TS[TC];
}
 
inline void treap_rotate_right(treap_node *&p)
{
	treap_node *q=p->left;
	p->left=q->right;
	q->right=p;
	p=q;
	q=p->right;
	q->size=q->lsize() + q->rsize() +q->weight;
	p->size=p->lsize() + p->rsize() +p->weight;
}
 
inline void treap_rotate_left(treap_node *&p)
{
	treap_node *q=p->right;
	p->right=q->left;
	q->left=p;
	p=q;
	q=p->left;
	q->size=q->lsize() + q->rsize() +q->weight;
	p->size=p->lsize() + p->rsize() +p->weight;
}
 
int treap_find(treap_node *p,int v)
{
	if (!p)
		return 0;
	else if (v<p->v)
		return treap_find(p->left,v);
	else if (v>p->v)
		return treap_find(p->right,v);
	else
		return p->weight;
}
 
void treap_insert(treap_node *&p,int v)
{
	if (!p)
		p=new_treap_node(v);
	else
	{
		p->size++;
		if (v < p->v)
		{
			treap_insert(p->left,v);
			if (p->left->fix < p->fix)
				treap_rotate_right(p);
		}
		else if (v > p->v)
		{
			treap_insert(p->right,v);
			if (p->right->fix < p->fix)
				treap_rotate_left(p);
		}
		else
			p->weight++;
	}
}
 
void treap_delete(treap_node *&p) //real deletion
{
	if (p->left && p->right)
	{
		if (p->left->fix < p->right->fix)
		{
			treap_rotate_right(p);
			treap_delete(p->right);
		}
		else
		{
			treap_rotate_left(p);
			treap_delete(p->left);
		}
	}
	else
	{
		if (p->left)
			p=p->left;
		else
			p=p->right;
	}
}
 
void treap_delete(treap_node *&p,int v) //lazy deletion
{
	if (v==p->v)
	{
		p->weight--;
		p->size--;
		if (p->weight==0)
			treap_delete(p);
	}
	else
	{
		if (v < p->v)
			treap_delete(p->left,v);
		else
			treap_delete(p->right,v);
		p->size--;
	}
}
 
void treap_succ(treap_node *p,int v,int &rs)
{
	if (!p) return;
	if (p->v >= v)
	{
		rs=p->v;
		treap_succ(p->left,v,rs);
	}
	else
		treap_succ(p->right,v,rs);
}
 
int treap_getmin(treap_node *p)
{
	while (p->left)
		p=p->left;
	return p->v;
}
 
int treap_getmax(treap_node *p)
{
	while (p->right)
		p=p->right;
	return p->v;
}
 
void treap_rank(treap_node *p,int v,int cur,int &rank)
{
	if (v == p->v)
		rank=p->lsize() + cur + 1;
	else if (v < p->v)
		treap_rank(p->left,v,cur,rank);
	else
		treap_rank(p->right,v,p->lsize() + cur + p->weight,rank);
}
 
inline sgt_node* new_sgt_node()
{
	SS[++SC].treap=0;
	SS[SC].a=SS[SC].b=0;
	SS[SC].left=SS[SC].right=0;
	return &SS[SC];
}
 
void sgt_build(sgt_node *&p,int a,int b)
{
	p=new_sgt_node();
	if (a==b)
		p->a=p->b=a;
	else
	{
		int m=(a+b) >> 1;
		sgt_build(p->left,a,m);
		sgt_build(p->right,m+1,b);
		p->a=a;p->b=b;
	}
}
 
int sgt_edit(sgt_node *p,int k,int v,bool del)
{
	int delter=0;
	if (p->a==p->b)
	{
		if (del)
			delter=p->treap->v;
	}
	else
	{
		int m=(p->a+p->b) >> 1;
		if (k>=p->a && k<=m)
			delter=sgt_edit(p->left,k,v,del);
		else
			delter=sgt_edit(p->right,k,v,del);
	}
	if (del)
		treap_delete(p->treap,delter);
	treap_insert(p->treap,v);
	return delter;
}
 
void sgt_get(sgt_node *p,int a,int b)
{
	if (p->a==a && p->b==b)
		T[++Tcnt]=p->treap;
	else
	{
		int m=(p->a+p->b) >> 1;
		if (b<=m)
			sgt_get(p->left,a,b);
		else if (a>=m+1)
			sgt_get(p->right,a,b);
		else
		{
			sgt_get(p->left,a,m);
			sgt_get(p->right,m+1,b);
		}
	}
}
 
void init()
{
	int i,v;
	TC=SC=-1;
	sgt_root=0;
	scanf("%d%d",&N,&M);
	sgt_build(sgt_root,1,N);
	for (i=1;i<=N;i++)
	{
		scanf("%d",&v);
		sgt_edit(sgt_root,i,v,false); //non-deletion
	}
}
 
int check(int result,int k)
{
	int totalrankL,totalrankR,minsucc=INF;
	int i,rank,succ,totalrank=0,totalcount=0;
	for (i=1;i<=Tcnt;i++)
	{
		succ=INF;
		treap_succ(T[i],result,succ);
		if (succ==INF)
			rank=T[i]->size+1;
		else
			treap_rank(T[i],succ,0,rank);
		totalrank+=rank-1;
		if (succ < minsucc)
			minsucc=succ;
	}
	for (i=1;i<=Tcnt;i++)
		totalcount+=treap_find(T[i],minsucc);
	totalrankL=++totalrank;
	totalrankR=totalrank+totalcount-1;
	if (k>=totalrankL && k<=totalrankR)
	{
		printf("%dn",minsucc);
		return 0;
	}
	else if (totalrankL > k)
		return 1;
	else
		return -1;
}
 
void binary(int a,int b,int k)
{
	int Min=INF,Max=0,i,m,r;
	Tcnt=0;
	sgt_get(sgt_root,a,b);
	for (i=1;i<=Tcnt;i++)
	{
		m=treap_getmax(T[i]);
		if (m>Max)
			Max=m;
		m=treap_getmin(T[i]);
		if (m<Min)
			Min=m;
	}
	m=(Max+Min)>>1;
	do
	{
		r=check(m,k); //-1=smaller 1=bigger
		if (r<0)
		{
			Min=m;
			m=(m+Max+1)>>1;
		}
		else if (r>0)
		{
			Max=m;
			m=(Min+m)>>1;
		}
	}while (r!=0);
}
 
void request()
{
	int i,a,b,c,j=0;
	for (i=1;i<=M;i++)
	{
		do c=getchar(); while (c==10 ||c==13);
		if (c=='C')
		{
			scanf("%d%d",&a,&b);
			sgt_edit(sgt_root,a,b,true);
		}
		else
		{
			scanf("%d%d%d",&a,&b,&c);
			binary(a,b,c);
		}
	}
}
 
int main()
{
	freopen("dynrank.in","r",stdin);
	freopen("dynrank.out","w",stdout);
	scanf("%d",&D);
	for (int i=1;i<=D;i++)
	{
		init();
		request();
	}
	return 0;
}

我的转述

动态排名系统

[问题描述]
给定一个长度为N的已知序列A[i](1<=i<=N)，要求维护这个序列，能够支持以下两种操作：
1、查询A[i],A[i+1],A[i+2],…,A[j](1<=i<=j<=N)中，升序排列后排名第k的数。
2、修改A[i]的值为j。

所谓排名第k，指一些数按照升序排列后，第k位的数。例如序列{6,1,9,6,6}，排名第3的数是6，排名第5的数是9。

[输入格式]
第一行包含一个整数D(0<=D<=4)，表示测试数据的数目。接下来有D组测试数据，每组测试数据中，首先是两个整数N(1<=N<=50000),M(1<=M<=10000)，表示序列的长度为N，有M个操作。接下来的N个不大于1,000,000,000正整数，第i个表示序列A[i]的初始值。然后的M行，每行为一个操作
Q i j k 或者
C i j
分别表示查询A[i],A[i+1],A[i+2],…,A[j](1<=i<=j<=N)中，升序排列后排名第k的数，和修改A[i]的值为j。

[输出格式]
对于每个查询，输出一行整数，为查询的结果。测试数据之间不应有空行。

[样例输入]
2
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

[样例输出]
3
6
3
6

题目原貌

Dynamic Rankings

Time limit: 10 Seconds Memory limit: 65536K

The Company Dynamic Rankings has developed a new kind of computer that is no longer satisfied with the query like to simply find the k-th smallest number of the given N numbers. They have developed a more powerful system such that for N numbers a[1], a[2], …, a[N], you can ask it like : what is the k-th smallest number of a[i], a[i+1], …, a[j]? (For some i<=j, 0<k<=j+1-i that you have given to it). More powerful, you can even change the value of some a[i], and continue to query, all the same.

Your task is to write a program for this computer, which

- Reads N numbers from the input (1<=N<=50,000)

- Processes M instructions of the input (1<=M<=10,000). These instructions include querying the k-th smallest number of a[i], a[i+1], …, a[j] and change some a[i] to t.

Input

The first line of the input is a single number X (0<X<=4), the number of the test cases of the input. Then X blocks each represent a single test case.

The first line of each block contains two integers N and M, representing N numbers and M instruction. It is followed by N lines. The (i+1)-th line represents the number a[i]. Then M lines that is in the following format

Q i j k or
C i t

It represents to query the k-th number of a[i], a[i+1],…, a[j] and change some a[i] to t, respectively. It is guaranteed that at any time of the operation. Any number a[i] is a non-negative integer that is less than 1,000,000,000.

There’re NO breakline between two continuous test cases.

Output

For each querying operation, output one integer to represent the result. (i.e. the k-th smallest number of a[i], a[i+1],…, a[j])

There’re NO breakline between two continuous test cases.

Sample Input

2
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3
5 3
3 2 1 4 7
Q 1 4 3
C 2 6
Q 2 5 3

Sample Output

3
6
3
6

Author: XIN, Tao (chief editor), ZHU, Zeyuan (subeditor), PAN, Zhenhao (adviser)

Site: http://zhuzeyuan.hp.infoseek.co.jp/index.files/our_contest_20040619.htm

Maybe you like

]]> http://www.byvoid.com/blog/zju-2112/feed/ 7 POI 2001 Glodmine 金矿 http://www.byvoid.com/blog/poi-2001-kop/ http://www.byvoid.com/blog/poi-2001-kop/#comments Sat, 07 Feb 2009 09:26:45 +0000 BYVoid http://www.byvoid.com/blog/?p=849 发现坐标的范围很大，而点并不是很多，首先想到了离散化的方法。然后横向扫描每个带状的区间，对于每个带状区间，再纵向扫描其中点的个数。这种方法是最容易想到的，但是时间复杂度却高达O(N^2logN)。关键在于优化每次确定带状区间的纵向扫描。

显然对于确定的带状区间，我们扫描时只需考虑它们的纵坐标。如果我们把一个纵坐标为y的点描述成两个事件(y,1)和 (y+h+1,-1)，然后把所有事件按照第一关键字排序，定义S[i]为前i项事件的第二关键字之和，那么Max{S[i]}就是确定的带状区间内高度 为w的矩形最多覆盖到的点数。为什么是这样，我们可以想象有两个挡板，分别是y=A-h-1(下板)和y=A(上板)，从下向上移动挡板，从而确定一个矩 形。某个点的第一个事件为(y,1)，当上板A=y时，该点被覆盖，若A继续增大，使得A-h-1=y，该点就恰好离开了覆盖区域，反过来我们可以以为是 A=y+h+1，所以定义第二个事件为(y+h+1,-1)。这样，前i个事件的第二关键字和S[i]，就代表了矩形在某个位置时覆盖的点数。S[i]的 最大值就是确定的带状区间内最大的覆盖点数。

带状区间的左右扫描，也可以考虑成两个挡板之间的问题，首先确定挡板的初始位置在最左端，依次向右移动左右两个挡板。确定一个区间后，统 计点事件的最大前缀和成了最关键的问题。由于左右挡板是移动的，我们需要动态统计一个排序结构。于是我们想到了用平衡树，维护每个点事件的第一关键字(y 坐标)升序，并记录权。移动右挡板时，把右挡边新位置所在线上的所有点对应的两个点事件加入平衡树；移动左挡板时，把左挡板时，把左挡边所在线上的所有点 事件从平衡树中删除。

为了快速统计出最大的前缀和，在此基础上，我们还需要对于平衡树中每个节点维护其子树所有节点权值和，以及子树中最大的前缀和。定义p的权值为p.w，以节点p为根的子树的权值和为p.s，以节点p为根的子树的最大的前缀和为p.m，我们可以递推算出p.m的值。

p.m=Max{
	p.left.m; //最大前缀和的尾元素在左子树
	p.left.s+p.w; //最大前缀和的尾元素就是p
	p.left.s+p.w+p.right.m; //最大前缀和的尾元素在右子树
}

于是全部序列的最大前缀和就是根节点root.m。

于是得到的算法如下：

  1. 建立离散化坐标系;
  2. 左右扫描，确定带状区间，维护平衡树中节点;
  3. 统计对于确定带状区间，平衡树中元素最大的前缀和;

算法总的时间复杂度为O(NlogN)，可以解决问题了。编程中细节要注意，尤其是在于平衡树维护平衡性时要对节点m值重新计算。我用了 Treap，在插入一个点要旋转时，注意要先重新计算旋转到子树的点的m值，再计算子树根节点的m值。而删除仅仅懒惰删除即可，重要的是维护m值。

?View Code CPP
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194

/* 
 * Problem: POI2001 kop
 * Author: Guo Jiabao
 * Time: 2009.2.7 16:16
 * State: Solved
*/
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
 
using namespace std;
 
const int MAXN=15001;
struct point{int x,y;};
struct linknode{int s;linknode *next;};
class Treap_node
{
	public:
		Treap_node *left,*right;
		int fix,weight,sum,m,key;
		Treap_node(int tk,int w):key(tk),weight(w),sum(w),m(w){fix=rand();left=right=0;}
		inline int leftsum (){return left ?left ->sum:0;}
		inline int rightsum(){return right?right->sum:0;}
};
 
int H,W;//区域高度 宽度
int N,L,Lc=-1,MaxAns;
int D[MAXN];
point P[MAXN];
linknode LS[MAXN],*Line[MAXN];
Treap_node *Treap_root;
 
void Treap_Rotate_Right(Treap_node *&p)
{
	Treap_node *q=p->left;
	q->sum+=p->rightsum()+p->weight;
	p->sum=q->rightsum()+p->rightsum()+p->weight;
	p->left=q->right;
	q->right=p;
	p=q;
}
 
void Treap_Rotate_Left(Treap_node *&p)
{
	Treap_node *q=p->right;
	q->sum+=p->leftsum()+p->weight;
	p->sum=q->leftsum()+p->leftsum()+p->weight;
	p->right=q->left;
	q->left=p;
	p=q;
}
 
void Treap_maintain(Treap_node *&p)
{
	int lm,ls,rm;
	lm=ls=rm=0;
	if (p->left)
		lm=p->left->m,ls=p->left->sum;
	if (p->right)
		rm=p->right->m;
	p->m=lm;
	if (ls + p->weight > p->m)	p->m = ls + p->weight;
	if (ls + p->weight + rm > p->m) p->m=ls + p->weight + rm;
}
 
void Treap_edit(Treap_node *&p,int v,int delta)
{
	if (!p)
		p=new Treap_node(v,delta);
	else
	{
		if ( v < p->key )
		{
			p->sum+=delta;
			Treap_edit(p->left,v,delta);
			if (p->left && p->left->fix < p->fix)
			{
				Treap_Rotate_Right(p);
				Treap_maintain(p->right);
			}
			Treap_maintain(p);
		}
		else if ( v > p->key )
		{
			p->sum+=delta;
			Treap_edit(p->right,v,delta);
			if (p->right && p->right->fix < p->fix)
			{
				Treap_Rotate_Left(p);
				Treap_maintain(p->left);
			}
			Treap_maintain(p);
		}
		else
		{
			p->weight+=delta;
			p->sum+=delta;
			Treap_maintain(p);
		}
	}
}
 
void linktable_ins(linknode *&p,int v)
{
	if (p)
	{
		linknode *t=p;
		p=&LS[++Lc];
		p->next=t;
	}
	else
		p=&LS[++Lc];
	LS[Lc].s=v;
}
 
void init()
{
	freopen("kop.in","r",stdin);
	freopen("kop.out","w",stdout);
	scanf("%d%d%d",&W,&H,&N);
	for (int i=1;i<=N;i++)
		scanf("%d%d",&P[i].x,&P[i].y);
}
 
inline int cmp(const void *a,const void *b)
{
	return ((point *)a)->x - ((point *)b)->x;
}
 
void discrete() //离散化横坐标 建立链表
{
	int i,lastv=-1;
	qsort(P+1,N,sizeof(P[0]),cmp);
	L=0;
	for (i=1;i<=N;i++)
	{
		if (P[i].x!=lastv)
		{
			lastv=P[i].x;
			D[++L]=P[i].x;
			linktable_ins(Line[L],P[i].y);
		}
		else
			linktable_ins(Line[L],P[i].y);
	}
}
 
void RemoveLine(int p)
{
	for (linknode *k=Line[p];k;k=k->next)
	{
		Treap_edit(Treap_root,k->s,-1);
		Treap_edit(Treap_root,k->s+H+1,1);
	}
}
 
void AddLine(int p)
{
	for (linknode *k=Line[p];k;k=k->next)
	{
		Treap_edit(Treap_root,k->s,1);
		Treap_edit(Treap_root,k->s+H+1,-1);
	}
}
 
 
void scanx() //横向扫描 确定区间
{
	int Lb,Rb;
	AddLine(1);
	for (Lb=Rb=1;Rb<L && Lb<=L;)
	{
		while (Rb+1<=L && D[Rb+1]-D[Lb]<=W)
			AddLine(++Rb);
		if (Treap_root->m>MaxAns)
			MaxAns=Treap_root->m;
		RemoveLine(Lb++);
	}
}
 
void solve()
{
	discrete();
	scanx();
	printf("%d",MaxAns);
}
 
int main()
{
	init();
	solve();
	return 0;
}

金矿

问题描述

金矿的老师傅年底要退休了。经理为了奖赏他的尽职尽责的工作，决定在一块包含 n(n ≤ 15000) 个采金点的长方形土地中划出一块长度为 S ，宽度为 W 的区域奖励给他(1 ≤ s , w ≤ 10 000)。老师傅可以自己选择这块地的位置，显然其 中包含的采金点越多越好。你的任务就是计算最多能得到多少个采金点。如果一个采金点的位置在长方形的边上，它也应当被计算在内。

输入格式

输入文件的第一行有两个整数,中间用一个空格隔开，表示长方形土地的长和宽即s和w(1<=s,w<=10 000)。第二行有一个整数n(1<=n<=15 000)，表示金矿数量。下面的n行与金矿相对应，每行两个整数x和y (-30 000<=x,y<=30 000),中间用一个空格隔开，表示金矿的坐标。

输出格式

输出文件只有一个整数，表示选择的最大金矿的数。

输入样例

1 2
12
0 0
1 1
2 2
3 3
4 5
5 5
4 2
1 4
0 5
5 0
2 3
3 2

输出样例

4

Maybe you like

]]> http://www.byvoid.com/blog/poi-2001-kop/feed/ 2