library

This documentation is automatically generated by online-judge-tools/verification-helper

---

Project maintained by tko919 Hosted on GitHub Pages — Theme by mattgraham

Verify/LC_dynamic_tree_vertex_add_subtree_sum.test.cpp

• View this file on GitHub
• Last update: 2025-06-15 03:24:42+09:00
• Problem: https://judge.yosupo.jp/problem/dynamic_tree_vertex_add_subtree_sum

Depends on

• Link-Cut Tree (Graph/linkcut.hpp)
• Template/template.hpp
• Fast IO (Utility/fastio.hpp)

Code

#define PROBLEM                                                                \
    "https://judge.yosupo.jp/problem/dynamic_tree_vertex_add_subtree_sum"

#include "Template/template.hpp"
#include "Utility/fastio.hpp"

#include "Graph/linkcut.hpp"

using Key = ll;
struct Monoid {
    ll sum, psum, csum, light;
    Monoid() : sum(0), psum(0), csum(0), light(0) {}
    void inverse() {
        swap(psum, csum);
    }
    void merge(Key val, Monoid p, Monoid c) {
        sum = p.sum + c.sum + val + light;
        psum = p.psum + val + light;
        csum = c.csum + val + light;
    }
    void add(Monoid v) {
        light += v.sum;
    }
    void sub(Monoid v) {
        light -= v.sum;
    }
};
ll f(ll x, ll y) {
    return x + y;
}
using V = LCT<Monoid, Key, f>::Node *;

int main() {
    int n, q;
    read(n, q);
    LCT<Monoid, Key, f> tree;
    vector<V> vs(n);
    rep(i, 0, n) {
        ll x;
        read(x);
        vs[i] = tree.make(i, x);
    }
    rep(i, 0, n - 1) {
        int x, y;
        read(x, y);
        tree.link(vs[x], vs[y]);
    }
    while (q--) {
        int t;
        read(t);
        if (t == 0) {
            int x, y;
            read(x, y);
            tree.cut(vs[x], vs[y]);
            read(x, y);
            tree.link(vs[x], vs[y]);
        }
        if (t == 1) {
            int v, x;
            read(v, x);
            tree.update(vs[v], x);
        }
        if (t == 2) {
            int v, p;
            read(v, p);
            auto ret = tree.query(vs[p], vs[v]);
            print(ret.csum);
        }
    }
    return 0;
}

#line 1 "Verify/LC_dynamic_tree_vertex_add_subtree_sum.test.cpp"
#define PROBLEM                                                                \
    "https://judge.yosupo.jp/problem/dynamic_tree_vertex_add_subtree_sum"

#line 1 "Template/template.hpp"
#include <bits/stdc++.h>

using namespace std;

#define rep(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rrep(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) sort(ALL(v)), (v).erase(unique(ALL(v)), (v).end())
#define SZ(v) (int)v.size()
#define MIN(v) *min_element(ALL(v))
#define MAX(v) *max_element(ALL(v))
#define LB(v, x) int(lower_bound(ALL(v), (x)) - (v).begin())
#define UB(v, x) int(upper_bound(ALL(v), (x)) - (v).begin())

using uint = unsigned int;
using ll = long long int;
using ull = unsigned long long;
using i128 = __int128_t;
using u128 = __uint128_t;
const int inf = 0x3fffffff;
const ll INF = 0x1fffffffffffffff;

template <typename T, typename S = T> S SUM(const vector<T> &a) {
    return accumulate(ALL(a), S(0));
}
template <typename S, typename T = S> S POW(S a, T b) {
    S ret = 1, base = a;
    for (;;) {
        if (b & 1)
            ret *= base;
        b >>= 1;
        if (b == 0)
            break;
        base *= base;
    }
    return ret;
}
template <typename T> inline bool chmax(T &a, T b) {
    if (a < b) {
        a = b;
        return 1;
    }
    return 0;
}
template <typename T> inline bool chmin(T &a, T b) {
    if (a > b) {
        a = b;
        return 1;
    }
    return 0;
}
template <typename T, typename U> T ceil(T x, U y) {
    assert(y != 0);
    if (y < 0)
        x = -x, y = -y;
    return (x > 0 ? (x + y - 1) / y : x / y);
}
template <typename T, typename U> T floor(T x, U y) {
    assert(y != 0);
    if (y < 0)
        x = -x, y = -y;
    return (x > 0 ? x / y : (x - y + 1) / y);
}
template <typename T> int popcnt(T x) {
    return __builtin_popcountll(x);
}
template <typename T> int topbit(T x) {
    return (x == 0 ? -1 : 63 - __builtin_clzll(x));
}
template <typename T> int lowbit(T x) {
    return (x == 0 ? -1 : __builtin_ctzll(x));
}

