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

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

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

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 行,每行表示一个操作。

  1. S u delta 表示将节点 u 的权值加上 delta 。
  2. M u delta 表示将以节点 u 为根的子树中的所有节点的权值加上 delta。
  3. 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。

分析:
val[x]val[x]val[x]为节点xxx的权值,sum[x]sum[x]sum[x]xxx子树内权值的和,size[x]size[x]size[x]表示xxx子树的大小,对于每一个节点xxx来说,
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])ans[x]=val[x](size[x]1)+yson[x]sum[y](size[x]size[y])
对于关于xxx的单点修改,xxx的答案值改变了delta∗(size[x]−1)delta*(size[x]-1)delta(size[x]1),直接可以线段树修改;而对于他的祖先iii,每个节点改变了delta∗(size[i]−size[j])delta*(size[i]-size[j])delta(size[i]size[j]),其中jjjiii在链上儿子。
由于每次的size[j]size[j]size[j]不一定相同,无法直接打标记;而一个节点的儿子很多,记录关于每一个儿子的贡献也不可行。于是可以想到树链剖分,只记录重儿子的贡献。
具体来说,对于每一个节点记录一个r[i]=size[i]−size[hson[i]]r[i]=size[i]-size[hson[i]]r[i]=size[i]size[hson[i]],线段树上每个节点iii的值维护成sum1+r[i]∗sum2sum_1+r[i]*sum_2sum1+r[i]sum2的形式。对于一个修改,每段链的最深的点直接修改sum1sum_1sum1,而链上直接区间加sum2sum_2sum2
而对于子树修改,子树内的所有点的期望值增加了2∗delta2*delta2delta,多开一个树状数组维护一下,然后剩下的就是子树的根到根的路径修改,方法同上,不过值变成了size[x]∗deltasize[x]*deltasize[x]delta

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

代码:

/**************************************************************
    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);
        }
    }
}
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值