#877141 (C++17) No.2337 Equidistant

提出ソース
結果

問題	No.2337 Equidistant
ユーザー	minato
提出日時	2023-06-02 22:13:36
言語	C++17 (gcc 13.2.0 + boost 1.83.0)
結果	AC
実行時間	440 ms / 4,000 ms
コード長	22,437 bytes
コンパイル時間	2,077 ms
コンパイル使用メモリ	160,896 KB
実行使用メモリ	52,664 KB
最終ジャッジ日時	2023-08-28 03:52:51
合計ジャッジ時間	10,829 ms
ジャッジサーバーID （参考情報）	judge15 / judge13
このコードへのチャレンジ（β）
テストケース

テストケース表示
入力	結果	実行時間実行使用メモリ
testcase_00	AC	1 ms 4,380 KB
testcase_01	AC	2 ms 4,380 KB
testcase_02	AC	1 ms 4,380 KB
testcase_03	AC	2 ms 4,380 KB
testcase_04	AC	2 ms 4,376 KB
testcase_05	AC	1 ms 4,376 KB
testcase_06	AC	4 ms 4,376 KB
testcase_07	AC	3 ms 4,384 KB
testcase_08	AC	3 ms 4,380 KB
testcase_09	AC	3 ms 4,376 KB
testcase_10	AC	3 ms 4,376 KB
testcase_11	AC	351 ms 39,392 KB
testcase_12	AC	340 ms 39,620 KB
testcase_13	AC	341 ms 39,304 KB
testcase_14	AC	346 ms 39,720 KB
testcase_15	AC	349 ms 39,604 KB
testcase_16	AC	347 ms 39,564 KB
testcase_17	AC	351 ms 39,376 KB
testcase_18	AC	336 ms 39,624 KB
testcase_19	AC	352 ms 39,596 KB
testcase_20	AC	346 ms 39,432 KB
testcase_21	AC	318 ms 52,664 KB
testcase_22	AC	247 ms 42,220 KB
testcase_23	AC	283 ms 41,732 KB
testcase_24	AC	402 ms 48,364 KB
testcase_25	AC	307 ms 41,840 KB
testcase_26	AC	440 ms 50,020 KB
testcase_27	AC	322 ms 44,836 KB
testcase_28	AC	326 ms 44,572 KB
権限があれば一括ダウンロードができます
ソースコード

