BZOJ 3786: 星系探索

最新推荐文章于 2021-01-19 08:48:41 发布
最新推荐文章于 2021-01-19 08:48:41 发布
阅读量670 收藏
点赞数
分类专栏： BZOJ 图论 |-----dfs序 数据结构 |-----Splay 文章标签： BZOJ Splay dfs序
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bblss123/article/details/52126257
版权
BZOJ 同时被 3 个专栏收录
19 篇文章 0 订阅
订阅专栏
图论
18 篇文章 0 订阅
订阅专栏
数据结构
13 篇文章 0 订阅
订阅专栏

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可能会进行若干次实验，对于他的每一次实验，请你告诉他这一次实验能量收集器的最终能量是多少。

Solution

本题非常卡常数，一开始直接扒3153的代码狂T不止，改写Splay后也是狂T不止，最后把Splay从数组储存改成结构体储存才AC。                                                 ———Claris

涨姿势题。。
用Splay维护一个dfs序，这个dfs序是那种进入也算，出去也算的dfs序
然后进入的算负的，出去的算正的，这样可以保证对于一个点正dfs序到根的正dfs序之间数字的和恰好是那条路径的权值(不是路径上的要不不出现在这段dfs序中，要不出现了2次，一次正一次负恰好抵消对答案无影响)。
然后就是Splay的板子啦

Code

这是那个结构体版的

/**************************************************************
    Problem: 3786
    User: bblss123
    Language: C++
    Result: Accepted
    Time:23772 ms
    Memory:14004 kb
****************************************************************/

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<time.h>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
typedef double db;
typedef unsigned ud;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

#define fi first 
#define se second
#define pb push_back
#define ph push
#define showtime fprintf(stderr,"time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)

const int INF=(ud)-1>>1;
const ll inf=(ull)-1>>1;

