Submission #230650

---

Source Code Expand

#include <iostream>
#include <sstream>
#include <string>
#include <cmath>
#include <cstdio>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <deque>
#include <algorithm>
#include <functional>
#include <numeric>

using namespace std;
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;

#define REP(i,n) for(int i = 0; i < (int)(n); ++i)
#define FOR(i,a,b) for(int i = (a); i < (int)(b); ++i)
#define FOREACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define SIZE(v) ((int)v.size())

#define pb push_back
#define mp make_pair

#define REP(i,n) for(int i = 0; i < (int)(n); ++i)
using namespace std;

// edge生成用
struct edge_element { int from, to, cost; };
struct edge { int to, cost; };
typedef pair<int, int> P; // <最短距離, 頂点番号>

const int INF = 1e9;


int V;
vector<vector<pair<int, int>>> routes(V + 1);


// 頂点sから各頂点までの距離を計算してdに格納
void dijkstra(int s, vector<vector<edge> >& G, vector<int>& d)
{
    priority_queue<P, vector<P>, greater<P> > que;
    fill(ALL(d), INF);
    d[s] = 0;
    que.push(P(0, s));

    while (!que.empty()) {
        P p = que.top();
        que.pop();

        int dist = p.first;
        int v = p.second;
        if (d[v] < dist) continue;
        REP(i, G[v].size()) {
            edge e = G[v][i];

            if (d[e.to] > d[v] + e.cost) {
                d[e.to] = d[v] + e.cost;
                que.push(P(d[e.to], e.to));

                // 交差点に来たらそれを覚えとく
                if (v == s || G[v].size() > 2) {
                    routes[e.to].pb( mp(v, i) );
                }
            }
        }
    }
}


int main(){
    cin >> V;

    routes.resize(V + 1);

    vector<vector<edge>> G(V + 1);
    REP(v, V-1) {
        int x, y;
        cin >> x >> y;

        edge tmp1{ y, 1 };
        edge tmp2{ x, 1 };
        G[x].pb(tmp1);
        G[y].pb(tmp2);
    }

    vector<int> d(V + 1);

    dijkstra(1, G, d);

    int Q;
    cin >> Q;
    REP(q,Q){
        int a, b;
        cin >> a >> b;

        // 共通の祖先を探す
        auto route_a = routes[a];
        auto route_b = routes[b];
        auto common = mp(1, -1);

        pair<int, int> a_last = common;
        pair<int, int> b_last = common;

        int idx = 0;
        while (idx < route_a.size() && idx < route_b.size()) {
            a_last = route_a[idx];
            b_last = route_b[idx];

            if (route_a[idx].first  == route_b[idx].first) {
                common = route_a[idx];
            }
            else break;
            ++idx;
        }

        int ret = 0;
        // 祖先と、その行き先が完全一致する場合
        if (a_last == b_last) {
            ret = abs(d[a] - d[b]) + 1;
        }
        else
        {
            int d1 = d[a] - d[common.first];
            int d2 = d[b] - d[common.first];
            ret = d1 + d2 + 1;
        }

        cout << ret << endl;
    }

    return 0;
}

Submission Info

Judge Result