bzoj 3683: Falsita 树链剖分+线段树

最新推荐文章于 2018-12-15 22:14:32 发布

原创最新推荐文章于 2018-12-15 22:14:32 发布 · 248 阅读

0 ·

CC 4.0 BY-SA版权

线段树同时被 2 个专栏收录

33 篇文章

订阅专栏

树链剖分

9 篇文章

订阅专栏

本文探讨了一种基于精神树模型的算法，用于解决Fine与Falsita两人在精神世界中达成共识的问题。在这个模型中，节点代表个人，权值表示个人状态，通过计算节点间的共识代价，即权值和，来评估共识过程的难度。文章详细介绍了如何通过树链剖分、线段树和树状数组等数据结构优化计算过程，实现高效的共识代价计算。

Description
描述
到海边了呢…
如果没有那次选择,现在是不是会好些呢…
都过去了。
仰望着星空,迎面吹过一阵阵海风,倚靠着护栏,Fine 在海边静静地伫立着,在一个个无际的长夜后,Fine 终于放下了往事的痛楚,得到了治愈。
但是作为 Fine 的另一重人格的 Falsita 就没那么幸运了。她仍然被各种繁忙的事务困扰着。
虽然同在一副躯体中,Fine 与 Falsita 的精神世界却相差甚远,Fine 可以轻易地构造出幻梦时,Falsita 却只能停留在现实的痛楚中。
但是为了生活需要,她们还是需要经常达成共识。
让我们形式化的描述一下吧。
她们所在的精神世界是一棵以 1 号节点为根的树,每个树上的节点 u 都有一个权值Wu,她们每个人分别都在一个节点上,达成共识的方法就是两个人都到达一个共识节点(即到达它们的最近公共祖先)。
一个点 u 与另外一个点 v 之间想要达到共识需要花费的代价为Wu+Wv。
有时两人的精神有所触动时,有时点的权值会改变成某个数,有时以某个点的子树中的所有点的权值会加上某个数。
Falsita 和 Fine 经常需要达成共识,每一次询问,已知达成的共识节点,求她们花费的期望代价。

Input
输入共 m + 3 行。
第一行两个整数 n, m ,表示节点个数和操作数。
第二行 n - 1 个整数Pi,表示节点 i ( i = 2 . . . n ) 的父亲节点的编号。
第三行 n 个整数Wi。
接下来 m 行,每行表示一个操作。

S u delta 表示将节点 u 的权值加上 delta 。
M u delta 表示将以节点 u 为根的子树中的所有节点的权值加上 delta。
Q u 表示询问共识节点为 u 时的答案。
询问保证 u 不是叶子节点。

Output
对于每组询问,输出答案,答案精确到小数点后 6 位。
你的程序输出的答案需要与标准答案之差不超过10^(-5)。

Sample Input
4 6
1 2 2
0 -6 3 0
S 2 -5
M 3 8
S 1 -1
M 4 7
M 3 2
Q 1

Sample Output
2.000000

HINT
前5个操作后，四个节点的权值分别为-1,-11,13,7。最近公共祖先为1的点对有(1,2),(1,3),(1,4)，权值和分别为-12,12,6，故答案为(-12+12+6)/3=2。

对于 100% 的数据,1 ≤ n, m ≤ 300000, 0≤ |delta|, |Wi|≤ 20000。

分析：
设 $v a l [x]$ 为节点 $x$ 的权值， $s u m [x]$ 为 $x$ 子树内权值的和， $s i z e [x]$ 表示 $x$ 子树的大小，对于每一个节点 $x$ 来说，
$ans[x]=val[x]∗(size[x]−1)+∑y∈son[x]sum[y]∗(size[x]−size[y])ans[x]=val[x]*(size[x]-1)+\sum_{y\in son[x]}sum[y]*(size[x]-size[y])$
对于关于 $x$ 的单点修改， $x$ 的答案值改变了 $d e l t a * (s i z e [x] - 1)$ ，直接可以线段树修改；而对于他的祖先 $i$ ，每个节点改变了 $d e l t a * (s i z e [i] - s i z e [j])$ ，其中 $j$ 是 $i$ 在链上儿子。
由于每次的 $s i z e [j]$ 不一定相同，无法直接打标记；而一个节点的儿子很多，记录关于每一个儿子的贡献也不可行。于是可以想到树链剖分，只记录重儿子的贡献。
具体来说，对于每一个节点记录一个 $r [i] = s i z e [i] - s i z e [h s o n [i]]$ ，线段树上每个节点 $i$ 的值维护成 $sum_1+r[i]*sum_2$ 的形式。对于一个修改，每段链的最深的点直接修改 $sum_1$ ，而链上直接区间加 $sum_2$ 。
而对于子树修改，子树内的所有点的期望值增加了 $2 * d e l t a$ ，多开一个树状数组维护一下，然后剩下的就是子树的根到根的路径修改，方法同上，不过值变成了 $s i z e [x] * d e l t a$ 。

复杂度是 $O(nlog^2n)$ 的。

代码：

/**************************************************************
    Problem: 3683
    User: ypxrain
    Language: C++
    Result: Accepted
    Time:8092 ms
    Memory:79160 kb
****************************************************************/
 