template<class T>void rd(T &a){
    a=0;char c;
    while(c=getchar(),c<48);
    do a=a*10+(c^48);
        while(c=getchar(),c>47);
}
inline void rdc(char &c){
    c=0;char s;
    while(s=getchar(),s<65);
    c=s;
}
template<class T>void nt(T x){
    if(!x)return;
    nt(x/10);
    putchar(48+x%10);
}
template<class T>void pt(T x){
    if(!x)putchar('0');
    else nt(x);
}
template<class T>void Max(T &a,T b){
    if(a<b)a=b;
}
template<class T>void Min(T &a,T b){
    if(a==-1||a>b)a=b;
}
const int M=2e5+10;
const int N=1e5+2;
int f[N],w[N];
struct Edge{
    int to,nxt;
}G[N];
int tot_edge,head[N];
inline void add_edge(int from,int to){
    G[tot_edge]=(Edge){to,head[from]};
    head[from]=tot_edge++;
}
struct Splay_Tree{
    struct node{
        int tr[2],fa,sz,pos;
        ll sum,add,val;
        inline node(){
            tr[0]=tr[1]=sum=add=val=fa=sz=pos=0;
        }
    }T[M];
    int que[M],allc,rt;
    inline void up(int &x){
        node &l=T[T[x].tr[0]],&r=T[T[x].tr[1]];
        T[x].sz=l.sz+r.sz+1;
        T[x].sum=l.sum+r.sum+T[x].val;
        T[x].pos=l.pos+r.pos+(x<=N);
    }
    inline void down(int &x){
        if(!T[x].add)return;
        ll &ad=T[x].add;
        T[x].val+=x>=N?-ad:ad;
        node &l=T[T[x].tr[0]],&r=T[T[x].tr[1]];
        l.add+=T[x].add,r.add+=T[x].add;
        int nagl=l.sz-l.pos,nagr=r.sz-r.pos;
        l.sum+=1ll*l.pos*ad-1ll*nagl*ad;
        r.sum+=1ll*r.pos*ad-1ll*nagr*ad;
        ad=0;
    }
    inline void rotate(int x,int &k){
        int y=T[x].fa,z=T[y].fa,r=T[y].tr[0]==x,l=r^1;
        if(y==k)k=x;
        else{
            if(T[z].tr[0]==y)T[z].tr[0]=x;
            else T[z].tr[1]=x;
        }
        T[x].fa=z,T[y].fa=x,T[T[x].tr[r]].fa=y;
        T[y].tr[l]=T[x].tr[r],T[x].tr[r]=y;
        up(y);
    }
    inline void Splay(int x,int &k){
        for(int v=x;v!=rt;v=T[v].fa)que[++allc]=v;
        que[++allc]=rt;
        for(;allc;)down(que[allc--]);
        for(;x!=k;){
            int y=T[x].fa,z=T[y].fa;
            if(y!=k){
                if(T[z].tr[0]==y^T[y].tr[0]==x)rotate(x,k);
                else rotate(y,k);
            }
            rotate(x,k);
        }
        up(x);
    }
    inline void Insert(int x,int w){
        T[x].val=w;
        if(!rt)rt=x;
        else T[rt].tr[1]=x,T[x].fa=rt,up(x),Splay(x,rt);
    }
    inline ll query(int &x){
        Splay(x,rt);
        return T[T[x].tr[0]].sum+T[x].val;
    }
    inline int search(int x,const bool &dir){
        if(!T[x].tr[dir])return x;
        return search(T[x].tr[dir],dir);
    }
    inline void Change(int x,int y){//turn x's father to y
        Splay(x,rt);
        int k1=search(T[rt].tr[0],1);
        Splay(x+N,rt);
        int k2=search(T[rt].tr[1],0);
        Splay(k1,rt),Splay(k2,T[rt].tr[1]);
        int w=T[k2].tr[0];
        T[k2].tr[0]=0,T[w].fa=0;
        Splay(y,rt);
        int k=search(T[y].tr[1],0);
        Splay(k,T[y].tr[1]);
        T[w].fa=k,T[k].tr[0]=w;
    }
    inline void Add(int x,int w){
        Splay(x,rt);
        int k1=search(T[rt].tr[0],1);
        Splay(x+N,rt);
        int k2=search(T[rt].tr[1],0);
        Splay(k1,rt),Splay(k2,T[rt].tr[1]);
        int s=T[k2].tr[0];
        T[s].add+=w,T[s].sum+=1ll*w*T[s].pos-1ll*(T[s].sz-T[s].pos)*w;
    }
}spt;
int dfs_clock;
inline void dfs(int v){
    spt.Insert(v+1,w[v]);
    for(int i=head[v];~i;i=G[i].nxt)
        dfs(G[i].to);
    spt.Insert(v+N+1,-w[v]);
}
int main(){
    int n,q,u,v;cin>>n;
    memset(head,-1,sizeof(head));
    tot_edge=0;
    for(int i=2;i<=n;++i)
        rd(f[i]),add_edge(f[i],i);
    for(int i=1;i<=n;++i)rd(w[i]);
    spt.Insert(1,0);
    dfs(1);
    spt.Insert(N<<1|1,0);
    char c;
    for(cin>>q;q--;){
        rdc(c);
        switch(c){
            case('Q'):
                rd(v),++v;
                pt(spt.query(v)),putchar('\n');
                break;
            case('C')://turn u's father to v
                rd(u),rd(v),++u,++v;
                spt.Change(u,v);
                break;
            case('F'):
                rd(u),rd(v);++u;
                spt.Add(u,v);
                break;
        }
    }
    return 0;
}


还有数组版。。

/**************************************************************
    Problem: 3786
    User: bblss123
    Language: C++
    Result: Time_Limit_Exceed
****************************************************************/

#include<iostream>
#include<string.h>
#include<stdio.h>
#include<algorithm>
#include<math.h>
#include<time.h>
#include<string>
#include<vector>
#include<queue>
#include<stack>
#include<set>
#include<map>
using namespace std;
typedef double db;
typedef unsigned ud;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

#define fi first 
#define se second
#define pb push_back
#define ph push
#define showtime fprintf(stderr,"time = %.15f\n",clock() / (double)CLOCKS_PER_SEC)

const int INF=(ud)-1>>1;
const ll inf=(ull)-1>>1;

