#line 1 "main.cpp" /** * @title Template */ #include #include #include #include #include #include #include #line 2 "/Users/kodamankod/Desktop/Programming/Library/other/chmin_chmax.cpp" template constexpr bool chmin(T &lhs, const U &rhs) { if (lhs > rhs) { lhs = rhs; return true; } return false; } template constexpr bool chmax(T &lhs, const U &rhs) { if (lhs < rhs) { lhs = rhs; return true; } return false; } /** * @title Chmin/Chmax */ #line 2 "/Users/kodamankod/Desktop/Programming/Library/other/range.cpp" #line 4 "/Users/kodamankod/Desktop/Programming/Library/other/range.cpp" class range { public: class iterator { private: int64_t M_position; public: constexpr iterator(int64_t position) noexcept: M_position(position) { } constexpr void operator ++ () noexcept { ++M_position; } constexpr bool operator != (iterator other) const noexcept { return M_position != other.M_position; } constexpr int64_t operator * () const noexcept { return M_position; } }; class reverse_iterator { private: int64_t M_position; public: constexpr reverse_iterator(int64_t position) noexcept: M_position(position) { } constexpr void operator ++ () noexcept { --M_position; } constexpr bool operator != (reverse_iterator other) const noexcept { return M_position != other.M_position; } constexpr int64_t operator * () const noexcept { return M_position; } }; private: const iterator M_first, M_last; public: constexpr range(int64_t first, int64_t last) noexcept: M_first(first), M_last(std::max(first, last)) { } constexpr iterator begin() const noexcept { return M_first; } constexpr iterator end() const noexcept { return M_last; } constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(*M_last - 1); } constexpr reverse_iterator rend() const noexcept { return reverse_iterator(*M_first - 1); } }; /** * @title Range */ #line 2 "/Users/kodamankod/Desktop/Programming/Library/other/rev.cpp" #include #include #line 6 "/Users/kodamankod/Desktop/Programming/Library/other/rev.cpp" template class rev_impl { public: using iterator = decltype(std::rbegin(std::declval())); private: const iterator M_begin; const iterator M_end; public: constexpr rev_impl(T &&cont) noexcept: M_begin(std::rbegin(cont)), M_end(std::rend(cont)) { } constexpr iterator begin() const noexcept { return M_begin; } constexpr iterator end() const noexcept { return M_end; } }; template constexpr decltype(auto) rev(T &&cont) { return rev_impl(std::forward(cont)); } /** * @title Reverser */ #line 2 "/Users/kodamankod/Desktop/Programming/Library/other/fix_point.cpp" #line 4 "/Users/kodamankod/Desktop/Programming/Library/other/fix_point.cpp" template struct fix_point_impl: private Func { explicit constexpr fix_point_impl(Func &&func): Func(std::forward(func)) { } template constexpr decltype(auto) operator () (Args &&... args) const { return Func::operator()(*this, std::forward(args)...); } }; template constexpr decltype(auto) fix_point(Func &&func) { return fix_point_impl(std::forward(func)); } /** * @title Lambda Recursion */ #line 2 "/Users/kodamankod/Desktop/Programming/Library/other/fast_io.cpp" #include #include #include #line 7 "/Users/kodamankod/Desktop/Programming/Library/other/fast_io.cpp" namespace fast_io { static constexpr size_t buf_size = 1 << 18; static constexpr size_t buf_margin = 1; static constexpr size_t block_size = 10000; static constexpr size_t integer_size = 20; static char inbuf[buf_size + buf_margin] = {}; static char outbuf[buf_size + buf_margin] = {}; static char block_str[block_size * 4 + buf_margin] = {}; static constexpr uint64_t power10[] = { 1, 10, 100, 1000, 10000, 100000, 1000000, 10000000, 100000000, 1000000000, 10000000000, 100000000000, 1000000000000, 10000000000000, 100000000000000, 1000000000000000, 10000000000000000, 100000000000000000, 1000000000000000000, 10000000000000000000u }; class scanner { private: size_t M_in_pos = 0, M_in_end = buf_size; void M_load() { M_in_end = fread(inbuf, 1, buf_size, stdin); inbuf[M_in_end] = '\0'; } void M_reload() { size_t length = M_in_end - M_in_pos; memmove(inbuf, inbuf + M_in_pos, length); M_in_end = length + fread(inbuf + length, 1, buf_size - length, stdin); inbuf[M_in_end] = '\0'; M_in_pos = 0; } void M_ignore_space() { while (inbuf[M_in_pos] <= ' ') { if (__builtin_expect(++M_in_pos == M_in_end, 0)) M_reload(); } } char M_next() { return inbuf[M_in_pos++]; } char M_next_nonspace() { M_ignore_space(); return inbuf[M_in_pos++]; } public: scanner() { M_load(); } void scan(char &c) { c = M_next_nonspace(); } void scan(std::string &s) { M_ignore_space(); s = ""; do { size_t start = M_in_pos; while (inbuf[M_in_pos] > ' ') ++M_in_pos; s += std::string(inbuf + start, inbuf + M_in_pos); if (inbuf[M_in_pos] != '\0') break; M_reload(); } while (true); } template typename std::enable_if::value, void>::type scan(T &x) { char c = M_next_nonspace(); if (__builtin_expect(M_in_pos + integer_size >= M_in_end, 0)) M_reload(); bool n = false; if (c == '-') n = true, x = 0; else x = c & 15; while ((c = M_next()) >= '0') x = x * 10 + (c & 15); if (n) x = -x; } template void scan(T &x, Args&... args) { scan(x); scan(args...); } template scanner& operator >> (T &x) { scan(x); return *this; } }; class printer { private: size_t M_out_pos = 0; void M_flush() { fwrite(outbuf, 1, M_out_pos, stdout); M_out_pos = 0; } void M_precompute() { for (size_t i = 0; i < block_size; ++i) { size_t j = 4, k = i; while (j--) { block_str[i * 4 + j] = k % 10 + '0'; k /= 10; } } } static constexpr size_t S_integer_digits(uint64_t n) { if (n >= power10[10]) { if (n >= power10[19]) return 20; if (n >= power10[18]) return 19; if (n >= power10[17]) return 18; if (n >= power10[16]) return 17; if (n >= power10[15]) return 16; if (n >= power10[14]) return 15; if (n >= power10[13]) return 14; if (n >= power10[12]) return 13; if (n >= power10[11]) return 12; return 11; } else { if (n >= power10[9]) return 10; if (n >= power10[8]) return 9; if (n >= power10[7]) return 8; if (n >= power10[6]) return 7; if (n >= power10[5]) return 6; if (n >= power10[4]) return 5; if (n >= power10[3]) return 4; if (n >= power10[2]) return 3; if (n >= power10[1]) return 2; return 1; } } public: printer() { M_precompute(); } ~printer() { M_flush(); } void print(char c) { outbuf[M_out_pos++] = c; if (__builtin_expect(M_out_pos == buf_size, 0)) M_flush(); } void print(const char *s) { while (*s != 0) { outbuf[M_out_pos++] = *s++; if (M_out_pos == buf_size) M_flush(); } } void print(const std::string &s) { for (auto c: s) { outbuf[M_out_pos++] = c; if (M_out_pos == buf_size) M_flush(); } } template typename std::enable_if::value, void>::type print(T x) { if (__builtin_expect(M_out_pos + integer_size >= buf_size, 0)) M_flush(); if (x < 0) print('-'), x = -x; size_t digit = S_integer_digits(x); size_t len = digit; while (len >= 4) { len -= 4; memcpy(outbuf + M_out_pos + len, block_str + (x % block_size) * 4, 4); x /= 10000; } memcpy(outbuf + M_out_pos, block_str + x * 4 + 4 - len, len); M_out_pos += digit; } template void print(const T &x, const Args&... args) { print(x); print(' '); print(args...); } template void println(const Args&... args) { print(args...); print('\n'); } template printer& operator << (const T &x) { print(x); return *this; } }; }; /** * @title Fast Input/Output */ #line 19 "main.cpp" using i32 = int32_t; using i64 = int64_t; using u32 = uint32_t; using u64 = uint64_t; constexpr i32 inf32 = (i32(1) << 30) - 1; constexpr i64 inf64 = (i64(1) << 62) - 1; constexpr i32 Bucket = 300; struct query_type { i32 vertex, index; query_type(): vertex(0), index(0) { } }; fast_io::scanner cin; fast_io::printer cout; int main() { i32 N, K, Q; cin >> N >> K >> Q; std::vector C(K); for (auto &x: C) { cin >> x; --x; } std::vector> graph(N); for (auto i: range(1, N)) { i32 u, v; cin >> u >> v; --u; --v; graph[u].push_back(v); graph[v].push_back(u); } std::vector> parent(N); std::vector depth(N); fix_point([&](auto dfs, i32 u, i32 p) -> void { if (p == -1) { depth[u] = 0; parent[u][0] = u; } else { depth[u] = depth[p] + 1; parent[u][0] = p; } for (auto v: graph[u]) { if (v != p) { dfs(v, u); } } })(0, -1); for (auto j: range(0, 16)) { for (auto i: range(0, N)) { parent[i][j + 1] = parent[parent[i][j]][j]; } } auto lca = [&](i32 u, i32 v) { if (depth[u] > depth[v]) { std::swap(u, v); } auto dif = depth[v] - depth[u]; for (auto j: range(0, 17)) { if (dif & 1) { v = parent[v][j]; } dif >>= 1; } if (u == v) { return u; } for (auto j: rev(range(0, 17))) { if (parent[u][j] != parent[v][j]) { u = parent[u][j]; v = parent[v][j]; } } return parent[u][0]; }; auto calc = [&](i32 u, i32 v) { return depth[u] + depth[v] - 2 * depth[lca(u, v)]; }; std::vector query(Q); std::vector answer; for (auto &[v, i]: query) { i32 type; cin >> type; if (type == 1) { cin >> i >> v; --i; --v; } else { cin >> v; --v; answer.push_back(0); i = -((i32) answer.size()); } } const i32 Block = (Q + Bucket - 1) / Bucket; for (auto steps: range(0, Block)) { const i32 first = steps * Bucket; const i32 last = std::min((steps + 1) * Bucket, Q); std::vector size(N), dist(N); std::vector stable(K, true); std::vector indices; for (auto i: range(first, last)) { if (query[i].index >= 0) { stable[query[i].index] = false; } } for (auto i: range(0, K)) { if (stable[i]) { ++size[C[i]]; } else { indices.push_back(i); } } fix_point([&](auto dfs, i32 u, i32 p) -> void { for (auto v: graph[u]) { if (v != p) { dfs(v, u); size[u] += size[v]; dist[u] += dist[v] + size[v]; } } })(0, -1); fix_point([&](auto dfs, i32 u, i32 p, i64 s, i64 d) -> void { size[u] += s; dist[u] += s + d; for (auto v: graph[u]) { if (v != p) { dfs(v, u, size[u] - size[v], dist[u] - (size[v] + dist[v])); } } })(0, -1, 0, 0); for (auto i: range(first, last)) { if (query[i].index >= 0) { C[query[i].index] = query[i].vertex; } else { const auto j = -(query[i].index + 1); answer[j] += dist[query[i].vertex]; for (auto k: indices) { answer[j] += calc(query[i].vertex, C[k]); } } } } for (auto x: answer) { cout << x << '\n'; } return 0; }