ACM-ICPC 2018 沈阳赛区网络预赛 J树分块

J. Ka Chang

Given a rooted tree ( the root is node 11 ) of NN nodes. Initially, each node has zero point.

Then, you need to handle QQ operations. There're two types:

1\ L\ X1 L X: Increase points by XX of all nodes whose depth equals LL ( the depth of the root is zero ). (x \leq 10^8)(x≤108)

2\ X2 X: Output sum of all points in the subtree whose root is XX.

Input

Just one case.

The first lines contain two integer, N,QN,Q. (N \leq 10^5, Q \leq 10^5)(N≤105,Q≤105).

The next n-1n−1 lines: Each line has two integer aa,bb, means that node aa is the father of node bb. It's guaranteed that the input data forms a rooted tree and node 11 is the root of it.

The next QQ lines are queries.

Output

For each query 22, you should output a number means answer.

样例输入复制

样例输出复制

1

0

题目来源

ACM-ICPC 2018 沈阳赛区网络预赛

首先这是一个原题，你需要更新深度为x的值，每次仅仅查询子树就可以，用线段树的话，需要更新的太多的

要树分块，打上time标记，每个数据太多不能暴力更新，单独列出来

#include<bits/stdc++.h>

using namespace std;

const int N=;

vector<int>G[N];

vector<int>pos[N];

vector<int>vec;

int L[N],R[N];

int tot,n,m,lim=;

long long s[N],c[N];

void dfs(int now,int deep)

{

    L[now]=++tot;//一块的左标记

    pos[deep].push_back(L[now]);

    for(auto X:G[now])dfs(X,deep+);

    R[now]=tot;//右标记，这个内全是其子树

    return;

}

void add(int x,int d)

{

    for(;x<=n;x+=x&-x)c[x]+=d;

}

long long sum(int x)

{

    long long ans=;

    for(;x>;x-=x&-x)ans+=c[x];

    return ans;

}

int main()

{

    scanf("%d%d",&n,&m);

    for(int i=,u,v;i<n;i++)

        scanf("%d%d",&u,&v),G[u].push_back(v);

    dfs(,);

    for(int i=;i<=n;i++)

        if(pos[i].size()>lim)vec.push_back(i);

    for(int i=,op,x,y;i<m;i++)

    {

        scanf("%d%d",&op,&x);

        if(op==)

        {

            scanf("%d",&y);

            if(pos[x].size()<=lim)

                for(auto X:pos[x])add(X,y);//小于所给块大小，直接树状数组更新

            else s[x]+=y;//大于的直接扔进去等更新

        }

        else

        {

            long long ans=sum(R[x])-sum(L[x]-);//查询所有小块的值,多余的进行下面的更新

             for(auto X:vec)

                ans+=(upper_bound(pos[X].begin(), pos[X].end(),R[x])-lower_bound(pos[X].begin(),pos[X].end(),L[x]))*s[X];

                //vec的元素不会太多，顶多1e5，直接搞进去更新

            printf("%lld\n",ans);

        }

    }

}

4765: 普通计算姬

Time Limit: 30 Sec Memory Limit: 256 MB
Submit: 1481 Solved: 318
[Submit][Status][Discuss]

Description

"奋战三星期，造台计算机"。小G响应号召，花了三小时造了台普通计算姬。普通计算姬比普通计算机要厉害一些。普通计算机能计算数列区间和，而普通计算姬能计算树中子树和。更具体地，小G的计算姬可以解决这么个问题：给定一棵n个节点的带权树，节点编号为1到n，以root为根，设sum[p]表示以点p为根的这棵子树中所有节点的权值和。计算姬支持下列两种操作:

1 给定两个整数u,v，修改点u的权值为v。

2 给定两个整数l,r，计算sum[l]+sum[l+1]+....+sum[r-1]+sum[r]

尽管计算姬可以很快完成这个问题，可是小G并不知道它的答案是否正确，你能帮助他吗？

Input

第一行两个整数n,m，表示树的节点数与操作次数。

接下来一行n个整数，第i个整数di表示点i的初始权值。

接下来n行每行两个整数ai,bi，表示一条树上的边，若ai=0则说明bi是根。

接下来m行每行三个整数，第一个整数op表示操作类型。

若op=1则接下来两个整数u,v表示将点u的权值修改为v。

若op=2则接下来两个整数l,r表示询问。

N<=10^5,M<=10^5

0<=Di,V<2^31,1<=L<=R<=N,1<=U<=N

Output

对每个操作类型2输出一行一个整数表示答案。

Sample Input

6 4

0 0 3 4 0 1

0 1

1 2

2 3

2 4

3 5

5 6

2 1 2

1 1 1

2 3 6

2 3 5

Sample Output

BZOJ这个题目也是啊，但是套路不太一样

#include<iostream>

#include<vector>

#include<math.h>

using namespace std;

#define N 100005

typedef unsigned long long ll;

int n,m,q,lim,root,belong[N];

int L[N],R[N],tot,cnt[N];

int g[N][];

ll c[N+N],sum[N],a[N],tag[N];

vector<int>G[N];

void add(int x,int d)

{

    for(; x<=n; x+=x&-x)c[x]+=d;

}

ll Sum(int x)

{

    ll ans=;

    for(; x>; x-=x&-x)ans+=c[x];

    return ans;

}

void dfs(int x,int fa)

{

    L[x]=++tot,add(L[x],a[x]),++cnt[belong[x]],sum[x]=a[x];

    for(int i=; i<=lim; i++)g[x][i]=cnt[i];

    int l=G[x].size();

    for(int i=,X;i<l;i++)

    {

        X=G[x][i];

        if(X==fa)continue;

        dfs(X,x);

        sum[x]+=sum[X];

    }

    R[x]=tot,--cnt[belong[x]],tag[belong[x]]+=sum[x];

}

ll query(int l,int r)

{

    ll ans=;

    for(int i=l;i<=min(r,belong[l]*m);i++)ans+=Sum(R[i])-Sum(L[i]-);

    if(belong[l]!=belong[r])

    {

        for(int i=(belong[r]-)*m+;i<=r;i++)ans+=Sum(R[i])-Sum(L[i]-);

    }

    for(int i=belong[l]+;i<=belong[r]-;i++)ans+=tag[i];

    return ans;

}

int main()

{

    cin>>n>>q;

    m=sqrt(n+0.5);//一块有几个

    for(int i=; i<=n; i++)cin>>a[i],belong[i]=(i-)/m+;

    lim=belong[n];

    for(int i=,u,v; i<=n; ++i)

    {

        cin>>u>>v;

        if(!u)root=v;

        else G[u].push_back(v),G[v].push_back(u);

    }

    dfs(root,-);

    for(int i=,op,u,v; i<q; i++)

    {

        cin>>op>>u>>v;

        if(op==)

        {

            for(int i=; i<=lim; i++)tag[i]+=g[u][i]*1LL*(v-a[u]);

            add(L[u],v-a[u]),a[u]=v;

        }

        else cout<<query(u,v)<<"\n";

    }

    return ;

}