template<class T>void rd(T &a){
    a=0;char c;
    while(c=getchar(),c<48);
    do a=a*10+(c^48);
        while(c=getchar(),c>47);
}
inline void rdc(char &c){
    c=0;char s;
    while(s=getchar(),s<65);
    c=s;
}
template<class T>void nt(T x){
    if(!x)return;
    nt(x/10);
    putchar(48+x%10);
}
template<class T>void pt(T x){
    if(!x)putchar('0');
    else nt(x);
}
template<class T>void Max(T &a,T b){
    if(a<b)a=b;
}
template<class T>void Min(T &a,T b){
    if(a==-1||a>b)a=b;
}
const int M=2e5+10;
const int N=1e5+2;
int f[N],w[N];
struct Edge{
    int to,nxt;
}G[N];
int tot_edge,head[N];
inline void add_edge(int from,int to){
    G[tot_edge]=(Edge){to,head[from]};
    head[from]=tot_edge++;
}
struct Splay_Tree{
    int tr[M][2],rt,fa[M],que[M],sz[M],allc,pos[M];
    ll sum[M],add[M],val[M];
    inline void up(int &x){
        sz[x]=sz[tr[x][0]]+sz[tr[x][1]]+1;
        sum[x]=sum[tr[x][0]]+sum[tr[x][1]]+val[x];
        pos[x]=pos[tr[x][0]]+pos[tr[x][1]]+(x<=N);
    }
    inline void down(int &x){
        if(!add[x])return;
        val[x]+=x>=N?-add[x]:add[x];
        int l=tr[x][0],r=tr[x][1];
        add[l]+=add[x],add[r]+=add[x];
        int nagl=sz[l]-pos[l],nagr=sz[r]-pos[r];
        sum[tr[x][0]]+=1ll*pos[l]*add[x]-1ll*nagl*add[x];
        sum[tr[x][1]]+=1ll*pos[r]*add[x]-1ll*nagr*add[x];
        add[x]=0;
    }
    inline void rotate(int x,int &k){
        int y=fa[x],z=fa[y],r=tr[y][0]==x,l=r^1;
        if(y==k)k=x;
        else{
            if(tr[z][0]==y)tr[z][0]=x;
            else tr[z][1]=x;
        }
        fa[x]=z,fa[y]=x,fa[tr[x][r]]=y;
        tr[y][l]=tr[x][r],tr[x][r]=y;
        up(y);
    }
    inline void Splay(int x,int &k){
        for(int v=x;v!=rt;v=fa[v])que[++allc]=v;
        que[++allc]=rt;
        for(;allc;)down(que[allc--]);
        for(;x!=k;){
            int y=fa[x],z=fa[y];
            if(y!=k){
                if(tr[z][0]==y^tr[y][0]==x)rotate(x,k);
                else rotate(y,k);
            }
            rotate(x,k);
        }
        up(x);
    }
    inline void Insert(int x,int w){
        val[x]=w;
        if(!rt)rt=x;
        else tr[rt][1]=x,fa[x]=rt,up(x),Splay(x,rt);
    }
    inline ll query(int &x){
        Splay(x,rt);
        return sum[tr[x][0]]+val[x];
    }
    inline int search(int x,const bool &dir){
        if(!tr[x][dir])return x;
        return search(tr[x][dir],dir);
    }
    inline void Change(int x,int y){//turn x's father to y
        Splay(x,rt);
        int k1=search(tr[rt][0],1);
        Splay(x+N,rt);
        int k2=search(tr[rt][1],0);
        Splay(k1,rt),Splay(k2,tr[rt][1]);
        int w=tr[k2][0];
        tr[k2][0]=0,fa[w]=0;
        Splay(y,rt);
        int k=search(tr[y][1],0);
        Splay(k,tr[y][1]);
        fa[w]=k,tr[k][0]=w;
    }
    inline void Add(int x,int w){
        Splay(x,rt);
        int k1=search(tr[rt][0],1);
        Splay(x+N,rt);
        int k2=search(tr[rt][1],0);
        Splay(k1,rt),Splay(k2,tr[rt][1]);
        int s=tr[k2][0];
        add[s]+=w,sum[s]+=1ll*w*pos[s]-1ll*(sz[s]-pos[s])*w;
    }
}spt;
int dfs_clock;
inline void dfs(int v){
    spt.Insert(v+1,w[v]);
    for(int i=head[v];~i;i=G[i].nxt)
        dfs(G[i].to);
    spt.Insert(v+N+1,-w[v]);
}
int main(){
    int n,q,u,v;cin>>n;
    memset(head,-1,sizeof(head));
    tot_edge=0;
    for(int i=2;i<=n;++i)
        rd(f[i]),add_edge(f[i],i);
    for(int i=1;i<=n;++i)rd(w[i]);
    spt.Insert(1,0);
    dfs(1);
    spt.Insert(N<<1|1,0);
    char c;
    for(cin>>q;q--;){
        rdc(c);
        switch(c){
            case('Q'):
                rd(v),++v;
                pt(spt.query(v)),putchar('\n');
                break;
            case('C')://turn u's father to v
                rd(u),rd(v),++u,++v;
                spt.Change(u,v);
                break;
            case('F'):
                rd(u),rd(v);++u;
                spt.Add(u,v);
                break;
        }
    }
    return 0;
}