template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
    os << "P(" << p.first << ", " << p.second << ")";
    return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
    os << "{";
    for (int i = 0; i < vec.size(); i++) {
        os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
    }
    os << "}";
    return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &map_var) {
    os << "{";
    for (auto itr = map_var.begin(); itr != map_var.end(); itr++) {
        os << "(" << itr->first << ", " << itr->second << ")";
        itr++;
        if (itr != map_var.end())
            os << ", ";
        itr--;
    }
    os << "}";
    return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) {
    os << "{";
    for (auto itr = set_var.begin(); itr != set_var.end(); itr++) {
        os << *itr;
        ++itr;
        if (itr != set_var.end())
            os << ", ";
        itr--;
    }
    os << "}";
    return os;
}
#ifdef LOCAL
#define debug 1
#define show(...) _show(0, #__VA_ARGS__, __VA_ARGS__)
#else
#define debug 0
#define show(...) true
#endif
template <typename T> void _show(int i, T name) {
    cerr << '\n';
}
template <typename T1, typename T2, typename... T3>
void _show(int i, const T1 &a, const T2 &b, const T3 &...c) {
    for (; a[i] != ',' && a[i] != '\0'; i++)
        cerr << a[i];
    cerr << ":" << b << " ";
    _show(i + 1, a, c...);
}
#line 2 "Utility/fastio.hpp"
#include <unistd.h>

namespace fastio {
static constexpr uint32_t SZ = 1 << 17;
char ibuf[SZ];
char obuf[SZ];
char out[100];
// pointer of ibuf, obuf


uint32_t pil = 0, pir = 0, por = 0;

struct Pre {
    char num[10000][4];
    constexpr Pre() : num() {
        for (int i = 0; i < 10000; i++) {
            int n = i;
            for (int j = 3; j >= 0; j--) {
                num[i][j] = n % 10 | '0';
                n /= 10;
            }
        }
    }
} constexpr pre;

inline void load() {
    memmove(ibuf, ibuf + pil, pir - pil);
    pir = pir - pil + fread(ibuf + pir - pil, 1, SZ - pir + pil, stdin);
    pil = 0;
    if (pir < SZ)
        ibuf[pir++] = '\n';
}

inline void flush() {
    fwrite(obuf, 1, por, stdout);
    por = 0;
}

void rd(char &c) {
    do {
        if (pil + 1 > pir)
            load();
        c = ibuf[pil++];
    } while (isspace(c));
}

void rd(string &x) {
    x.clear();
    char c;
    do {
        if (pil + 1 > pir)
            load();
        c = ibuf[pil++];
    } while (isspace(c));
    do {
        x += c;
        if (pil == pir)
            load();
        c = ibuf[pil++];
    } while (!isspace(c));
}

template <typename T> void rd_real(T &x) {
    string s;
    rd(s);
    x = stod(s);
}

template <typename T> void rd_integer(T &x) {
    if (pil + 100 > pir)
        load();
    char c;
    do
        c = ibuf[pil++];
    while (c < '-');
    bool minus = 0;
    if constexpr (is_signed<T>::value || is_same_v<T, i128>) {
        if (c == '-') {
            minus = 1, c = ibuf[pil++];
        }
    }
    x = 0;
    while ('0' <= c) {
        x = x * 10 + (c & 15), c = ibuf[pil++];
    }
    if constexpr (is_signed<T>::value || is_same_v<T, i128>) {
        if (minus)
            x = -x;
    }
}

void rd(int &x) {
    rd_integer(x);
}
void rd(ll &x) {
    rd_integer(x);
}
void rd(i128 &x) {
    rd_integer(x);
}
void rd(uint &x) {
    rd_integer(x);
}
void rd(ull &x) {
    rd_integer(x);
}
void rd(u128 &x) {
    rd_integer(x);
}
void rd(double &x) {
    rd_real(x);
}
void rd(long double &x) {
    rd_real(x);
}

template <class T, class U> void rd(pair<T, U> &p) {
    return rd(p.first), rd(p.second);
}
template <size_t N = 0, typename T> void rd_tuple(T &t) {
    if constexpr (N < std::tuple_size<T>::value) {
        auto &x = std::get<N>(t);
        rd(x);
        rd_tuple<N + 1>(t);
    }
}
template <class... T> void rd(tuple<T...> &tpl) {
    rd_tuple(tpl);
}

template <size_t N = 0, typename T> void rd(array<T, N> &x) {
    for (auto &d : x)
        rd(d);
}
template <class T> void rd(vector<T> &x) {
    for (auto &d : x)
        rd(d);
}

void read() {}
template <class H, class... T> void read(H &h, T &...t) {
    rd(h), read(t...);
}

void wt(const char c) {
    if (por == SZ)
        flush();
    obuf[por++] = c;
}
void wt(const string s) {
    for (char c : s)
        wt(c);
}
void wt(const char *s) {
    size_t len = strlen(s);
    for (size_t i = 0; i < len; i++)
        wt(s[i]);
}

template <typename T> void wt_integer(T x) {
    if (por > SZ - 100)
        flush();
    if (x < 0) {
        obuf[por++] = '-', x = -x;
    }
    int outi;
    for (outi = 96; x >= 10000; outi -= 4) {
        memcpy(out + outi, pre.num[x % 10000], 4);
        x /= 10000;
    }
    if (x >= 1000) {
        memcpy(obuf + por, pre.num[x], 4);
        por += 4;
    } else if (x >= 100) {
        memcpy(obuf + por, pre.num[x] + 1, 3);
        por += 3;
    } else if (x >= 10) {
        int q = (x * 103) >> 10;
        obuf[por] = q | '0';
        obuf[por + 1] = (x - q * 10) | '0';
        por += 2;
    } else
        obuf[por++] = x | '0';
    memcpy(obuf + por, out + outi + 4, 96 - outi);
    por += 96 - outi;
}

template <typename T> void wt_real(T x) {
    ostringstream oss;
    oss << fixed << setprecision(15) << double(x);
    string s = oss.str();
    wt(s);
}

void wt(int x) {
    wt_integer(x);
}
void wt(ll x) {
    wt_integer(x);
}
void wt(i128 x) {
    wt_integer(x);
}
void wt(uint x) {
    wt_integer(x);
}
void wt(ull x) {
    wt_integer(x);
}
void wt(u128 x) {
    wt_integer(x);
}
void wt(double x) {
    wt_real(x);
}
void wt(long double x) {
    wt_real(x);
}

template <class T, class U> void wt(const pair<T, U> val) {
    wt(val.first);
    wt(' ');
    wt(val.second);
}
template <size_t N = 0, typename T> void wt_tuple(const T t) {
    if constexpr (N < std::tuple_size<T>::value) {
        if constexpr (N > 0) {
            wt(' ');
        }
        const auto x = std::get<N>(t);
        wt(x);
        wt_tuple<N + 1>(t);
    }
}
template <class... T> void wt(tuple<T...> tpl) {
    wt_tuple(tpl);
}
template <class T, size_t S> void wt(const array<T, S> val) {
    auto n = val.size();
    for (size_t i = 0; i < n; i++) {
        if (i)
            wt(' ');
        wt(val[i]);
    }
}
template <class T> void wt(const vector<T> val) {
    auto n = val.size();
    for (size_t i = 0; i < n; i++) {
        if (i)
            wt(' ');
        wt(val[i]);
    }
}

void print() {
    wt('\n');
}
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
    wt(head);
    if (sizeof...(Tail))
        wt(' ');
    print(forward<Tail>(tail)...);
}
void __attribute__((destructor)) _d() {
    flush();
}
} // namespace fastio