#include <iostream>
#include <cstdio>
#include <cmath>
#define LL long long
 
const int maxn=3e5+7;
 
using namespace std;
 
LL n,m,x,y,cnt;
LL ls[maxn],a[maxn];
LL dfn[maxn][2],top[maxn],size[maxn],fa[maxn],r[maxn];
LL num[maxn];
double ans;
char op[5];
 
struct node{
    LL l,r;
    LL data1,data2;
}t[maxn*4];
 
struct edge{
    LL y,next;
}g[maxn];
 
struct treearray{
    LL t[maxn];
    void updata(LL x,LL k)
    {
        for (LL i=x;i<=n;i+=i&(-i)) t[i]+=(LL)k;
    }
    LL getsum(LL x)
    {
        LL sum=0;
        for (LL i=x;i>0;i-=i&(-i)) sum+=t[i];
        return sum;
    }
    void ins(LL l,LL r,LL k)
    {
        updata(l,k);
        if (r<n) updata(r+1,-k);
    }
}A;
 
void dfs1(LL x,LL F)
{
    size[x]=1;
    fa[x]=F;
    for (LL i=ls[x];i>0;i=g[i].next)
    {
        LL y=g[i].y;
        if (y==F) continue;
        dfs1(y,x);
        num[x]+=(LL)size[x]*(LL)size[y];
        size[x]+=size[y];
    }
}
 
void dfs2(LL x,LL F)
{
    dfn[x][0]=dfn[x][1]=++cnt;
    top[x]=F;
    LL c=0;
    for (LL i=ls[x];i>0;i=g[i].next)
    {
        LL y=g[i].y;
        if (y==fa[x]) continue;
        if (size[y]>size[c]) c=y;
    }
    if (!c) return;
    dfs2(c,F);
    dfn[x][1]=dfn[c][1];
    r[x]=size[x]-size[c];
    for (LL i=ls[x];i>0;i=g[i].next)
    {
        LL y=g[i].y;
        if ((y==fa[x]) || (y==c)) continue;
        dfs2(y,y);
        dfn[x][1]=dfn[y][1];
    }
}
 
void ins(LL p,LL l,LL r,LL x,LL y,LL k1,LL k2)
{
    if ((l==x) && (r==y))
    {
        t[p].data1+=k1;
        t[p].data2+=k2;
        return;
    }
    LL mid=(l+r)/2;
    if (y<=mid) ins(p*2,l,mid,x,y,k1,k2);
    else if (x>mid) ins(p*2+1,mid+1,r,x,y,k1,k2);
    else
    {
        ins(p*2,l,mid,x,mid,k1,k2);
        ins(p*2+1,mid+1,r,mid+1,y,k1,k2);
    }
}
 
LL getsum(LL p,LL l,LL r,LL x,LL k)
{
    if (l==r) return t[p].data1+t[p].data2*(LL)k;
    LL mid=(l+r)/2;
    if (x<=mid) return getsum(p*2,l,mid,x,k)+t[p].data1+t[p].data2*(LL)k;
           else return getsum(p*2+1,mid+1,r,x,k)+t[p].data1+t[p].data2*(LL)k;
}
 
void change(LL x,LL delta)
{
    while (top[x]!=1)
    {
        if (x!=top[x]) ins(1,1,n,dfn[top[x]][0],dfn[fa[x]][0],0,delta);
        ins(1,1,n,dfn[fa[top[x]]][0],dfn[fa[top[x]]][0],(LL)delta*(size[fa[top[x]]]-size[top[x]]),0);
        x=fa[top[x]];
    }
    if (x!=1) ins(1,1,n,1,dfn[fa[x]][0],0,delta);
}
 
int main()
{
    scanf("%lld%lld",&n,&m);
    for (LL i=1;i<n;i++)
    {
        scanf("%lld",&x);
        g[i].y=i+1;
        g[i].next=ls[x];
        ls[x]=i;
    }
    for (LL i=1;i<=n;i++) scanf("%lld",&a[i]);
    dfs1(1,0);
    dfs2(1,1);  
    for (LL i=1;i<=n;i++)
    {
        ins(1,1,n,dfn[i][0],dfn[i][0],(LL)a[i]*((LL)size[i]-1),0);
        change(i,a[i]);
    }       
    for (LL i=1;i<=m;i++)
    {
        scanf("%s",op);
        if (op[0]=='S')
        {
            scanf("%lld%lld",&x,&y);
            ins(1,1,n,dfn[x][0],dfn[x][0],(LL)y*((LL)size[x]-1),0);
            change(x,y);
        }
        if (op[0]=='M')
        {
            scanf("%lld%lld",&x,&y);            
            A.ins(dfn[x][0],dfn[x][1],y*2);
            change(x,(LL)size[x]*(LL)y);
        }       
        if (op[0]=='Q')
        {           
            scanf("%lld",&x);
            ans=(double)getsum(1,1,n,dfn[x][0],r[x])/(double)num[x]+(double)A.getsum(dfn[x][0]);
            printf("%.6lf\n",ans);
        }
    }
}