北京化工大学1/17寒假集训题解（＞1800）
目录
A - 文艺平衡树
B - 可持久化文艺平衡树
C - 可持久化平衡树
主要思路：FHQ Treap + 可持久化
D - 维护数列
初始化
Insert操作
Delete操作
Reverse操作
Make-Same操作
Get-Sum操作
Max-Sum操作
懒标记的处理
E - 文本编辑器
A - 文艺平衡树
这里的Splay维护是按照的是序列中的编号排序
那么，继续考虑，其实最终的结果也就是整颗Splay的中序遍历（平衡树的性质诶）
那么，现在如果按照权值来维护显然是不正确的
继续找找规律，发现，如果一个点在序列中的位置为第K个
那么，他就是平衡树的第K大（就当做普通的Splay来看的话）
所以，序列中的位置就变成了区间的第K大点
继续考虑如何翻转
翻转也就是整颗子树的每一个节点的左右儿子交换
因此，只要在根节点的地方打一个标记
在旋转之前下方一下标记就行了
最后输出的时候输出的就是Splay的中序遍历
至于初始的Splay怎么建立，可以直接构造完美的Splay
像我这种比较懒得，直接弄了一个insert。。。
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
using namespace std;
#define MAX 200000
inline int read()
{int x=0,t=1;char ch=getchar();while((ch<'0'||ch>'9')&&ch!='-')ch=getchar();if(ch=='-')t=-1,ch=getchar();while(ch<='9'&&ch>='0')x=x*10+ch-48,ch=getchar();return x*t;
}
struct Node
{int ch[2];int ff,v;int size;int mark;void init(int x,int fa){ff=ch[0]=ch[1]=0;size=1;v=x;ff=fa;}
}t[MAX];
int N,root,M,tot;
inline void pushup(int x)
{t[x].size=t[t[x].ch[0]].size+t[t[x].ch[1]].size+1;
}
inline void pushdown(int x)
{if(t[x].mark){t[t[x].ch[0]].mark^=1;t[t[x].ch[1]].mark^=1;t[x].mark=0;swap(t[x].ch[0],t[x].ch[1]);}
}
inline void rotate(int x)
{int y=t[x].ff;int z=t[y].ff;int k=t[y].ch[1]==x;t[z].ch[t[z].ch[1]==y]=x;t[x].ff=z;t[y].ch[k]=t[x].ch[k^1];t[t[x].ch[k^1]].ff=y;t[x].ch[k^1]=y;t[y].ff=x;pushup(y);pushup(x);
}
inline void Splay(int x,int goal)
{while(t[x].ff!=goal){int y=t[x].ff;int z=t[y].ff;if(z!=goal)(t[z].ch[1]==y)^(t[y].ch[1]==x)?rotate(x):rotate(y);rotate(x);}if(goal==0)root=x;
}
inline void insert(int x)
{int u=root,ff=0;while(u)ff=u,u=t[u].ch[x>t[u].v];u=++tot;if(ff)t[ff].ch[x>t[ff].v]=u;t[u].init(x,ff);Splay(u,0);
}
inline int Kth(int k)
{int u=root;while(233){pushdown(u);if(t[t[u].ch[0]].size>=k)u=t[u].ch[0];else if(t[t[u].ch[0]].size+1==k)return u;else k-=t[t[u].ch[0]].size+1,u=t[u].ch[1];}
}
void write(int u)
{pushdown(u);if(t[u].ch[0])write(t[u].ch[0]);if(t[u].v>1&&t[u].v<N+2)printf("%d ",t[u].v-1);if(t[u].ch[1])write(t[u].ch[1]);
}
inline void Work(int l,int r)
{l=Kth(l);r=Kth(r+2);Splay(l,0);Splay(r,l);t[t[t[root].ch[1]].ch[0]].mark^=1;
}
int main()
{N=read();M=read();for(int i=1;i<=N+2;++i)insert(i);while(M--){int l=read(),r=read();Work(l,r);}write(root);printf("\n");return 0;
}
B - 可持久化文艺平衡树
FHQ Treap其实是一种加强版的Treap。与一般的Treap树不同，FHQ Treap不依赖旋转操作保持自身结构的平衡，而是依赖分裂和合并操作维持树的平衡性质。
我们先来介绍一下关键操作:
代码如下
#include<cstdio>
#include<cstring>
#include<cmath>
#include<climits>
#include<cstdlib>
#include<ctime>
#include<algorithm>
#include<complex>
#include<iostream>
#include<map>
#include<queue>
#include<vector>
#define ll long long
#define INF 0x3f3f3f3f
#define ls(p) tree[p].lson
#define rs(p) tree[p].rson
#define tls(p) tree[ls(p)]
#define trs(p) tree[rs(p)]
#define t(p) tree[p]
#define tpi t(++tot)
#define tp t(tot)
using namespace std;
const int N(2e5);
int n;ll lastans;
struct node
{int rand,size,tag;ll val,sum;int lson,rson;
}tree[(N<<7)+10];
int rt[N+10];
inline int new_node(long long v=0)
{static int tot(0);tpi.val=v;tp.sum=v;tp.rand=rand();tp.size=1;return tot;
}
inline int copy_node(int p)
{int ret=new_node();tree[ret]=tree[p];return ret;
}
inline void push_up(int p)
{tree[p].size=tls(p).size+trs(p).size+1;tree[p].sum=tls(p).sum+trs(p).sum+t(p).val;
}
inline void push_down(int p)
{if(!t(p).tag)return;if(ls(p))ls(p)=copy_node(ls(p));if(rs(p))rs(p)=copy_node(rs(p));swap(ls(p),rs(p));if(ls(p))tls(p).tag^=1;if(rs(p))trs(p).tag^=1;tree[p].tag=0;
}
void split(int p,int k,int &x,int &y)
{if(!p){x=y=0;return;}push_down(p);if(tls(p).size<k){x=copy_node(p);split(rs(x),k-tls(p).size-1,rs(x),y);push_up(x);}else{y=copy_node(p);split(ls(y),k,x,ls(y));push_up(y);}
}
int merge(int x,int y)
{if(!x||!y)return x|y;push_down(x);push_down(y);if(t(x).rand<t(y).rand){rs(x)=merge(rs(x),y);push_up(x);return x;}else{ls(y)=merge(x,ls(y));push_up(y);return y;}
}
int main()
{srand(224144);scanf("%d",&n);int cnt(0);int v,op;ll a,b;int x,y,z;while(n--){scanf("%d%d",&v,&op);if(op==1){scanf("%lld%lld",&a,&b);a^=lastans;b^=lastans;split(rt[v],a,x,y);rt[++cnt]=merge(merge(x,new_node(b)),y);}if(op==2){scanf("%lld",&a);a^=lastans;split(rt[v],a,x,z);split(x,a-1,x,y);rt[++cnt]=merge(x,z);}if(op==3){scanf("%lld%lld",&a,&b);a^=lastans;b^=lastans;split(rt[v],b,x,z);split(x,a-1,x,y);t(y).tag^=1;rt[++cnt]=merge(merge(x,y),z);}if(op==4){scanf("%lld%lld",&a,&b);a^=lastans;b^=lastans;split(rt[v],b,x,z);split(x,a-1,x,y);printf("%lld\n",lastans=t(y).sum);rt[++cnt]=merge(merge(x,y),z);}}return 0;
}C - 可持久化平衡树
主要思路：FHQ Treap + 可持久化
普通FHQ Treap加上一点可持久化的东西如下：(打上注释的代码是可持久化的特殊操作)
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<string>
#include<vector>
#include<set>
#include<queue>
#include<stack>
using namespace std;
#define go(i,j,n,k) for(int i=j;i<=n;i+=k)
#define fo(i,j,n,k) for(int i=j;i>=n;i-=k)
#define rep(i,x) for(int i=h[x];i;i=e[i].nxt)
#define mn 500010
#define ld long double
#define fi first
#define se second
#define inf 1<<30
#define ll long long
#define root 1,n,1
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
#define bson l,r,rt
inline ll read(){ll x=0,f=1;char ch=getchar();while(ch>'9'||ch<'0'){if(ch=='-')f=-f;ch=getchar();}while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}return x*f;
}
struct edge{int ch[2], sze, pri;ll w;
} z[mn * 50];
int rot[mn], xx, yy, zz, n, cnt;
inline void update(int rt) {z[rt].sze = 1;if(z[rt].ch[0]) z[rt].sze += z[z[rt].ch[0]].sze;if(z[rt].ch[1]) z[rt].sze += z[z[rt].ch[1]].sze;
}
inline int newnode(ll w = 0) {z[++cnt].w = w;z[cnt].sze = 1;z[cnt].pri = rand();return cnt;
}
inline int merge(int x, int y) {if(!x || !y) return x + y;if(z[x].pri < z[y].pri) {int rt = newnode();z[rt] = z[x];z[rt].ch[1] = merge(z[rt].ch[1], y);update(rt);return rt;} else {int rt = newnode();z[rt] = z[y];z[rt].ch[0] = merge(x, z[rt].ch[0]);update(rt);return rt;}
}
inline void split(int rt, ll k, int &x, int &y) {if(!rt) x = y = 0;else {if(z[rt].w <= k) {x = newnode();z[x] = z[rt];split(z[x].ch[1], k, z[x].ch[1], y);update(x);} else {y = newnode();z[y] = z[rt];split(z[y].ch[0], k, x, z[y].ch[0]);update(y);} }
}
inline int findkth(int rt, int k) {while(1119) {if(k <= z[z[rt].ch[0]].sze)rt = z[rt].ch[0];else {if(z[rt].ch[0]) k -= z[z[rt].ch[0]].sze;if(!--k) return rt;rt = z[rt].ch[1];}}
}
int main(){n = read();go(i, 1, n, 1) {xx = yy = zz = 0;int tmp = read(), s = read(); ll a = read();rot[i] = rot[tmp];if(s == 1) {split(rot[i], a, xx, yy);rot[i] = merge(merge(xx, newnode(a)), yy);} else if(s == 2) {split(rot[i], a, xx, zz);split(xx, a - 1, xx, yy);yy = merge(z[yy].ch[0], z[yy].ch[1]);rot[i] = merge(merge(xx, yy), zz);} else if(s == 3) {split(rot[i], a - 1, xx, yy);printf("%lld\n", z[xx].sze + 1);rot[i] = merge(xx, yy);} else if(s == 4) {printf("%lld\n", z[findkth(rot[i], a)].w);} else if(s == 5) {split(rot[i], a - 1, xx, yy);if(xx == 0) {printf("-2147483647\n");continue;}printf("%lld\n", z[findkth(xx, z[xx].sze)].w);rot[i] = merge(xx, yy); } else if(s == 6) {split(rot[i], a, xx, yy);if(yy == 0) {printf("2147483647\n");continue;}printf("%lld\n", z[findkth(yy, 1)].w);rot[i] = merge(xx, yy);}}return 0;
}D - 维护数列
首先，要有一点splay维护区间操作的基础。
splay维护区间的基本原理，就是将区间[l,r]的端点l-1,和r+1不断的通过伸展操作即splay到根，将l-1伸展到根，将r+1伸展到根的右儿子，那么[l,r]这段区间就在根的右儿子的左儿子上了。
特别要注意的是，==这里的l,r不是给出的区间端点的编号，而是我们在平衡树的中序遍历中区间端点的编号。即在平衡树中排名(rank)为l,r的两个节点的真实编号，而对于l=1或r=n的情况就非常特殊了，我们有两种解决方案，一种就是分类讨论，将这4种情况枚举，然后进行操作，这么做固然可行，但是当操作变多时，会使整个程序显得繁琐，并且难于调试。另一种解决方案就是建立虚拟节点，我们把需要维护的区间全部变成[l+1,r+1]，那么我们虚拟出一个1号节点和一个n+2号节点，那么整个操作就显得十分自然了==。
那么问题就明显是一个splay的基本模板题了。而维护区间翻转，在洛谷的P3391文艺平衡树中有更裸的题目。
这里，一个操作一个操作的解决。
初始化
首先，对于原序列，我们不应该一个一个读入，然后插入，那么效率就是O(nlogn),而splay的常数本身就很大，所以考虑一个优化，就是把原序列一次性读入后，直接类似线段树的build，搞一个整体建树，即不断的将当前点维护的区间进行二分，到达单元素区间后，就把对应的序列值插入进去，这样，我们一开始建的树就是一个非常平衡的树，可以使后续操作的常数更小，并且建树整个复杂度只是O(2n)的。
Insert操作
其次，我们来考虑一下如何维护一个insert操作。我们可以这么做，首先如上将需要insert的区间变成节点数目为tot的平衡树,然后把k+1（注意我们将需要操作的区间右移了一个单位，所以题目所给k就是我们需要操作的k+1）移到根节点的位置，把原树中的k+2移到根节点的右儿子的位置。然后把需要insert的区间，先build成一个平衡树，把需要insert的树的根直接挂到原树中k+1的左儿子上就行了。
Delete操作
再然后，我们来考虑一下delete操作，我们同样的，把需要delete的区间变成[k+1,k+tot]（注意，是删去k后面的tot个数，那么可以发现我们需要操作的原区间是[k,k+tot-1]!），然后把k号节点移到根节点的位置，把k+tot+2移到根节点的右儿子位置，然后直接把k+tot+2的左儿子的指针清为0，就把这段区间删掉了。可以发现，比insert还简单一点。
Reverse操作
接下来，这道题的重头戏就要开始了。splay的区间操作基本原理还类似于线段树的区间操作，即延迟修改，又称打懒标记。
对于翻转（reverse）操作，我们依旧是将操作区间变成[k+1,k+tot]，然后把k和k+tot+1分别移到对应根的右儿子的位置，然后对这个右儿子的左儿子打上翻转标记即可。
Make-Same操作
对于Make-Same操作，我们同样需要先将需要操作的区间变成[k+1,k+tot]，然后把k和k+tot+1分别移到根和右儿子的位置，然后对这个右儿子的左儿子打上修改标记即可。
Get-Sum操作
对于Get-Sum操作，我们还是将操作区间变成[k+1,k+tot],然后把k和k+tot+1分别移到根和右儿子的位置，然后直接输出这个右儿子的左儿子上的sum记录的和。
Max-Sum操作
对于这个求最大子序列的操作，即Max-Sum操作，我们不能局限于最开始学最大子序列的线性dp方法，而是要注意刚开始，基本很多书都会介绍一个分治的O(nlogn)的方法，但是由于存在O(n)的方法，导致这个方法并不受重视，但是这个方法确实很巧妙，当数列存在修改操作时，线性的算法就不再适用了。
这种带修改的最大子序列的问题，最开始是由线段树来维护，具体来说就是，对于线段树上的每个节点所代表的区间，维护3个量：lx表示从区间左端点l开始的连续的前缀最大子序列。rx表示从区间右端点r开始的连续的后缀最大子序列。mx表示这个区间中的最大子序列。
那么在合并[l,mid]和[mid+1,r]时，就类似一个dp的过程了！
懒标记的处理
最后，相信认真看了的童鞋会有疑问，这个标记怎么下传呢？首先，我们在每次将k和k+tot+1移到对应的位置时，需要一个类似查找k大值的find操作，即找出在平衡树中，实际编号为k在树中中序遍历的编号，这个才是我们真正需要处理的区间端点编号，那么就好了，我们只需在查找的过程中下传标记就好了！（其实线段树中也是这么做的），因为我们所有的操作都需要先find一下，所以我们可以保证才每次操作的结果计算出来时，对应的节点的标记都已经传好了。而我们在修改时，直接修改对应节点的记录标记和懒标记，因为我们的懒标记记录的都是已经对当前节点产生贡献，但是还没有当前节点的子树区间产生贡献！然后就是每处有修改的地方都要pushup一下就好了。
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<queue>
#define rint register int
#define For(i,a,b) for (rint i=a;i<=b;++i)
using namespace std;
const int inf=0x3f3f3f3f;
const int N=1e6+17;
int n,m,rt,cnt;
int a[N],id[N],fa[N],c[N][2];
int sum[N],sz[N],v[N],mx[N],lx[N],rx[N];
bool tag[N],rev[N];
//tag表示是否有统一修改的标记，rev表示是否有统一翻转的标记
//sum表示这个点的子树中的权值和，v表示这个点的权值
queue<int> q;
inline int read(){rint x=0,f=1;char ch=getchar();while (ch<'0' || ch>'9'){if (ch=='-')f=-1;ch=getchar();}while ('0'<=ch && ch<='9')x=(x<<1)+(x<<3)+(ch^48),ch=getchar();return x*f;
}
inline void pushup(rint x){rint l=c[x][0],r=c[x][1];sum[x]=sum[l]+sum[r]+v[x];sz[x]=sz[l]+sz[r]+1;mx[x]=max(mx[l],max(mx[r],rx[l]+v[x]+lx[r]));lx[x]=max(lx[l],sum[l]+v[x]+lx[r]);rx[x]=max(rx[r],sum[r]+v[x]+rx[l]);
}
//上传记录标记
inline void pushdown(rint x){rint l=c[x][0],r=c[x][1];if (tag[x]){rev[x]=tag[x]=0;//我们有了一个统一修改的标记，再翻转就没有什么意义了if (l)tag[l]=1,v[l]=v[x],sum[l]=v[x]*sz[l];if (r)tag[r]=1,v[r]=v[x],sum[r]=v[x]*sz[r];if (v[x]>=0){if (l)lx[l]=rx[l]=mx[l]=sum[l];if (r)lx[r]=rx[r]=mx[r]=sum[r];}else{if (l)lx[l]=rx[l]=0,mx[l]=v[x];if (r)lx[r]=rx[r]=0,mx[r]=v[x];}}if (rev[x]){rev[x]=0;rev[l]^=1;rev[r]^=1;swap(lx[l],rx[l]);swap(lx[r],rx[r]);//注意，在翻转操作中，前后缀的最长上升子序列都反过来了，很容易错swap(c[l][0],c[l][1]);swap(c[r][0],c[r][1]);}
}
//下传标记
inline void rotate(rint x,rint &k){rint y=fa[x],z=fa[y],l=(c[y][1]==x),r=l^1;if (y==k)k=x;else c[z][c[z][1]==y]=x;fa[c[x][r]]=y;fa[y]=x;fa[x]=z;c[y][l]=c[x][r];c[x][r]=y;pushup(y);pushup(x);//旋转操作，一定要上传记录标记
}
inline void splay(rint x,rint &k){while (x!=k){int y=fa[x],z=fa[y];if (y!=k){if (c[z][0]==y ^ c[y][0]==x)rotate(x,k);else rotate(y,k);}rotate(x,k);}
}
//这是整个程序的核心之一，毕竟是伸展操作嘛
inline int find(rint x,rint rk){pushdown(x);//因为所有的操作都需要find，所以我们只需在这里下传标记就行了rint l=c[x][0],r=c[x][1];if (sz[l]+1==rk)return x;if (sz[l]>=rk)return find(l,rk);else return find(r,rk-sz[l]-1);
}
//这个find是我们整个程序的核心之二
//因为我们的区间翻转和插入及删除的操作的存在
//我们维护的区间的实际编号并不是连续的
//而，我们需要操作的区间又对应着平衡树的中序遍历中的那段区间
//所以这个find很重要
inline void recycle(rint x){rint &l=c[x][0],&r=c[x][1];if (l)recycle(l);if (r)recycle(r);q.push(x);fa[x]=l=r=tag[x]=rev[x]=0;
}
//这就是用时间换空间的回收冗余编号机制，很好理解
inline int split(rint k,rint tot){rint x=find(rt,k),y=find(rt,k+tot+1);splay(x,rt);splay(y,c[x][1]);return c[y][0];
}
//这个split操作是整个程序的核心之三
//我们通过这个split操作，找到[k+1,k+tot]，并把k,和k+tot+1移到根和右儿子的位置
//然后我们返回了这个右儿子的左儿子，这就是我们需要操作的区间
inline void query(rint k,rint tot){rint x=split(k,tot);printf("%d\n",sum[x]);
}
inline void modify(rint k,rint tot,rint val){rint x=split(k,tot),y=fa[x];v[x]=val;tag[x]=1;sum[x]=sz[x]*val;if (val>=0)lx[x]=rx[x]=mx[x]=sum[x];else lx[x]=rx[x]=0,mx[x]=val;pushup(y);pushup(fa[y]);//每一步的修改操作，由于父子关系发生改变//及记录标记发生改变，我们需要及时上传记录标记
}
inline void rever(rint k,rint tot){rint x=split(k,tot),y=fa[x];if (!tag[x]){rev[x]^=1;swap(c[x][0],c[x][1]);swap(lx[x],rx[x]);pushup(y);pushup(fa[y]);}//同上
}
inline void erase(rint k,rint tot){rint x=split(k,tot),y=fa[x];recycle(x);c[y][0]=0;pushup(y);pushup(fa[y]);//同上
}
inline void build(rint l,rint r,rint f){rint mid=(l+r)>>1,now=id[mid],pre=id[f];if (l==r){mx[now]=sum[now]=a[l];tag[now]=rev[now]=0;//这里这个tag和rev的清0是必要，因为这个编号可能是之前冗余了lx[now]=rx[now]=max(a[l],0);sz[now]=1;}if (l<mid)build(l,mid-1,mid);if (mid<r)build(mid+1,r,mid);v[now]=a[mid]; fa[now]=pre;pushup(now);//上传记录标记c[pre][mid>=f]=now;//当mid>=f时，now是插入到又区间取了，所以c[pre][1]=now，当mid<f时同理
}
inline void insert(rint k,rint tot){For(i,1,tot)a[i]=read();For(i,1,tot)if (!q.empty())id[i]=q.front(),q.pop();else id[i]=++cnt;//利用队列中记录的冗余节点编号build(1,tot,0);//将读入的tot个树建成一个平衡树rint z=id[(1+tot)>>1];//取中点为根rint x=find(rt,k+1),y=find(rt,k+2);//首先，依据中序遍历，找到我们需要操作的区间的实际编号splay(x,rt);splay(y,c[x][1]);//把k+1(注意我们已经右移了一个单位）和(k+1)+1移到根和右儿子fa[z]=y;c[y][0]=z;//直接把需要插入的这个平衡树挂到右儿子的左儿子上去就好了pushup(y);pushup(x);//上传记录标记
}
//对于具体在哪里上传标记和下传标记
//可以这么记，只要用了split就要重新上传标记
//只有find中需要下传标记
//但其实，你多传几次是没有关系的，但是少传了就不行了
int main(){n=read(),m=read();mx[0]=a[1]=a[n+2]=-inf;For(i,1,n)a[i+1]=read();For(i,1,n+2)id[i]=i;//虚拟了两个节点1和n+2，然后把需要操作区间整体右移一个单位build(1,n+2,0);//建树rt=(n+3)>>1;cnt=n+2;//取最中间的为根rint k,tot,val;char ch[10];while (m--){scanf("%s",ch);if (ch[0]!='M' || ch[2]!='X') k=read(),tot=read();if (ch[0]=='I')insert(k,tot);if (ch[0]=='D')erase(k,tot);if (ch[0]=='M'){if (ch[2]=='X')printf("%d\n",mx[rt]);else val=read(),modify(k,tot,val);}if (ch[0]=='R')rever(k,tot);if (ch[0]=='G')query(k,tot);}return 0;
}E - 文本编辑器
平衡树的模板题。这里使用的是非旋Treap。由于这道题用平衡树维护的是文本，所以只需要考虑文字之间的相对顺序，因此之后所有对于树的split操作指的都是按照排名进行split。
不难想到用一个变量p存下来光标前面一个字符的下标（下标从11开始）。下面考虑对于题目中各个操作的处理：
1.Move,Prev,Next：对于这三个操作，修改p即可。
2.Delete：设文本为S。把树分成三个部分，一个为x树，对应[1,p]的文本；一个为y树，对应要删除的(p,p+n]的文本；还有一个为z树，对应(p+n,∣S∣]的文本。于是乎y树就是要删除的部分。我们直接将x树和z树合成新树即可。
3.Rotate：同上，把需要修改的部分提出来，打标记。然后在拆分、修改的操作的时候下传标记即可。
4.Get：相当于求文本中第p+1小的值。套板子。
5.Insert：先把书分成两个部分，一个为x树，对应[1,p]；另一个为z树，对应(p,∣S∣]。下面有两种处理方法。一种是把要插入的串暴力一个一个字符地插入到x树，然后合并x和z，时间是可以过的，但是显然效率很低；另一种是对于要插入的串建立一颗y树，再把x,y,z合并起来。因为我很懒， 我用的第一种方法。
由于出题人很恶心，插入的时候有可能出现换行符也需要插入，所以需要严格地按照输入的n来插入而不是用scanf之类的。同时，如果Get需要输出换行符，就只需要输出一个。
然后你就发现这道黑题就被这样愉快地水过去解决了。
#include <cstdio>
#include <cstdlib>
#include <cstring>#define random myRandomconst int MAXSIZ = 1024 * 1024 * 2 + 5;template<typename _T>
void read( _T &x )
{x = 0;char s = getchar();int f = 1;while( s > '9' || s < '0' ){if( s == '-' ) f = -1; s = getchar();}while( s >= '0' && s <= '9' ){x = ( x << 3 ) + ( x << 1 ) + ( s - '0' ), s = getchar();}x *= f;
}template<typename _T>
void write( _T x )
{if( x < 0 ){ putchar( '-' ); x = ( ~ x ) + 1; }if( 9 < x ){ write( x / 10 ); }putchar( x % 10 + '0' );
}template<typename _T>
void swapp( _T &x, _T &y ) { _T t = x; x = y, y = t; }int ch[MAXSIZ][2], aux[MAXSIZ], siz[MAXSIZ];
char val[MAXSIZ], S[MAXSIZ];
bool rot[MAXSIZ];
int nsiz, mpos = 0, rt;void srd() { int a, *aa = &a; srand( ( unsigned long long ) aa ); }
int random() { return rand() * rand(); }
int newNode( const char c ) { aux[++ nsiz] = random(), siz[nsiz] = 1, val[nsiz] = c, rot[nsiz] = false; return nsiz; }
void upt( const int u ) { siz[u] = siz[ch[u][0]] + siz[ch[u][1]] + 1; }
void swp( const int u ) { swapp( ch[u][0], ch[u][1] ), rot[u] ^= 1; }
void normalize( const int u )
{if( ! rot[u] ) return ;swp( ch[u][0] ), swp( ch[u][1] );rot[u] = false;
}void splitRnk( const int u, const int k, int &x, int &y )
{if( ! u ) { x = y = 0; return ; }normalize( u );if( k <= siz[ch[u][0]] ) y = u, splitRnk( ch[u][0], k, x, ch[u][0] );else x = u, splitRnk( ch[u][1], k - siz[ch[u][0]] - 1, ch[u][1], y );upt( u );
}int merg( const int u, const int v )
{if( ! u || ! v ) return u + v;if( aux[u] < aux[v] ) { normalize( u ), ch[u][1] = merg( ch[u][1], v ), upt( u ); return u; }else { normalize( v ), ch[v][0] = merg( u, ch[v][0] ), upt( v ); return v; }
}void insert( const char *buf )
{int l = strlen( buf ), y;splitRnk( rt, mpos, rt, y );for( int i = 0 ; i < l ; i ++ ) rt = merg( rt, newNode( buf[i] ) );rt = merg( rt, y );
}void del( const int length )
{int x, y;splitRnk( rt, mpos, rt, x ), splitRnk( x, length, x, y );rt = merg( rt, y );
}void rotate( const int length )
{int x, y;splitRnk( rt, mpos, rt, x ), splitRnk( x, length, x, y );swp( x ), rt = merg( merg( rt, x ), y );
}char Get()
{int u = rt, k = mpos + 1;while( true ){normalize( u );if( k <= siz[ch[u][0]] ) u = ch[u][0];else if( k <= siz[ch[u][0]] + 1 ) return val[u];else k -= siz[ch[u][0]] + 1, u = ch[u][1];}
}int main()
{srd();char op[10];int N, k;read( N );while( N -- ){scanf( "%s", op );if( op[0] == 'M' ) { read( mpos ); }if( op[0] == 'I' ){read( k );for( int i = 0 ; i < k ; i ++ ) S[i] = getchar();insert( S );for( int i = 0 ; i < k ; i ++ ) S[i] = '\0';}if( op[0] == 'D' ) read( k ), del( k );if( op[0] == 'R' ) read( k ), rotate( k );if( op[0] == 'G' ) {char tmp; putchar( tmp = Get() );if( tmp ^ '\n' ) putchar( '\n' );}if( op[0] == 'P' ) mpos --;if( op[0] == 'N' ) mpos ++;}return 0;
}北京化工大学1/17寒假集训题解（＞1800）相关推荐
- 北京化工大学2018年10月程序设计竞赛部分题解（A,C,E,H）
目录 北京化工大学2018年10月程序设计竞赛部分题解(A,C,E,H) 竞赛事件相关 竞赛链接 竞赛题目 总结 北京化工大学2018年10月程序设计竞赛部分题解(A,C,E,H) 竞赛事件相关 竞赛 ...
- 北京化工大学计算机调剂学院,北京化工大学2018年考研调剂信息
2018考研初试之后,有些考生可能觉得自己考得不理想,对于目标院校没有太大把握,那么这个时候你就需要及时关注一下调剂信息,先人一步做好调剂的准备.下面是研招网小编为大家整理的北京化工大学2018年考研 ...
- 北京化工大学 计算机专硕 缺额,北京化工大学2020年硕士研究生调剂工作办法
一.调剂基本要求 为促进硕士研究生招生复试工作的规范化和制度化,科学选拔人才,秉承公平公正.公开的要求,根据<教育部关于印发2020年全国硕士研究生招生工作管理规定的通知><教育部办 ...
- 北京化工大学2022-2023-1 ACM集训队每周程序设计竞赛（8）题解
文章目录 问题 A: 鬼抓人 问题 B: 坠落之前 问题 C: 数据结构:树的子结点计数 问题 D: 糖果合并 问题 E: 幼儿园排座 问题 F: 简单路径计数 (((糖豆人小专题( •̀ ω •́ ...
- 北京化工大学2022-2023-1 ACM集训队每周程序设计竞赛（11）题解
文章目录 问题 A: 起名废柴 问题 B: 可视消息 问题 C: 虫洞旅行 问题 D: 整数化简分析 问题 E: 向量选取 问题 F: 勤劳的扫地机器人 问题 A: 起名废柴 根据题意,判断字符串 T ...
- 2018 北京化工大学ACCA精英班招生简章
院校介绍 北京化工大学创办于1958年,原名北京化工学院,是新中国为"培养尖端科学技术所需求的高级化工人才"而创建的一所高水平大学.作为教育部直属的全国重点大学,国家"2 ...
- LSNU寒假集训 题解
目录 LSNU寒假第一场(基础算法+几何) A - Fifa and Fafa B - Anton and Lines C - Minimum path D - Thematic Contests E ...
- 北京化工大学2018年10月程序设计竞赛 F. 罗dalao的密码(递归)
题目链接:http://39.105.0.22/problem.php?cid=1022&pid=5 数据范围不大,直接对端点进行递归就好,根据p的值来判断在左区间还是右区间,然 ...
- 2021北京化工大学计算机学院招生网,北京化工大学2021年硕士研究生招生简章
4. 以同等学力参加复试的考生,在复试中须加试至少两门与报考专业相关的本科主干课程.加试科目不得与初试科目相同.加试方式为笔试.报考法律硕士(非法学).工商管理硕士.公共管理硕士.工程管理硕士的同等学 ...
最新文章
- eclipse编辑窗口不见了（打开左边的java、xml文件，中间不会显示代码)
- 一个简单的Dockerfile
- php递归复制文件内容,PHP实现递归复制整个文件夹的类实例_php技巧
- Live Source Address 2019最新的电视广播包_Arturia MiniLab MkII迷你MIDI键盘2019年换新装:反色纯黑版...
- IOS开发之MD5加密和钥匙串的使用-oc
- 模拟实现priority_queue优先级队列
- VisualNet铁路通信管理
- Linux tshark发送抓取的数据到kafka
- java中一个char_java 中一个char包含几个字节
- object.\__mro__
- java基础---线程
- 获取win10官方镜像
- 用html制作圆的周长,几何画板制作圆周长展开动画
- 想更快成长更应该关注的博客
- MAC和夜神模拟器配置adb适配报错
- [物联网+云存储]-关于人工智能开关的学习思路
- 计算机协会活动策划,计算机协会活动策划书
- ubuntu开启客户端nfs服务_ubuntu16.04搭建nfs服务的方法
- DCGAN论文改进之处+简化代码
- Markdown极简教程