牛客小白月赛9 树上求和【树链剖分模板】

最新推荐文章于 2021-06-03 19:01:05 发布

什么都不会的菜鸡

最新推荐文章于 2021-06-03 19:01:05 发布

阅读量294

点赞数 1

分类专栏：数据结构图论

本文链接：https://blog.csdn.net/qq_42211531/article/details/88964321

版权

图论同时被 2 个专栏收录

55 篇文章 0 订阅

订阅专栏

数据结构

45 篇文章 1 订阅

订阅专栏

传送门

题目描述：
给你一棵根为1的有N个节点的树，以及Q次操作。
每次操作诸如:
1 x y：将节点x所在的子树的所有节点的权值加上y
2 x：询问x所在子树的所有节点的权值的平方和，答案模23333后输出

输入描述：
第一行两个整数N,Q
第二行N个整数，第i个表示节点i的初始权值
接下来N-1行每行两个整数u,v，表示u和v之间存在一条树边
接下来Q行每行一个操作，格式如题目描述

输出描述：
对于每个询问操作，输出一行一个整数，表示答案在模23333后的结果

思路：
树链剖分模板题，主要就是线段树部分，我们维护两个值：总和，平方和。 $\sum a$ 和 $\sum a^{^{2}}$

$\sum a$ 用 lazy 标记很好推，主要就是怎么推 $\sum a^{^{2}}$

$\sum \left ( a+x \right )^{^{2}}= \sum \left ( a^{2} \right + 2 * a * b + b^{^{2}})= \sum a^{2}+ 2*x*\sum a+ len*\sum b^{^{2}}$ 。

Pushdown函数如下：

void pushdown(int sign,int l,int r)
{
    if(lazy[sign])
    {
        int mid=(l+r)>>1;
        lazy[sign<<1]=(lazy[sign<<1]+lazy[sign])%mod;
        lazy[sign<<1|1]=(lazy[sign<<1|1]+lazy[sign])%mod;
        ///必须先推平方和
        squ[sign<<1]=(squ[sign<<1]+2*lazy[sign]%mod*sum[sign<<1]%mod+(mid-l+1)*lazy[sign]%mod*lazy[sign]%mod)%mod;
        squ[sign<<1|1]=(squ[sign<<1|1]+2*lazy[sign]%mod*sum[sign<<1|1]%mod+(r-mid)*lazy[sign]%mod*lazy[sign]%mod)%mod;
        ///推总和
        sum[sign<<1]=(sum[sign<<1]+lazy[sign]*(mid-l+1))%mod;
        sum[sign<<1|1]=(sum[sign<<1|1]+lazy[sign]*(r-mid))%mod;
        lazy[sign]=0;
    }
}

全部代码：

///#include<bits/stdc++.h>
///#include<unordered_map>
///#include<unordered_set>
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<queue>
#include<set>
#include<stack>
#include<map>
#include<new>
#include<vector>
#define MT(a,b) memset(a,b,sizeof(a));
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
const double pai=acos(-1.0);
const double E=2.718281828459;
const int INF=0x3f3f3f3f;
const ll mod=23333;

int n,q;
ll value[100005];

struct node
{
    int e;
    int p;
}load[200005];
int head[100005],sign;

///DFS1
int depth[100005];
int father[100005];
int h_son[100005];
int sizes[100005];
///DFS2
int times;
int top[100005];
int id[100005];
int ranks[100005];

void add_edge(int s,int e)
{
    load[++sign]=node{e,head[s]};
    head[s]=sign;
}
void dfs1(int s,int pre)
{
    depth[s]=depth[pre]+1;
    father[s]=pre;
    sizes[s]=1;
    for(int i=head[s]; i!=-1; i=load[i].p)
    {
        int e=load[i].e;
        if(e!=pre)
        {
            dfs1(e,s);
            sizes[s]+=sizes[e];
            if(sizes[e]>sizes[h_son[s]])
                h_son[s]=e;
        }
    }
}

void dfs2(int s,int root)
{
    top[s]=root;
    id[s]=++times;
    ranks[times]=s;
    if(!h_son[s])
        return ;
    dfs2(h_son[s],root);
    for(int i=head[s]; i!=-1; i=load[i].p)
    {
        int e=load[i].e;
        if(e!=father[s]&&e!=h_son[s])
            dfs2(e,e);
    }
}

ll sum[400005];
ll squ[400005];
ll lazy[400005];

