[BZOJ2333][SCOI2011]棘手的操作（可并堆||线段树）

=== ===

这里放传送门

=== ===

题解

这道题有两种做法：可并堆和线段树。相比于可并堆的写法来说线段树的写法非常简单并且好懂。。。然而这道题作为可并堆的练习也确实很有价值。。

首先提一句线段树的解法。可以发现它只要并到一起去的联通块是不会再拆开的，所以我们能够把每个时刻出现的连通块都标号为一个连续的区间，那么就可以用线段树进行区间修改区间查询。

操作方法是先把操作离线，然后对于每个合并操作用并查集来维护，为每个集合维护一个ed数组表示这一块的最后一个点的编号，再为每个点维护一个nxt值表示它的下一个节点编号。也就是说用并查集的father数组可以找到这个连通块的第一个节点，而ed数组可以找到最后一个，这就保证了节点的顺序。

在合并两个集合的时候按照顺序把一段节点接到另一段节点后面，这就要求在修改的时候一定要按顺序进行。并且这种操作方式决定了只有代表元素的ed值是正确的，因为每次修改的时候不能顺着并查集全改一遍不然肯定T死。

遍历所有点的时候每次遇到一个代表元素就用nxt数组遍历所有连通块然后依次标号就可以了。然后把father和ed数组初始化，重新做一边操作来处理询问就可以了。

对于可并堆来说的话就不需要离线直接在线处理就可以了。对于第一个操作就是直接合并两个堆，对于第二个操作它需要修改单个元素的值，那么这个可并堆必须支持找到某个元素的位置并且修改它，那么向上调整和向下调整两个操作都要搞出来；然后因为可并堆用指针记录了左右儿子和父亲的位置，相当于是搞了一个双向指针的东西，动了一个地方其它都跟着乱动就特烦人。。

因为第三个操作要修改整个连通块，所以要在可并堆里面维护lazy标记，每次merge操作的时候得先push一下把标记传下去。并且向上调整之前还要先把它祖先的标记都放下来。

最麻烦的操作就是整体最大值的维护。。因为编号是散乱的所以没法直接用线段树之类的东西来搞，所以就搞了个堆套堆。。似乎用STL也可以？这题ATP在WC的时候调了三天因为搞得断断续续所以也写得奇丑无比。。目测根本没法看qwq

代码

