This documentation is automatically generated by online-judge-tools/verification-helper
#define PROBLEM "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2995"
#include "../../data_structure/undo_unionfind.hpp"
#include "../../template/template.hpp"
#include "../../tree/dsu_on_tree.hpp"
#include "../../tree/heavy_light_decomposition.hpp"
namespace ebi {
void main_() {
int n, k;
std::cin >> n >> k;
Graph<int> g(n);
g.read_tree();
std::vector<std::pair<int, int>> cs(n);
for (auto &[c, d] : cs) {
std::cin >> c >> d;
c--;
d--;
}
std::vector<bool> is_tree(k, true);
undo_unionfind uf(k);
std::vector<int> ans(n);
int res = 0;
auto val = [&](int v) -> int {
v = uf.leader(v);
return is_tree[v] ? uf.size(v) - 1 : uf.size(v);
};
auto add = [&](int v) -> void {
auto [c, d] = cs[v];
c = uf.leader(c);
d = uf.leader(d);
if (c != d) {
res -= val(c) + val(d);
}
if (uf.merge(c, d)) {
is_tree[uf.leader(c)] = is_tree[c] && is_tree[d];
res += val(uf.leader(c));
} else if (is_tree[c]) {
res++;
is_tree[c] = false;
}
};
auto query = [&](int v) -> void { ans[v] = res; };
auto clear = [&](int v) -> void {
auto [c, d] = cs[v];
is_tree[c] = is_tree[d] = true;
uf.undo();
};
auto reset = [&]() -> void { res = 0; };
heavy_light_decomposition hld(g);
hld.dsu_on_tree(add, query, clear, reset);
for (auto x : ans) {
std::cout << x << '\n';
}
}
} // namespace ebi
int main() {
ebi::fast_io();
int t = 1;
// std::cin >> t;
while (t--) {
ebi::main_();
}
return 0;
}
#line 1 "test/aoj/aoj_2995.test.cpp"
#define PROBLEM "https://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2995"
#line 2 "data_structure/undo_unionfind.hpp"
#include <cassert>
#include <stack>
#include <vector>
namespace ebi {
struct undo_unionfind {
private:
std::stack<std::pair<int, int> > stack;
public:
std::vector<int> par;
undo_unionfind(int n = 0) : par(n, -1) {}
bool same(int x, int y) const {
return leader(x) == leader(y);
}
bool merge(int x, int y) {
x = leader(x);
y = leader(y);
stack.push({x, par[x]});
stack.push({y, par[y]});
if (x == y) return false;
if (par[x] > par[y]) std::swap(x, y);
par[x] += par[y];
par[y] = x;
return true;
}
int leader(int x) const {
if (par[x] < 0)
return x;
else
return leader(par[x]);
}
int size(int x) const {
return -par[leader(x)];
}
int count_group() const {
int c = 0;
for (int i = 0; i < int(par.size()); i++) {
if (par[i] < 0) c++;
}
return c;
}
void undo() {
assert(!stack.empty());
par[stack.top().first] = stack.top().second;
stack.pop();
par[stack.top().first] = stack.top().second;
stack.pop();
return;
}
};
} // namespace ebi
#line 1 "template/template.hpp"
#include <bits/stdc++.h>
#define rep(i, a, n) for (int i = (int)(a); i < (int)(n); i++)
#define rrep(i, a, n) for (int i = ((int)(n)-1); i >= (int)(a); i--)
#define Rep(i, a, n) for (i64 i = (i64)(a); i < (i64)(n); i++)
#define RRep(i, a, n) for (i64 i = ((i64)(n)-i64(1)); i >= (i64)(a); i--)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#line 2 "template/debug_template.hpp"
#line 4 "template/debug_template.hpp"
namespace ebi {
#ifdef LOCAL
#define debug(...) \
std::cerr << "LINE: " << __LINE__ << " [" << #__VA_ARGS__ << "]:", \
debug_out(__VA_ARGS__)
#else
#define debug(...)
#endif
void debug_out() {
std::cerr << std::endl;
}
template <typename Head, typename... Tail> void debug_out(Head h, Tail... t) {
std::cerr << " " << h;
if (sizeof...(t) > 0) std::cerr << " :";
debug_out(t...);
}
} // namespace ebi
#line 2 "template/int_alias.hpp"
#line 4 "template/int_alias.hpp"
namespace ebi {
using ld = long double;
using std::size_t;
using i8 = std::int8_t;
using u8 = std::uint8_t;
using i16 = std::int16_t;
using u16 = std::uint16_t;
using i32 = std::int32_t;
using u32 = std::uint32_t;
using i64 = std::int64_t;
using u64 = std::uint64_t;
using i128 = __int128_t;
using u128 = __uint128_t;
} // namespace ebi
#line 2 "template/io.hpp"
#line 5 "template/io.hpp"
#include <optional>
#line 7 "template/io.hpp"
namespace ebi {
template <typename T1, typename T2>
std::ostream &operator<<(std::ostream &os, const std::pair<T1, T2> &pa) {
return os << pa.first << " " << pa.second;
}
template <typename T1, typename T2>
std::istream &operator>>(std::istream &os, std::pair<T1, T2> &pa) {
return os >> pa.first >> pa.second;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const std::vector<T> &vec) {
for (std::size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i + 1 == vec.size() ? "" : " ");
return os;
}
template <typename T>
std::istream &operator>>(std::istream &os, std::vector<T> &vec) {
for (T &e : vec) std::cin >> e;
return os;
}
template <typename T>
std::ostream &operator<<(std::ostream &os, const std::optional<T> &opt) {
if (opt) {
os << opt.value();
} else {
os << "invalid value";
}
return os;
}
void fast_io() {
std::cout << std::fixed << std::setprecision(15);
std::cin.tie(nullptr);
std::ios::sync_with_stdio(false);
}
} // namespace ebi
#line 2 "template/utility.hpp"
#line 5 "template/utility.hpp"
#line 2 "graph/base.hpp"
#line 5 "graph/base.hpp"
#include <ranges>
#line 7 "graph/base.hpp"
#line 2 "data_structure/simple_csr.hpp"
#line 6 "data_structure/simple_csr.hpp"
namespace ebi {
template <class E> struct simple_csr {
simple_csr() = default;
simple_csr(int n, const std::vector<std::pair<int, E>>& elements)
: start(n + 1, 0), elist(elements.size()) {
for (auto e : elements) {
start[e.first + 1]++;
}
for (auto i : std::views::iota(0, n)) {
start[i + 1] += start[i];
}
auto counter = start;
for (auto [i, e] : elements) {
elist[counter[i]++] = e;
}
}
simple_csr(const std::vector<std::vector<E>>& es)
: start(es.size() + 1, 0) {
int n = es.size();
for (auto i : std::views::iota(0, n)) {
start[i + 1] = (int)es[i].size() + start[i];
}
elist.resize(start.back());
for (auto i : std::views::iota(0, n)) {
std::copy(es[i].begin(), es[i].end(), elist.begin() + start[i]);
}
}
int size() const {
return (int)start.size() - 1;
}
const auto operator[](int i) const {
return std::ranges::subrange(elist.begin() + start[i],
elist.begin() + start[i + 1]);
}
auto operator[](int i) {
return std::ranges::subrange(elist.begin() + start[i],
elist.begin() + start[i + 1]);
}
const auto operator()(int i, int l, int r) const {
return std::ranges::subrange(elist.begin() + start[i] + l,
elist.begin() + start[i + 1] + r);
}
auto operator()(int i, int l, int r) {
return std::ranges::subrange(elist.begin() + start[i] + l,
elist.begin() + start[i + 1] + r);
}
private:
std::vector<int> start;
std::vector<E> elist;
};
} // namespace ebi
#line 9 "graph/base.hpp"
namespace ebi {
template <class T> struct Edge {
int from, to;
T cost;
int id;
};
template <class E> struct Graph {
using cost_type = E;
using edge_type = Edge<cost_type>;
Graph(int n_) : n(n_) {}
Graph() = default;
void add_edge(int u, int v, cost_type c) {
buff.emplace_back(u, edge_type{u, v, c, m});
edges.emplace_back(edge_type{u, v, c, m++});
}
void add_undirected_edge(int u, int v, cost_type c) {
buff.emplace_back(u, edge_type{u, v, c, m});
buff.emplace_back(v, edge_type{v, u, c, m});
edges.emplace_back(edge_type{u, v, c, m});
m++;
}
void read_tree(int offset = 1, bool is_weighted = false) {
read_graph(n - 1, offset, false, is_weighted);
}
void read_parents(int offset = 1) {
for (auto i : std::views::iota(1, n)) {
int p;
std::cin >> p;
p -= offset;
add_undirected_edge(p, i, 1);
}
build();
}
void read_graph(int e, int offset = 1, bool is_directed = false,
bool is_weighted = false) {
for (int i = 0; i < e; i++) {
int u, v;
std::cin >> u >> v;
u -= offset;
v -= offset;
if (is_weighted) {
cost_type c;
std::cin >> c;
if (is_directed) {
add_edge(u, v, c);
} else {
add_undirected_edge(u, v, c);
}
} else {
if (is_directed) {
add_edge(u, v, 1);
} else {
add_undirected_edge(u, v, 1);
}
}
}
build();
}
void build() {
assert(!prepared);
csr = simple_csr<edge_type>(n, buff);
buff.clear();
prepared = true;
}
int size() const {
return n;
}
int node_number() const {
return n;
}
int edge_number() const {
return m;
}
edge_type get_edge(int i) const {
return edges[i];
}
std::vector<edge_type> get_edges() const {
return edges;
}
const auto operator[](int i) const {
return csr[i];
}
auto operator[](int i) {
return csr[i];
}
private:
int n, m = 0;
std::vector<std::pair<int,edge_type>> buff;
std::vector<edge_type> edges;
simple_csr<edge_type> csr;
bool prepared = false;
};
} // namespace ebi
#line 8 "template/utility.hpp"
namespace ebi {
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> T safe_ceil(T a, T b) {
if (a % b == 0)
return a / b;
else if (a >= 0)
return (a / b) + 1;
else
return -((-a) / b);
}
template <class T> T safe_floor(T a, T b) {
if (a % b == 0)
return a / b;
else if (a >= 0)
return a / b;
else
return -((-a) / b) - 1;
}
constexpr i64 LNF = std::numeric_limits<i64>::max() / 4;
constexpr int INF = std::numeric_limits<int>::max() / 2;
const std::vector<int> dy = {1, 0, -1, 0, 1, 1, -1, -1};
const std::vector<int> dx = {0, 1, 0, -1, 1, -1, 1, -1};
} // namespace ebi
#line 2 "tree/dsu_on_tree.hpp"
#line 2 "tree/heavy_light_decomposition.hpp"
#line 6 "tree/heavy_light_decomposition.hpp"
#line 8 "tree/heavy_light_decomposition.hpp"
namespace ebi {
template <class T> struct heavy_light_decomposition {
private:
void dfs_sz(int v) {
for (auto &e : g[v]) {
if (e.to == par[v]) continue;
par[e.to] = v;
depth_[e.to] = depth_[v] + 1;
dist[e.to] = dist[v] + e.cost;
dfs_sz(e.to);
sz[v] += sz[e.to];
if (sz[e.to] > sz[g[v][0].to] || g[v][0].to == par[v])
std::swap(e, g[v][0]);
}
}
void dfs_hld(int v) {
in[v] = num++;
rev[in[v]] = v;
for (auto e : g[v]) {
if (e.to == par[v]) continue;
nxt[e.to] = (e.to == g[v][0].to ? nxt[v] : e.to);
dfs_hld(e.to);
}
out[v] = num;
}
// [u, v) パスの取得 (v は u の祖先)
std::vector<std::pair<int, int>> ascend(int u, int v) const {
std::vector<std::pair<int, int>> res;
while (nxt[u] != nxt[v]) {
res.emplace_back(in[u], in[nxt[u]]);
u = par[nxt[u]];
}
if (u != v) res.emplace_back(in[u], in[v] + 1);
return res;
}
// (u, v] パスの取得 (u は v の祖先)
std::vector<std::pair<int, int>> descend(int u, int v) const {
if (u == v) return {};
if (nxt[u] == nxt[v]) return {{in[u] + 1, in[v]}};
auto res = descend(u, par[nxt[v]]);
res.emplace_back(in[nxt[v]], in[v]);
return res;
}
public:
heavy_light_decomposition(const Graph<T> &gh, int root_ = 0)
: n(gh.size()),
root(root_),
g(gh),
sz(n, 1),
in(n),
out(n),
nxt(n),
par(n, -1),
depth_(n, 0),
rev(n),
dist(n, 0) {
nxt[root] = root;
dfs_sz(root);
dfs_hld(root);
}
int idx(int u) const {
return in[u];
}
int rev_idx(int i) const {
return rev[i];
}
int la(int v, int k) const {
while (1) {
int u = nxt[v];
if (in[u] <= in[v] - k) return rev[in[v] - k];
k -= in[v] - in[u] + 1;
v = par[u];
}
}
int lca(int u, int v) const {
while (nxt[u] != nxt[v]) {
if (in[u] < in[v]) std::swap(u, v);
u = par[nxt[u]];
}
return depth_[u] < depth_[v] ? u : v;
}
int jump(int s, int t, int i) const {
if (i == 0) return s;
int l = lca(s, t);
int d = depth_[s] + depth_[t] - depth_[l] * 2;
if (d < i) return -1;
if (depth_[s] - depth_[l] >= i) return la(s, i);
i = d - i;
return la(t, i);
}
std::vector<int> path(int s, int t) const {
int l = lca(s, t);
std::vector<int> a, b;
for (; s != l; s = par[s]) a.emplace_back(s);
for (; t != l; t = par[t]) b.emplace_back(t);
a.emplace_back(l);
std::reverse(b.begin(), b.end());
a.insert(a.end(), b.begin(), b.end());
return a;
}
int root_of_heavy_path(int u) const {
return nxt[u];
}
int parent(int u) const {
return par[u];
}
T distance(int u, int v) const {
return dist[u] + dist[v] - 2 * dist[lca(u, v)];
}
T distance_from_root(int v) const {
return dist[v];
}
T depth(int v) const {
return depth_[v];
}
bool at_path(int u, int v, int s) const {
return distance(u, v) == distance(u, s) + distance(s, v);
}
std::pair<int, int> subtree_section(int v) const {
return {in[v], out[v]};
}
bool is_subtree(int u, int v) const {
return in[u] <= in[v] && in[v] < out[u];
}
template <class F>
void path_noncommutative_query(int u, int v, bool vertex,
const F &f) const {
int l = lca(u, v);
for (auto [a, b] : ascend(u, l)) f(a + 1, b);
if (vertex) f(in[l], in[l] + 1);
for (auto [a, b] : descend(l, v)) f(a, b + 1);
}
std::vector<std::pair<int, int>> path_sections(int u, int v,
bool vertex) const {
int l = lca(u, v);
std::vector<std::pair<int, int>> sections;
for (auto [a, b] : ascend(u, l)) sections.emplace_back(a + 1, b);
if (vertex) sections.emplace_back(in[l], in[l] + 1);
for (auto [a, b] : descend(l, v)) sections.emplace_back(a, b + 1);
return sections;
}
template <class F>
int max_path(int u, int v, bool vertex, F binary_search) const {
int prev = -1;
int l = lca(u, v);
for (auto [a, b] : ascend(u, l)) {
a++;
int m = binary_search(a, b);
if (m == b) {
prev = rev[b];
} else {
return (m == a ? prev : rev[m]);
}
}
if (vertex) {
int m = binary_search(in[l], in[l] + 1);
if (m == in[l]) {
return prev;
} else {
prev = l;
}
}
for (auto [a, b] : descend(l, v)) {
b++;
int m = binary_search(a, b);
if (m == b) {
prev = rev[b - 1];
} else {
return m == a ? prev : rev[m - 1];
}
}
return v;
}
template <class F> void subtree_query(int u, bool vertex, const F &f) {
f(in[u] + int(!vertex), out[u]);
}
const std::vector<int> &dfs_order() const {
return rev;
}
template <class ADD, class QUERY, class CLEAR, class RESET>
void dsu_on_tree(const ADD &add, const QUERY &query, const CLEAR &clear,
const RESET &reset) const;
std::vector<std::pair<int, int>> lca_based_auxiliary_tree_dfs_order(
std::vector<int> vs) const;
std::pair<std::vector<int>, Graph<T>> lca_based_auxiliary_tree(
std::vector<int> vs) const;
private:
int n, root;
Graph<T> g;
std::vector<int> sz, in, out, nxt, par, depth_, rev;
std::vector<T> dist;
int num = 0;
};
} // namespace ebi
#line 4 "tree/dsu_on_tree.hpp"
namespace ebi {
template <class T>
template <class ADD, class QUERY, class CLEAR, class RESET>
void heavy_light_decomposition<T>::dsu_on_tree(const ADD &add,
const QUERY &query,
const CLEAR &clear,
const RESET &reset) const {
auto dfs = [&](auto &&self, int v) -> void {
for (auto e : g[v].next()) {
if (e.to == parent(v)) continue;
self(self, e.to);
}
if (sz[v] != 1) {
self(self, g[v][0].to);
for (int i = out[g[v][0].to]; i < out[v]; i++) {
add(rev[i]);
}
}
add(v);
query(v);
if (nxt[v] == v) {
for (int i = in[v]; i < out[v]; i++) {
clear(rev[i]);
}
reset();
}
return;
};
dfs(dfs, root);
return;
}
} // namespace ebi
#line 7 "test/aoj/aoj_2995.test.cpp"
namespace ebi {
void main_() {
int n, k;
std::cin >> n >> k;
Graph<int> g(n);
g.read_tree();
std::vector<std::pair<int, int>> cs(n);
for (auto &[c, d] : cs) {
std::cin >> c >> d;
c--;
d--;
}
std::vector<bool> is_tree(k, true);
undo_unionfind uf(k);
std::vector<int> ans(n);
int res = 0;
auto val = [&](int v) -> int {
v = uf.leader(v);
return is_tree[v] ? uf.size(v) - 1 : uf.size(v);
};
auto add = [&](int v) -> void {
auto [c, d] = cs[v];
c = uf.leader(c);
d = uf.leader(d);
if (c != d) {
res -= val(c) + val(d);
}
if (uf.merge(c, d)) {
is_tree[uf.leader(c)] = is_tree[c] && is_tree[d];
res += val(uf.leader(c));
} else if (is_tree[c]) {
res++;
is_tree[c] = false;
}
};
auto query = [&](int v) -> void { ans[v] = res; };
auto clear = [&](int v) -> void {
auto [c, d] = cs[v];
is_tree[c] = is_tree[d] = true;
uf.undo();
};
auto reset = [&]() -> void { res = 0; };
heavy_light_decomposition hld(g);
hld.dsu_on_tree(add, query, clear, reset);
for (auto x : ans) {
std::cout << x << '\n';
}
}
} // namespace ebi
int main() {
ebi::fast_io();
int t = 1;
// std::cin >> t;
while (t--) {
ebi::main_();
}
return 0;
}