raw source code
#line 1 "library-cpp/other/template.hpp"
// clang-format off
#include <algorithm>
#include <array>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <forward_list>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ull = unsigned long long;
using i128 = __int128_t;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
template <class T> using maxheap = priority_queue<T>;
template <class T> using minheap = priority_queue<T, vector<T>, greater<T>>;
template <class T> using vec = vector<T>;
template <class T> using vvec = vector<vector<T>>;
#define OVERLOAD_REP(_1, _2, _3, name, ...) name
#define REP0(n) for (auto minato = decay_t<decltype(n)>{}; minato < (n); ++minato)
#define REP1(i, n) for (auto i = decay_t<decltype(n)>{}; (i) < (n); (i)++)
#define REP2(i, l, r) for (auto i = (l); (i) < (r); (i)++)
#define rep(...) OVERLOAD_REP(__VA_ARGS__, REP2, REP1, REP0)(__VA_ARGS__)
#define OVERLOAD_RREP(_1, _2, _3, name, ...) name
#define RREP1(i, n) for (auto i = (n) - 1; (i) >= decay_t<decltype(n)>{}; (i)--)
#define RREP2(i, l, r) for (auto i = (r) - 1; (i) >= (l); (i)--)
#define rrep(...) OVERLOAD_RREP(__VA_ARGS__, RREP2, RREP1)(__VA_ARGS__)
#define all(x) begin(x), end(x)
template <class Container> int SZ(const Container& v) { return int(v.size()); }
template <class T> void UNIQUE(vector<T>& v) { v.erase(unique(v.begin(), v.end()), v.end()); }
template <class T> T MAX(const vector<T>& v) { return *max_element(v.begin(), v.end()); }
template <class T> T MIN(const vector<T>& v) { return *min_element(v.begin(), v.end()); }
template <class T> T SUM(const vector<T>& v) { return accumulate(v.begin(), v.end(), T(0)); }
template <class T> T ABS(T x) { return max(x, -x); }
template <class T1, class T2> bool chmax(T1& a, T2 b) { if (a < b) { a = b; return true; } return false; }
template <class T1, class T2> bool chmin(T1& a, T2 b) { if (a > b) { a = b; return true; } return false; }
int topbit(ull x) { return x == 0 ? -1 : 63 - __builtin_clzll(x); }
int botbit(ull x) { return x == 0 ? 64 : __builtin_ctzll(x); }
int popcount(ull x) { return __builtin_popcountll(x); }
int kthbit(ull x, int k) { return (x >> k) & 1; }
constexpr long long TEN(int x) { return x == 0 ? 1 : TEN(x - 1) * 10; }
template <typename S> void rearrange(const vector<S>& id) { (void)id; }
template <typename S, typename T> void rearrange_exec(const vector<S>& id, vector<T>& v) { vector<T> w(v.size()); for (size_t i = 0; i < id.size(); i++) { w[i] = v[id[i]]; } v.swap(w); }
template <typename S, typename Head, typename... Tail> void rearrange(const vector<S>& id, Head& a, Tail& ...tail) { rearrange_exec(id, a); rearrange(id, tail...); }
istream& operator>>(istream& is, __int128_t& x) {
    x = 0;
    string s;
    is >> s;
    int n = int(s.size()), it = 0;
    if (s[0] == '-') it++;
    for (; it < n; it++) x = (x * 10 + s[it] - '0');
    if (s[0] == '-') x = -x;
    return is;
}
ostream& operator<<(ostream& os, __int128_t x) {
    if (x == 0) return os << 0;
    if (x < 0) os << '-', x = -x;
    deque<int> deq;
    while (x) deq.emplace_front(x % 10), x /= 10;
    for (int e : deq) os << e;
    return os;
}
template <class T> vector<T> &operator++(vector<T>& v) { for (auto& e : v) { e++; } return v;} 
template <class T> vector<T> operator++(vector<T>& v, int) { auto res = v; for (auto& e : v) { e++; } return res; }
template <class T> vector<T> &operator--(vector<T>& v) { for (auto& e : v) { e--; } return v; }
template <class T> vector<T> operator--(vector<T>& v, int) { auto res = v; for (auto& e : v) { e--; } return res; }
template <class T1, class T2> pair<T1, T2> operator-(const pair<T1, T2>& x) { return pair<T1, T2>(-x.first, -x.second); }
template <class T1, class T2> pair<T1, T2> operator-(const pair<T1, T2>& x, const pair<T1, T2>& y) { return pair<T1, T2>(x.first - y.first, x.second - y.second); }
template <class T1, class T2> pair<T1, T2> operator+(const pair<T1, T2>& x, const pair<T1, T2>& y) { return pair<T1, T2>(x.first + y.first, x.second + y.second); }
template <class T1, class T2> pair<T1, T2> operator+=(pair<T1, T2>& l, const pair<T1, T2>& r) { return l = l + r; }
template <class T1, class T2> pair<T1, T2> operator-=(pair<T1, T2>& l, const pair<T1, T2>& r) { return l = l - r; }
constexpr char ln = '\n';
const string YESNO[2] = {"NO", "YES"};
const string YesNo[2] = {"No", "Yes"};
void YES(bool t = true) { cout << YESNO[t] << "\n"; }
void NO(bool t = 1) { YES(!t); }
void Yes(bool t = true) { cout << YesNo[t] << "\n"; }
void No(bool t = 1) { Yes(!t); }
template <class T> void drop(T x) { cout << x << "\n"; exit(0); }
#define INT(...)     \
    int __VA_ARGS__; \
    IN(__VA_ARGS__)
#define LL(...)     \
    ll __VA_ARGS__; \
    IN(__VA_ARGS__)
#define STR(...)        \
    string __VA_ARGS__; \
    IN(__VA_ARGS__)
#define CHR(...)      \
    char __VA_ARGS__; \
    IN(__VA_ARGS__)
#define LDB(...)             \
    long double __VA_ARGS__; \
    IN(__VA_ARGS__)
#define VEC(type, name, size) \
    vector<type> name(size);  \
    IN(name)
