jzoj5662 [GDOI2018Day1模拟4.17]尺树寸泓

版权声明:虽然是个蒟蒻但是转载还是要说一声的哟 https://blog.csdn.net/jpwang8/article/details/79980788

Description


给定一棵splay,每个节点都有一个权值,节点x的价值为以x为根的子树中所有节点的权值和

分别有一下三种操作:

0 x:将x节点左旋
1 x:将x节点右旋
2 x:查询节点x所在子树中所有点的价值乘积

答案模1e9+7

Solution


题目是图片,懒癌晚期

看到这样多姿的树形态就想到了LCT维护(雾
容易发现旋转后改变权值的点只有两个,而改变乘积的节点却组成了一条通向根节点的链
那么可以LCT维护旋转操作,link一下两个旋转节点然后对splay中的节点打乘法标记即可(口胡

显然这样编程复杂度极高,考虑另一种做法
对于一棵splay来说,任意旋转后仍然是一棵splay,也就是说仍然保证满足二叉搜索树的性质,即中序遍历不变
我们可以把中序遍历求出来,记录一个节点左子树的size、右子树的size、中序遍历中的位置,那么只需要单点修改区间查询区间乘积了,线段树树状数组随便上

LL取模的时候记得不能漏啊啊啊啊

Code


#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)

typedef long long LL;
const int MOD=1000000007;
const int N=400005;

struct treeNode {int son[2],fa,pos,l,r; LL p,v;} t[N];

LL pro[N<<2];
int pos[N],root,tot;

void push_up(int x) {
    t[x].v=(t[t[x].son[0]].v%MOD+t[t[x].son[1]].v%MOD+t[x].p%MOD)%MOD;
    t[x].l=(t[t[x].son[0]].l+t[t[x].son[0]].r+1)*(t[x].son[0]>0);
    t[x].r=(t[t[x].son[1]].l+t[t[x].son[1]].r+1)*(t[x].son[1]>0);
}

void rotate(int x) {
    int y=t[x].fa; int z=t[y].fa;
    int k=t[y].son[1]==x;
    t[z].son[t[z].son[1]==y]=x; t[x].fa=z;
    t[y].son[k]=t[x].son[!k]; t[t[x].son[!k]].fa=y;
    t[x].son[!k]=y; t[y].fa=x;
    push_up(y); push_up(x);
}

int modify(int now,int tl,int tr,int x,LL v) {
    if (tl==tr) return pro[now]=v;//(pro[now]+v)%MOD;
    int mid=(tl+tr)>>1;
    if (x<=mid) modify(now<<1,tl,mid,x,v);
    else modify(now<<1|1,mid+1,tr,x,v);
    pro[now]=(pro[now<<1]*pro[now<<1|1])%MOD;
}

LL query(int now,int tl,int tr,int l,int r) {
    if (tl==l&&tr==r) return pro[now]%MOD;
    int mid=(tl+tr)>>1;
    if (r<=mid) return query(now<<1,tl,mid,l,r);
    if (l>mid) return query(now<<1|1,mid+1,tr,l,r);
    LL qx=query(now<<1,tl,mid,l,mid);
    LL qy=query(now<<1|1,mid+1,tr,mid+1,r);
    return (qx*qy)%MOD;
}

void build_tree(int x) {
    if (!x) return ;
    build_tree(t[x].son[0]);
    pos[t[x].pos=++tot]=x;
    t[x].l=(t[t[x].son[0]].l+t[t[x].son[0]].r+1)*(t[x].son[0]>0);
    build_tree(t[x].son[1]);
    t[x].r=(t[t[x].son[1]].l+t[t[x].son[1]].r+1)*(t[x].son[1]>0);
    push_up(x);
    t[t[x].son[0]].fa=t[t[x].son[1]].fa=x;
}

int main(void) {
    freopen("splay1.in","r",stdin);
    freopen("splay.out","w",stdout);
    int n,m; scanf("%d%d",&n,&m);
    rep(i,1,n) scanf("%lld%d%d",&t[i].p,&t[i].son[0],&t[i].son[1]);
    build_tree(root=1);
    rep(i,1,n) modify(1,1,n,t[i].pos,t[i].v);
    while (m--) {
        int opt,x; scanf("%d%d",&opt,&x);
        if (opt<=1) {
            if (t[x].son[opt]) {
                // LL delta=(t[x].v-t[t[x].son[opt]].v+MOD)%MOD;
                // modify(1,1,n,t[t[x].son[opt]].pos,delta);
                // modify(1,1,n,t[x].pos,(t[t[t[x].son[opt]].son[!opt]].v-t[t[x].son[opt]].v+MOD)%MOD);
                modify(1,1,n,t[t[x].son[opt]].pos,t[x].v);
                modify(1,1,n,t[x].pos,(t[x].v%MOD-t[t[x].son[opt]].v%MOD+t[t[t[x].son[opt]].son[!opt]].v%MOD+MOD)%MOD);
                rotate(t[x].son[opt]);
            }
        } else printf("%lld\n", query(1,1,n,t[x].pos-t[x].l,t[x].pos+t[x].r));
    }
    return 0;
}
阅读更多

没有更多推荐了,返回首页