[bzoj3786][splay]星系探索

最新推荐文章于 2021-05-24 22:15:14 发布
最新推荐文章于 2021-05-24 22:15:14 发布
阅读量224 收藏
点赞数
分类专栏： bzoj splay
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36993218/article/details/79580832
版权
bzoj 同时被 2 个专栏收录
102 篇文章 0 订阅
订阅专栏
splay
6 篇文章 0 订阅
订阅专栏

3786: 星系探索

Time Limit: 40 Sec Memory Limit: 256 MB
Submit: 1524 Solved: 484
[Submit][Status][Discuss]
Description

物理学家小C的研究正遇到某个瓶颈。

他正在研究的是一个星系，这个星系中有n个星球，其中有一个主星球(方便起见我们默认其为1号星球)，其余的所有星球均有且仅有一个依赖星球。主星球没有依赖星球。

我们定义依赖关系如下：若星球a的依赖星球是b,则有星球a依赖星球b.此外，依赖关系具有传递性，即若星球a依赖星球b,星球b依赖星球c,则有星球a依赖星球c.

对于这个神秘的星系中，小C初步探究了它的性质，发现星球之间的依赖关系是无环的。并且从星球a出发只能直接到达它的依赖星球b.

每个星球i都有一个能量系数wi.小C想进行若干次实验，第i次实验，他将从飞船上向星球di发射一个初始能量为0的能量收集器，能量收集器会从星球di开始前往主星球，并收集沿途每个星球的部分能量，收集能量的多少等于这个星球的能量系数。

但是星系的构成并不是一成不变的，某些时刻，星系可能由于某些复杂的原因发生变化。

有些时刻，某个星球能量激发，将使得所有依赖于它的星球以及他自己的能量系数均增加一个定值。还有可能在某些时刻，某个星球的依赖星球会发生变化，但变化后依然满足依赖关系是无环的。

现在小C已经测定了时刻0时每个星球的能量系数,以及每个星球(除了主星球之外)的依赖星球。接下来的m个时刻，每个时刻都会发生一些事件。其中小C可能会进行若干次实验，对于他的每一次实验，请你告诉他这一次实验能量收集器的最终能量是多少。

Input

第一行一个整数n,表示星系的星球数。

接下来n-1行每行一个整数,分别表示星球2-n的依赖星球编号。

接下来一行n个整数，表示每个星球在时刻0时的初始能量系数wi.

接下来一行一个整数m,表示事件的总数。

事件分为以下三种类型。

(1)”Q di”表示小C要开始一次实验,收集器的初始位置在星球di.

(2)”C xi yi”表示星球xi的依赖星球变为了星球yi.

(3)”F pi qi”表示星球pi能量激发，常数为qi.

Output

对于每一个事件类型为Q的事件，输出一行一个整数，表示此次实验的收集器最终能量。

Sample Input

3

1

1

4 5 7

5

Q 2

F 1 3

Q 2

C 2 3

Q 2

Sample Output

9

15

25
HINT

n<=100000,m<=300000,1

sol:

这题卡常数，请尽量手动updata

由于要对子树修改，所以不能lct了。因为这题并不会出现森林，我们考虑使用splay维护dfs序，点进栈时设为1，退栈时设为-1，那么他到根的前缀和就是他到根的路径和。这题只要维护子树和和子树系数和就好了。
思考一下这题的加强版，如果询问的是任意 u,v路径的权值和的话怎么做。
可以用u到根的权值和+v到根的-lca到根-fa[lca]到根的
那么问题就变成了怎么求lca了。
用lct维护一下树的形态，然后用access求lca即可。其余代码不变。

T的代码

#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cmath>
using namespace std;
typedef long long ll;
int n,m;

