結果

問題 No.2676 A Tourist
ユーザー 👑 nu50218nu50218
提出日時 2024-02-13 20:00:19
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
TLE  
(最新)
AC  
(最初)
実行時間 -
コード長 7,016 bytes
コンパイル時間 2,955 ms
コンパイル使用メモリ 227,740 KB
実行使用メモリ 256,708 KB
最終ジャッジ日時 2024-03-13 21:30:30
合計ジャッジ時間 32,563 ms
ジャッジサーバーID
（参考情報） 		judge12 / judge14
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
6,548 KB
testcase_01 AC 330 ms
76,304 KB
testcase_02 AC 1,190 ms
231,348 KB
testcase_03 AC 1,168 ms
231,348 KB
testcase_04 AC 1,173 ms
231,348 KB
testcase_05 AC 1,187 ms
231,348 KB
testcase_06 AC 315 ms
76,916 KB
testcase_07 AC 1,166 ms
233,360 KB
testcase_08 AC 438 ms
233,356 KB
testcase_09 AC 907 ms
233,360 KB
testcase_10 AC 497 ms
233,360 KB
testcase_11 AC 551 ms
216,296 KB
testcase_12 AC 269 ms
82,632 KB
testcase_13 AC 737 ms
250,208 KB
testcase_14 AC 672 ms
250,208 KB
testcase_15 AC 705 ms
250,096 KB
testcase_16 AC 354 ms
76,924 KB
testcase_17 AC 1,196 ms
233,108 KB
testcase_18 AC 1,130 ms
233,116 KB
testcase_19 AC 1,191 ms
233,132 KB
testcase_20 AC 1,137 ms
231,424 KB
testcase_21 AC 33 ms
6,676 KB
testcase_22 AC 33 ms
6,676 KB
testcase_23 AC 16 ms
6,676 KB
testcase_24 AC 31 ms
6,676 KB
testcase_25 AC 9 ms
6,676 KB
testcase_26 AC 2 ms
6,676 KB
testcase_27 AC 222 ms
76,316 KB
testcase_28 AC 705 ms
233,260 KB
testcase_29 AC 439 ms
233,260 KB
testcase_30 AC 668 ms
233,260 KB
testcase_31 AC 609 ms
233,260 KB
testcase_32 TLE -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>

#include <atcoder/fenwicktree.hpp>
using namespace std;

// 解説の計算を、次数で平方分割する

template <class S, S (*op)(S, S)>
struct sparse_table {
   public:
    sparse_table() {}

    sparse_table(const std::vector<S>& v) : _n(int(v.size())) {
        int max_log = 0;

        log_table.resize(_n + 1);
        log_table[1] = 0;
        for (int i = 2; i < _n + 1; i++) {
            log_table[i] = log_table[i >> 1] + 1;
            max_log = log_table[i];
        }

        table.resize(max_log + 1);
        for (int i = 0; i <= max_log; i++) {
            table[i].resize(_n);
        }
        for (int j = 0; j < _n; j++) {
            table[0][j] = v[j];
        }

        for (int i = 1; i <= max_log; i++) {
            for (int j = 0; j < _n; j++) {
                if (j + (1 << (i - 1)) >= _n)
                    continue;
                table[i][j] = op(table[i - 1][j], table[i - 1][j + (1 << (i - 1))]);
            }
        }
    }

    S query(int l, int r) {
        assert(0 <= l && l < _n);
        assert(0 < r && r <= _n);
        assert(l < r);

        int i = log_table[r - l];
        return op(table[i][l], table[i][r - (1 << i)]);
    }

   private:
    int _n;
    std::vector<int> log_table;
    std::vector<std::vector<S>> table;
};

// returns a list of (vertex, depth) pairs
inline std::vector<std::pair<int, int>> euler_tour(const int n, const std::vector<std::pair<int, int>>& edges, const int root = 0) {
    std::vector<int> adj[n];
    for (auto&& [u, v] : edges) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    std::vector<std::pair<int, int>> ret;

    std::function<void(int, int, int)> dfs = [&](int v, int p = -1, int d = 0) -> void {
        for (auto&& u : adj[v]) {
            if (u != p) {
                ret.push_back({v, d});
                dfs(u, v, d + 1);
            }
        }
        ret.push_back({v, d});
    };

    dfs(root, -1, 0);

    return ret;
}

namespace nu50218 {
inline std::pair<int, int> lca_st_op(std::pair<int, int> x, std::pair<int, int> y) {
    return min(x, y);
}
};  // namespace nu50218

struct LCA {
    int lca(int u, int v) {
        if (idx[u] > idx[v]) std::swap(u, v);
        return st.query(idx[u], idx[v] + 1).second;
    }

    int depth(int v) {
        return dep[v];
    }

    int dist(int u, int v) {
        return dep[u] + dep[v] - 2 * dep[lca(u, v)];
    }