简洁明了的线段树版本

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,m,a[300010],father[300010],ed[300010],w[300010],num[300010],next[300010],cnt;
int Max[1500000],dlt[1500000];
struct question{
int k,x,y;
}q[300010];
char get(){
int c=getchar();
while (c>'Z'||c<'A') c=getchar();
return c;
}
int find(int x){
if (father[x]!=x) father[x]=find(father[x]);
return father[x];
}
void update(int i){
Max[i]=max(Max[i<<1],Max[(i<<1)+1]);
}
void pushdown(int i){
if (dlt[i]!=0){
Max[i<<1]+=dlt[i];Max[(i<<1)+1]+=dlt[i];
dlt[i<<1]+=dlt[i];dlt[(i<<1)+1]+=dlt[i];
dlt[i]=0;
}
}
void build(int i,int l,int r){
if (l==r){
Max[i]=num[l];return;
}
int mid=(l+r)>>1;
build(i<<1,l,mid);
build((i<<1)+1,mid+1,r);
update(i);
}
void change(int i,int l,int r,int left,int right,int v){
if (left<=l&&right>=r){
Max[i]+=v;dlt[i]+=v;return;
}
int mid=(l+r)>>1;
pushdown(i);
if (left<=mid) change(i<<1,l,mid,left,right,v);
if (right>mid) change((i<<1)+1,mid+1,r,left,right,v);
update(i);
}
int ask(int i,int l,int r,int left,int right){
if (left<=l&&right>=r) return Max[i];
int mid=(l+r)>>1,ans=-0x7fffffff;
pushdown(i);
if (left<=mid) ans=max(ans,ask(i<<1,l,mid,left,right));
if (right>mid) ans=max(ans,ask((i<<1)+1,mid+1,r,left,right));
return ans;
}
int main()
{
scanf("%d",&n);
for (int i=1;i<=n;i++){
scanf("%d",&a[i]);
father[i]=ed[i]=i;
}
scanf("%d",&m);
for (int i=1;i<=m;i++){
char c=get();
if (c=='U'){
int r1,r2;
q[i].k=1;scanf("%d%d",&q[i].x,&q[i].y);
r1=find(q[i].x);r2=find(q[i].y);
if (r1!=r2){//注意合并操作的顺序要求
father[r2]=r1;next[ed[r1]]=r2;ed[r1]=ed[r2];
}
}
if (c=='A'){
char z=getchar();
if (z=='3'){
q[i].k=4;scanf("%d",&q[i].x);
}else{
q[i].k=z-'0'+1;scanf("%d%d",&q[i].x,&q[i].y);
}
}
if (c=='F'){
char z=getchar();
if (z=='3') q[i].k=7;
else {q[i].k=z-'0'+4;scanf("%d",&q[i].x);}
}
}
for (int i=1;i<=n;i++)
if (find(i)==i){
for (int j=i;j!=0;j=next[j]){
w[j]=++cnt;num[cnt]=a[j];
}
}
for (int i=1;i<=n;i++) father[i]=ed[i]=i;
build(1,1,n);
for (int i=1;i<=m;i++)
switch (q[i].k){
case 1:{
int r1,r2;
r1=find(q[i].x);r2=find(q[i].y);
if (r1!=r2){
father[r2]=r1;next[ed[r1]]=r2;ed[r1]=ed[r2];
}//重新进行一遍操作
break;
}
case 2:{
change(1,1,n,w[q[i].x],w[q[i].x],q[i].y);
break;
}
case 3:{
int r=find(q[i].x);
change(1,1,n,w[r],w[ed[r]],q[i].y);
break;
}
case 4:{
change(1,1,n,1,n,q[i].x);
break;
}
case 5:{
printf("%d\n",ask(1,1,n,w[q[i].x],w[q[i].x]));
break;
}
case 6:{
int r=find(q[i].x);
printf("%d\n",ask(1,1,n,w[r],w[ed[r]]));
break;
}
case 7:{
printf("%d\n",ask(1,1,n,1,n));
break;
}
}
return 0;
}