inline int read()
{
    char c;
    bool pd=0;
    while((c=getchar())>'9'||c<'0')
    if(c=='-') pd=1;
    int res=c-'0';
    while((c=getchar())>='0'&&c<='9')
    res=(res<<3)+(res<<1)+c-'0';
    return pd?-res:res;
}
const int N=210000;
int lc[N],rc[N],fa[N],mul[N],muls[N],tag[N],val[N];
ll sum[N];
inline void updata(const int &x)
{
    muls[x]=muls[lc[x]]+muls[rc[x]]+mul[x];
    sum[x]=val[x]+sum[lc[x]]+sum[rc[x]];
}
inline void tag_add(const int &x,const int &y)
{
    if(!x) return;
    sum[x]+=(ll)muls[x]*y;
    val[x]+=mul[x]>0?y:-y;
    tag[x]+=y;
}
inline void tag_down(const int &x)
{
    if(tag[x])
    {
        tag_add(lc[x],tag[x]);
        tag_add(rc[x],tag[x]);
        tag[x]=0;
    }
}
inline void rotate(const int &x)
{
    int y=fa[x],z=fa[y];
    int b=lc[y]==x?rc[x]:lc[x];
    if(b) fa[b]=y;
    fa[y]=x;fa[x]=z;
    if(z)
    {
        if(lc[z]==y) lc[z]=x;
        else rc[z]=x;
    }
    if(lc[y]==x) lc[y]=b,rc[x]=y;
    else rc[y]=b,lc[x]=y;
    updata(y);
}
int sta[N],rt;
inline void simplex(const int &x,const int &f)
{
    if(x!=f) simplex(fa[x],f);
    tag_down(x);
}
inline void splay(int x,const int &f)
{
    sta[sta[0]=1]=x;
    for(int y=x;y!=f;y=fa[y]) sta[++sta[0]]=fa[y];
    while(sta[0]) tag_down(sta[sta[0]--]);
//  simplex(x,f);
    while(fa[x]!=f)
    {
        if(fa[fa[x]]!=f)
        {
            if((lc[fa[fa[x]]]==fa[x])==(lc[fa[x]]==x)) rotate(fa[x]);
            else rotate(x);
        }
        rotate(x);
    }
    updata(x);
    if(!fa[x]) rt=x;
}
int tot,fir[N],nex[N],go[N];
inline void add(const int &x,const int &y)
{
    nex[++tot]=fir[x];fir[x]=tot;go[tot]=y;
    nex[++tot]=fir[y];fir[y]=tot;go[tot]=x;
}
int q[N];
inline void dfs(const int &u,const int &f)
{
    q[++q[0]]=2*u-1;
    int e,v;
    for(e=fir[u];v=go[e],e;e=nex[e])
    if(v!=f) dfs(v,u);
    q[++q[0]]=2*u;
}
inline void build(int &k,const int &l,const int &r)
{
    if(l>r) return;
    int mid=l+r>>1;
    k=q[mid];
    build(lc[k],l,mid-1);
    build(rc[k],mid+1,r);
    if(lc[k]) fa[lc[k]]=k;
    if(rc[k]) fa[rc[k]]=k;
    updata(k);
}
char sr[5];
inline int find_nex(const int &x)
{
    splay(x,0);
    int y=rc[x];
    while(lc[y]) y=lc[y];
    return y;
}
inline int find_pre(const int &x)
{
    splay(x,0);
    int y=lc[x];
    while(rc[y]) y=rc[y];
    return y;
}
int main()
{
//  freopen("3786.in","r",stdin);
//  freopen(".out","w",stdout);
    srand(19260817);
    n=read();
    for(int i=2;i<=n;++i) add(read(),i);
    q[++q[0]]=2*n+1;
    dfs(1,0);
    q[++q[0]]=2*n+2;
    for(int i=1;i<=n;++i) mul[(i<<1)-1]=1,mul[i<<1]=-1;
    for(int i=1;i<=n;++i)
    {
        val[(i<<1)-1]=val[i<<1]=read();
        val[i<<1]*=-1;
    }
    build(rt,1,q[0]);
    m=read();
    int x,y,z,l,r;
    while(m--)
    {
        scanf("%s",sr+1);
        x=read();
//      splay((rand()%(2*n+2))+1,0);
        if(sr[1]=='Q')
        {
            r=find_nex((x<<1)-1);
            splay(r,0);
            printf("%lld\n",sum[lc[r]]);
        }
        if(sr[1]=='C')
        {
            y=read();
            l=find_pre((x<<1)-1);
            r=find_nex(x<<1);
            splay(l,0);
            splay(r,l);
            z=lc[r];
            lc[r]=0;
            splay(r,0);
            r=find_nex((y<<1)-1);
//          splay((y<<1)-1,0);
            splay(r,(y<<1)-1);
            lc[r]=z;
            fa[z]=r;
            splay(z,0);
        }
        if(sr[1]=='F')
        {
            y=read();
            l=find_pre((x<<1)-1);
            r=find_nex(x<<1);
            splay(l,0);
            splay(r,l);
            tag_add(lc[r],y);
            splay(lc[r],0);
        }
    }
}