void pushup(int sign)
{
    sum[sign]=(sum[sign<<1]+sum[sign<<1|1])%mod;
    squ[sign]=(squ[sign<<1]+squ[sign<<1|1])%mod;
}

void pushdown(int sign,int l,int r)
{
    if(lazy[sign])
    {
        int mid=(l+r)>>1;
        lazy[sign<<1]=(lazy[sign<<1]+lazy[sign])%mod;
        lazy[sign<<1|1]=(lazy[sign<<1|1]+lazy[sign])%mod;
        ///必须先推平方和
        squ[sign<<1]=(squ[sign<<1]+2*lazy[sign]%mod*sum[sign<<1]%mod+(mid-l+1)*lazy[sign]%mod*lazy[sign]%mod)%mod;
        squ[sign<<1|1]=(squ[sign<<1|1]+2*lazy[sign]%mod*sum[sign<<1|1]%mod+(r-mid)*lazy[sign]%mod*lazy[sign]%mod)%mod;
        ///推总和
        sum[sign<<1]=(sum[sign<<1]+lazy[sign]*(mid-l+1))%mod;
        sum[sign<<1|1]=(sum[sign<<1|1]+lazy[sign]*(r-mid))%mod;
        lazy[sign]=0;
    }
}

void build_root(int sign,int l,int r)
{
    if(l==r)
    {
        sum[sign]=value[ranks[l]]%mod;
        squ[sign]=(sum[sign]*sum[sign])%mod;
        return ;
    }
    int mid=(l+r)>>1;
    build_root(sign<<1,l,mid);
    build_root(sign<<1|1,mid+1,r);
    pushup(sign);
}

void update(int sign,int l,int r,int a,int b,ll x)
{
    if(a==l&&b==r)
    {
        lazy[sign]=(lazy[sign]+x)%mod;
        squ[sign]=(squ[sign]+2*x%mod*sum[sign]%mod+(r-l+1)*x%mod*x%mod)%mod;
        sum[sign]=(sum[sign]+x*(r-l+1)%mod)%mod;
        return ;
    }
    pushdown(sign,l,r);
    int mid=(l+r)>>1;
    if(b<=mid)
        update(sign<<1,l,mid,a,b,x);
    else if(a>mid)
        update(sign<<1|1,mid+1,r,a,b,x);
    else
    {
        update(sign<<1,l,mid,a,mid,x);
        update(sign<<1|1,mid+1,r,mid+1,b,x);
    }
    pushup(sign);
}

ll find_root(int sign,int l,int r,int a,int b)
{
    if(a==l&&b==r)
        return squ[sign];
    pushdown(sign,l,r);
    int mid=(l+r)>>1;
    if(b<=mid)
        return find_root(sign<<1,l,mid,a,b);
    else if(a>mid)
        return find_root(sign<<1|1,mid+1,r,a,b);
    else
        return (find_root(sign<<1,l,mid,a,mid)+find_root(sign<<1|1,mid+1,r,mid+1,b))%mod;
}
void init()
{
    sign=0;
    times=0;
    memset(head,-1,sizeof(head));
    memset(sum,0,sizeof(sum));
    memset(squ,0,sizeof(squ));
    ///DFS1
    memset(depth,0,sizeof(depth));
    memset(father,0,sizeof(father));
    memset(h_son,0,sizeof(h_son));
    memset(sizes,0,sizeof(sizes));
    ///DFS2
    memset(top,0,sizeof(top));
    memset(id,0,sizeof(id));
    memset(ranks,0,sizeof(ranks));
}

int main()
{
    init();
    int s,e;
    scanf("%d %d",&n,&q);
    for(int i=1; i<=n; i++)
        scanf("%lld",&value[i]);
    for(int i=1; i<n; i++)
    {
        scanf("%d %d",&s,&e);
        add_edge(s,e);
        add_edge(e,s);
    }
    dfs1(1,0);
    dfs2(1,1);
    build_root(1,1,n);
    int op,x;
    ll y;
    while(q--)
    {
        scanf("%d",&op);
        if(op==1)
        {
            scanf("%d %lld",&x,&y);
            update(1,1,n,id[x],id[x]+sizes[x]-1,y);
        }
        else
        {
            scanf("%d",&x);
            printf("%lld\n",find_root(1,1,n,id[x],id[x]+sizes[x]-1)%mod);
        }
    }
    return 0;
}