///////////////////////////////////////////////////////// /** * Useful Macros * by subcrip * (requires C++17) */ #include using namespace std; /* macro helpers */ #define __NARGS(...) std::tuple_size::value #define __DECOMPOSE_S(a, x) auto x = a; #define __DECOMPOSE_N(a, ...) auto [__VA_ARGS__] = a; constexpr void __() {} #define __AS_PROCEDURE(...) __(); __VA_ARGS__; __() #define __as_typeof(container) decltype(container)::value_type /* type aliases */ using ll = int64_t; using ull = uint64_t; using pii = pair; using pil = pair; using pli = pair; using pll = pair; /* constants */ constexpr int INF = 0x3f3f3f3f; constexpr ull MDL = 1e9 + 7; constexpr ull PRIME = 998'244'353; constexpr ull MDL1 = 825; constexpr ull MDL2 = 87825; /* bit-wise operations */ #define lowbit(x) ((x) & -(x)) #define popcount(x) (__builtin_popcountll(ll(x))) #define parity(x) (__builtin_parityll(ll(x))) #define msp(x) (63LL - __builtin_clzll(ll(x))) #define lsp(x) (__builtin_ctzll(ll(x))) /* arithmetic operations */ #define mod(x, y) (((x) + (y)) % (y)) /* fast pairs */ #define upair ull #define umake(x, y) (ull(x) << 32 | ull(y)) #define u1(p) ((p) >> 32) #define u2(p) ((p) & ((1ULL << 32) - 1)) #define ult std::less #define ugt std::greater #define ipair ull #define imake(x, y) (umake(x, y)) #define i1(p) (int(u1(p))) #define i2(p) (int(u2(p))) struct ilt { bool operator()(const ipair& a, const ipair& b) const { if (i1(a) == i1(b)) return i2(a) < i2(b); else return i1(a) < i1(b); } }; struct igt { bool operator()(const ipair& a, const ipair& b) const { if (i1(a) == i1(b)) return i2(a) > i2(b); else return i1(a) > i1(b); } }; /* conditions */ #define loop while (1) #define if_or(var, val) if (!(var == val)) var = val; else #define continue_or(var, val) __AS_PROCEDURE(if (var == val) continue; var = val;) #define break_or(var, val) __AS_PROCEDURE(if (var == val) break; var = val;) /* build data structures */ #define unordered_counter(from, to) __AS_PROCEDURE(unordered_map<__as_typeof(from), size_t> to; for (auto&& x : from) ++to[x];) #define counter(from, to, cmp) __AS_PROCEDURE(map<__as_typeof(from), size_t, cmp> to; for (auto&& x : from) ++to[x];) #define pa(a) __AS_PROCEDURE(__typeof(a) pa; pa.push_back({}); for (auto&&x : a) pa.push_back(pa.back() + x);) #define sa(a) __AS_PROCEDURE(__typeof(a) sa(a.size() + 1); {int n = a.size(); for (int i = n - 1; i >= 0; --i) sa[i] = sa[i + 1] + a[i];};) #define adj(ch, n) __AS_PROCEDURE(vector> ch((n) + 1);) #define edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v), ch[v].push_back(u);) #define Edge(ch, u, v) __AS_PROCEDURE(ch[u].push_back(v);) /* io */ #define untie __AS_PROCEDURE(ios_base::sync_with_stdio(0), cin.tie(NULL)) template void __read(T& x) { cin >> x; } template void __read(T& x, U&... args) { cin >> x; __read(args...); } #define read(type, ...) __AS_PROCEDURE(type __VA_ARGS__; __read(__VA_ARGS__);) #define readvec(type, a, n) __AS_PROCEDURE(vector a(n); for (int i = 0; i < (n); ++i) cin >> a[i];) #define putvec(a) __AS_PROCEDURE(for (auto&& x : a) cout << x << ' '; cout << endl;) #define debug(x) __AS_PROCEDURE(cerr << #x" = " << (x) << endl;) #define debugvec(a) __AS_PROCEDURE(cerr << #a" = "; for (auto&& x : a) cerr << x << ' '; cerr << endl;) template ostream& operator<<(ostream& out, vector vec) { for (auto&& i : vec) out << i << ' '; return out; } /* pops */ #define poptop(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.top(); q.pop();) #define popback(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.back(); q.pop_back();) #define popfront(q, ...) __AS_PROCEDURE(auto [__VA_ARGS__] = q.front();q.pop_front();) /* algorithms */ vector calc_next(string t) { // pi function of t int n = (int)t.length(); vector pi(n); for (int i = 1; i < n; i++) { int j = pi[i - 1]; while (j > 0 && t[i] != t[j]) j = pi[j - 1]; if (t[i] == t[j]) j++; pi[i] = j; } return pi; } vector calc_z(string t) { // z function of t int m = t.length(); vector z; z.push_back(m); pair prev = {1, -1}; for (int i = 1; i < m; ++i) { if (z[i - prev.first] + i <= prev.second) { z.push_back(z[i - prev.first]); } else { int j = max(i, prev.second + 1); while (j < m && t[j] == t[j - i]) ++j; z.push_back(j - i); prev = {i, j - 1}; } } return z; } vector kmp(string s, string t) { // find all t in s string cur = t + '#' + s; int sz1 = s.size(), sz2 = t.size(); vector v; vector lps = calc_next(cur); for (int i = sz2 + 1; i <= sz1 + sz2; i++) { if (lps[i] == sz2) v.push_back(i - 2 * sz2); } return v; } int period(string s) { // find the length of shortest recurring period int n = s.length(); auto z = calc_z(s); for (int i = 1; i <= n / 2; ++i) { if (n % i == 0 && z[i] == n - i) { return i; } } return n; } ///////////////////////////////////////////////////////// using pii = pair; constexpr int MAXN = 1e4 + 10; constexpr int MAXM = 2e4 + 10; int curr[27], lca[MAXM], cnt[MAXN][27], sz[MAXN]; pii heavy[MAXN]; vector ch[MAXN]; vector tag[MAXN]; unordered_map tags; int prep(int v, int pa) { int curr = 1; heavy[v].first = -1; for (auto&& [u, w] : ch[v]) { if (u != pa) { int t = prep(u, v); curr += t; if (heavy[v].first == -1 || t > sz[heavy[v].first]) { heavy[v] = {u, w}; } } } sz[v] = curr; return curr; } void dfs(int v, int pa, int save) { cerr << "dfs(" << v << ", " << pa << ", " << save << ")\n"; if (save) { for (int i = 0; i < 27; ++i) { cnt[v][i] = curr[i]; } for (auto&& [u, w] : ch[v]) { if (u != pa && u != heavy[v].first) { curr[w] += 1; dfs(u, v, 1); curr[w] -= 1; tags.clear(); } } } if (heavy[v].first != -1) { curr[heavy[v].second] += 1; dfs(heavy[v].first, v, save); curr[heavy[v].second] -= 1; } for (auto&& i : tag[v]) { tags[i] += 1; if (tags[i] > 1 && save) { if (lca[i] == -1) lca[i] = v; tags[i] = 0; } } for (auto&& [u, w] : ch[v]) { if (u != pa && u != heavy[v].first) { dfs(u, v, 0); for (auto&& [i, o] : tags) { if (o > 1 && save) { if (lca[i] == -1) lca[i] = v; tags[i] = 0; } } } } } class Solution { public: vector minOperationsQueries(int n, vector>& edges, vector>& queries) { int q = queries.size(); memset(sz, 0, sizeof(sz)); memset(curr, 0, sizeof(curr)); memset(lca, 0xff, q * sizeof(int)); memset(cnt, 0, sizeof(cnt)); for (int i = 0; i < n; ++i) { ch[i].clear(), tag[i].clear(); } tags.clear(); for (auto&& e : edges) { ch[e[0]].emplace_back(e[1], e[2]); ch[e[1]].emplace_back(e[0], e[2]); } for (int i = 0; i < q; ++i) { tag[queries[i][0]].push_back(i); tag[queries[i][1]].push_back(i); } prep(0, 0); dfs(0, 0, 1); vector res(q); for (int i = 0; i < q; ++i) { int u = queries[i][0], v = queries[i][1]; if (u == v) { res[i] = 0; continue; } int l = lca[i]; int mx = 0, tot = 0; for (int i = 1; i < 27; ++i) { int curr = cnt[u][i] + cnt[v][i] - 2 * cnt[l][i]; tot += curr; mx = max(mx, curr); } res[i] = tot - mx; } return res; } }; int main() { vector> edges = {{9,7,1},{5,9,2},{0,9,4},{3,9,5},{1,9,5},{4,0,4},{2,0,2},{8,7,4},{6,3,2}}; vector> queries = {{4,3},{8,1},{9,6},{7,0},{1,1},{5,0},{4,8},{3,6},{8,2},{9,7}}; cout << Solution().minOperationsQueries(6, edges, queries); }