codeforces 519E A and B and Lecture Rooms LCA倍增

Time Limit:2000MS     Memory Limit:262144KB     64bit IO Format:%I64d & %I64u

Submit Status Practice CodeForces 519E

Description

A and B are preparing themselves for programming contests.

The University where A and B study is a set of rooms connected by corridors. Overall, the University has n rooms connected by n - 1corridors so that you can get from any room to any other one by moving along the corridors. The rooms are numbered from 1 to n.

Every day А and B write contests in some rooms of their university, and after each contest they gather together in the same room and discuss problems. A and B want the distance from the rooms where problems are discussed to the rooms where contests are written to be equal. The distance between two rooms is the number of edges on the shortest path between them.

As they write contests in new rooms every day, they asked you to help them find the number of possible rooms to discuss problems for each of the following m days.

Input

The first line contains integer n (1 ≤ n ≤ 10⁵) — the number of rooms in the University.

The next n - 1 lines describe the corridors. The i-th of these lines (1 ≤ i ≤ n - 1) contains two integers a_i and b_i (1 ≤ a_i, b_i ≤ n), showing that the i-th corridor connects rooms a_i and b_i.

The next line contains integer m (1 ≤ m ≤ 10⁵) — the number of queries.

Next m lines describe the queries. The j-th of these lines (1 ≤ j ≤ m) contains two integers x_j and y_j (1 ≤ x_j, y_j ≤ n) that means that on the j-th day A will write the contest in the room x_j, B will write in the room y_j.

Output

In the i-th (1 ≤ i ≤ m) line print the number of rooms that are equidistant from the rooms where A and B write contest on the i-th day.

Sample Input

Input

4
1 2
1 3
2 4
1
2 3

Output

1

Input

4
1 2
2 3
2 4
2
1 2
1 3

Output

0
2

Hint

in the first sample there is only one room at the same distance from rooms number 2 and 3 — room number 1.

思路：

题意：给你一棵有n个节点的树，m个询问，每个询问a，b，求树中到a，b距离相等的节点个数

我们先使得deg[a] >= deg[b]

首先，若a~b之间的距离为奇数的话，找不到唯一的中点，此时答案为0

（怎么求a~b之间的距离呢？预处理节点i到根的距离（此处为深度）deg[i]，求出lcaq = lca(a,b);

那么dist(a,b) = deg[a] - deg[lcaq] + deg[b] - deg[lcaq];）

否则：找出ab路径的中点mid，calc(u, d)可以找出节点u的深度为d的祖先，也就是我们求出中点的深度就可以找出中点！

怎么求中点的深度dmid？通过画图可知：

dmid = dist(a,b) / 2  - deg[b] + 2 * deg[lcaq];

最终答案的计算：num[i]表示以节点i为根的子树的节点总数

若a和b的深度相同，那么ans = num[lcaq] - num[xa] - num[xb]; 其中xa是lcaq在a~lcaq的下一个节点，xb是lcaq在b~lcaq的下一个节点

若a和b深度不同，那么ans = num[mid] - num[k], 其中k表示ab的中点的下一位置（在a和b路径上靠近a的下一位置）,画图可以理解。

#include <bits/stdc++.h>
using namespace std;

const int N = 1e5 + 5;
struct edge {
    int v, to;
    edge() {};
    edge(int v, int to) : v(v), to(to) {};
}e[N << 1];
int head[N], num[N], deg[N], tot, n, m;
int p[N][30];

void init()
{
    memset(head, -1, sizeof head);
    memset(p, -1, sizeof p);
    tot = 0;
}
void addedge(int u, int v)
{
    e[tot] = edge(v, head[u]);
    head[u] = tot++;
}
void dfs(int u, int fa, int d)
{
    deg[u] = d; p[u][0] = fa; num[u] = 1;
    for(int i = head[u]; ~i; i = e[i].to) {
        int v = e[i].v;
        if(v != fa) {
            dfs(v, u, d + 1);
            num[u] += num[v];
        }
    }
}
void pre()
{
    for(int j = 0; (1 << j) <= n; ++j)
        for(int i = 1; i <= n; ++i) {
            if(p[i][j - 1] != -1)
            p[i][j] = p[ p[i][j - 1] ][j - 1];
    }
}

int calc(int u, int d) ///返回节点u的深度为d的祖先
{
    for(int j = 25; j >= 0; --j) {
        if(deg[u] - (1 << j) >= d) u = p[u][j];
    }
    return u;
}
int lca(int a, int b)
{
    a = calc(a, deg[b]);///使a和b处在同一层
    if(a == b) return a; ///若此时a和b相等，那么lca就是a
    ///否则a和b同时向上爬
    for(int j = 25; j >= 0; --j) {
        if(p[a][j] != -1 && p[a][j] != p[b][j]) {
            a = p[a][j];
            b = p[b][j];
        }
    }
    return p[a][0];
}
int main()
{
    while(~scanf("%d", &n))
    {
        init();
        int u, v;
        for(int i = 1; i < n; ++i) {
            scanf("%d%d", &u, &v);
            addedge(u, v);
            addedge(v, u);
        }
        dfs(1, -1, 0);
        pre();

        scanf("%d", &m);
        int a, b;
        while(m --)
        {
            scanf("%d%d", &a, &b);
            if(deg[a] < deg[b]) swap(a, b);
            if(a == b) { printf("%d\n", n); continue; }
            int lcaq = lca(a, b);
            int dist = deg[a] + deg[b] - 2 * deg[lcaq]; ///a和b之间的距离
            if(dist & 1) { puts("0"); continue; }
            if(deg[a] == deg[b]) { ///xa和xb分别是在a~lca和b~lca的路径上距离lca为1的点
                int xa = calc(a, deg[lcaq] + 1);
                int xb = calc(b, deg[lcaq] + 1);
                printf("%d\n", n - num[xa] - num[xb]);
            }
            else {
                int mid = dist / 2 - deg[b] + 2 * deg[lcaq]; ///mid为ab之间的路径的中点的深度
                printf("%d\n", num[ calc(a, mid) ] - num[ calc(a, mid + 1) ]);
            }
        }
    }
    return 0;
}