#define VEC2(type, name1, name2, size)     \
    vector<type> name1(size), name2(size); \
    for (int i = 0; i < size; i++) IN(name1[i], name2[i])
#define VEC3(type, name1, name2, name3, size)           \
    vector<type> name1(size), name2(size), name3(size); \
    for (int i = 0; i < size; i++) IN(name1[i], name2[i], name3[i])
#define VEC4(type, name1, name2, name3, name4, size)                 \
    vector<type> name1(size), name2(size), name3(size), name4(size); \
    for (int i = 0; i < size; i++) IN(name1[i], name2[i], name3[i], name4[i]);
#define VV(type, name, N, M)                       \
    vector<vector<type>> name(N, vector<type>(M)); \
    IN(name)
template <class T> void scan(T& a) { cin >> a; }
template <class T> void scan(vector<T>& a) { for (auto& i : a) scan(i); }
void IN() {}
template <class Head, class... Tail> void IN(Head& head, Tail&... tail) { scan(head); IN(tail...); }
void print() { cout << "\n"; }
template <class T> void print(const vector<T>& v) { for (auto it = v.begin(); it != v.end(); ++it) { if (it != v.begin()) { cout << " "; } cout << *it; } print(); }
template <class T, class... Args> void print(const T& x, const Args& ... args) { cout << x; if (sizeof...(Args)) cout << " "; print(args...); }
#ifdef MINATO_LOCAL
template <class T1, class T2> ostream& operator<<(ostream& os, pair<T1, T2> p) { return os << "(" << p.first << ", " << p.second << ")"; }
template <size_t N, class TUPLE> void debug_tuple(ostream& os, TUPLE _) { (void)os; (void)_; }
template <size_t N, class TUPLE, class T, class ...Args> void debug_tuple(ostream &os, TUPLE t) { os << (N == 0 ? "" : ", ") << get<N>(t); debug_tuple<N + 1, TUPLE, Args...>(os, t); }
template <class ...Args> ostream& operator<<(ostream& os, tuple<Args...> t) { os << "("; debug_tuple<0, tuple<Args...>, Args...>(os, t); return os << ")"; }
string debug_delim(int& i) { return i++ == 0 ? "" : ", "; }
#define debug_embrace(x) { int i = 0; os << "{";  { x } return os << "}"; }
template <class T> ostream& operator<<(ostream& os, vector<T> v) { debug_embrace( for (T e : v) { os << debug_delim(i) << e; } ) }
template <class T, size_t N> ostream& operator<<(ostream& os, array<T, N> a) { debug_embrace( for (T e : a) { os << debug_delim(i) << e; } ) }
template <class T, size_t N> enable_if_t<!is_same_v<char, remove_cv_t<T>>, ostream>& operator<<(ostream& os, T(&a)[N]) { debug_embrace( for (T e : a) { os << debug_delim(i) << e; } ) }
template <class Key> ostream& operator<<(ostream& os, set<Key> s) { debug_embrace( for (Key e : s) { os << debug_delim(i) << e; }) }
template <class Key, class T> ostream& operator<<(ostream& os, map<Key, T> mp) { debug_embrace( for (auto e : mp) { os << debug_delim(i) << e; }) }
template <class Key> ostream& operator<<(ostream& os, multiset<Key> s) { debug_embrace( for (Key e : s) { os << debug_delim(i) << e; }) }
template <class T> ostream& operator<<(ostream& os, queue<T> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.front(); } ) }
template <class T> ostream& operator<<(ostream& os, deque<T> q) { debug_embrace( for (T e : q) { os << debug_delim(i) << e; } ) }
template <class T> ostream& operator<<(ostream& os, priority_queue<T> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.top(); } ) }
template <class T> ostream& operator<<(ostream& os, priority_queue<T, vector<T>, greater<T>> q) { debug_embrace( for (; !q.empty(); q.pop()) { os << debug_delim(i) << q.top(); } ) }
void debug_out() { cerr << endl; }
template <class T, class... Args> void debug_out(const T& x, const Args& ... args) { cerr << " " << x; debug_out(args...); }
#define debug(...) cerr << __LINE__ << " : [" << #__VA_ARGS__ << "] =", debug_out(__VA_ARGS__)
#else
#define debug(...) (void(0))
#endif
///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
// clang-format on
#line 2 "D.cpp"