卡常数又到了一个新境界

bblss123
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
BZOJ全代码
02-05
BZOJ平台全部代码，解压到一个文件夹在打开使用。BZOJ平台全部代码，解压到一个文件夹在打开使用。
BZOJ第一部分
11-03
BZOJ原题-BZOJP1000-P2000的题目，下载后可以离线做题。
【BZOJ-3786】星系探索 Splay + DFS序
weixin_30389003的博客
09-11 136
3786: 星系探索 Time Limit:40 SecMemory Limit:256 MBSubmit:647Solved:212[Submit][Status][Discuss] Description 物理学家小C的研究正遇到某个瓶颈。 他正在研究的是一个星系，这个星系中有n个星球，其中有一个主星球(方便起见我们默认其为1号星球)，其余的所有星球均有且仅有一...
【BZOJ】3786: 星系探索
weixin_33835103的博客
12-03 108
【题意】给定一棵带点权树，三种操作： 1.询问点x到根的路径和 2.子树x内的点权加定值y 3.将点x的父亲更换为y，保证仍是树。 【算法】平衡树（fhq-treap） 【题解】 将树的dfs序作为序列维护，对每个点入栈+1，出栈-1，这样操作1就是前缀和（非此路径的都会正负抵消），操作2就是区间加值，操作3就是区间移动，可以用平衡树维护。 具体实现：原树上每个点在序列中对应两个点（...
[BZOJ 3786] 星系探索
LPA的博客
03-18 283
BZOJ传送门 题目描述 物理学家小C的研究正遇到某个瓶颈。 他正在研究的是一个星系，这个星系中有nnn个星球，其中有一个主星球(方便起见我们默认其为111号星球)，其余的所有星球均有且仅有一个依赖星球。主星球没有依赖星球。 我们定义依赖关系如下：若星球aaa的依赖星球是bbb,则有星球aaa依赖星球bbb.此外，依赖关系具有传递性，即若星球aaa依赖星球bbb,星球bbb依赖星球ccc,则有星球...
BZOJ3786 星系探索 【ETT】
BlueSky
09-29 172
题目链接：http://lydsy.com/JudgeOnline/problem.php?id=3786 诈尸了 其实我写了很多blog不过还没有公开233 题解： 对于原树求出欧拉序，然后发现F操作可以转变为区间平移，这显然可以用splay维护 代码： // by Balloons #include <cstdio> #include <cstring> #includ...
BZOJ#3786. 星系探索(平衡树，fhq-treap，弱化版ETT)
xmr_pursue_dreams的博客
01-19 266
BZOJ#3786. 星系探索 Solution 子树加，换fatherfatherfather（保证还是树），询问到根路径和。 树上路径求和不好动态维护，于是转化到序列上，维护一个括号序，dfndfndfn处贡献为www，fnsfnsfns处贡献为−w-w−w，一段路径(x,y)(x,y)(x,y)的和相当于序列上dfnxdfn_xdfnx​到dfnydfn_ydfny​的贡献和。 于是子树加相当于区间加，交换子树相当于在dfsdfsdfs序上取出一个区间插入到其他地方去。 这个可以直接用平衡树维护，这里
BZOJ_problem_rank:BZOJ问题等级按交流比排序
05-25
#BZOJ Problem Rankrank.cpp 程序文件data.dat bzoj题库数据done.dat AC过的题，初始可以把所有A过的题粘进去，正常退出的话自动维护。black.dat 黑名单。选题时会跳过。错题、神题、没题面、不想做等等。//Thank ...
BZOJ3230相似子串测试数据
08-19
BZOJ3230相似子串的测试数据，希望能够帮到大家。
bzoj problem
08-21
八中OJ所有题目
架构探险 原书源码
08-21
本书首先从一个简单的 Web 应用开始，让读者学会如何使用 IDEA、Maven、Git 等开发工具搭建 Java Web 应用；接着通过一个简单的应用场景，为该 Web 应用添加若干业务功能，从需求分析与系统设计开始，带领读者动手完成该 Web 应用，完善相关细节，并对已有代码进行优化；然后基于传统 Servlet 框架搭建一款轻量级 Java Web 框架，一切都是从零开始，逐个实现类加载器、Bean 容器、IoC 框架、MVC 框架，所涉及的代码也是整个框架的核心基础。为了使框架具备 AOP 特性，从代理技术讲到 AOP 技术，从 ThreadLocal 技术讲到事务控制技术。最后对框架进行优化与扩展，通过对现有框架的优化，使其可以提供更加完备的功能，并以扩展 Web 服务插件与安全控制插件为例，教会读者如何设计一款可扩展的Web应用框架。
Bzoj3786: 星系探索——Splay
weixin_30532973的博客
08-16 104
题面 　　Bzoj3786 解析 　　上课讲稿上的例题 　　这道题是套路题，是括号序的应用，进入节点时打上$+1$标记, 退出时打上$-1$标记，这个是作为点权的系数　　先看操作2， 需要更改父节点，就是把一段区间提取出来，插入另一个地方，显然可以用Splay维护，先提取区间，再把新父亲的$+1$点旋转至根，把区间挂在根的后继的左儿子上，再把这个节点旋转至根，以更新信息 　...
BZOJ3786星系探索——非旋转treap(平衡树动态维护dfs序)
weixin_33847182的博客
11-27 132
题目描述 物理学家小C的研究正遇到某个瓶颈。 他正在研究的是一个星系，这个星系中有n个星球，其中有一个主星球(方便起见我们默认其为1号星球)，其余的所有星球均有且仅有一个依赖星球。主星球没有依赖星球。 我们定义依赖关系如下：若星球a的依赖星球是b,则有星球a依赖星球b.此外，依赖关系具有传递性，即若星球a依赖星球b,星球b依赖星球c,则有星球a依赖星球c. 对于这个神秘的星系中，小C初...
[BZOJ3786]星系探索-ETT
「嫌われ者のフィロソフィ」
12-07 1358
星系探索Description物理学家小C的研究正遇到某个瓶颈。他正在研究的是一个星系，这个星系中有n个星球，其中有一个主星球(方便起见我们默认其为1号星球)，其余的所有星球均有且仅有一个依赖星球。主星球没有依赖星球。我们定义依赖关系如下：若星球a的依赖星球是b,则有星球a依赖星球b.此外，依赖关系具有传递性，即若星球a依赖星球b,星球b依赖星球c,则有星球a依赖星球c.对于这个神秘的星系中，小C初
bzoj 3786: 星系探索 splay
lych的博客
12-06 943
bzoj真是坑爹，本地跑的差不多的程序，指针比数组快到不知道哪里去了。        然后我就开始了艰辛的卡常数，最终比很多指针快多辣~~~        由于有子树移动，那么考虑维护括号序列。也就是dfs入栈为'('，出栈为')'，然后'('为正的权值。那么子树移动相当于平衡树的分裂和合并。用splay实现。        PS：求卡常数大神优化代码>. AC代码如下（目前最快的）：
BZOJ3786 星系探索 蒟蒻出题人给跪
守望、御神木
12-04 2327
BZOJ3786 题解、数据、标程
bzoj3786 星际探索
AaronPolaris
01-21 2356
DFS序+splay
BZOJ 3786 星系探索 DFS序+Splay
世界
12-01 3878
题目大意：给定一棵有根树，提供下列操作： 1.询问某个点到根路径上的点权和 2.修改某个点的父亲，保证修改之后仍然是一棵树 3.将某个点所在子树的所有点权加上一个值 子树修改，LCT明显是搞不了了，在想究竟会不会有人去写自适应Top-Tree…… 首先我们DFS搞出这棵树的入栈出栈序 然后入栈为正出栈为负 那么一个点到根的路径上的点权和就是从根节点的入栈位置到这个点的入栈位置的和 子
BZOJ3786 星系探索
neither_nor
12-27 1295
ETT搞上，每条边如果是一条从父到子的边，那么设其权值为儿子节点的权值，如果是一条从子到父的边，那么设其权值为儿子节点的权值的相反数，我们用一个splay来维护整棵树的欧拉序，那么一个节点到根的路径的点权和就等于从根走欧拉序到这个点的边权和 linkcut操作就相当于区间平移 子树加就相当于把区间里父到子的边加，子到父的边减 维护区间和 就过了 注意w[i]开始可以得0 #includ
BZOJ2839:集合计数(容斥,组合数学)
最新发布
06-08
这个问题是一个比较经典的容斥原理的应用题目。我们可以考虑使用容斥原理来求解这个问题。具体来说，我们可以考虑求出所有集合的个数，然后减去至少包含一个特定元素的集合的个数，再加上至少包含两个特定元素的集合...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值