【bzoj3223】文艺平衡树
Description
您需要写一种数据结构(可参考题目标题),来维护一个有序数列,其中需要提供以下操作:翻转一个区间,例如原有序序列是5 4 3 2 1,翻转区间是[2,4]的话,结果是5 2 3 4 1
Input
第一行为n,m n表示初始序列有n个数,这个序列依次是(1,2……n-1,n) m表示翻转操作次数
接下来m行每行两个数[l,r] 数据保证 1<=l<=r<=n
Output
输出一行n个数字,表示原始序列经过m次变换后的结果
Sample Input
1 3
1 3
1 4
Sample Output
HINT
N,M<=100000
【题目分析】
模板题。维护rev标记。
下放标记的地方:$Merge(), Split()$
【CODE】
#include<iostream>
#include<cstdlib>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std; const int N = 1e5;
int n, m; struct node{
node *lc, *rc;
bool reverse;
int value, pri, size;
node(){}
node(const int &_v) : value(_v), lc(NULL), rc(NULL), pri(rand()), reverse(false) {}
inline node* update(){
size = (lc ? lc->size : ) + (rc ? rc->size : ) + ;
return this;
}
}tree[N], *root = NULL; inline void pushDown(node *u){
if(u->reverse){
if(u->lc) u->lc->reverse ^= ;
if(u->rc) u->rc->reverse ^= ;
swap(u->lc, u->rc);
u->reverse = false;
}
} inline node* Merge(node *u, node *v){
if(!u) return v;
if(!v) return u;
pushDown(u), pushDown(v);
if(u->pri < v->pri){
u->rc = Merge(u->rc, v);
return u->update();
}
else{
v->lc = Merge(u, v->lc);
return v->update();
}
} #define sz(u) (u? u->size : 0)
inline void Split(node *u, const int &Kth, node *&L, node *&R){
if(!u) return (void)(L = R = NULL);
pushDown(u);
if(sz(u->lc) < Kth){
Split(u->rc, Kth - sz(u->lc) - , L, R);
u->rc = NULL, u->update();
L = Merge(u, L);
}
else{
Split(u->lc, Kth, L, R);
u->lc = NULL, u->update();
R = Merge(R, u);
}
} inline void Split2(node *u, const int &v, node *&L, node *&R){
if(!u) return (void)(L = R = NULL);
pushDown(u);
if(u->value < v){
Split2(u->rc, v, L, R);
u->rc = NULL, u->update();
L = Merge(u, L);
}
else{
Split2(u->lc, v, L, R);
u->lc = NULL, u->update();
R = Merge(R, u);
}
}
inline node* Insert(node *u, int v){
node *L, *R;
Split2(u, v, L, R);
node *ret = new node(v);
return Merge(Merge(L, ret), R);
} inline void print(node *u){
if(u->lc) pushDown(u->lc), print(u->lc);
cout<<u->value<<" ";
if(u->rc) pushDown(u->rc), print(u->rc);
} inline node* Modify(node *u, int l, int r){
node *L, *R, *p, *q;
Split(u, l - , L, R);
Split(R, r - l + , p, q);
p->reverse ^= ;
return Merge(L, Merge(p, q));
} int main(){
// freopen("h.in", "r", stdin);
cin>>n>>m;
scanf("\n");
for(int i = ; i <= n; i++)
root = Insert(root, i);
for(int i = ; i <= m; i++){
int a, b;
cin>>a>>b;
scanf("\n");
Modify(root, a, b);
}
print(root);
return ;
}
【bzoj3224普通平衡树】
Description
您需要写一种数据结构(可参考题目标题),来维护一些数,其中需要提供以下操作:
1. 插入x数
2. 删除x数(若有多个相同的数,因只删除一个)
3. 查询x数的排名(若有多个相同的数,因输出最小的排名)
4. 查询排名为x的数
5. 求x的前驱(前驱定义为小于x,且最大的数)
6. 求x的后继(后继定义为大于x,且最小的数)
Input
第一行为n,表示操作的个数,下面n行每行有两个数opt和x,opt表示操作的序号(1<=opt<=6)
Output
对于操作3,4,5,6每行输出一个数,表示对应答案
Sample Input
1 106465
4 1
1 317721
1 460929
1 644985
1 84185
1 89851
6 81968
1 492737
5 493598
Sample Output
84185
492737
HINT
【题目分析】
求前驱后继见代码。其余都是基本操作。
【CODE】
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
using namespace std; const int N = 1e5 + ;
#define SZ(x) (x ? x->sze : 0) inline int Rand(){
static int RAND_VAL = ;
return RAND_VAL += RAND_VAL << | ;
} struct node{
node *lc, *rc;
int pri, val, sze;
inline node* upt(){
sze = SZ(lc) + SZ(rc) + ;
return this;
}
}pool[N], *root, *tail = pool; inline node* Merge(node *a, node *b){
if(!a) return b->upt();
if(!b) return a->upt();
if(a->pri < b->pri){
a->rc = Merge(a->rc, b);
return a->upt();
}
else{
b->lc = Merge(a, b->lc);
return b->upt();
}
} inline void Split_k(node *u, int k, node *&x, node *&y){
if(!u){
x = y = NULL;
return;
}
if(SZ(u->lc) < k){
Split_k(u->rc, k - SZ(u->lc) - , x, y);
u->rc = NULL; u->upt();
x = Merge(u, x);
}
else{
Split_k(u->lc, k, x, y);
u->lc = NULL; u->upt();
y = Merge(y, u);
}
} inline void Split_v(node *u, const int &v, node *&x, node *&y){
if(!u){
x = y = NULL;
return;
}
if(u->val <= v){
Split_v(u->rc, v, x, y);
u->rc = NULL; u->upt();
x = Merge(u, x);
}
else{
Split_v(u->lc, v, x, y);
u->lc = NULL; u->upt();
y = Merge(y, u);
}
} inline node *newnode(const int &v){
node *x = tail++;
x->pri = Rand(), x->val = v;
x->lc = x->rc = NULL;
x->sze = ;
return x;
} inline node* Insert(const int &v){
node *L, *R;
Split_v(root, v, L, R);
node *newN = newnode(v);
return Merge(Merge(L, newN), R);
} inline node *Delete(node *u, const int &v){
node *L, *R, *p, *q, *a, *b;
Split_v(u, v, L, R);
Split_v(L, v - , p, q);
if(SZ(q) > ){
Split_k(q, SZ(q) - , a, b);
return Merge(Merge(p, a), R);
}
else
return Merge(p, R);
} inline int getPre(node *u, const int &v){
node *L, *R;
Split_v(u, v - , L, R);
node *tmp = L;
if(tmp) while(tmp->rc) tmp = tmp->rc;
u = Merge(L, R);
return tmp->val;
} inline int getSuf(node *u, const int &v){
node *L, *R;
Split_v(u, v, L, R);
node *tmp = R;
if(tmp) while(tmp->lc) tmp = tmp->lc;
u = Merge(L, R);
return tmp->val;
} inline int query_v_Rank(node *u, int v){
node *L, *R;
Split_v(u, v - , L, R);
int ret = SZ(L) + ;
u = Merge(L, R);
return ret;
} inline int query_Rank_v(node *u, int k){
node *y = u;
while(y){
int rank = SZ(y->lc) + ;
if(rank == k)
return y->val;
if(rank > k)
y = y->lc;
else{
y = y->rc;
k -= rank;
}
}
} int n, opt, x; int main(){
ios::sync_with_stdio(false);
cin.tie(NULL);
cin>>n;
for(int i = ; i <= n; i++){
cin>>opt>>x;
switch(opt){
case :
root = Insert(x);
break;
case :
root = Delete(root, x);
break;
case :
cout<<query_v_Rank(root, x)<<endl;
break;
case :
cout<<query_Rank_v(root, x)<<endl;
break;
case :
cout<<getPre(root, x)<<endl;
break;
case :
cout<<getSuf(root, x)<<endl;
break;
}
}
return ;
}
【poj3580】SuperMemo
Description
Your friend, Jackson is invited to a TV show called SuperMemo in which the participant is told to play a memorizing game. At first, the host tells the participant a sequence of numbers, {A1, A2, ... An}. Then the host performs a series of operations and queries on the sequence which consists:
- ADD x y D: Add D to each number in sub-sequence {Ax ... Ay}. For example, performing "ADD 2 4 1" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5, 5}
- REVERSE x y: reverse the sub-sequence {Ax ... Ay}. For example, performing "REVERSE 2 4" on {1, 2, 3, 4, 5} results in {1, 4, 3, 2, 5}
- REVOLVE x y T: rotate sub-sequence {Ax ... Ay} T times. For example, performing "REVOLVE 2 4 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 2, 5}
- INSERT x P: insert P after Ax. For example, performing "INSERT 2 4" on {1, 2, 3, 4, 5} results in {1, 2, 4, 3, 4, 5}
- DELETE x: delete Ax. For example, performing "DELETE 2" on {1, 2, 3, 4, 5} results in {1, 3, 4, 5}
- MIN x y: query the participant what is the minimum number in sub-sequence {Ax ... Ay}. For example, the correct answer to "MIN 2 4" on {1, 2, 3, 4, 5} is 2
To make the show more interesting, the participant is granted a chance to turn to someone else that means when Jackson feels difficult in answering a query he may call you for help. You task is to watch the TV show and write a program giving the correct answer to each query in order to assist Jackson whenever he calls.
Input
The first line contains n (n ≤ 100000).
The following n lines describe the sequence.
Then follows M (M ≤ 100000), the numbers of operations and queries.
The following M lines describe the operations and queries.
Output
Sample Input
5
1
2
3
4
5
2
ADD 2 4 1
MIN 4 5
Sample Output
5
【题目分析】
所有操作都可以用无旋式treap完成
【CODE】
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
using namespace std; const int N = ;
int n, M;
#define SZ(x) (x?x->sze:0)
inline void Wr(int);
inline int Re();
struct node{
node *lc, *rc;
int pri, val, sze;
int add, minn;
bool rev;
inline void upt(){
sze = SZ(lc) + SZ(rc) + ;
minn = val;
if(lc) minn = min(minn, lc->minn + lc->add);
if(rc) minn = min(minn, rc->minn + rc->add);
return;
}
inline void PushDown(){
if(rev){
if(lc) lc->rev ^= ;
if(rc) rc->rev ^= ;
swap(lc, rc);
rev = ;
}
if(add){
minn += add;
val += add;
if(lc) lc->add += add;
if(rc) rc->add += add;
add = ;
}
upt();
}
inline void print(){
if(lc) lc->print();
PushDown(); Wr(val), putchar(' ');
if(rc) rc->print();
}
}pool[N], *root, *tail = pool; inline int Rand(){
static int RAND_VAL = ;
return RAND_VAL += RAND_VAL << | ;
} inline node* NewNode(const int &v){
node *x = tail++;
x->val = v;
x->pri = Rand();
x->lc = x->rc = NULL;
x->minn = v;
x->sze = ;
x->rev = ;
return x;
} inline node* Merge(node *u, node *v){
if(!u){
v->upt();
return v;
}
if(!v){
u->upt();
return u;
}
u->PushDown(), v->PushDown();
u->upt(), v->upt();
if(u->pri < v->pri){
u->rc = Merge(u->rc, v);
u->upt();
return u;
}
else{
v->lc = Merge(u, v->lc);
v->upt();
return v;
}
} inline void Split_k(node *u, int k, node *&x, node *&y){
if(!u){
x = y = NULL;
return;
}
u->PushDown();
u->upt();
if(SZ(u->lc) < k){
Split_k(u->rc, k - SZ(u->lc) - , x, y);
u->rc = NULL, u->upt();
x = Merge(u, x);
}
else{
Split_k(u->lc, k, x, y);
u->lc = NULL, u->upt();
y = Merge(y, u);
}
} inline int Re(){
int x = , f = ; char ch = getchar();
for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
if(ch == '-') f = -, ch = getchar();
for(; ch >= '' && ch <= ''; ch = getchar())
x = (x << ) + (x << ) + (ch - '');
return x * f;
} inline void Wr(int x){
if(x < ) putchar('-'), x = -x;
if(x > ) Wr(x / );
putchar(x % + '');
} inline void Reverse(const int &l, const int &r){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
if(p)p->rev ^= ;
root = Merge(L, Merge(p, q));
} inline void AddTo(const int &l, const int &r, const int &v){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
if(p)p->add += v;
root = Merge(L, Merge(p, q));
} inline node* Insert(const int &k, const int &v){
node *L, *R;
Split_k(root, k, L, R);
node *res = NewNode(v);
return Merge(Merge(L, res), R);
} inline void Revolve(const int &l, const int &r, const int &k){
if(!(k % (r - l + ))) return;
node *L, *R, *p, *q, *a, *b;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
int o = r - l + ;
Split_k(p, o - (k % o), a, b);
p = Merge(b, a);
root = Merge(L, Merge(p, q));
} inline void Delete(const int &k){
node *L, *R, *p, *q;
Split_k(root, k - , L, R);
Split_k(R, , p, q);
root = Merge(L, q);
} inline int Min(const int &l, const int &r){
node *L, *R, *p, *q;
root->PushDown();
Split_k(root, l - , L, R);
R->PushDown();
Split_k(R, r - l + , p, q);
if(p)p->PushDown();
int ret = p->minn;
root = Merge(L, Merge(p, q));
return ret;
} int main(){
// freopen("h.in", "r", stdin);
scanf("%d", &n);
for(int i = ; i <= n; i++) root = Insert(i, Re());
// root->print();
scanf("%d", &M); char opt[];
for(int i = ; i <= M; i++){
scanf("%s", opt + );
if(opt[] == 'A'){
//add
int l = Re(), r = Re(), v = Re();
AddTo(l, r, v);
}
else if(opt[] == 'R'){
if(opt[] == 'E'){
//reverse
int l = Re(), r = Re();
Reverse(l, r);
}
else if(opt[] == 'O'){
//revolve
int l = Re(), r = Re(), k = Re();
Revolve(l, r, k);
}
}
else if(opt[] == 'I'){
//insert
int k = Re(), v = Re();
root = Insert(k, v);
}
else if(opt[] == 'M'){
//min
int l = Re(), r = Re();
printf("%d\n", Min(l, r));
}
else if(opt[] == 'D'){
//delete
int k = Re();
Delete(k);
}
// root->print(), cout<<endl;
}
return ;
}
【noi2003】文本编辑器
题目背景
NOI2003 DAY1 T2
题目描述
很久很久以前,DOS3.x 的程序员们开始对 EDLIN 感到厌倦。于是,人们开始纷纷改用自己写的文本编辑器……
多年之后,出于偶然的机会,小明找到了当时的一个编辑软件。进行了一些简单的测试后,小明惊奇地发现:那个软件每秒能够进行上万次编辑操作(当然,你不能手工进行这样的测试)!于是,小明废寝忘食地想做一个同样的东西出来。你能帮助他吗?
为了明确任务目标,小明对“文本编辑器”做了一个抽象的定义:
文本:由 0 个或多个字符构成的序列。这些字符的 ASCII 码在闭区间 [32, 126] 内,也就是说,这些字符均为可见字符或空格。
光标:在一段文本中用于指示位置的标记,可以位于文本的第一个字符之前,文本的最后一个字符之后或文本的某两个相邻字符之间。
文本编辑器:为一个可以对一段文本和该文本中的一个光标进行如下六条操作的程序。如果这段文本为空,我们就说这个文本编辑器是空的。
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAAkkAAADuCAYAAAAtBpNLAAAgAElEQVR4nO2dvY4UObiGZ4/2KhBCiNlrIECwAQFwAQSwERHSEK8gISQZtDFIREQMARcABAQMIuAaAKEV4jY4vL3Hc9we/3x2uaq6q59HKnV3lf/KrrLf/vyV67efv9gDAAAAgDX+Z+4CAAAAAGwiiCQAAACACL+HO3777bc5ygEAAAAwK6EH0imRFAsEm4tELe01H9Q/AMAyiBmJmG4DAAAAiIBIAgAAAIiASNphcv5nVt+0IT5stXFj4XukAQAAEAORBKdwfjYWQWEN1zMuQgcAAKYg6rgNy8cJDffpnI99R2QnYjbBMbmlHCkxFdu/CecIAACbBSJpR4kJoJgQsQglS5iWqT1rev73WPnDeLF9AAAAIYikHSUlkFJWlqEWpZIYK+0vlRsAAKA3iKQdx4kMf4otRsmqM9bUXCjeEEQAADAVOG7vMKFfkj79LRa2BzGLVUpgIYoAAGAuEEk7Ssp65O8XJXEUc/QGAABYAky3wRpTiRx/eq5mms6yVlJJ5CHkAADAAiIJTlmD3L6aeI4a0dPix2R5Wq02PKIJAABibMR0W8w/Jecfk4o7x8KE2zrA+vUaWl6mOqeaRStbsIov/J4A/mPISvvb2hcC5NgIkRTD+cZs2gA2pYgYk1TdWus8Z8GxCB98mQC2E4v1dyn9JMDGTre13mA1CxOGT3el4uQWK1w6NesZhfFyU1upabpUngDQhyErzpfWKeMehqUxq0hKLRLYcsPWOgHnwoXHSn46S3vNRW4Ks8aHKHTOdvty4f08t7kOATaV2CuI3G//MxY+djzVd7PQKyyBWUVS7GYNrTa9rTj+AJyydLT+qwrz2AZiYjC2L/Xbmv4Q5+xc/NbyAMA6qVcV+cdjbFN/B1DLRk63xcRRbnHDWutGmG7qn1Uqr1haLWUBANh28C2EJbORIqm02nNpCie3bk6IZSqoJKL8YwgkAFgqJdcC+j9YGhsjklIio+VVFbULE9bc2FiKAGCXSU3HlZy6AbaRjXHcnnLqyvpestRTGzkncToGAFgyrQvNAmwjG+O47X/61EydlSg5befytZahZRVpAIA5aLGmpyxJrekBbDIbM90map+qSJGaN2+9cWMrQyOEAGAbyflyWpdPSUGfCEtjI1fcHroasxNE/jaEWr+oXekoWl5N0Pt1BqUFQQFgnaF9orVf5Z6EJbBRlqSpV2PmJl4OTHMCtMO9AxBnYxy3xdTWmVafpJZwS6O0HIJPrQm/ta3p5AHqqXl9UCyMg3WSYIn89jO4C/hHsV3M0V4pn6/c037WOLkVf61MWR/cLwAAyyDWn2/UdBtsD6GQKYmF1CtoSksqWPweECkAADAGG+m4DdtHi1AJnfMROwAAsEkgkqAruemx0lvEU3GdpcrfAAAAxgaRBE2kBIvFedMPY1nuwX/cmPfjAQDAVCCSoInaNajC6bScDxLWIgAA2ARw3IbuWBffzFmOavLCnwkAAMYASxLMTq+V0QUWKAAA6AUiCbaKmC8Ui9gBAMAYMN0GTfQUJZYn4hwpaxNCCQAAeoNIgiZKq2LXvGsvl1aLfxIAAEAPEElQjWVV7JzFpzatIWUDAABoBZ8kAAAAgAiIJAAAAIAIiCQAAACACIgkAAAAgAiIJAAAAIAI0afbeIx6u6C95oX6BwBYJlGRxGPU2wPvLZsX6h8AYBnE/vAy3QYAAAAQAZEEAAAAEAGRBDARoSm3xZfJGqe3n1Rrej3KkXvtzRj5WRiz7XJhe6RRS+yl0j3SHFKO1LZN7GJ/UJPGkDx6ni+vJQGYkdy76qz+TqVwuQ4jFq/mvXux9K1lrilTKY1e7/8bE/duwanOrya/Hu0xBbn7Y9tEUoxt7w96Xke198tYIJIARiR1k8c6+Nh77CwdXqkTqe3cwvDuWKqzbOnEWjr/MHyuDsfsXFP5h2Fy8WOEZe9xfrUviJ6LUp0shaX3B0Pu602F6TaAEXEdm48/CPq/rfHDdMJ9frrWf9dKJ9d5p46niJUjVp5w4Pf3p9J14XN1mKs3n69fv67C3bt3z3xesfxj+PVW2nqcn2U6as5pqTD/sCypOrGkUXNOamuFV9tb+eOPP1Zx9DmEXekPWu7r1HU6xrEaEEkAExMOgq3//GL7/c6rVtiE1HTelnLEOvBaYZOyYqXqosSFCxf2rl+/vvf3338Xw+b+3fciJ5gsZbGIMYsAGUNg9bg2Y+dSm9Zff/21d3BwsGp7CxJVd+/eXeWhzxs3blSXO8fS+oPW+zrVrrn2zv3hsBw3nffPINZSTGS7Au01LzX1H4YN/22Fx2qJpW1JJxUuVVafVPq58yqVKxwsWuvG2i6yDnz+/DkbJtd2sd/Wslr/jdccmyq9VmJtm7KC1NS59RweP368d+7cub1bt26tfksEPX369FS4w8PDvZs3b+7t7++fyufLly9mkZVil/oDP93UOVrSLrVveD3VXtex8PgkAcxA6eatHTDCsKkwqXi5jivXsZU6vBS5waEmbiwNazri5cuXK+uAkFjS4KfB8f79+2vpWP7dx8K2ihJLnVjLZslvWwjrokU8PHv2bCWK1fa3b99e7UvVzYcPH1aWRh/9/vHjx2CR5LO0/iAWzkpM3Mx5/SKSACbA7yT8TisWpldnkPtHZbEqhOWZoqOyDvg1+3M8f/5878mTJ6vB8NGjRyfWhZry1IYdIihb0qgNW1uWGoZcQ9YBPofa+dq1a6vv79+/n23g3bX+YIp6jpWnxZoUgk8SwMjE/m2Fm7+/d14xYiZ1vxN06YT/BPXptlieVqESphNLN0eu/mrr8dWrV1GBNAbWKQPLvl75hcSuzzEGOWvZ/Gsjd91YrqGPHz+ufJIURp/COXKHm6blxmDJ/cHQ+zpWnpppNuu51YBP0pZDe81L7bRJ6l9YTTq98k1NUdWa9nO/LeWuNenXmu5TuOkWOfG+ffu26JdUKnN4vJbcP/0wz6EDRyqsxaIQ2+/K35qX9bqIxa85Tzelqjb/888/i8JYT8BZfJKsdbAL/UFu/xjXcEufUpMWliSAEenx72YsIVz6t+b+AebCWS1MLWXLHQv/cYf7Lflqqk2DnabbNHhqKqYXOWtM6VguTSstAmkqaoWNTyye9V5yU20KLyuS2r+EhJAElbMq6VM+Sa3+SEvvDyx5WAnzyoXxy5fqk5otSj8DIrtOoTC/Lpzs8cPDw7V9vzqj1X5/Ozo6Ojmu9H4p9mSaCuvKFqbjb8fHx2vxfl3Qq7guf32GKE4u701mrPaaAtW5fw1sI5b6t4StPRbuS/22hhtaRkveuX3+VhOnFCaFrj13X+j+T/UfKWravSVeKVzqeKoOrWn1vEZLYcN8Y1suj5pr140fbgzQuKDv+rTgrpfcODGk3oce28T+oOW+bilHS9lq4jWLpNQAp4tOx/xBV99jHVA4eOc6KT9Na2em8rn0cyLJlTEnJDaVMdprKhBJ5WPW/dZOpWXwHTrwxvaXOtBUWpYOt6W8tWyiSGqpg9h1k9taylrKL5VGeK1Y8p2i7WO05LnE/qD1vq5J20LP+7N5uk2PzerpAB+3gqm/Kqn2PXjwYGXWvnz58lp4lUnrU8g3QMisKQfKEJlJFd89lmtF/gapReKUpkxvbqVdpa2y1KzCuk1Y20u4unGbax+3P6wj7XNTFQrrx62ZwlD4oSvabhs5p0aLM6LVKbLFedI3r6fKkYoXhvfTcuX3N2uZLWWpLe8UtNR/TTphnbs68K+RcHPhQsK2KbWRta5TU2W5cvjlsTBH2/ec/tr2/qD1vq5Ju9e9ZKVZJGkxLjk7+ugpkTt37pzal5vDlTByc8MSNG/evDk1CEs4ae2SGjRYp/LVwH3lypW94+PjlT+CXxaVd4lY28uvG12Q+pTY1H6JXDkx+nWketY+HXOOsO5ilrBVWhahpItebVzjPLttlAYkS/hU3NTgY8knFa91wMmdZ2061nhTD4xjnksufWt7x8JbBrBc+Vqu0dawc6TXSms5dqU/yJWzJe3acg9lkOO2rBPOyiC0SNfFixfXwnz79i3r5KYnDNzA6Jzk/vnnn5PjEkwSTlr51EeDb/jPyLdCyGoSy/fTp08nIiC0bKksOoelYmmvFy9erNrA1Y0+fQuf0nj37t1JeAlctxifvh8dHZ0cc+2pNHM4gVRrKQQAABiTQSJJwsVZgWQtkEgZugqpnjrwl4iXYIq9Z8dZOvzNt0LIaiLRE+JWWD1z5sypY2fPnl1ZP5aKpb0kSs+fP7+2zxeySsO39un7pUuXTr6rfn3hWprCdO0hSxcAAMAmMUgkuQFWg6AW6QqnboQG3NwgKYuPbwGS5ULTZO6RSw2ylpdPWpGlQ6Ir99bvpfolWdrLkoabcvOn2hwx8fr69etkemoLtYkTSwAAAJvC4HWSrl69uhowNXUTW5jLWR5SfikSQeFg/fDhw1V6Ob+iVjS95Hyf/Kknn575bRql9tK5a4rUJxSybspNVim3xL+QYJL4qsEt6Ka4OeEKAAAwNYNFkkSQnl7zB0sfDbryN4k58Go6RpaEcLCWZUKDsqwLEkwtqDzh01xhmULrxffv31eD9ZIptZeb7nRtpU/99tvBCV9tbml/Ib8lpe23s9rRIn4kuPx8AQAA5mawSJLgkLUn5v/jkEOue9LJ91fRNIv/dJmPrEtKN3SudsQct7W5aTqVJ3yaKyyTBFHo7O2ckJdKqb1U35oyc/Ubc3J3U27hVJvErtrUbxvVZ6qNw3wlmBV3qdOdAACwXSz63W0SQBJK1ukznXv4Tp5NZ0nttY1Y67/m/UZj0JJPj1dbjPV6jFJY7gsAqGXn3t2m6R9/OYEcskDFnqID6EVqsbfYIn+bgFu4zcrQ86vJLxcWgQQAvVi0JUncuHFjNXWXe9uzW0BxG897ae21bVjq339Rox82fDnjWO2Yyj8MU0tY9inOb0g5AQByRN8WsHSRtHRor3mpnfbJCZYx2jInXIbkXRJGlvOrETxc4wAwNrF+6/eZygKwE6ReDzD0FQ8WUu/K6inGUgLMIgBbfblS4moK0QkAuwUiCWBkavxseuaZEzCxF6JaypoTeb0pvdAzDFuKAwBQCyIJYGQs01sxZ+eWfHJvd7eEzfksWacVcw7VlrJZ8gMAmAJEEsDIlERDjJ5vFh8atlawTLEUwCY9BQgAywWRBDAB2+ov0ypYWs/PGs/qpwQAMAREEsAEpIREyFzCKScyco7S/tNsqWM1ZdgG4QgAuwMiCWBkah6Rn4tWX6TWY7X5xMIDAIwNIglgAmqclneJ1npJCUzqFwB6gkgCGBHL4L2rA3zsibhdqwMA2GwQSQAj0uKEvAn0ms6yvl/Nsk5T6qk5a54AALXwWpIth/aaF+ofAGAZxPrz/5mpLAAAAAAbDSIJAAAAIAIiCQAAACBC1HEbx8ftgvaaF+ofAGCZREUSjqjbA47D80L9AwAsg9gfXqbbAAAAACIgkgAAAAAiIJIAAAAAIiCSAAAAACIgknaAGzdu7D1+/Hjn8gYAABgCIgm2EgmvDx8+zF0MAABYMIikHePr16+rxxwlMvSp7Y8//lgLo9+pYxIm7pi2ly9fnhxTmvfu3Vs7/ubNm70HDx6sLEotZQEAAJgLRNKO8u7du9X6Pm6NHzclJpFz7dq1k2MSLdonJJCuXLmy9+XLl5Pjt2/fXhNKT58+3Ts+Pj45fv369b3Dw8O9169fV5cFAABgThBJO8rDhw9PvksUffv2bfVd1h0fiZsnT56svr948WIleC5cuHByXL+fP39+8nt/f3/v8uXLXcoCAAAwJ9EVt2H5nDlzZu23E0cSLLIWySIk/NWk3759u7IiafrMR8LI0TJdlioLAADAnGBJgjVkBfKnvuQn5PsTHR0dnRx32+fPn+cqLgAAwGggkiCJBJD8i+R8LWQlev/+/aRlkFXJ+UQBAABMCSIJ1vAdtcXHjx9PptM0FadpON9RW1am2JNrPVC6ylt5+k/MaQun/AAAAHqDSII1NHXmixKJETedpqk4WZb0RJs7Lifu3JNrd+7cSS4BUELpygfq4ODg1BSftloHcQAAgBp+++l75u7954MS7IINhvaal5b6H9Jm1rhjXBdK0xGmncsvF88SP1eeoelN3X5D86nJu0fY2nPd5P5oinsnjFtKy783SoxRr5vcXnMQq48mS1L4qgklHPMb0bRM+LRTuNhgeNxfWDDcnDUiXNDQ38Jy5bawXGOvz+MWWwSwYO1AS+Gs90AprG/Fq8nPEk/HagaMUv7Wjt+ab6+yTUltnaaui9I1s4nMce/EsLSBf2+E90rsvimNazVl7XnfLZVu022hr0oMiRw54voXgtbFCRtJCxDGplfCaZ3wuKaCNLXjXlfhH9OUTTht41B4lev+/fudaiOO0lc+pXqC5ZDqsCwdmqUDswiC2L2UEy01YUvxp8byz93aHj5TDyYlK5n1eiodC/MKn2zNDditdTkFc907U1AqU2r/kGtkSmRI2KQxsptIkrCRr0oOPSXlLxwo3EKFPSpFPioSQlr0sAb5zfjl0sURWrRqyL3WQ/mEdQDLxdqJpTrfXGcf6+RjHd+Y9MxvqBCxWpBybREeD+NNQWzgcr9L14p18/PyzzvMy0871jaW63supr53/DRzIiQWL9fmve7hUlulwkyNNIGeotZ5t66ZJz3Ra729biJJA7+eRMo56Or4o0ePTu1XY9y6datLOWorxlmdQifgZ8+enVwoEoDWabLcaz38fHg56+6R6phL5Cw+sX2lwd5STsuWyq/0L3UMrALJL0+qbBaryNj/vGNWgDEGrZxg8hkr/7GZ+t4J07L8CaqxBuWwtpHFwjY3Eko6l9hMUw6JI4UvGWxq6Pp0m1ZklrUoZRXSU1I67ncqMbEQhnFbydqktBT3r7/+MpdZj7jHVon2xdzVq1fN4iv3Wg+HGr7W2gW7RS/TuFXs+NRaI3LxY+nlzrnVmlQzoNVYknoOYkMopR+zYOTauld5Ldfn1Mxx71jOM2dFspSzNu1WWu/BMZBmcOWxvM1BxhZn2OhFV5Gkx8H1Lq+cinMdih7tFnoFRtggKZ+k0NoUXkRKS35JNY+G6+WqEkEhZ8+eXfttXVXarSWUu7DPnz/Pqzd2jNpOZ4hp3O9oLQP8GITn22vAtA56NYNLzYA+xKLiHjjxp/JrX+NTKmNO0FoEqvueG7hzeeX2l9AsRA9xNfW9E7smrOXvUYc1+Vuv315Cqcc1L6QrXHpT032dJDknS+SU1sWRoHKNr2m4lifL/AtIaSjfudfOKb3Ww8GrPHaHsGPKDfQ98Tu6mGgplblWeIQDTFiWUn7+AJHKo9bqk8u3NnyszDWob1AfpYdL/D+KqbRjdd0yeNUKu9LAHZZviLXGIZcE/cF0eci3dE5q7p2hfzQsdZiLG8s/dp2EYWvv0RZqrvkYTmQJjZlzjO+jvOBW00v+S0+FpspkYYo1RI83v6sCVZm62cLprbnQuaqRZeEKaVHTsH2UBMMQy0QuP9expNJ2YUoiIpVH7PtYVikLlvPxsVhkeufprMcu/KdPn/bu3r1bzH+IeLaUL5a+JV7seCpe6RxkXVc/qUFUf6Dn6MN73zs110bJUpQrr7UMvsC1lKfH/VxzzYfxnOFjzn5FjLLitpt2c+/8Epoqizl2qzI0PVXjR5RCU22WpQh8NNWmKbde5F7r4ZAgVB3B8pn6Bq8ZuHrlZxkUa/8Nt1hMauLkpk9y4nBIPb569Wr1JK3j+fPnezdv3qxOJ1XfLZadGkvEmGgGQnmmHHXHsLSGjHnvjPVnqESsHUtTeiXBVtMOLde8//BT7m0OUzHaa0nctJuPm2Lyb1QJCP178M1oKcftUuO4JQBksbIKpUuXLq2JOQsqR2puNPdaD4cc3HuIQtgNxhI5YQfaM58pTPmpfGuE0tDzrwmvP2MXL148+a1+odefpdzUYelYLs0cNaIsh/+nUnXS0+l2qnunJ6V0e5yTZTquBy3XvKyIG+WO8jMgsmvx/Lopfx4fH5vDHx4eVoX3UbxfwrApboxdbK9Noqb+Y2Et8S3xUr+t4XLfa8tTk2bp/C3lsKabSkv7h5TDEsbl4foO9zvWj5TarKZc1uuzNp1cXdbs//UH+aQucnViKaM1zhj3Tql8Ncdq0m0JF8axXP+t5bFe8z4HBwenrgm3HR0dZePquB9eY3sNsXPj3W17/zmH6ZF/q2lPU4atZkDFlfmx17pQu9hem0RPPxiHn17OxyMXzhovF99axjB+Lq6ljDVljpUldTx1jmG5c+dWW8YWYvWXO8dcvkPruHc6rbSkO9W90zuetTy1+YRhRe5+GJrHNhI7v9Gm27YJTdPJBGh9wq5VILn0ewmkGkrvzINp+JmY+vA3R65D+vnz9KKNOUrhYvmUypdL1xLP2tm6c7WWOyxDmJ8rc1gu99vis+OfxxgDR6rerPn28uGZwhfIUoZeAkn0vndS4XNTkGG6ufAtZSiVK3Zthdf/FNNx2wCWpC3H0l7OWd4XdxJN8p2irYfB/QIAsAxi/TkiacuxTgXEFtnU/qOjo1ksW0uB+wUAYBkgkhaIpb00taZtEx6nXBrcLwAAywCRtEBqnPp8al/fAnG4XwAAlgEiaYHUtpdbydRBWw+D+wUAYBnwdBt0eWceAADALoBIWjhaeTz16GiPd+YBAAAsFabbtpxWx2037YZv0jC4XwAAlgHTbTuK9Z15AAAA8P9gSdpyaK95of4BAJYBliQAAAAAI4gkAAAAgAiIJAAAAIAIiCQAAACACIgkAAAAgAiIJAAAAIAIiCQAAACACL/HdqZeYwGbCe01L9Q/AMAyiYokFsfbHljMcF6ofwCAZRD7w8t0GwAAAEAERBIAAABABEQSAAAAQIQmkfTHH3+svVHebR8+fFgLd+PGjWg4bY8fP16Fefny5Sq9FPfu3UumoWNfv35NHtfm0raUxaHfSruEzjdX9k3B2l45XD3rs2dYWMfqBF7rLD5WutY03WbNcypn+JZ8auLUnPMYTNHuYdxSWrn+OtzGgActoIZmS9LR0dHKYdVtx8fHe1euXFmJHp/Dw8O1cG67f/++Oa+Dg4NoGk+ePNm7cOHC2r7r16+v5fn58+eqsmhgf/bs2SrtEpcvX967e/euSVDNjbW9YBzCjt8iHFoHi14DY83glQvrX3dLQOdRK5Ri9dZbEMzR7jEs9eNfD+H1EbtWaoRVqay17Qe7TbfpNgkGDcS3b9/uleQsSPA8evTo5LesMLIs+TefbyGRwHr69OnWWU1S7eVb3EpWMt9CpXhC9bC/v7/6rk8nwmS18uswJ87UBtr89Jcg5sKOvyQaUsLCCY9UR28ZBFwalvxjW0341nKMbVUo1WOsDCmhGyunf25+XfjCMTw2hLnafQpKZUrtH9J+U6L+bgl93BLp6pN069at1WfNNM4moQH+zZs3J+fhePDgwcmNJ6tWaDnSvlevXk1Z1C6E7SWh41vmZCVLCSXt13EXVvFc/C9fvqzC6FN5KH1ZrfTbhZc4y3UKEp7Pnz9fhV2C+C5RYwXwB4YWoRQbKGODx9ikrGqh9WmMwdlaj+64dSulH9Z9b6vG1O3up5kTIbF4ufbvVSclQZUKMzWauXj//v2pP+G1hK4jMJzujtuyHnz//v3ktwRGTK3XXAgaMGNp1IqxUlk+ffp0YgXx0TSd488//1ybwnP7NEW3jbj2cgLRn2aUlUzCJqxn99ufpvz7779X8WPt+uLFi1UdSkA59FsiKIWmTWXtEhcvXlx9bpu1rgfhIBSzRuWEknV/D8tGyzRI7J//2ANVbT22kBNMpbL0zLu0v6dFy2qBqrUG5bDWn8XCNjfqe3Uu165dqy6Ps7p/+/ZtnMLtMKM/3ZbyA/IHzBIpnyQ3iPYqi5S8LtCQc+fOrf12lhLH2bNnT+3bNiQQRWxA80Wv+Pjx4+p8/XBOXP748eNU2m/fvj0lUPU7FJs+sesjlvau4E8NhVtoqegxvVArdkSttSXG1ALJP4+YUCpN24R1MZclYo52twzkOSuSpZy1abfSWyQPQf2iK4/1wSDFkZ8p9Ke7SNLgKdGwi2yjpcNvLwmd2KAWTj8KWXpqhGvoOK4tJ5KWhD8I5D5juM4y9m8//O7va5le8Mtj+ac/JjUDlvN3830Hw8HFF5Q5fCEa7s9ZQHLnkRNa/v4hTN3usbq0nkMPS1JN/lZrU0+h5Hw7/Wuy1ufIzWBsq/vKUugqknQRaKCttfAshRrr2Cbgt5ezhlmEnixrmlqzogFLVrpdJSZkYp+bQmiZ8rH8u6+xPqWO1QxYun4l2p3vYMyqWyPsrGGtg2+YbkoczE1Nuw8tr8WSlIsbyz92zYRhw3hj1fvDhw/X8tBsiBUn+oX+SO7qeLopdBNJalg51/pPhm0b8i3S1FAtmo6K+TJtMmF7uYHGn250N2v4T0aWJZ2ve6JNSHApbExkqcOQX5n/T0px/fhQJjeo9Eg7N5j4+0v51Uyz9bBMuWvOpaGpYz1UMCYWgZQShZtE73avOb/UdVJrQcqVIWfFi4myXqJJfpia/nJ+mxpXYhZ5H7e+nPpklaNmmRwYj2aRpAHWv8D09JIuitiTYbEL0h8gQ/+W0FyectyuXcixVBY5CFutKT6ykozdKQ/F0l6vX79ee+zePZEW+yejfzjaXFilrxtb1jRtElxuCQDFV15+GRRG+YGd0nTK0LRDai0lvbHmrSdL79y5c/JbDwTcvHmzSxlyA2rpmNXaUcp7TMZs997Xz5Bps9KUXkmY1baDRJHrN/UnM+br6qMnphVG5aBf3Cx++xlcHXN3jHOji1UWpZLq91GdSUzMMd226+01N9b6d+FSn7FwjpgfSOp7qWyl8lrzqC1LKY3auD76k+MWlhUS+lZ/t9b7p7bdW463WjemavfS757XQs01XrO/xiJobQeJIlmS3JPC8kuSi0LNmNJCmC/UE70efikFwXwAABJCSURBVAZEdu0Uv8TOz/39fXP4w8PDnwcHByOWKM+ut9fcWOvfhUt9psKl8krFq91nzT/3O1eulrwtcf392nQfHh8fn/zWdwut909tu4913BpnjHYvlW+sa6ElXBjHbTVxLOg69NO+fv366rs+c2gM8cvlb0dHR8V8NWb5cazXP6wTa2csSRGk/LXeREmRu0US56wv2mterP9Ef3rWIffd/4yFje1v/d07Xi5+jlLYVF2OdZ1vuiWptmxTtXvveC0WnppwLqyIXYOtbQTLImqFRSRtN7TXvLQMIinR5IiJJD+uH661TD6lwaqUnzXvloGxdcrJSu3906s+Sun0FEixPMN8W9s9Nj2cwhouFq+Uf+64NZ1YOPrX3QKRtEBor3mh/gEAlkGsPx99xW0AAACAbQSRBAAAABABkQQAAAAQAZEEAAAAEOH32M6WJxBgPmiveaH+AQCWSVQk8bTO9sDTVfNC/QMALIPYH16m2wAAAAAiIJIAAAAAIiCSAAAAACIMEkl6+7bm8Pzt69eva2HC4/6md5/pPWm5MDruUHi94duCwik8/D+W9sqh+sRJuZ5cndXWZ2v9W+ON0b7+9WbNc6rrrCWfmjg15zwGU7R7GLeUVq6/D7cxoA+DGppFki60CxcurJxW3XZ0dLS3v79/SpwcHx+vhXPb5cuX9+7fv3/y+8uXL6vw+nT7dNxx586dvbdv35rKp3B6+Sz8R017wTSU3nvVOsD1GhhrBq9cWP+aWwK17yBL1VtvQTBHu8ew1I9/PYTXR+xaqRFWpbK2vkMOdpMmkXTv3r29g4ODvSdPnqztv3Xr1t7h4eHeo0ePuhTORxala9eurQZ691uWEd864ludFE5l9PftKrXt5Xc0iiskpJzodFbAkFKb7CKuMw47bv+puN6dtiU9y1N5sT82ObFTE9ZSjrGtCiWRGiuDX5bS4By2sfvuC8fw2BDmavcpKJUptX9I+02J+tmXL1/OkjcU+BkQ2XUKhTk+Pi6Gqw375cuXVXh9huzv76+l82twX4U9Ojpa/daxMK72Kd6SGaO9XJ2K69ev//wlsFbfXR2nsLTJ0rDWvyWOJZx1X7g/9d3fF2411IbP5Vlzjq20tok13VT6U5/blO0eSyuWZi5cS1lqymxt9zlQPzu0v1QfDO3ErodqS5KzIGiqzIosEKFat/oWCfnNaAruzJkza/s1VSRriF+eHz9+nBzXPsXb5emkmvbSP5lfouikTsXDhw/3nj59as6v1Ca7RvjP3bdexKaleluUrPt/drBstEyDuLxcfhZLx1BieYxZ96FFqVSWnnmX9vdo9zCt2FYKl9ufw1p/Fgvb3MjSr3PRjElteTSeKs63b9/GKdwO0+XpNufQm+oIYz5Jnz9/Nqf/6dOn1eDrptocMaH1/fv3td+KF+7bdVLt9f79+703b96s7XdTbFYHb0ub7CKujksDQmwQLU0T5MK3Ti+0+HzkBknrwDe1QPLPIyaUfPFmqYuxy59ijna3DOSxMDXlrE27ld4ieQgaG115rMYExdE4C/2pFknOmuMPmrIYuA5wExvq33//nbsIs1HbXvJdig1soUAFO/4g4D5zIsfR8o+7FD4VJiyfJd8xqRmwnOj3n5QNBxffWpfDt/KF+63CNsw3J7T8/UOYut1jdWk9hx6WpJr8rdamnkLJ+WX612Stz5H8RcUuz4RsAtUiSYOlpmT++eefMcozCufOnZu7CLNR017nz583Pz0INlKDaWqg2gT8wSIn4mLUWp9Sx2oGLIl+XeMPHjxYxXNPyYbpWYVd76meMN2UOJibmnYfWl6LJSkXN5Z/7JoJw4bxxqp3uSn4eejPpxV/qRVZiGpcW6A/TdNtr1+/XvmpSC37yFoxxmP3Fy9eXHV8NWv6OBTv7Nmz3cu0TVjbS8stqL7cE23C/ROCvlgGgtr0hpYnN5j4+0t51Uyz9bBMuX7BpaHp+bt37zanZ8EikFKicJPo3e4155e6TmotSLky5Kx4MVHWSzS9ePFiZaV3S9joz6fv6xlD17HKoaeNVQ5/+RuYj2afJDWirBT+RSb/H629E15oMcdtZ4q0oHyUtjq/GqTIFQ8lbm8vfZegcmGePXt2clz1qDjajwm4nthU2qYQK0utpaQ31rxfvXq1WkPN8fz5872bN292KUNuQC0ds1o7SnmPyZjt3vv6GTJtVprSKwmz2naQKHLjjvpKOWPn0B9ThVE59KcWNofffgZXx9wdYwrN58qxOFzrJ4cuPE0hLVmRb2p77Qql+k/9q/VxnXrs05pfykfDsi91PPW9Jlwu79Jva7llIVW/4Pzm5I9kfTCk9f6xxqup79gxUVu+qdq99LvntdDjfqhJN4wjrO0gUSRLkhurZAyQy0fJkjSUMF+oJ3o9/AyI7NoYtOaRdQ0Jt+bS0tmFc9xkrPXvh4t9T31a84vtt+xL/baGy31vzdsS19+vTevDuHW5tNWsC9ZCS7uPcdwaZ4x2L5VvrGuhJVwYx201cSy4teJceK0zp+/6zOHWSIpt/rp1KTQ2+nGs1z+sE2vnrbEkCSllmdUt/xL1b1Jzu2Or97nZ5PbaBVosCpZ/6i3TLLF0SuXt/Y/d4reSC5uqy7Gu8023JNWWbap27x2vxcJTE86FFbFrsLWNYFlErbDbJJLgNLTXvAwRSX4HHZuWay1HzRRgmF9O9AwdtFoGxtYpJyu190+v+iil01MgxfIM821t9xpR30P8p/LPHbemEwtH/7pbIJIWCO01L9Q/AMAyiPXnXVbcBgAAAFgaiCQAAACACIgkAAAAgAiIJAAAAIAIv8d2jr3KK/SF9poX6h8AYJlERRJP62wPPF01L9Q/AMAyiP3hZboNAAAAIAIiCQAAACACIglgBqx+TK3+TqV4telO5XfVkk9NnFRY/MoAIEbUJwkA+tHzPV8pwnjuFRCt79WKpbmp5M41Ru4VFGG6ALDbNFmS9PJYdSjh9vjx45Mw+h4Lo00vqnW8fPkyGU75uONfv36NlkX7wzQVT78V98aNGy2nuCgs7QXjYXlnlWWQ1/HU5qfjtvB3an/4O5amH2YsLO8BS/UVpWN++sI/x/Ccw/MHgN2lebrt6OjoVEf94MGDlTBxXL9+/VSYw8PDvStXrqyltb+/H+34P3/+vHfr1q1VOq9evYqW459//lkdv3z58uq3Bv67d++ufivuhQsXEAN7tvaC8cgN/qkXu7aIk5yQygmslDDwBcSYwiEUMCWrWc255dIP6771JawAsEy6+iRJAD1//jwb5v79+ytRVDM437lzZzWgx3j69Onew4cPV99lVVI45eH4+++/k3F3Hb+97t27t9rcgOwsd74VyrfK6XfYhjqOIE2TEhmx/UMsGyWLih+ulE5OUPQilm5vsZITTKWyAMDuMovj9pcvX6rCyyIUE1YakH0rkqxNBwcHa2FkSVIYLCZlJDjVNhokVG8SSLLKuUFa+5xQUj37glii6s2bN3s3b96cqfSbyZDpIUs6qXg5i0ouff97aHmZQiCF/kIpPyFrXSB4AGAI3USSs+LI6pPDWRokfBwamEs+M48ePTqxGDmePXu2lt+7d+/2zp8/fyrPq1evFi1cu0asvSQmJYSE8/EKrXISQor7119/rb47JFD9+PAfuamt2O+UL1ApnaFiIGe58oVMKFos4i0nEC1+WBYRGJY/RXguubIBADSLpNu3b691LrL0yO/FFz8aRMNOSANz2ImlfJL8AVrpSky5wdtZhsL8Ll26dKqs586dW/k37TKW9vIFzsePH0+JV8URP378WFnvfOueBKrEKPQnnPLysVqeakgJmdS0WE8fqBjWsLXWrh5lA4Bl09Vx2x9whe+47abY5AfTiuLKoiRkGXLfLdRO8S0NS3uFxBzvtbnpzWvXrq3agam2/sQcimOkfHdarEwuHX96LbQgtQqvsbEIpBa/LADYbSZbJ0lWiuPj49WTbbLslAboGLIsyRIla5IG5devX5vjOisI2FAb+dNpMTTlpvbUVJvql6m2fsQG/CmdilPTbVOXIyQnalLHfNEXm7bDWRsAUkzquC0LhKxBmvpJrXtUwi0hELNIyfKhaaKQf//9d+WEDHacs7z/RFu4ZpWbcpNwlYM35BlrMI4N/rXTbbGy+dNtoX/UXFim8Gr9lBBIAJBi8qfb3BIA2txgm3Lc9gdkh5vS8f2VHPKJkW9MiPaVHMrhNPLj0ubaQuJWA4pvMdKUm2CqrQ85H6Mh/jb+/lT4VBru+9wCCQBgan77GfR6294RhuWXyHKO4Utk29tr27HWfypcaSrLGq90bOg+McV11no9D22HofkDwPYTu/8X94JbTcP5SwdoRe4hzuIAQ8kNvM5CUzMtVuNsHAtfm9cmP+3Vy4l8E53RAWB+FmdJEvI/0lNX379/X62ttOTH/5fQXtsM9Q8AsAyilvQliqRdgvaaF+ofAGAZ7MR0GwAAAEAPEEkAAAAAERBJAAAAABEQSQAAAAAREEkAAAAAEaLvbmO9kO2C9poX6h8AYJlERRKPNG8PPII+L9Q/AMAyiP3hZboNAAAAIAIiCWAGrFN0Y0zl1bwGZcxy9Mqnx3kwZQoAMaLTbQDQj54vX02ReimtJWwqn22ZRnTvv7OW16+b8GXCYboAsNs0WZL0brQbN26c2v/hw4e1jkZh/H+t/uZeQqu0Yh36y5cvV/vdZ27zuXfv3irtr1+/8u/w/7C21xCUjtKD07hBPIdlkHcvmo1tNeFT+adeaOvKPvZLYF3euTxyfUCpf/Dr2D/H8Jw3+YW+ADAtzdNtb968ORE6OQ4PD6Md9f3791fH9fLZ/f39tUFcAuf27dt7R0dHe7du3VqLd3BwsNpinb4GacVV2hcuXFjFj4mDXcTaXjAOucE/+lLFyOA/dvliwsAXEGMKh1DAlCxh1q2Uflj3FkELALtDs0i6fv363oMHD1aiZCjPnz9fG8SvXbu2EkISSDXcuXNn7+HDhye/FV8iDAuHvb18658sUOF+H/2W5c7tv3LlCkIsQ87iE9s31LJRssCWxFdo2RnrSb5Yur3FSk4wlcoCALtLs0iSINHAK0EzlMuXL68sThrEneXnyZMnVWk4IaS0fO7evbv34sWLwWXcdiztpbqXBc4Nyqo7J5Rev369svhJFAl9Kj21kxtUjo+PTyyE8B9Dpocs6eTi1VhbYuUKLS9TCKTQXyjlJ2StCwQPAAxh0NNtGji/fPmStR5I+MQ6sdCiocFVg64sSm/fvq0uy8ePH9csH45Lly7tPX36tDq9JZJrL7WH6t4Xp2oThXcCVBY/1aUEkj5rhewuEhMkud8pX6BSOkPFQM5y5QuZmDWxdvPjWfywYiIwJ/hyaYbnkisbAMDgJQDk95Obxkn5JMli4eMGafHq1avqcrx7927v6tWrp/afOXPmJH1It9enT59Wn7FB4/v376tPWek0DSqBpHYN2xDGIZzy8ikN5i1TbSkhk5oWq938eNbzt4SttXb1KBsALJvBIkl+Pxo4h067OT8kN4j39iP68eNH1/S2lVx7aTotNnDU+obBcGIOxTEsvjslp2Y/Tz/NcDrOfW6ipcUikGJl3rTzAIDNoss6SZp2UWfz6NGjpvjOz8VN32haR07APf/NOYsSxNvr7Nmzq6k1WZhSFiItxyArkoSsnj68efMm1qSRSImYqSwcqem2qcsRUnI0j+GLvti0Hc7aAJCi24rbGjjddFkNbuCVMHLId0Y48WRBU22acgtxFiQG83XC9tJUWujY7dZRclY9CSNNszlrVE37wHjiIhz8W/KJxfGn28Z+ws2KZQqv1k8JgQQAKbqJJDdwhqQct/UklQSSG3jDp9L0pJRzErYgB+2YSJNDd6xcu06svSRO3eKe2mTNk3VJbaP9ElHu6TVZo1Tfrn2UFksADCfnJzTmYB5LOxQZcwskAICp+e1n0Ottc0co4aV1knzBpcFdVqpQhC2FbW6vJWCt/1S40lSWNV4ufo6Y9Si2LxZ2DFqv56HtMDR/ANh+Yvf/ol5wK4Hk+9nIUiWRtFSBBNtBbuD1H3G3OBGXwuUsQiXH7VRem/y0Vy8n8k10RgeA+VmUJUlo+uf8+fMrp2I9raXpoiX7I217e2071D8AwDKIWtKXJpJ2DdprXqh/AIBlsPjpNgAAAIBeIJIAAAAAIiCSAAAAACJEV9zmKY/tgvaaF+ofAGCZYEkCAAAAiHDKksSTOgAAAABYkgAAAACiIJIAAAAAIvwvLHcRLhq7SFMAAAAASUVORK5CYII=" alt="" />
比如从一个空的文本编辑器开始,依次执行操作INSERT(13, “Balanced□tree”),MOVE(2),DELETE(5),NEXT(),INSERT(7, “□editor”),MOVE(0),GET(15)后,会输出“Bad□editor□tree”,如下表所示:
aaarticlea/png;base64,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" alt="" />
上表中,“|”表示光标,“□”表示空格。
你的任务是:
- 建立一个空的文本编辑器。
- 从输入文件中读入一些操作指令并执行。
- 对所有执行过的 GET 操作,将指定的内容写入输出文件。
输入格式
输入文件的第一行是指令条数 t ,以下是需要执行的 t 个操作。其中:
为了使输入文件便于阅读,Insert 操作的字符串中可能会插入一些回车符,请忽略掉它们(如果难以理解这句话,可以参考样例)。
除了回车符之外,输入文件的所有字符的 ASCII码 都在闭区间 [32, 126] 内。且行尾没有空格。
这里我们有如下假定:
MOVE 操作不超过 50000 个,INSERT 和 DELETE 操作的总个数不超过 4000 ,PREV 和 NEXT 操作的总个数不超过 200000 。
所有 INSERT 插入的字符数之和不超过 2M(1M=1024*1024),正确的输出文件长度不超过 3M 字节。
DELETE 操作和 GET 操作执行时光标后必然有足够的字符。MOVE、PREV、NEXT 操作不会把光标移动到非法位置。
输入文件没有错误。
对 C++ 选手的提示:经测试,对最大的测试数据使用 fstream 进行输入有可能会比使用 stdio 慢约 1 秒,因此建议在可以的情况下使用后者。
输出格式
输出多行,每行依次对应输入文件中每条 GET 指令的输出。
样例数据 1
输入
15
Insert 26
abcdefghijklmnop
qrstuv wxy
Move 15
Delete 11
Move 5
Insert 1
^
Next
Insert 1
_
Next
Next
Insert 4
.\/.
Get 4
Prev
Insert 1
^
Move 0
Get 22
输出
.\/.
abcde^_^f.\/.ghijklmno
【题目分析】
无旋式treap
【CODE】
#include<iostream>
#include<cstring>
#include<string>
#include<cmath>
#include<cstdio>
#include<cstdlib>
#include<algorithm>
using namespace std; #define SZ(x) (x?x->sze:0) const int N = 1e6;
struct node{
node *lc, *rc;
int pri, sze;
char val;
inline node* upt(){
sze = SZ(lc) + SZ(rc) + ;
return this;
}
inline void print(){
if(lc) lc->print();
putchar(val);
if(rc) rc->print();
}
}pool[(N << ) + ], *root, *tail = pool;
int t, pos; inline int Re(){
int x = , f = ; char ch = getchar();
for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
if(ch == '-') f = -, ch = getchar();
for(; ch >= '' && ch <= ''; ch = getchar())
x = (x << ) + (x << ) + (ch - '');
return x * f;
} inline void Wr(int x){
if(x < ) putchar('-'), x = -x;
if(x > ) Wr(x / );
putchar(x % + '');
} inline node* Merge(node *u, node *v){
if(!u) return v;
if(!v) return u;
if(u->pri < v->pri){
u->rc = Merge(u->rc, v);
return u->upt();
}
else{
v->lc = Merge(u, v->lc);
return v->upt();
}
} inline void Split_k(node *u, int k, node *&x, node *&y){
if(!u){
x = y = NULL;
return ;
}
if(SZ(u->lc) < k){
Split_k(u->rc, k - SZ(u->lc) - , x, y);
u->rc = NULL, u->upt();
x = Merge(u, x);
}
else{
Split_k(u->lc, k, x, y);
u->lc = NULL, u->upt();
y = Merge(y, u);
}
} inline int Rand(){
static int RAND_VAL = ;
return RAND_VAL += RAND_VAL << | ;
} inline node* NewNode(const char &v){
node *x = tail++;
x->val = v;
x->pri = Rand();
x->sze = ;
x->lc = x->rc = NULL;
return x;
} inline node* build(char *a, int length){
static node *stack[(N << ) + ], *pre, *u;
int top = ;
for(int i = ; i <= length; i++){
u = NewNode(a[i]);
pre = NULL;
while(top && stack[top]->pri > u->pri){
pre = stack[top]->upt();
stack[top--] = NULL;
}
if(top) stack[top]->rc = u;
u->lc = pre;
stack[++top] = u;
}
while(top) stack[top--]->upt();
return stack[];
} char q[(N << ) + ]; inline node* Insert(const int &k, const int &l){
if(l == ) return root;
node *L, *R;
Split_k(root, k, L, R);
for(int i = ; i <= l; i++){
char c; c = getchar();
while(c < || c > ) c = getchar();
q[i] = c;
}
node *tmp = build(q, l);
return Merge(Merge(L, tmp), R);
} inline node* Delete(const int &l, const int &r){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
return Merge(L, q);
} inline void PrintStr(const int &l, const int &r){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
if(p) p->print(), cout<<endl;
root = Merge(L, Merge(p, q));
} int main(){
t = Re();
pos = ;
for(int i = ; i <= t; i++){
char opt[];
scanf("%s", opt + );
if(opt[] == 'I'){
int len = Re() ,tmp = pos;
root = Insert(pos, len);
pos = tmp;
}
else if(opt[] == 'M') pos = Re();
else if(opt[] == 'D'){
int k = Re();
root = Delete(pos + , pos + k);
}
else if(opt[] == 'G'){
int k = Re();
PrintStr(pos + , pos + k);
}
else if(opt[] == 'P') pos--;
else if(opt[] == 'N') pos++;
}
return ;
}
【维护数列】
题目背景
NOI2005 DAY1 T2
题目描述
请写一个程序,要求维护一个数列,支持以下 6 种操作:(请注意,格式栏中的下划线‘_’表示实际输入文件中的空格)
aaarticlea/png;base64,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" alt="" />
输入格式
第 1 行包含两个数 N 和 M ,N 表示初始时数列中数的个数,M 表示要进行的操作数目。
第 2 行包含 N 个数字,描述初始时的数列。
以下 M 行,每行一条命令,格式参见问题描述中的表格。
输出格式
对于输入数据中的 GET-SUM 和 MAX-SUM 操作,向输出文件依次打印结果,每个答案(数字)占一行。
样例数据 1
输入
9 8
2 -6 3 5 1 -5 -3 6 3
GET-SUM 5 4
MAX-SUM
INSERT 8 3 -5 7 2
DELETE 12 1
MAKE-SAME 3 3 2
REVERSE 3 6
GET-SUM 5 4
MAX-SUM
输出
-1
10
1
10
备注
【样例说明】
初始时,我们拥有数列:
2 -6 3 5 1 -5 -3 6 3
执行操作 GET-SUM 5 4 ,表示求出数列中从第 5 个数开始连续 4 个数字之和,如下图中的灰色部分 1+(-5)+(-3)+6 = -1:
2 -6 3 5 1 -5 -3 6 3
执行操作 MAX-SUM ,表示要求求出当前数列中最大的一段和,即如下图所示,应为 3+5+1+(-5)+(-3)+6+3 = 10:
2 -6 3 5 1 -5 -3 6 3
执行操作 INSERT 8 3 -5 7 2,即在数列中第 8 个数字后插入 -5 7 2,如下所示的灰色部分:
2 -6 3 5 1 -5 -3 6 -5 7 2 3
执行操作 DELETE 12 1,表示删除第 12 个数字,即最后一个:
2 -6 3 5 1 -5 -3 6 -5 7 2
执行操作 MAKE-SAME 3 3 2 ,表示从第 3 个数开始的 3 个数字,即下图中的灰色部分,统一修改为 2 :
2 -6 3 5 1 -5 -3 6 -5 7 2
改为
2 -6 2 2 2 -5 -3 6 -5 7 2
执行操作 REVERSE 3 6,表示取出数列中从第 3 个数开始的连续 6 个数:
aaarticlea/png;base64,iVBORw0KGgoAAAANSUhEUgAAATwAAABGCAYAAABRyygVAAARU0lEQVR4nO2dCViU17nH/8OOMIAgq8jmgkhFZREQfVxxAQLaSKM1dcO9JtXba5Lm1ptce7VRk5pEY8zTNqkGaVyK+xL3PYrgLi64oRYBBYVh3+bOe7yjIKMBnW9mZN7f87zPzHwDc863nP95z3nf73wypQowDMMYASb6rgDDMIyuYMFjGMZoYMFjGMZoYMFjGMZoMNN3BRj9UVtbi6KiImGPHj1qZOrv1FZVVdXk37a2toa9vb1Gc3BwaLTNzIwvRUZ6ZBylbXnU1NTg7t27uHHjBm7evPnEaNvDhw+fCBqderUA1Te5XA5TU9NGv2tlZdVIqFq1agWFQtFIHKurqzXW61lxffDggTBbW9snQkivbdu2hY+PTwPz9vYW5THMy8KC9xpCp6ygoADXr18XovassJGAeHp6wtfXt4HRNkdHxyfCYm5uru9dEZSXlwsxvn37trDs7GyxD/WFkYQ6NzdXeIL1RdDf3x/du3dHYGAgLC0t9b0rjIHDgmfgVFRU4Pz588jIyEB6ejpOnz4thM7Ozg5+fn5o3759I2Fzc3ODTCbTd9Ulobi4WAjirVu3hF26dEkcm8zMTLHvJH49evRASEiIeCVvlWHUsOAZEHV1dbhy5QpOnDghLC0tDZcvX0ZAQADCw8PRs2dPhIWFCZFjb6YhNIQm0SPxU3cO1FF4eXkJ8aPjRseQRJCG5oxxwoKnR/Ly8p6IG9mZM2fE3BU1ULV169ZNBACY5qMWQRI/6jzoGF+9elUMf3v16oUhQ4agX79+PC9oRLDg6RCKih4/fhybNm3C5s2bkZ+fj8jISPTu3RtRUVEIDQ3lxicxpaWlwgM8fPgwduzYITqZPn36YNiwYejfv78QQxMTztZqqbDgSUxZWRn27NkjRG7r1q1o06YNEhIShNEwixuXfqFgyO7du7Fz504cO3ZMdEI09KUOKDY2VgyBmZYDC54EFBYWCoHbuHEj9u3bh+DgYCFw8fHx6NChg76rx7wAEsCTJ0+K4e+WLVtEKs3EiRMxZswYtG7d+oX/S5FzCiYZSvSbaQwLnpaghrJhwwasW7cOR44cwcCBAzFixAjhJZBXx7ye0PzfV199JTqv6OhoJCYmIiYmBjY2No3+9t133xUpP/PmzdNDTZmmwIL3ilAO3JIlS5CcnCwmwKlBxMXFiZ6eaTmQ90adGRl5gBTwSEpKEq+UAkSpMp06dRIe4dGjRxEREaHvKjMaYMF7SSjqt3jxYjFknTx5sujdPTw89F0tRgfQPF9qaiqWLVsm7kh57733sGvXLqxatUp8T9MWlC9Jd48whgULXjOgPLlt27YJoaP0hjlz5mDKlCmc3Gqk0PVAkV7y9CjFqD5Tp07FihUr9FQz5nmw4DUBSidZv369mJuhoc0HH3wghI5TSBhi1KhRWLNmTaPtFJWnOVzGcGDB+xn279+PmTNnstAxGjl79qy4nU0Trq6u4m4PZ2dnHdeKeR6cBPYzULb+pEmTRHBi1qxZLHZMA8jrpzQUTUbpSdRZsk9hOLCHxzCM0cAeHsMwRgMLHsMwRgMLHsMwRkOLe5AArR9HK+Q+j3Pnzr3S7wcFBWncfu/ePbi7u0tWLi0TpWm6lfK/XFxcnrvg56uWS0tUaVqunZJvnZycNC4Fr41yn3ecaSXkF63WLEW5dNzpONPCqs9Dqv0l+K4N7dHighbbt28Xy4W3NGhVFUp01TW0WCatuszoD0qFYrQDD2kZhjEaWPAYhjEaWPAYhjEaWPAYhjEaNEdplaXI2vk91hzLhXXAMLydGA5XPS3iWqfIwsFth3Db8hcY9kY4XKSIKysrkXfxONKvF8PC/RcID/GFnebgI5erNWpRfP0Csh7ViE+mdn4I7Nga0l5mSlQ9uITjaVkosvBE91490K6VLvr8OlTkZeF8ViHM2gYiyNcOujzc1Xk/Ycfhu6hUAjJzN0QM6wNPrT/0rgZ5x7fj8J1KPI2CmsE5bCj6+lhD0oeGNkOvNERpy3BmfhzG7XVGsGs+9vxwACXx/8CZf42Dt06TWKpwe8P7mLRChqQv5iGxs22T3NHmR2mrcGf7Mnx32RZecgUupV9FZdB4zJ0WCSdJr8rmlau9KG3zypUqSlunOIvvFq/GFfHTlvBOmIVpUU6SCkHN/Z+wZvMtyF1NcfvIXlywScB/fxADDylVtqYQp1NX4RCi8FZ8CNysmi+wrxSlrbuPzWP7YNp+hRAdm9A/Yfe/Jmq/LSsOIKnLG9hm7gEHC1VJymo8uFGBxENZ+DpSyvvPm6dXjTcVn8Fe57/g2N7usJHVoWDseHSO+V98d2UUPg7U1bNQa3EvNQn9/8sBfz36BQY4StgLl9/BZdtEvD+7HSxV+1sS+Q98tHQbjuWF4g0pW4KxlduAauSlnYffjAVIctNVL1qLsgpPxI+PhFylqtVBZvho4XncLh+qEjyJrq+6Ipxa9Rk2Wf8G773VGTZ6mECqvJKC7ZGbcCvZHxaSlaJEUeYNDPkxF3/rYvPYm1PsR9LgVIztJvFiG83Uq8anwDYEMyZ2U/3z46+dev0KwaorxESHT7Kvy9+I307agZBP/wf9pRQ7wtILfaM8VY2fPpjAtn0ovCxNVCdN4v01tnLroSzJxJbtqmHW37/BmoPXUFyri1JNYdeunRC7xx8t4Ni1L/wlU6E6VVtMwfcXvDEy3l8vYgdlAXZ9PB8rF4xB4qwVOJLXOIFcO8hgHz4Rv1KLnQpF+mpcCvs1pNa75upV49NgYglrs6d/XJ17AYX+b2NkB+n6h4bUIHvtAmwocof9ic8wY3gYAntPxreZpZAkQ9rEHBamT/e3tigHpW7hCJZkstCIy61HnVKOkOEJCHdT4ETKYsxdug85VTorHrXFV7FnQxY6DgqCvVRj6NpCZOw4g3J7a9zcnYLlCz7Gou+PIqdSh3n+tXVwTpyPP73dGXnJ09GnUyy+zCzXQcEKpK/OROjobpB8MbVm6tWL+x1lMY7/9TD6/+UdBOhK71CC81vPA8Ez8Ic/zsfXqdvxifcGJMXMRXqZxEUry3HjSBb8EwfAXZfzlUZWrqncDyF9BuPNpPex4MNfwvPaeiSnFUIX95HUVeTiQtopZN27gu2ffo5dORJ5PZX/xrl/A179hiJm+BhMe2cEnE6vwtJN2dCZtps5I2LkZPznwmT8dDMdC7sdwZwpq3FHao9akYGUzFCMlty9e4Ym6NULLvM6FB78HGvbL8LCPvYSDXjqkL/jPUxbmgkxd23REZOXzYGiqBb2nQLgIirtjEG/Gw33lG34MfsThEmmvHUovboX6c5v4s2OEkeVjKZc1bDuQipW78uBkBUzV/T59Uj0cFC7VTJYeQ/C2LgT+DQzD1W9HWElcbkmVm7oNmgUgnqHI3XeQhxOy8PQ4Z5aKbVBDarLUF5nDVc3+eNGJg/AgDB7pJ2/iIJf+mi5g9HQjpZ/hhEeTwuRyUMw+28fIbnvblwtn4R2Ej5fSJGxGplhSdIPZxvQNL16zmFXouziSiw5Mwjz3g2U0C2VwcavP0YkBkIkJ5i2QSc7ezzo4IDqAsXjbSosXDvD1eoQ5JZSTYQoUZXzE/bcCUD8AA8JJ3eNrVwZLNv4o0eIO4RTYWILV8tnL0VT2Hm6wqlSrsUI7c+XK7Nqi5DuzrhgKs01ZWLlBBfrWpRUqP1WM9iR+GVZwUzrvYuGdmTbeL/M3YLg71MCZ0ljUwpkpKiGsxODpB/OPqHpeqVB8FT/nLkS89a3wfTfB8O6qhzFBWewebclEsYHQ7vP51KdKP9Y/Ma/4daSGWPgOnItThbFIdpehqq8LFSHTkRsO0mS8ETj35phi77RXrCorUJ50R2cvWSO7r28tORxGGu5KuFx64qIBouMKFFdlIuHquGWi42piGRevmiDftHuWszB01SuqqiaKihNLSCmMOvKkFfYBhEJLlortQEUHAqX45uMWygP6gJrWQ2K82vhE9UVjlqfN9TcjpSq4fuVuxbo0MFR1dBrcW/vTjj99vfoImWyRckp/DMzDBOCdCV3zdOrRgpSkfk54sL/A/tLgIUfq7e2QtyGbIyRuu7/j23EfKz93RjMeudzlLzliFOpJvjj99PRQYKeqTpnL5Z9sg5XKoEft6q3WqDr9D8jXPvFGW259WqAuzu/wCcHTNA5NADucjt4Rb6JCO2rQEOUpTj/zR/w9V1f9A7vCLvaMphFjcUQySYvreA3fAoG/n0t/rm3EmE2t3FKFosJfV10lnRcce7PGBq+HKaD3kJ0gAtcgsdj4VgvSdeEK8lIwcXQCdCV3jVXrwx4eSiVJ1KYjVuPrNHOxxXWTRx58PJQ2kWSxGNlNRQPClBm7oA2Dla6u+tAJXKF9x+h0kyONo5ySJV+1wBlDUoLVPtq0RpOdhYvdS/nyyceK1Fx/6aqDVmhra8H5DoITFXdv4a7Fr7wkyz8/WoY8AKgMlg4+qCTo77rwWgdmTnkzm5anh5pAqat4Oim48ihzAw2bVxho9tS1YXDytkPnXX4lEgL5w7w011xzYYXD2AYxmhgwWMYxmhgwWMYxmgw4KAFwzCMdmEPj2EYo4EFj2EYo4EFj2EYo4EFj2EYo8GAE48Ng7KyMsyePRvl5c9fR2zYsGEYPXq0DmvFvC7cu3cPeXl56N69u76rwoAF72dp1aoVIiMjMWHCBI3f0y1fH374oY5rxRg6JHSLFi3CypUr8e2337LgGQg8pG0C48ePx+TJkzV+R55d586ddVwjxlC5ceMGZs6cicDAQPH54sWLGD58uJ5rxahhwWsiX375JYKDgxttl8vlePDggR5qxBgKlMp64sQJJCYmYsCAAXB2dhZCt2TJEri7u+u7ekw9eEjbRGjVkPXr1yMkJAQPHz4U22jurm3btujRowciIiIwdepUDBw4EDIdPvCI0R+0Ks/q1auRkpKCdu3aYdq0afjhhx9gamqYK4UwfKdFs9m2bRvi4uLE3B314jScpYAGzdUsXboUtbW1mD59OsaNGwcHBwd9V5fRMrm5uUhNTcW6devE+afpDhI6Pz9DXiOEUcOC9xLMnTsXN2/eRHJycoPtdCgPHjyI5cuXY9euXRg0aBASEhIQGxsLR0de5+p1pb7IZWRkICYmRgxf6dXa2lrf1WOaAQveS0BeXH5+/gvnZygVYcuWLdi0aRMOHDiA0NBQIX7x8fHsDbwG5OTkYOPGjY1EjqYxKHLPvJ6w4OmA0tJS7N69W4jf1q1b4ebmJsRv8ODBYk7QxkY/y0MyT6FmQENUOkdk169fF+dn5MiRLHItCBY8HUPe4bFjx0SjOnToEC5cuIBOnTqhZ8+eIt8vOjoanp7af2wg05Di4mKcPHlSRFfJ6D11ROTJkcCFh4fDzIxjei0NFjw9Q8+LOHv2rGh0JIT79u2Dq6uraHRkFP3leaJXo7q6WnQsanFLS0vDrVu3hHcdFRUljDobJycnfVeVkRgWPAODHtRz7tw5MQTes2ePaJw0nGrfvr2Y+yPr0qWLyNyn9xQtZp5CEfOrV6+KeTey9PR0IXZeXl7Ca1Nb165dYW4u6QNaGQOEBe81oLCwUGTwk9HcEjVgaswUPaSGS+IXEBDwRBB9fHxgYaG7x3rrEuoQKKBAUXK1qY8NGR0rX19fkRtJHhwFi+g9JYgzDAveawzNQ50+fRqnTp3CtWvXxDCN7M6dO2jdujW8vb2FZ1PfPDw8xHeUI0giYEgeIg09i4qK8OjRIxQUFCA7O7uBsJGp941ETW31vV/aP0PaJ8awYMFrgdAppdvd1AKoNhIMSqchUSFTKBTiDhJ7e3uNRqL47DaKKDf1TpLKykohXk01qnf9sih4U1/YyEjEeU6TeVlY8IwcCpqoBVCTkRDV/0wpNk2FhtVqb1Jt9YW0/jayljoMZwwHFjyGYYwGnuxgGMZoYMFjGMZo+D/TfUbeBf4wBwAAAABJRU5ErkJggg==" alt="" />
如上所示的灰色部分 2 2 2 -5 -3 6 ,翻转后得到 6 -3 -5 2 2 2 ,并放回原来位置:
2 -6 6 -3 -5 2 2 2 -5 7 2
最后执行 GET-SUM 5 4 和 MAX-SUM ,不难得到答案 1 和 10 。
aaarticlea/png;base64,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" alt="" />
【评分方法】
本题设有部分分,对于每一个测试点:
- 如果你的程序能在输出文件正确的位置上打印 GET-SUM 操作的答案,你可以得到该测试点 60% 的分数;
- 如果你的程序能在输出文件正确的位置上打印 MAX-SUM 操作的答案,你可以得到该测试点 40% 的分数;
- 以上两条的分数可以叠加,即如果你的程序正确输出所有 GET-SUM 和 MAX-SUM 操作的答案,你可以得到该测试点 100% 的分数。
请注意:如果你的程序只能正确处理某一种操作,请确定在输出文件正确的位置上打印结果,即必须为另一种操作留下对应的行,否则我们不保证可以正确评分。
【数据规模和约定】
你可以认为在任何时刻,数列中至少有 1 个数。
输入数据一定是正确的,即指定位置的数在数列中一定存在。
50% 的数据中,任何时刻数列中最多含有 30,000 个数;
100% 的数据中,任何时刻数列中最多含有 500,000 个数。
100% 的数据中,任何时刻数列中任何一个数字均在 [-1,000,1,000] 内 。
100% 的数据中,M≤20,000,插入的数字总数不超过 4,000,000 个,输入文件大小不超过 20 MBytes 。
【题目分析】
除了子串和,其他都没什么难的。
通过本题也学到了求最大子串和的方法:多记录$lx(从左端起最大和), rx(从右端起最大和), mx(最大子串和)$
更新时(当前节点为$k$, 左儿子$lc$, 右儿子$rc$):
$k->lx = max(lc->lx, lc->sum + rc->lx)$
rx同理
【CODE】
AC代码。
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<algorithm>
#include<ctime>
#include<cmath>
#include<vector>
using namespace std; const int N = , oo = ;
#define SZ(x) (x?x->sze:0)
#define SUM(x) (x?x->sum:0)
#define LX(x) (x?x->lx:-oo)
#define RX(x) (x?x->rx:-oo)
#define MX(x) (x?x->mx:-oo) struct node{
node *lc, *rc;
int pri, val, sze;
int rev, tag;
int lx, rx, mx;
int sum;
inline node* upt(){
sze = SZ(lc) + SZ(rc) + ;
sum = SUM(lc) + val + SUM(rc);
lx = max(LX(lc), SUM(lc)+ val + max(, LX(rc)));
rx = max(RX(rc), SUM(rc) + val + max(, RX(lc)));
mx = max(, LX(rc)) + val + max(, RX(lc));
mx = max(mx, max(MX(lc), MX(rc)));
return this;
}
inline void pushDown(){
if(rev){
if(lc)lc->reverse();
if(rc)rc->reverse();
rev = ;
}
if(tag != ){
if(lc) lc->cover(tag);
if(rc) rc->cover(tag);
tag = ;
}
}
inline void print(){
if(lc) lc->print();
pushDown(), upt(), cout<<val<<" ";
if(rc) rc->print();
}
inline void cover(const int &v){
val = v, sum = v * sze;
lx = rx = mx = max(sum, v);
tag = v;
}
inline void reverse(){
swap(lc, rc);
swap(lx, rx);
rev ^= ;
}
}pool[N], *root, *tail = pool, *rec[N];
int n, m, recTop; inline int Rand(){
static int RAND_VAL = ;
return RAND_VAL += RAND_VAL << | ;
} inline int Re(){
int i = , f = ; char ch = getchar();
for(; (ch < '' || ch > '') && ch != '-'; ch = getchar());
if(ch == '-') f = -, ch = getchar();
for(; ch >= '' && ch <= ''; ch = getchar())
i = (i << ) + (i << ) + (ch - '');
return i * f;
} inline void Wr(int x){
if(x < ) putchar('-'), x = -x;
if(x > ) Wr(x / );
putchar(x % + '');
} inline void recycle(node *u){
rec[++recTop] = u;
} inline void clear(node *u){
if(u->lc) clear(u->lc);
if(u->rc) clear(u->rc);
recycle(u);
} inline node* NewNode(const int &v){
node *x;
if(recTop) x = rec[recTop--];
else x = tail++;
x->pri = rand();
x->val = x->sum = x->lx = x->rx = x->mx = v;
x->sze = ;
x->lc = x->rc = NULL;
x->rev = ;
x->tag = ;
return x;
} inline node* Merge(node *u, node *v){
if(!u) return v;
if(!v) return u;
if(u->pri < v->pri){
u->pushDown();
u->rc = Merge(u->rc, v);
return u->upt();
}
else{
v->pushDown();
v->lc = Merge(u, v->lc);
return v->upt();
}
} inline void Split_k(node *u, const int &k, node *&x, node *&y){
if(!u){
x = y = NULL;
return;
}
u->pushDown();
if(SZ(u->lc) < k){
Split_k(u->rc, k - SZ(u->lc) - , x, y);
u->rc = NULL, u->upt();
x = Merge(u, x);
}
else{
Split_k(u->lc, k, x, y);
u->lc = NULL, u->upt();
y = Merge(y, u);
}
} inline node* build(int*, int);
int t[N];
inline node* Insert(const int &pos, const int &l){
node *L, *R;
Split_k(root, pos, L, R);
for(int i = ; i <= l; i++)
t[i] = Re();
node *tmp = build(t, l);
return Merge(Merge(L, tmp), R);
} inline node* Delete(const int &l, const int &r){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
if(p) clear(p);
return Merge(L, q);
} inline node* MakeSame(const int &l, const int &r, const int &v){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
if(p) p->cover(v);
return Merge(L, Merge(p, q));
} inline void PrintSum(const int &l, const int &r){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
int ret = ;
if(p) ret = SUM(p);
root = Merge(L, Merge(p, q));
Wr(ret), putchar('\n');
} inline node* Reverse(const int &l, const int &r){
node *L, *R, *p, *q;
Split_k(root, l - , L, R);
Split_k(R, r - l + , p, q);
if(p) p->reverse();
return Merge(L, Merge(p, q));
} inline node* build(int *a, int len){
static node *stack[N], *pre, *u;
int top = ;
for(int i = ; i <= len; i++){
u = NewNode(a[i]);
pre = NULL;
while(top && stack[top]->pri > u->pri){
pre = stack[top]->upt();
stack[top--] = NULL;
}
if(top)
stack[top]->rc = u;
u->lc = pre;
stack[++top] = u;
}
while(top) stack[top--]->upt();
return stack[];
} int main(){
// freopen("h.in", "r",stdin);
n = Re(), m = Re(); Rand();
int a[N];
for(int i = ; i <= n; i++) a[i] = Re();
root = build(a, n);
for(int i = ; i <= m; i++){
char opt[];
int pos, tot, v;
scanf("%s", opt + );
if(opt[] == 'I'){
pos = Re(), tot = Re();
root = Insert(pos, tot);
}
else if(opt[] == 'D'){
pos = Re(), tot = Re();
root = Delete(pos, pos + tot - );
}
else if(opt[] == 'M'){
if(opt[] == 'K'){
pos = Re(), tot = Re(), v = Re();
root = MakeSame(pos, pos + tot - , v);
}
else{
Wr(root->mx), putchar('\n');
}
}
else if(opt[] == 'R'){
pos = Re(), tot = Re();
root = Reverse(pos, pos + tot - );
}
else if(opt[] == 'G'){
pos = Re(), tot = Re();
PrintSum(pos, pos + tot - );
}
// root->print();cout<<endl;
}
return ;
}
【无旋式treap】例题的更多相关文章
-
【无旋 treap】例题
[bzoj3223]文艺平衡树 Description 您需要写一种数据结构(可参考题目标题),来维护一个有序数列,其中需要提供以下操作:翻转一个区间,例如原有序序列是5 4 3 2 1,翻转区间是[ ...
-
NOIP 模拟 序列操作 - 无旋treap
题意: 一开始有n个非负整数h[i],接下来会进行m次操作,第i次会给出一个数c[i],要求选出c[i]个大于0的数并将它们-1,问最多可以进行多少次? 分析: 首先一个显然的贪心就是每次都将最大的c ...
-
[转载]无旋treap:从单点到区间(例题 BZOJ1500&;NOI2005 维护数列 )
转自ZZH大佬,原文:http://www.cnblogs.com/LadyLex/p/7182631.html 1500: [NOI2005]维修数列 Time Limit: 10 Sec Mem ...
-
[转载]无旋treap:从好奇到入门(例题:bzoj3224 普通平衡树)
转载自ZZH大佬,原文:http://www.cnblogs.com/LadyLex/p/7182491.html 今天我们来学习一种新的数据结构:无旋treap.它和splay一样支持区间操作,和t ...
-
[您有新的未分配科技点]无旋treap:从好奇到入门(例题:bzoj3224 普通平衡树)
今天我们来学习一种新的数据结构:无旋treap.它和splay一样支持区间操作,和treap一样简单易懂,同时还支持可持久化. 无旋treap的节点定义和treap一样,都要同时满足树性质和堆性质,我 ...
-
[您有新的未分配科技点] 无旋treap:从单点到区间(例题 BZOJ1500&;NOI2005 维护数列 )
1500: [NOI2005]维修数列 Time Limit: 10 Sec Memory Limit: 64 MB Description Input 输入的第1 行包含两个数N 和M(M ≤20 ...
-
【算法学习】Fhq-Treap(无旋Treap)
Treap——大名鼎鼎的随机二叉查找树,以优异的性能和简单的实现在OIer们中广泛流传. 这篇blog介绍一种不需要旋转操作来维护的Treap,即无旋Treap,也称Fhq-Treap. 它的巧妙之处 ...
-
无旋treap的简单思想以及模板
因为学了treap,不想弃坑去学splay,终于理解了无旋treap... 好像普通treap没卵用...(再次大雾) 简单说一下思想免得以后忘记.普通treap因为带旋转操作似乎没卵用,而无旋tre ...
-
[BZOJ3223]文艺平衡树 无旋Treap
3223: Tyvj 1729 文艺平衡树 Time Limit: 10 Sec Memory Limit: 128 MB Description 您需要写一种数据结构(可参考题目标题),来维护一个 ...
随机推荐
-
Merge用法
Merge用来从一个表中选择一些数据更新或者插入到另一个表中.而最终是用更新还是用插入的方式取决于该语句中的条件. 下面我们简单的举一个例子: SQL> create table merge ...
-
Demo学习: ClientInfo
ClientInfo 获取客户端环境参数,从0.9版本开始新增了TUniClientInfoRec对象,可以得到客户端的一些信息,之前为了获取浏览器版本号需要自己写函数,现在可以直接使用TUniCli ...
-
XXX 用户 is not in the sudoers file. This incident will be reported 的问题解决方案
说的是,这种问题,是出现在ubuntu系统里. root@SparkSingleNode:/usr/local/jdk# pwd /usr/local/jdk root@SparkSingleNode ...
-
Redis教程03——Redis 发布/订阅(Pub/Sub)
Pub/Sub 订阅,取消订阅和发布实现了发布/订阅消息范式(引自wikipedia),发送者(发布者)不是计划发送消息给特定的接收者(订阅者).而是发布的消息分到不同的频道,不需要知道什么样的订阅者 ...
-
VSCode里的一些有用的插件
1.EaseServer 作用:开启本地 http server,然后在browser里打开html: 在调试页面的时候,打开页面比较方便,不需要先开启server,再打开html 2.Debugge ...
-
[转载] Dubbo实现RPC调用使用入门
转载自http://shiyanjun.cn/archives/341.html 使用Dubbo进行远程调用实现服务交互,它支持多种协议,如Hessian.HTTP.RMI.Memcached.Red ...
-
Material Theme 文件名的标签(tab)被大写了
我们平时使用的都是小写的,今天第一次使用Material Theme 这个发现标签被大写了,百度后没找到然后自己找了找设置,解决了 原来是这样的, 设置如下 设置后: 希望能帮到有同样问题的同学
-
paho.mqtt.c打印日志
mqtt中自身就带有日志系统Log.h和Log.c,这些日志文件是在客户端调用MQTTClient_create函数是初始化的,MQTTClient_create源码如下: int MQTTClien ...
-
UILTView经典知识点练习
作者:韩俊强 未经允许,请勿转载! 关注博主:http://weibo.com/hanjunqiang 声明:UILTView 指:UILabel 和 UITextField 的复合 #impor ...
-
灵活的按键处理程序 FlexibleButton
前言 正好工作中用到按键处理,需要处理单击.长按等按键事件,然后就造了这么一个*,为了以后更方便地加入其它的项目中使用,遂将其开源到 GitHub 中. 后面发现 RT-Thread 软件包里也有一 ...