手动updata版本

#include<iostream>
#include<string>
#include<cstring>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cmath>
using namespace std;
typedef long long ll;
int n,m;

inline int read()
{
    char c;
    bool pd=0;
    while((c=getchar())>'9'||c<'0')
    if(c=='-') pd=1;
    int res=c-'0';
    while((c=getchar())>='0'&&c<='9')
    res=(res<<3)+(res<<1)+c-'0';
    return pd?-res:res;
}
const int N=210000;
int lc[N],rc[N],fa[N],mul[N],muls[N],tag[N],val[N];
ll sum[N];
inline void updata(const int &x)
{
    muls[x]=muls[lc[x]]+muls[rc[x]]+mul[x];
    sum[x]=val[x]+sum[lc[x]]+sum[rc[x]];
}
inline void tag_add(const int &x,const int &y)
{
    if(!x) return;
    sum[x]+=(ll)muls[x]*y;
    val[x]+=mul[x]>0?y:-y;
    tag[x]+=y;
}
inline void tag_down(const int &x)
{
    if(tag[x])
    {
        tag_add(lc[x],tag[x]);
        tag_add(rc[x],tag[x]);
        tag[x]=0;
    }
}
inline void rotate(const int &x)
{
    int y=fa[x],z=fa[y];
    int b=lc[y]==x?rc[x]:lc[x];
    if(b) fa[b]=y;
    fa[y]=x;fa[x]=z;
    if(z)
    {
        if(lc[z]==y) lc[z]=x;
        else rc[z]=x;
    }
    if(lc[y]==x) lc[y]=b,rc[x]=y;
    else rc[y]=b,lc[x]=y;
    updata(y);
}
int sta[N],rt;
inline void simplex(const int &x,const int &f)
{
    if(x!=f) simplex(fa[x],f);
    tag_down(x);
}
inline void splay(int x,const int &f)
{
    sta[sta[0]=1]=x;
    for(int y=x;y!=f;y=fa[y]) sta[++sta[0]]=fa[y];
    while(sta[0]) tag_down(sta[sta[0]--]);
//  simplex(x,f);
    while(fa[x]!=f)
    {
        if(fa[fa[x]]!=f)
        {
            if((lc[fa[fa[x]]]==fa[x])==(lc[fa[x]]==x)) rotate(fa[x]);
            else rotate(x);
        }
        rotate(x);
    }
    updata(x);
    if(!fa[x]) rt=x;
}
int tot,fir[N],nex[N],go[N];
inline void add(const int &x,const int &y)
{
    nex[++tot]=fir[x];fir[x]=tot;go[tot]=y;
    nex[++tot]=fir[y];fir[y]=tot;go[tot]=x;
}
int q[N];
inline void dfs(const int &u,const int &f)
{
    q[++q[0]]=2*u-1;
    int e,v;
    for(e=fir[u];v=go[e],e;e=nex[e])
    if(v!=f) dfs(v,u);
    q[++q[0]]=2*u;
}
inline void build(int &k,const int &l,const int &r)
{
    if(l>r) return;
    int mid=l+r>>1;
    k=q[mid];
    build(lc[k],l,mid-1);
    build(rc[k],mid+1,r);
    if(lc[k]) fa[lc[k]]=k;
    if(rc[k]) fa[rc[k]]=k;
    updata(k);
}
char sr[5];
inline int find_nex(const int &x)
{
    splay(x,0);
    int y=rc[x];
    while(lc[y]) y=lc[y];
    return y;
}
inline int find_pre(const int &x)
{
    splay(x,0);
    int y=lc[x];
    while(rc[y]) y=rc[y];
    return y;
}
int main()
{
//  freopen("3786.in","r",stdin);
//  freopen(".out","w",stdout);
    srand(19260817);
    n=read();
    for(int i=2;i<=n;++i) add(read(),i);
    q[++q[0]]=2*n+1;
    dfs(1,0);
    q[++q[0]]=2*n+2;
    for(int i=1;i<=n;++i) mul[(i<<1)-1]=1,mul[i<<1]=-1;
    for(int i=1;i<=n;++i)
    {
        val[(i<<1)-1]=val[i<<1]=read();
        val[i<<1]*=-1;
    }
    build(rt,1,q[0]);
    m=read();
    int x,y,z,l,r;
    while(m--)
    {
        scanf("%s",sr+1);
        x=read();
        if(sr[1]=='Q')
        {
            r=find_nex((x<<1)-1);
            splay(r,0);
            printf("%lld\n",sum[lc[r]]);
        }
        if(sr[1]=='C')
        {
            y=read();
            l=find_pre((x<<1)-1);
            r=find_nex(x<<1);
            splay(l,0);
            splay(r,l);
            z=lc[r];
            lc[r]=0;
            updata(r);updata(l);
            r=find_nex((y<<1)-1);
            splay(r,(y<<1)-1);
            lc[r]=z;
            fa[z]=r;
            updata(r);
            updata((y<<1)-1);
        }
        if(sr[1]=='F')
        {
            y=read();
            splay((x<<1)-1,0);
            splay(x<<1,(x<<1)-1);
            z=rc[rt];
            val[rt]+=mul[rt]*y;
            val[z]+=mul[z]*y;
            tag_add(lc[z],y);
            updata(z);updata(rt);
        }
    }
}
Gzb1128
关注
专栏目录
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
bzoj 3159: 决战 （树链剖分+splay）
clover_hxy的博客
04-18 546
题目描述传送门题解其实就是之前用线段树维护的东西改成用splay维护 比较麻烦的就是翻转操作，需要把翻转的位置提出来插入的另一个splay中，翻转后再插回去 具体的细节还是见代码吧。代码#include<iostream> #include<cstdio> #include<cstring> #include<algorithm> #include<cmath> #define N 100003
BZOJ#3786. 星系探索(平衡树，fhq-treap，弱化版ETT)
xmr_pursue_dreams的博客
01-19 360
BZOJ#3786. 星系探索 Solution 子树加，换fatherfatherfather（保证还是树），询问到根路径和。 树上路径求和不好动态维护，于是转化到序列上，维护一个括号序，dfndfndfn处贡献为www，fnsfnsfns处贡献为−w-w−w，一段路径(x,y)(x,y)(x,y)的和相当于序列上dfnxdfn_xdfnx​到dfnydfn_ydfny​的贡献和。 于是子树加相当于区间加，交换子树相当于在dfsdfsdfs序上取出一个区间插入到其他地方去。 这个可以直接用平衡树维护，这里
BZOJ 3786: 星系探索
bblss123的博客
08-05 712
物理学家小C的研究正遇到某个瓶颈。 他正在研究的是一个星系，这个星系中有n个星球，其中有一个主星球(方便起见我们默认其为1号星球)，其余的所有星球均有且仅有一个依赖星球。主星球没有依赖星球。 我们定义依赖关系如下：若星球a的依赖星球是b,则有星球a依赖星球b.此外，依赖关系具有传递性，即若星球a依赖星球b,星球b依赖星球c,则有星球a依赖星球c. 对于这个神秘的星系中，小C初步探究了它的性质，发现星球之间的依赖
【BZOJ-3786】星系探索 Splay + DFS序
weixin_30389003的博客
09-11 158
3786: 星系探索 Time Limit:40 SecMemory Limit:256 MBSubmit:647Solved:212[Submit][Status][Discuss] Description 物理学家小C的研究正遇到某个瓶颈。 他正在研究的是一个星系，这个星系中有n个星球，其中有一个主星球(方便起见我们默认其为1号星球)，其余的所有星球均有且仅有一...
BZOJ3786: 星系探索 splay维护dfs序
リーインカーネイション
12-27 617
题目大意：n个点的树，m个操作 1.询问到根权值和 2.改变父亲，保证不出环 3.子树加 n<=100000,m<=300000，要开long long toptree轻松虐，可惜我不会 因为本题的询问都是一个点到根的，根又不会变，因此可以通过维护入栈出栈序的方法，每个点入栈时向splay中push _ back一个正权值点，出栈时向splay中push _ back一个负权值点，这样从
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
BZOJ上面的题目以及数据
10-13
【BZOJ】全称是“北京邮电大学在线评测系统”，它是一个为编程爱好者和参赛者提供在线编程练习和比赛的平台。该平台涵盖了多种算法和编程问题，旨在提升用户的编程技能和解决复杂问题的能力。BZOJ支持C、C++、Java等...
bzoj problem
08-21
【标题】"bzoj problem" 指的是“八中OJ（Online Judge）问题集”，这是一个在线编程竞赛平台的题目合集。八中OJ可能是某所中学的在线编程训练系统，它提供了大量的编程题目供用户练习和挑战，以提升编程能力和算法...
序列终结者 c语言,BZOJ-1251: 序列终结者（Splay）
weixin_32165903的博客
05-24 170
代码(用splay树维护区间，注意每次不是直接splay(l-1,roof),splay(r+1,R[roof])而是splay(select(l-1,roof),roof),splay(select(r+1,R[roof]),R[roof])):#include #include #include #include using namespace std;#define MAXN 50010#d...
bzoj 3786 星系探索 (splay+dfs序)
guapisolo的博客
09-08 178
题目大意：给你一棵树，支持一下三种操作 1.获取某节点到根节点的路径上所有节点的权值和 2.更换某棵子树的父亲 3.某子树内所有节点的权值都增加一个值w 当时想到了splay维护dfs序，查完题解发现思路是对的，然后我就写了足足6个小时才A st[x]代表入栈时间，ed[x]代表出栈时间 对于第一个操作，每个树上节点在splay中都有两个位置，分别对应入栈出栈序，然后把入栈的点权*1，...
【平衡二叉树】宠物收养所
void* ptr = &OI;
04-19 878
Description 最近，阿Q开了一间宠物收养所。收养所提供两种服务：收养被主人遗弃的宠物和让新的主人领养这些宠物。每个领养者都希望领养到自己满意的宠物，阿Q根据领养者的要求通过他自己发明的一个特殊的公式，得出该领养者希望领养的宠物的特点值a（a是一个正整数，a<2^31），而他也给每个处在收养所的宠物一个特点值。这样他就能够很方便的处理整个领养宠物的过程了，宠物收养所总是会有两种情况发生：被
bzoj3786 星际探索
AaronPolaris
01-21 2387
DFS序+splay
Bzoj3786: 星系探索——Splay
weixin_30532973的博客
08-16 120
题面 　　Bzoj3786 解析 　　上课讲稿上的例题 　　这道题是套路题，是括号序的应用，进入节点时打上$+1$标记, 退出时打上$-1$标记，这个是作为点权的系数　　先看操作2， 需要更改父节点，就是把一段区间提取出来，插入另一个地方，显然可以用Splay维护，先提取区间，再把新父亲的$+1$点旋转至根，把区间挂在根的后继的左儿子上，再把这个节点旋转至根，以更新信息 　...
Bzoj3786星系探索:splay维护dfs序
蜜の夜明け
06-09 782
题目链接：星系探索 最近越来越懒了都不想写blog了QAQ 子树修改，链查询，树结构改变，单纯的lct已经不能满足这道题了QAQ 考虑dfs序，设每个点再dfs序中的位置为st[x],ed[x]，我们在st[x]的位置上赋值为x的值，在ed[x]上赋值为-x的值，这样查询链的时候不在链上的点的贡献会被抵消 修改也很简单 至于改变父节点，只要把当前子树的那一段dfs序删去并加在新父节点的后
bzoj 1861 splay
weixin_33728268的博客
12-08 110
就是裸地splay，然后自己写的不是特别好，tle了，最近时间比较紧迫，有时间了改下，在此记录 另附转载pascal AC代码最下面 /************************************************************** Problem: 1861 User: BLADEVIL Language: Pascal ...
BZOJ[4071][Apio2015]巴邻旁之桥 Splay
谁能代表肯德基
02-08 293
传送门ber~ 考虑k=1k=1k=1的情况 设桥的位置是xxx，那么dis=Σ1≤i≤n∣ai−x∣+∣bi−x∣dis=Σ1≤i≤n∣ai−x∣+∣bi−x∣dis=\Sigma_{1\le i\le n}\mid a_i-x\mid+\mid b_i-x\mid 只要把a,ba,ba,b放一起排序取中位数就可以了 那么k=2k=2k=2时怎么办 发现每个人(x,y)(x,y)(x,...
BZOJ 3786: 星系探索 ETT
EM LGH
08-10 132
Code: #include <cstdio> #include <algorithm> #define N 200005 #define ll long long #define lson t[x].ch[0] #define rson t[x].ch[1] #define setIO(s) freopen(s"....
bzoj.org俄罗斯方块
最新发布
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。其中包括了很多有趣的游戏算法问题，比如Puzzle，Tetris等。 而bzoj.org俄罗斯方块就是在该平台上的一个经典的俄罗斯方块游戏。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值