using fastio::flush;
using fastio::print;
using fastio::read;

inline void first(bool i = true) {
    print(i ? "first" : "second");
}
inline void Alice(bool i = true) {
    print(i ? "Alice" : "Bob");
}
inline void Takahashi(bool i = true) {
    print(i ? "Takahashi" : "Aoki");
}
inline void yes(bool i = true) {
    print(i ? "yes" : "no");
}
inline void Yes(bool i = true) {
    print(i ? "Yes" : "No");
}
inline void No() {
    print("No");
}
inline void YES(bool i = true) {
    print(i ? "YES" : "NO");
}
inline void NO() {
    print("NO");
}
inline void Yay(bool i = true) {
    print(i ? "Yay!" : ":(");
}
inline void Possible(bool i = true) {
    print(i ? "Possible" : "Impossible");
}
inline void POSSIBLE(bool i = true) {
    print(i ? "POSSIBLE" : "IMPOSSIBLE");
}

/**
 * @brief Fast IO
 */
#line 6 "Verify/LC_dynamic_tree_vertex_add_subtree_sum.test.cpp"

#line 2 "Graph/linkcut.hpp"

template <typename M, typename N, N (*f)(N, N)> struct LCT {
    struct Node {
        Node *lp = nullptr, *rp = nullptr, *par = nullptr;
        N val;
        M sum;
        int idx, sz = 1;
        bool rev = 0;
        Node() {}
        Node(int idx, N val) : idx(idx), val(val) {}
        void inverse() {
            swap(lp, rp);
            sum.inverse();
            rev ^= 1;
        }
        void eval() {
            if (rev) {
                if (lp)
                    lp->inverse();
                if (rp)
                    rp->inverse();
                rev = 0;
            }
        }
        void update() {
            sz = 1;
            if (lp)
                sz += lp->sz;
            if (rp)
                sz += rp->sz;
            sum.merge(val, lp ? lp->sum : M(), rp ? rp->sum : M());
        }
        bool is_root() {
            return !par || (par->lp != this && par->rp != this);
        }
        void rotate() {
            Node *pp, *p, *c;
            p = par, pp = p->par;
            if (p->lp == this) {
                c = rp;
                rp = p;
                p->lp = c;
            } else {
                c = lp;
                lp = p;
                p->rp = c;
            }
            if (pp) {
                if (pp->lp == p)
                    pp->lp = this;
                if (pp->rp == p)
                    pp->rp = this;
            }
            par = pp;
            p->par = this;
            if (c)
                c->par = p;
            p->update();
            update();
        }
        void splay() {
            eval();
            while (!is_root()) {
                Node *q = par;
                if (q->is_root()) {
                    q->eval();
                    eval();
                    if (q->lp == this)
                        rotate();
                    else
                        rotate();
                } else {
                    Node *r = q->par;
                    r->eval();
                    q->eval();
                    eval();
                    if (r->lp == q) {
                        if (q->lp == this) {
                            q->rotate();
                            rotate();
                        } else {
                            rotate();
                            rotate();
                        }
                    } else {
                        if (q->rp == this) {
                            q->rotate();
                            rotate();
                        } else {
                            rotate();
                            rotate();
                        }
                    }
                }
            }
        }
    };
    std::vector<Node *> all_nodes;
    LCT() {}
    ~LCT() {
        // デストラクタで全 Node を delete
        for (Node *p : all_nodes) {
            delete p;
        }
        all_nodes.clear();
    }
    Node *make(int idx, N val) {
        Node *p = new Node(idx, val);
        all_nodes.push_back(p);
        return p;
    }
    Node *expose(Node *v) {
        Node *pre = nullptr;
        for (Node *cur = v; cur; cur = cur->par) {
            cur->splay();
            if (cur->rp)
                cur->sum.add(cur->rp->sum);
            cur->rp = pre;
            if (cur->rp)
                cur->sum.sub(cur->rp->sum);
            cur->update();
            pre = cur;
        }
        v->splay();
        return pre;
    }
    void link(Node *c, Node *p) {
        evert(c);
        expose(p);
        c->par = p;
        p->rp = c;
        p->update();
    }
    void cut(Node *c, Node *p) {
        evert(p);
        expose(c);
        c->lp->par = nullptr;
        c->lp = nullptr;
        c->update();
    }
    void evert(Node *v) {
        expose(v);
        v->inverse();
        v->eval();
    }
    Node *lca(Node *u, Node *v) {
        expose(u);
        return expose(v);
    }
    Node *root(Node *v) {
        expose(v);
        while (v->lp)
            v->eval(), v = v->lp;
        return v;
    }
    bool same(Node *u, Node *v) {
        return root(u) == root(v);
    }
    void update(Node *v, N x) {
        expose(v);
        v->val = f(v->val, x);
        v->update();
    }
    M &query(Node *u, Node *v) { // root = u -> v
        evert(u);
        expose(v);
        return v->sum;
    }
};