/*
    HeavyLightDecomposition
    構築 O(n) 空間 O(n)

    HeavyLightDecomposition (int n)
    n 頂点 0 辺の無向グラフを作る。
    O(n)

    int size()
    頂点数を返す。
    O(1)

    void add_edge(int u, int v)
    頂点 u と v を結ぶ無向辺を追加する。
    O(1)

    void build(vector<int> rs = {0})
    根集合を根とした有向森を構築する。
    O(n)

    int operator[](int v)
    オイラーツアーを行ったあとの v の頂点番号を返す。
    O(1)

    int depth(int v)
    v の深さを返す。
    O(1)

    int subtree_size(int v)
    v を根とする部分木の頂点数を返す。
    O(1)

    int parent(int v)
    v の親を返す。
    v が根のとき、-1 を返す。
    O(1)

    int kth_ancestor(int v, int k)
    v から k 回親を辿った頂点を返す。
    存在しない場合、-1 を返す。
    O(log(n))

    int level_ancestor(int v, int d)
    v の祖先で深さが d の物を返す。
    存在しない場合 -1 を返す。
    O(log(n))

    int lca(int u, int v)
    u と v の最小共通祖先を返す。
    O(log(n))

    int distance(int u, int v)
    uv パスの長さを返す。
    O(log(n))

    int distance(int u, int v, int w)
    w が u と v の最小共通祖先であるときの uv パスの長さを返す。
    O(1)

    int cut_size(int u, int v)
    辺 uv を切ったときにできる 2 つの木のうち、
    u を含む方の頂点数を返す。
    uv 辺が存在しない場合 -1 を返す。
    O(1)

    int jump(int u, int v, int d)
    uv パス上の頂点で、u からの距離が d であるものを返す。
    存在しない場合 -1 を返す。
    O(log(n))

    int step(int u, int v)
    uv パス上の頂点で、u から距離 1 であるものを返す。
    u == v のとき -1 を返す。
    O(log(n))

    int meet(int u, int v, int w)
    u, v, w までのパスが辺を共有しないような唯一の頂点を返す。
    O(log(n))

    vector<int> path(int u, int v)
    uv パス上の頂点（端点含む）をその順に返す。
    O(n)


    頂点 v の情報は HLD[v] に持たせる。
    辺 uv の情報は dep[u] < dep[v] として HLD[v] に持たせる。
    （つまり深い方,子の頂点に対応させる）
    いずれにせよデータ構造は n 頂点分構築する。

    template<class F>
    void path_query_vertex(int u, int v, const F& f)
    template<class F>
    void path_query_edge(int u, int v, const F& f)
    uv パスを複数の区間として取得し、操作する。
    区間の要素をマージするときは可換であることが求められる。
    F f は区間 [l,r) を引数にとる関数。
    auto f=[&](int l, int r) {
        //区間[l,r)に対する処理
    };
    一つの区間への操作の計算量を O(X) として O(Xlog(n))

    template<class F>
    void subtree_query_vertex(int v, const F& f)
    template<class F>
    void subtree_query_edge(int v, const F& f)
    v を根とした部分木を一つの区間として取得し、操作する。
    F f は区間 [l,r) を引数にとる関数。
    auto f=[&](int l, int r) {
        //区間[l,r)に対する処理
    };
    一つの区間への操作の計算量を O(X) として O(X)

    template<class T, class F, class M>
    T noncommutative_query_vertex(int u, int v, T e, const F& f, const M& op)
    template<class T, class F, class M>
    T noncommutative_query_edge(int u, int v, T e, const F& f, const M& op)
    uv パスを複数の区間として取得し、操作する。
    モノイドが非可換でも動く。
    F f は区間 [l,r) を引数にとる関数。
    auto f=[&](int l, int r) {
        if (l < r) {
            //左から右に要素をマージしたときの積を取得
            return get(l,r)
        } else {
            //右から左に要素をマージしたときの積を取得
            return get(r,l)
        }
    };
    M op はマージする関数
    T e は単位元
    一つの区間への操作の計算量を O(X) として O(Xlog(n))
*/

