#ifndef LOCAL #define FAST_IO #endif // ============ #include #define OVERRIDE(a, b, c, d, ...) d #define REP2(i, n) for (i32 i = 0; i < (i32)(n); ++i) #define REP3(i, m, n) for (i32 i = (i32)(m); i < (i32)(n); ++i) #define REP(...) OVERRIDE(__VA_ARGS__, REP3, REP2)(__VA_ARGS__) #define PER2(i, n) for (i32 i = (i32)(n)-1; i >= 0; --i) #define PER3(i, m, n) for (i32 i = (i32)(n)-1; i >= (i32)(m); --i) #define PER(...) OVERRIDE(__VA_ARGS__, PER3, PER2)(__VA_ARGS__) #define ALL(x) begin(x), end(x) #define LEN(x) (i32)(x.size()) using namespace std; using u32 = unsigned int; using u64 = unsigned long long; using i32 = signed int; using i64 = signed long long; using f64 = double; using f80 = long double; using pi = pair; using pl = pair; template using V = vector; template using VV = V>; template using VVV = V>>; template using VVVV = V>>>; template using PQR = priority_queue, greater>; template bool chmin(T &x, const T &y) { if (x > y) { x = y; return true; } return false; } template bool chmax(T &x, const T &y) { if (x < y) { x = y; return true; } return false; } template i32 lob(const V &arr, const T &v) { return (i32)(lower_bound(ALL(arr), v) - arr.begin()); } template i32 upb(const V &arr, const T &v) { return (i32)(upper_bound(ALL(arr), v) - arr.begin()); } template V argsort(const V &arr) { V ret(arr.size()); iota(ALL(ret), 0); sort(ALL(ret), [&](i32 i, i32 j) -> bool { if (arr[i] == arr[j]) { return i < j; } else { return arr[i] < arr[j]; } }); return ret; } #ifdef INT128 using u128 = __uint128_t; using i128 = __int128_t; #endif [[maybe_unused]] constexpr i32 INF = 1000000100; [[maybe_unused]] constexpr i64 INF64 = 3000000000000000100; struct SetUpIO { SetUpIO() { #ifdef FAST_IO ios::sync_with_stdio(false); cin.tie(nullptr); #endif cout << fixed << setprecision(15); } } set_up_io; void scan(char &x) { cin >> x; } void scan(u32 &x) { cin >> x; } void scan(u64 &x) { cin >> x; } void scan(i32 &x) { cin >> x; } void scan(i64 &x) { cin >> x; } void scan(f64 &x) { cin >> x; } void scan(string &x) { cin >> x; } template void scan(V &x) { for (T &ele : x) { scan(ele); } } void read() {} template void read(Head &head, Tail &...tail) { scan(head); read(tail...); } #define CHAR(...) \ char __VA_ARGS__; \ read(__VA_ARGS__); #define U32(...) \ u32 __VA_ARGS__; \ read(__VA_ARGS__); #define U64(...) \ u64 __VA_ARGS__; \ read(__VA_ARGS__); #define I32(...) \ i32 __VA_ARGS__; \ read(__VA_ARGS__); #define I64(...) \ i64 __VA_ARGS__; \ read(__VA_ARGS__); #define F64(...) \ f64 __VA_ARGS__; \ read(__VA_ARGS__); #define STR(...) \ string __VA_ARGS__; \ read(__VA_ARGS__); #define VEC(type, name, size) \ V name(size); \ read(name); #define VVEC(type, name, size1, size2) \ VV name(size1, V(size2)); \ read(name); // ============ #ifdef DEBUGF #else #define DBG(...) (void)0 #endif // ============ #include #include #include template struct Edge { using W = T; int from, to, id; W weight; Edge rev() const { return Edge{to, from, id, weight}; } }; template void debug(const Edge &e) { std::cerr << e.from << " -> " << e.to << " id = " << e.id << std::cerr << " weight = "; debug(e.weight); } template class Graph { public: using E = Edge; using W = T; static constexpr bool DIRECTED = DIR; struct Adjacency { using Iter = typename std::vector::iterator; Iter be, en; Iter begin() const { return be; } Iter end() const { return en; } int size() const { return (int)std::distance(be, en); } E &operator[](int idx) const { return be[idx]; } }; struct ConstAdjacency { using Iter = typename std::vector::const_iterator; Iter be, en; Iter begin() const { return be; } Iter end() const { return en; } int size() const { return (int)std::distance(be, en); } const E &operator[](int idx) const { return be[idx]; } }; private: int n, m; std::vector edges, csr; std::vector sep; bool built; public: Graph(int n) : n(n), m(0), built(false) {} int v() const { return n; } int e() const { return m; } int add_vertex() { return n++; } void add_edge(int from, int to, W weight = 1) { assert(0 <= from && from < n && 0 <= to && to < n); edges.emplace_back(E{from, to, m++, weight}); } void build() { sep.assign(n + 1, 0); csr.resize(DIRECTED ? m : 2 * m); for (const E &e : edges) { ++sep[e.from + 1]; if (!DIRECTED) { ++sep[e.to + 1]; } } for (int i = 0; i < n; ++i) { sep[i + 1] += sep[i]; } std::vector c = sep; for (const E &e : edges) { csr[c[e.from]++] = e; if (!DIRECTED) { csr[c[e.to]++] = e.rev(); } } built = true; } Adjacency operator[](int v) { assert(built && 0 <= v && v < n); return Adjacency{csr.begin() + sep[v], csr.begin() + sep[v + 1]}; } ConstAdjacency operator[](int v) const { assert(built && 0 <= v && v < n); return ConstAdjacency{csr.begin() + sep[v], csr.begin() + sep[v + 1]}; } }; // ============ // ============ // ============ #include #include // ============ // ============ class StaticTopTree { public: enum class NodeType { AddEdge, AddVertex, Compress, Rake }; struct Node { NodeType ty; int par, lch, rch, top, bottom; }; std::vector nodes; int stt_root; template StaticTopTree(Graph& g, int root = 0) { assert(0 <= root && root < g.v()); nodes.reserve(3 * g.v()); dfs(g, root, -1); nodes.resize(g.v()); for (int v = 0; v < g.v(); ++v) { nodes[v] = {NodeType::AddVertex, -1, -1, -1, v, v}; } stt_root = compress(g, root, -1).second; } private: template int dfs(Graph& g, int v, int p) { int sz = 1, mx = 0; for (Edge& e : g[v]) { if (e.to == p) { continue; } int t = dfs(g, e.to, v); if (mx < t) { mx = t; std::swap(g[v][0], e); } sz += t; } for (Edge& e : g[v]) { if (e.to == p) { std::swap(e, g[v][g[v].size() - 1]); break; } } return sz; } int make_node(NodeType ty, int lch, int rch) { int v = (int)nodes.size(); nodes.emplace_back(Node{ty, -1, lch, rch, nodes[lch].top, ty == NodeType::Compress ? nodes[rch].bottom : nodes[lch].bottom}); if (lch != -1) { nodes[lch].par = v; } if (rch != -1) { nodes[rch].par = v; } return v; } void merge(std::vector>& path) { auto [xf, xs] = path.back(); path.pop_back(); auto [yf, ys] = path.back(); path.pop_back(); path.emplace_back(std::max(xf, yf) + 1, make_node(NodeType::Compress, ys, xs)); } template std::pair compress(const Graph& g, int v, int p) { std::vector> path; while (true) { path.emplace_back(rake(g, v, p)); while (true) { int l = (int)path.size(); if (l >= 3 && (path[l - 3].first == path[l - 2].first || path[l - 3].first <= path[l - 1].first)) { std::pair t = path.back(); path.pop_back(); merge(path); path.emplace_back(t); } else if (l >= 2 && path[l - 2].first <= path[l - 1].first) { merge(path); } else { break; } } if (g[v].size() == 0 || g[v][0].to == p) { break; } p = v; v = g[v][0].to; } while (path.size() >= 2) { merge(path); } auto [xf, xs] = path.back(); int z = make_node(NodeType::AddEdge, xs, -1); return std::pair(xf + 1, z); } template std::pair rake(const Graph& g, int v, int p) { std::priority_queue, std::vector>, std::greater<>> pq; for (int i = 1; i < (int)g[v].size(); ++i) { const Edge& e = g[v][i]; if (e.to == p) { continue; } pq.emplace(compress(g, e.to, v)); } if (pq.empty()) { return std::pair(0, v); } while (pq.size() >= 2) { auto [xf, xs] = pq.top(); pq.pop(); auto [yf, ys] = pq.top(); pq.pop(); pq.emplace(std::max(xf, yf) + 1, make_node(NodeType::Rake, xs, ys)); } auto [rf, rs] = pq.top(); nodes[v].lch = rs; nodes[rs].par = v; return std::pair(rf + 1, v); } }; // ============ template class DynamicRerootingDP { using Value = typename TreeDP::Value; using Func = typename TreeDP::Func; using NT = typename StaticTopTree::NodeType; Graph &g; TreeDP &dp; StaticTopTree stt; int root; std::vector value; std::vector up, down; void init(int x) { const StaticTopTree::Node &node = stt.nodes[x]; if (node.lch != -1) { init(node.lch); } if (node.rch != -1) { init(node.rch); } update_single(x); } void update_single(int x) { const StaticTopTree::Node &node = stt.nodes[x]; if (node.ty == NT::AddVertex) { Value s = (node.lch == -1 ? dp.id() : value[node.lch]); if (x != root) { auto e = g[x][g[x].size() - 1]; up[x] = dp.lift(x, e.to, e.id, s); } if (has_heavy(x)) { auto e = g[x][0]; down[x] = dp.lift(x, e.to, e.id, s); } } else if (node.ty == NT::Compress) { if (node.top != root) { up[x] = dp.composite(up[node.lch], up[node.rch]); } if (has_heavy(node.bottom)) { down[x] = dp.composite(down[node.rch], down[node.lch]); } } else if (node.ty == NT::AddEdge) { if (node.top != root) { value[x] = dp.apply(up[node.lch], dp.id()); } } else { value[x] = dp.op(value[node.lch], value[node.rch]); } } bool has_heavy(int v) const { return g[v].size() > int(v != root); } void descend(int x, Value &a, Value &b, Value &side) const { int p = stt.nodes[x].par; if (p == -1) { return; } descend(p, a, b, side); const StaticTopTree::Node &node = stt.nodes[p]; if (node.ty == NT::Compress) { if (node.lch == x) { b = dp.apply(up[node.rch], b); } else { a = dp.apply(down[node.lch], a); } } else if (node.ty == NT::AddVertex) { side = dp.op(a, b); } else if (node.ty == NT::Rake) { side = dp.op(side, value[node.lch == x ? node.rch : node.lch]); } else { int v = node.top; if (v != root) { auto e = g[v][g[v].size() - 1]; a = dp.apply(dp.lift(e.to, v, e.id, side), dp.id()); b = dp.id(); } } } public: DynamicRerootingDP(Graph &g, TreeDP &dp, int root = 0) : g(g), dp(dp), stt(g, root), root(root), value(stt.nodes.size()), up(stt.nodes.size()), down(stt.nodes.size()) { init(stt.stt_root); } // edge update: call update on both endpoints (in any order) void update(int v) { for (int x = v; x != -1; x = stt.nodes[x].par) { update_single(x); } } Value get(int v) const { Value a = dp.id(), b = dp.id(), side = dp.id(); descend(v, a, b, side); Value s = dp.op(a, b); const StaticTopTree::Node &node = stt.nodes[v]; if (node.lch != -1) { s = dp.op(value[node.lch], s); } return dp.vertex(v, s); } }; // ============ struct TreeDP { using Value = pi; // p[root], end using Func = tuple; // ans, p[top], p[light], bottom? V p; Value id() const { return pi(-1, -1); } Value op(Value x, Value y) const { return max(x, y); } Func composite(Func f, Func g) const { if (!get<3>(f)) { return Func(get<0>(f), get<1>(f), get<2>(f), false); } if (get<2>(f) < get<1>(g)) { return Func(get<0>(g), get<1>(f), get<2>(g), get<3>(g)); } else { return Func(get<0>(f), get<1>(f), get<2>(f), false); } } Value apply(Func f, Value x) const { if (!get<3>(f)) { return Value(get<1>(f), get<0>(f)); } if (get<2>(f) < x.first) { return Value(get<1>(f), x.second); } else { return Value(get<1>(f), get<0>(f)); } } Value vertex(i32 v, Value x) const { return Value(p[v], x.first == -1 ? v : x.second); } Func lift(i32 v, i32 _p, i32 e, Value x) const { return Func(x.first == -1 ? v : x.second, p[v], x.first, true); } }; void solve() { I32(n); Graph<> g(n); REP(i, n - 1) { I32(u, v); --u; --v; g.add_edge(u, v); } g.build(); TreeDP dp; dp.p.resize(n); iota(ALL(dp.p), 0); DynamicRerootingDP dyn(g, dp); auto swp = [&](i32 u, i32 v) -> void { swap(dp.p[u], dp.p[v]); dyn.update(u); dyn.update(v); }; auto qry = [&](i32 w) -> i32 { i32 ans = dyn.get(w).second; return ans; }; i32 x = 0; I32(q); REP(qi, q) { I32(u, v); u = (u + n - 1 + x) % n + 1; v = (v + n - 1 + x) % n + 1; --u; --v; swp(u, v); x = qry(u) + 1; cout << x << '\n'; } } int main() { i32 t = 1; // cin >> t; while (t--) { solve(); } }