丑陋至极的可并堆版本

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
int n,q,a[300010],delta,father[300010],ptr[300010];
struct Node{
Node *l,*r,*fa;
int val,NPL,dlt;
Node();
Node(int x);
void count(){NPL=r->NPL+1;}
void push();
void Add(int v);
void pushdlt();
void faswap();
void pushup(int rt);
void pushdown(int rt);
}*null,H[300010],*h[300010],*st[300010];
struct Temp{
Node* *p;
int id;
}tmp[300010];
Node::Node(){l=r=fa=null;val=NPL=dlt=0;}
Node::Node(int x){l=r=fa=null;val=x;NPL=1;dlt=0;}
void Node::Add(int v){val+=v;dlt+=v;}
void Node::push(){
if (dlt!=0){
if (l!=null) l->Add(dlt);
if (r!=null) r->Add(dlt);
dlt=0;
}
}
void Node::pushdlt(){
Node *ptr=this;
int top=0;
while (ptr!=null){
st[++top]=ptr;
ptr=ptr->fa;
}
for (int i=top;i>=1;i--) st[i]->push();
}
void Node::faswap(){
Node *k=fa;
if (this==k->l){
swap(r,k->r);k->l=l;l=k;
}else{swap(l,k->l);k->r=r;r=k;}
fa=k->fa;
if (k==k->fa->l) k->fa->l=this;
else k->fa->r=this;
if (k->r!=null) k->r->fa=k;
if (k->l!=null) k->l->fa=k;
if (l!=null) l->fa=this;
if (r!=null) r->fa=this;
count();k->count();
}
void Node::pushup(int rt){
Node *k=fa;
if (k==null){h[rt]=this;return;}
if (val<=k->val) return;
faswap();pushup(rt);
}
void Node::pushdown(int rt){
int Maxs=-1;
Node *tmp;
if (this==null||(l==null&&r==null)) return;
Maxs=max(l->val,r->val);
l->push();r->push();
if (Maxs<=val) return;
if (Maxs==l->val) l->faswap();
else r->faswap();
if (fa->fa==null) h[rt]=fa;
pushdown(rt);
}
Node* merge(Node *x,Node *y){
if (x==null) return y;
if (y==null) return x;
if (x->val<y->val) swap(x,y);
x->push();
x->r=merge(x->r,y);
x->r->fa=x;
if (x->l->NPL<x->r->NPL) swap(x->l,x->r);
x->count();return x;
}
int comp(Temp x,Temp y){return (*(x.p))->val>(*(y.p))->val;}
int find(int x){
if (father[x]==x) return father[x];
father[x]=find(father[x]);
return father[x];
}
int getnum(char x,char y){
int c;
if (x=='U') return 1;
if (x=='A') c=1;
else c=4;
return c+y-'0';
}
void pushup(int now){
int fa=now>>1;
if (fa==0||(*tmp[now].p)->val<=(*tmp[fa].p)->val) return;
tmp[now].id=find(tmp[now].id);
tmp[fa].id=find(tmp[fa].id);
if (tmp[now].id!=0&&tmp[fa].id!=0)
swap(ptr[tmp[now].id],ptr[tmp[fa].id]);
swap(tmp[now],tmp[fa]);
pushup(fa);
}
void pushdown(int now){
int Maxs=-0x7fffffff,l=now<<1,r=l+1,r1,r2,r3;
if (l>n&&r>n) return;
if (l<=n) Maxs=max(Maxs,(*tmp[l].p)->val);
if (r<=n) Maxs=max(Maxs,(*tmp[r].p)->val);
tmp[now].id=r1=find(tmp[now].id);
tmp[l].id=r2=find(tmp[l].id);
tmp[r].id=r3=find(tmp[r].id);
if (r2==0&&r3==0) return;
if (Maxs<=(*tmp[now].p)->val||r1==0) return;
if (r2!=0&&Maxs==(*tmp[l].p)->val){
swap(ptr[r2],ptr[r1]);
swap(tmp[l],tmp[now]);
pushdown(l);
}else if (r3!=0){
swap(ptr[tmp[r].id],ptr[tmp[now].id]);
swap(tmp[r],tmp[now]);
pushdown(r);
}
}
void Union(int x,int y){
int r1=find(x),r2=find(y);
if (r1==r2) return;
tmp[ptr[r2]].p=&null;
pushdown(ptr[r2]);
tmp[ptr[r2]].id=ptr[r2]=0;
father[r2]=r1;
h[r1]=merge(h[r1],h[r2]);
pushup(ptr[r1]);
}
void Addpoint(int x,int v){
int rt=find(x);
H[x].pushdlt();//下放当前节点的标记
H[x].val+=v;
if (v>0) H[x].pushup(rt);
else H[x].pushdown(rt);//调整节点在当前堆里的位置
if (v<0) pushdown(ptr[rt]);//调整当前堆顶的位置
else pushup(ptr[rt]);
}
void Addblock(int x,int v){
int rt=find(x);
h[rt]->Add(v);
if (v<0) pushdown(ptr[rt]);
else pushup(ptr[rt]);
}
int main()
{
null=new Node;*null=Node();
null->val=-0x7fffffff;
scanf("%d",&n);
for (int i=1;i<=n;i++){
scanf("%d",&a[i]);
father[i]=i;H[i]=Node(a[i]);
h[i]=H+i;tmp[i].p=h+i;
tmp[i].id=i;
}
sort(tmp+1,tmp+n+1,comp);
for (int i=1;i<=n;i++) ptr[tmp[i].id]=i;
scanf("%d",&q);
for (int i=1;i<=q;i++){
char s[5];scanf("%s",s);
int opt,x,y,v,rt;
opt=getnum(s[0],s[1]);
switch (opt){
case 1:{
scanf("%d%d",&x,&y);
Union(x,y);break;
}
case 2:{
scanf("%d%d",&x,&v);
Addpoint(x,v);break;
}
case 3:{
scanf("%d%d",&x,&v);
Addblock(x,v);break;
}
case 4:{
scanf("%d",&v);
delta+=v;break;
}
case 5:{
scanf("%d",&x);H[x].pushdlt();
printf("%d\n",H[x].val+delta);break;
}
case 6:{
scanf("%d",&x);rt=find(x);
printf("%d\n",h[rt]->val+delta);break;
}
case 7:{printf("%d\n",(*tmp[1].p)->val+delta);break;}
}
}
return 0;
}

偏偏在最后出现的补充说明

这题的线段树做法是很经典的思路啊

可并堆的做法就适合闲着没事的时候花上一天磨磨蹭蹭写着玩啊