NC204871 求和

Posted 2023-06-21 空白菌

题目链接

题目

题目描述

已知有 \\(n\\) 个节点，有 \\(n-1\\) 条边，形成一个树的结构。

给定一个根节点 \\(k\\) ，每个节点都有一个权值，节点i的权值为 \\(v_i\\) 。

给 \\(m\\) 个操作，操作有两种类型：

1 a x ：表示将节点 \\(a\\) 的权值加上 \\(x\\)

2 a ：表示求 \\(a\\) 节点的子树上所有节点的和（包括 \\(a\\) 节点本身）

输入描述

第一行给出三个正整数 \\(n,m,k\\) ，表示树的节点数、操作次数、和这棵树的根节点.第二行给出 \\(n\\) 个正整数，第 iii 个正整数表示第 \\(i\\) 个节点的权值 \\(val_i\\)下面 \\(n-1\\) 行每行两个正整数 \\(u,v\\) ，表示边的两个端点接下来 \\(m\\) 行，每行给出一个操作

输出描述

对于每个类型为 2 的操作,输出一行一个正整数,表示以 \\(a\\) 为根的子树的所有节点的权值和

示例1

输入

5 6 1
1 2 3 4 5
1 3
1 2
2 4
2 5
1 2 10
1 3 10
1 4 5
1 5 1
2 3
2 2

输出

13
27

备注

\\(1\\leq n,m\\leq 1e6,1\\leq k\\leq n\\)

\\(1\\leq u,v \\leq n\\)

\\(1\\leq a\\leq n\\)

\\(−1e6\\leq val_i,x\\leq 1e6\\)

建议使用 scanf 读入

题解

知识点：DFS序，线段树。

用dfs序可以将树转换成包含子树信息的线性序列，只确定子树结束时间即可。那么，一个子树的根节点开始时间和结束时间之间的节点，都是这个子树的节点。随后，可以用线段树处理这个序列了。

时间复杂度 \\(O(n + m\\log n)\\)

空间复杂度 \\(O(n)\\)

代码

#include <bits/stdc++.h>
using namespace std;
using ll = long long;

struct Graph 
    struct edge 
        int v, nxt;
    ;
    int idx;
    vector<int> h;
    vector<edge> e;

    Graph(int n = 0, int m = 0)  init(n, m); 

    void init(int n, int m) 
        idx = 0;
        h.assign(n + 1, 0);
        e.assign(m + 1, );
    

    void add(int u, int v) 
        e[++idx] =  v,h[u] ;
        h[u] = idx;
    
;

struct T 
    ll sum;
    static T e()  return  0 ; 
    friend T operator+(const T &a, const T &b)  return  a.sum + b.sum ; 
;

struct F 
    ll add;
    T operator()(const T &x)  return  x.sum + add ; 
;

template<class T, class F>
class SegmentTree 
    int n;
    vector<T> node;

    void update(int rt, int l, int r, int x, F f) 
        if (r < x || x < l) return;
        if (l == r) return node[rt] = f(node[rt]), void();
        int mid = l + r >> 1;
        update(rt << 1, l, mid, x, f);
        update(rt << 1 | 1, mid + 1, r, x, f);
        node[rt] = node[rt << 1] + node[rt << 1 | 1];
    

    T query(int rt, int l, int r, int x, int y) 
        if (r < x || y < l) return T::e();
        if (x <= l && r <= y) return node[rt];
        int mid = l + r >> 1;
        return query(rt << 1, l, mid, x, y) + query(rt << 1 | 1, mid + 1, r, x, y);
    

public:
    SegmentTree(int _n = 0)  init(_n); 
    SegmentTree(const vector<T> &src)  init(src); 

    void init(int _n) 
        n = _n;
        node.assign(n << 2, T::e());
    
    void init(const vector<T> &src) 
        assert(src.size() >= 2);
        init(src.size() - 1);
        function<void(int, int, int)> build = [&](int rt, int l, int r) 
            if (l == r) return node[rt] = src[l], void();
            int mid = l + r >> 1;
            build(rt << 1, l, mid);
            build(rt << 1 | 1, mid + 1, r);
            node[rt] = node[rt << 1] + node[rt << 1 | 1];
        ;
        build(1, 1, n);
    

    void update(int x, F f)  update(1, 1, n, x, f); 

    T query(int x, int y)  return query(1, 1, n, x, y); 
;

const int N = 1000007;
Graph g;
int val[N];

int dfncnt;
int pos[N], lst[N];
void dfs(int u, int fa) 
    pos[u] = ++dfncnt;
    for (int i = g.h[u];i;i = g.e[i].nxt) 
        int v = g.e[i].v;
        if (v == fa) continue;
        dfs(v, u);
    
    lst[u] = dfncnt;


int main() 
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n, m, k;
    cin >> n >> m >> k;
    g.init(n, n << 1);
    for (int i = 1;i <= n;i++) cin >> val[i];
    for (int i = 1;i <= n - 1;i++) 
        int u, v;
        cin >> u >> v;
        g.add(u, v);
        g.add(v, u);
    
    dfs(k, 0);
    vector<T> src_val(n + 1);
    for (int i = 1;i <= n;i++) src_val[pos[i]] =  val[i] ;
    SegmentTree<T, F> sgt(src_val);
    while (m--) 
        int op, u;
        cin >> op >> u;
        if (op == 1) 
            int x;
            cin >> x;
            sgt.update(pos[u],  x );
        
        else cout << sgt.query(pos[u], lst[u]).sum << \'\\n\';
    
    return 0;

本文来自博客园，作者：空白菌，转载请注明原文链接：https://www.cnblogs.com/BlankYang/p/17495906.html