    LCA(const int n, const std::vector<std::pair<int, int>>& edges, const int root = 0) {
        dep.resize(n);
        idx.resize(n);

        auto tour = euler_tour(n, edges, root);

        std::vector<std::pair<int, int>> a(tour.size());

        for (int i = 0; i < (int)tour.size(); i++) {
            auto [v, d] = tour[i];
            dep[v] = d;
            idx[v] = i;
            a[i] = {d, v};
        }

        st = sparse_table<std::pair<int, int>, nu50218::lca_st_op>(a);
    }

   private:
    std::vector<int> dep;
    std::vector<int> idx;
    inline std::pair<int, int> op(std::pair<int, int> x, std::pair<int, int> y) {
        return min(x, y);
    }
    sparse_table<std::pair<int, int>, nu50218::lca_st_op> st;
};

template <typename T = long long>
struct vertex_add_path_sum {
    vertex_add_path_sum(const int n, const std::vector<std::pair<int, int>>& edges) : n(n), index(n), fwt(2 * n + 1), lca(n, edges, 0) {
        std::vector<std::vector<int>> adj(n);
        for (auto&& [u, v] : edges) {
            adj[u].push_back(v);
            adj[v].push_back(u);
        }

        int i = 1;

        std::function<void(int, int)> dfs = [&](int v, int p = -1) -> void {
            index[v].first = i++;
            for (auto&& u : adj[v]) {
                if (u != p) {
                    dfs(u, v);
                }
            }
            index[v].second = i++;
        };

        dfs(0, -1);
    }

    void add(int p, T x) {
        fwt.add(index[p].first, x);
        fwt.add(index[p].second, -x);
    }

    T sum(int u, int v) {
        auto sub = index[lca.lca(u, v)].first;
        return fwt.sum(0, index[u].first + 1) + fwt.sum(0, index[v].first + 1) - fwt.sum(0, sub) - fwt.sum(0, sub + 1);
    }

   private:
    int n;
    std::vector<std::pair<int, int>> index;
    atcoder::fenwick_tree<T> fwt;
    LCA lca;
};

using ll = long long;

// sqrt(200000)
const int border = 447;

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int N, Q;
    cin >> N >> Q;

    vector<ll> a(N);
    for (auto&& x : a) {
        cin >> x;
    }

    vector<pair<int, int>> edges;
    for (int i = 0; i < N - 1; i++) {
        int u, v;
        cin >> u >> v;
        u--;
        v--;
        edges.emplace_back(u, v);
    }

    vector<vector<int>> adj(N);
    for (auto&& [u, v] : edges) {
        adj[u].push_back(v);
        adj[v].push_back(u);
    }

    vector<int> heavy_vertices;
    for (int i = 0; i < N; i++) {
        if ((int)adj[i].size() > border) {
            heavy_vertices.push_back(i);
        }
    }

    LCA lca(N, edges);

    // a の path sum を計算する
    vertex_add_path_sum a_sum(N, edges);
    for (int i = 0; i < N; i++) {
        a_sum.add(i, a[i]);
    }

    // 各頂点の重み := 隣接する「次数が border 以下」頂点の a の合計
    // に対して path sum を計算する
    vertex_add_path_sum low_deg_neighbor_sum(N, edges);
    for (int i = 0; i < N; i++) {
        if ((int)adj[i].size() <= border) {
            for (auto&& v : adj[i]) {
                low_deg_neighbor_sum.add(v, a[i]);
            }
        }
    }

    for (int q = 0; q < Q; q++) {
        int t;
        cin >> t;

        if (t == 0) {
            int u;
            ll x;
            cin >> u >> x;
            u--;

            a[u] += x;
            a_sum.add(u, x);

            // 次数が小さい頂点は愚直に反映する
            if ((int)adj[u].size() <= border) {
                for (auto&& v : adj[u]) {
                    low_deg_neighbor_sum.add(v, x);
                }
            }

            continue;
        }

        if (t == 1) {
            int u, v;
            cin >> u >> v;
            u--;
            v--;

            ll ans = low_deg_neighbor_sum.sum(u, v);
            ans -= a_sum.sum(u, v);
            ans += a[u] + a[v];

            // 次数が大きい頂点が u-v パスの近くにあったら調整する
            for (auto&& h : heavy_vertices) {
                int dist_uv = lca.dist(u, v);
                int dist_uh = lca.dist(u, h);
                int dist_hv = lca.dist(h, v);

                // h がパスの頂点に隣接している
                if (dist_uv + 2 >= dist_uh + dist_hv) {
                    ans += a[h];
                }
                // h がパスの2頂点に隣接している
                if (dist_uv == dist_uh + dist_hv && h != u && h != v) {
                    ans += a[h];
                }
            }

            cout << ans << "\n";
            continue;
        }
    }
}
0