結果

問題 No.2337 Equidistant
ユーザー hiro71687khiro71687k
提出日時 2023-06-02 21:52:05
言語 C++17
(gcc 12.3.0 + boost 1.83.0)
結果
WA  
実行時間 -
コード長 3,431 bytes
コンパイル時間 2,843 ms
コンパイル使用メモリ 215,768 KB
実行使用メモリ 66,236 KB
最終ジャッジ日時 2024-06-08 22:50:32
合計ジャッジ時間 20,237 ms
ジャッジサーバーID
（参考情報） 		judge1 / judge3
このコードへのチャレンジ
（要ログイン）

テストケース

テストケース表示
入力 結果 実行時間
実行使用メモリ
testcase_00 AC 2 ms
5,248 KB
testcase_01 WA -
testcase_02 WA -
testcase_03 WA -
testcase_04 WA -
testcase_05 WA -
testcase_06 WA -
testcase_07 WA -
testcase_08 WA -
testcase_09 WA -
testcase_10 WA -
testcase_11 WA -
testcase_12 WA -
testcase_13 WA -
testcase_14 WA -
testcase_15 WA -
testcase_16 WA -
testcase_17 WA -
testcase_18 WA -
testcase_19 WA -
testcase_20 WA -
testcase_21 AC 948 ms
66,236 KB
testcase_22 AC 728 ms
52,928 KB
testcase_23 WA -
testcase_24 WA -
testcase_25 WA -
testcase_26 WA -
testcase_27 WA -
testcase_28 WA -
権限があれば一括ダウンロードができます

ソースコード

diff # 

#include <bits/stdc++.h>
using namespace std;
using ll=long long;
using ld=long double;
ld pie=3.141592653589793;
ll inf=2000000000000000000;
ll mod=998244353;
/* LCA(G, root): 木 G に対する根を root として Lowest Common Ancestor を求める構造体
    query(u,v): u と v の LCA を求める。計算量 O(logn)
    前処理: O(nlogn)時間, O(nlogn)空間
*/
struct LCA {
    vector<vector<long long>> parent;  // parent[k][u]:= u の 2^k 先の親
    vector<ll> dist;            // root からの距離
    LCA(vector<vector<ll>> &G, ll root = 0) { init(G, root); }

    // 初期化
    void init(vector<vector<ll>> &G, int root = 0) {
        ll V = G.size();
        int K = 1;
        while ((1 << K) < V) K++;
        parent.assign(K, vector<ll>(V, -1));
        dist.assign(V, -1);
        dfs(G, root, -1, 0);
        for (int k = 0; k + 1 < K; k++) {
            for (int v = 0; v < V; v++) {
                if (parent[k][v] < 0) {
                    parent[k + 1][v] = -1;
                } else {
                    parent[k + 1][v] = parent[k][parent[k][v]];
                }
            }
        }
    }

    // 根からの距離と1つ先の頂点を求める
    void dfs(vector<vector<ll>> &G, int v, int p, int d) {
        parent[0][v] = p;
        dist[v] = d;
        for (auto e : G[v]) {
            if (e != p) dfs(G, e, v, d + 1);
        }
    }

    int query(int u, int v) {
        if (dist[u] < dist[v]) swap(u, v);  // u の方が深いとする
        int K = parent.size();
        // LCA までの距離を同じにする
        for (int k = 0; k < K; k++) {
            if ((dist[u] - dist[v]) >> k & 1) {
                u = parent[k][u];
            }
        }
        // 二分探索で LCA を求める
        if (u == v) return u;
        for (int k = K - 1; k >= 0; k--) {
            if (parent[k][u] != parent[k][v]) {
                u = parent[k][u];
                v = parent[k][v];
            }
        }
        return parent[0][u];
    }
};
ll dfs(ll now,vector<ll>&m,vector<vector<ll>>&g){
    m[now]=-1;
    ll x=1;
    for (ll i = 0; i < g[now].size(); i++)
    {
        if (m[g[now][i]]==-1)
        {
            continue;
        }
        x+=dfs(g[now][i],m,g);
    }
    m[now]=x;
    return x;
}
int main(){
    ll n,q;
    cin >> n >> q;
    vector<vector<ll>>g(n);
    for (ll i = 0; i < n-1; i++)
    {
        ll a,b;
        cin >> a >> b;
        a--,b--;
        g[a].push_back(b);
        g[b].push_back(a);
    }
    vector<ll>m(n,0);
    dfs(0,m,g);
    queue<ll>que;
    vector<ll>memo(n,inf);
    memo[0]=0;
    que.push(0);
    while (!que.empty())
    {
        ll v=que.front();
        que.pop();
        for (ll i = 0; i < g[v].size(); i++)
        {
            if (memo[g[v][i]]>memo[v]+1)
            {
                memo[g[v][i]]=memo[v]+1;
                que.push(g[v][i]);
            }
        }
    }
    LCA lca(g,0);
    vector<ll>ans;
    for (ll i = 0; i < q; i++)
    {
        ll s,t;
        cin >> s >> t;
        s--,t--;
        ll x=lca.query(s,t);
        ll a=memo[s]-memo[x];
        ll b=memo[t]-memo[x];
        if (a%2!=b%2)
        {
            ans.push_back(0);
        }else if (a==b)
        {
            ans.push_back(n-m[s]-m[b]-(a-1)-(b-1));
        }else{
            ans.push_back(1);
        }
    }
    for (ll i = 0; i < ans.size(); i++)
    {
        cout << ans[i] << endl;
    }

}
0