struct HeavyLightDecomposition {
    vector<vector<int>> g;

    HeavyLightDecomposition(int n)
        : g(n),
          n_(n),
          vid(n, -1),
          head(n),
          sub(n, 1),
          par(n, -1),
          dep(n, 0),
          inv(n),
          type(n) {
    }

    int size() const {
        return n_;
    }

    void add_edge(int u, int v) {
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    }

    void build(vector<int> rs = {0}) {
        int c = 0, pos = 0;
        for (int r : rs) {
            dfs_sz(r);
            head[r] = r;
            dfs_hld(r, c++, pos);
        }
    }

    int operator[](int v) const {
        assert(0 <= v and v < n_);
        return vid[v];
    }

    int depth(int v) const {
        assert(0 <= v and v < n_);
        return dep[v];
    }

    int subtree_size(int v) const {
        assert(0 <= v and v < n_);
        return sub[v];
    }

    int parent(int v) const {
        assert(0 <= v and v < n_);
        return par[v];
    }

    int kth_ancestor(int v, int k) const {
        assert(0 <= v and v < n_);
        return kth_ancestor_(v, k);
    }

    int level_ancestor(int v, int d) const {
        assert(0 <= v and v < n_);
        return kth_ancestor_(v, dep[v] - d);
    }

    int lca(int u, int v) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        return lca_(u, v);
    }

    int distance(int u, int v) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        int w = lca_(u, v);
        return distance_(u, v, w);
    }

    int distance(int u, int v, int w) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        assert(0 <= w and w < n_);
        return distance_(u, v, w);
    }

    int cut_size(int u, int v) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        if (par[u] == v) return sub[u];
        if (par[v] == u) return n_ - sub[v];
        return -1;
    }

    int jump(int u, int v, int d) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        return jump_(u, v, d);
    }

    int step(int u, int v) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        return jump_(u, v, 1);
    }

    int meet(int u, int v, int w) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        assert(0 <= w and w < n_);
        comparator_in(u, v);
        comparator_in(v, w);
        comparator_in(u, v);
        int a = lca_(u, v);
        int b = lca_(v, w);
        if (dep[a] < dep[b]) return b;
        return a;
    }

    vector<int> path(int u, int v) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        int w = lca_(u, v);
        int L = distance_(u, v, w);
        vector<int> ret(L + 1);
        int it = 0;
        while (u != w) {
            ret[it++] = u;
            u = par[u];
        }
        it = L;
        while (v != w) {
            ret[it--] = v;
            v = par[v];
        }
        ret[it] = w;
        return ret;
    }

    template <class F> void path_query_vertex(int u, int v, const F& f) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        while (true) {
            comparator_in(u, v);
            f(max(vid[head[v]], vid[u]), vid[v] + 1);
            if (head[u] != head[v])
                v = par[head[v]];
            else
                break;
        }
    }

    template <class F> void path_query_edge(int u, int v, const F& f) const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        while (true) {
            comparator_in(u, v);
            if (head[u] != head[v]) {
                f(vid[head[v]], vid[v] + 1);
                v = par[head[v]];
            } else {
                if (u != v) f(vid[u] + 1, vid[v] + 1);
                break;
            }
        }
    }

    template <class F> void subtree_query_vertex(int v, const F& f) const {
        assert(0 <= v and v < n_);
        f(vid[v], vid[v] + sub[v]);
    }

    template <class F> void subtree_query_edge(int v, const F& f) const {
        assert(0 <= v and v < n_);
        f(vid[v] + 1, vid[v] + sub[v]);
    }

    template <class T, class F, class M>
    T noncommutative_query_vertex(int u, int v, T e, const F& f, const M& op)
        const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        int w = lca_(u, v);
        T resl = e, resr = e;
        while (true) {
            resl = op(resl, f(vid[u] + 1, max(vid[head[u]], vid[w])));
            if (head[w] != head[u])
                u = par[head[u]];
            else
                break;
        }
        while (true) {
            if (head[w] != head[v]) {
                resr = op(f(vid[head[v]], vid[v] + 1), resr);
                v = par[head[v]];
            } else {
                if (w != v) resr = op(f(vid[w] + 1, vid[v] + 1), resr);
                break;
            }
        }
        return op(resl, resr);
    }

    template <class T, class F, class M>
    T noncommutative_query_edge(int u, int v, T e, const F& f, const M& op)
        const {
        assert(0 <= u and u < n_);
        assert(0 <= v and v < n_);
        int w = lca_(u, v);
        T resl = e, resr = e;
        while (true) {
            if (head[w] != head[u]) {
                resl = op(resl, f(vid[u] + 1, vid[head[u]]));
                u = par[head[u]];
            } else {
                if (w != u) resl = op(resl, f(vid[u] + 1, vid[w] + 1));
                break;
            }
        }
        while (true) {
            if (head[w] != head[v]) {
                resr = op(f(vid[head[v]], vid[v] + 1), resr);
                v = par[head[v]];
            } else {
                if (w != v) resr = op(f(vid[w] + 1, vid[v] + 1), resr);
                break;
            }
        }
        return op(resl, resr);
    }

  private:
    int n_;
    vector<int> vid, head, sub, par, dep, inv, type;

    void dfs_sz(int v) {
        vector<int>& es = g[v];
        if (~par[v]) es.erase(find(es.begin(), es.end(), par[v]));

        for (int& u : es) {
            par[u] = v;
            dep[u] = dep[v] + 1;
            dfs_sz(u);
            sub[v] += sub[u];
            if (sub[u] > sub[es[0]]) swap(u, es[0]);
        }
    }

    void dfs_hld(int v, int c, int& pos) {
        vid[v] = pos++;
        inv[vid[v]] = v;
        type[v] = c;
        for (int u : g[v]) {
            if (u == par[v]) continue;
            head[u] = (u == g[v][0] ? head[v] : u);
            dfs_hld(u, c, pos);
        }
    }

    void comparator_in(int& u, int& v) const {
        if (vid[u] > vid[v]) swap(u, v);
    }

    int kth_ancestor_(int v, int k) const {
        if (dep[v] < k or k < 0) return -1;
        while (true) {
            if (dep[v] - dep[head[v]] + 1 <= k) {
                k -= dep[v] - dep[head[v]] + 1;
                v = par[head[v]];
            } else {
                return inv[vid[v] - k];
            }
        }
    }

    int lca_(int u, int v) const {
        while (true) {
            comparator_in(u, v);
            if (head[u] == head[v]) return u;
            v = par[head[v]];
        }
    }

    int distance_(int u, int v, int w) const {
        return dep[u] + dep[v] - 2 * dep[w];
    }

    int jump_(int u, int v, int d) const {
        int w = lca_(u, v);
        int L = distance_(u, v, w);
        if (L < d) return -1;
        if (d <= distance_(u, w, w)) return kth_ancestor_(u, d);
        return kth_ancestor_(v, L - d);
    }
};
void solve() {
    INT(N, Q);
    vvec<int> G(N);
    HeavyLightDecomposition HLD(N);
    rep(N - 1) {
        INT(a, b);
        a--;
        b--;
        G[a].push_back(b);
        G[b].push_back(a);
        HLD.add_edge(a, b);
    }
    HLD.build();
    VEC2(int, S, T, Q);
    S--;
    T--;
    using Tu = tuple<int, int, int>;
    vvec<Tu> qs(N);
    vec<int> ans(Q);
    rep(i, Q) {
        int d = HLD.distance(S[i], T[i]);
        if (d & 1) continue;
        int m = d / 2;
        int w = HLD.jump(S[i], T[i], m);
        qs[w].emplace_back(S[i], T[i], i);
        ans[i] = N;
    }
    rep(v, N) {
        for (auto [s, t, i] : qs[v]) {
            int a = HLD.step(v, s);
            int b = HLD.step(v, t);
            ans[i] -= HLD.cut_size(a, v);
            ans[i] -= HLD.cut_size(b, v);
        }
    }
    for (auto e : ans) print(e);
}

int main() {
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    cout << fixed << setprecision(20);
    cerr << fixed << setprecision(7);

    int T = 1;
    // cin >> T;
    for (int test_case = 1; test_case <= T; test_case++) {
        // debug(test_case);
        solve();
    }
}
yukicoder

結果

テストケース

ソースコード