/**
 * @brief Link-Cut Tree
 */
#line 8 "Verify/LC_dynamic_tree_vertex_add_subtree_sum.test.cpp"

using Key = ll;
struct Monoid {
    ll sum, psum, csum, light;
    Monoid() : sum(0), psum(0), csum(0), light(0) {}
    void inverse() {
        swap(psum, csum);
    }
    void merge(Key val, Monoid p, Monoid c) {
        sum = p.sum + c.sum + val + light;
        psum = p.psum + val + light;
        csum = c.csum + val + light;
    }
    void add(Monoid v) {
        light += v.sum;
    }
    void sub(Monoid v) {
        light -= v.sum;
    }
};
ll f(ll x, ll y) {
    return x + y;
}
using V = LCT<Monoid, Key, f>::Node *;

int main() {
    int n, q;
    read(n, q);
    LCT<Monoid, Key, f> tree;
    vector<V> vs(n);
    rep(i, 0, n) {
        ll x;
        read(x);
        vs[i] = tree.make(i, x);
    }
    rep(i, 0, n - 1) {
        int x, y;
        read(x, y);
        tree.link(vs[x], vs[y]);
    }
    while (q--) {
        int t;
        read(t);
        if (t == 0) {
            int x, y;
            read(x, y);
            tree.cut(vs[x], vs[y]);
            read(x, y);
            tree.link(vs[x], vs[y]);
        }
        if (t == 1) {
            int v, x;
            read(v, x);
            tree.update(vs[v], x);
        }
        if (t == 2) {
            int v, p;
            read(v, p);
            auto ret = tree.query(vs[p], vs[v]);
            print(ret.csum);
        }
    }
    return 0;
}

Back to top page