每日一题之 hiho1746 路径包含问题

描述
给定一棵N的节点的树，节点编号1~N，并且1号节点是根节点。

小Hi会反复询问小Ho一个问题：给定两个节点a和b，有多少对节点c和d满足c < d且c到d的路径包含完整的a到b的路径？

你能帮帮小Ho吗？

输入
第一行包含两个数N和M，依次是节点总数和问题总数。

第2~N行每行包含两个整数u和v，代表u是v的父节点。

以下M行每行包含两个整数a和b，代表一个问题。

对于30%的数据，1 ≤ N, M ≤ 1000

对于100%的数据，1 ≤ N, M ≤ 100000

输出
对于每个问题输出一个整数，代表答案。

样例输入
7 2
1 2
1 3
2 4
2 5
3 6
3 7
2 3
2 4
样例输出
9
6

思路：

题解转载自：待字闺中
本题的理论做法其实很简单。对于位于不同子树的两个节点，计算出节点子树的大小，相乘即可。对于位于相同子树的节点，即节点A是节点B的祖先，我们需要对节点B的子树节数，并且需要对以A节点为根的子树减去B节点所在的子树的剩余部分计数。（看晕了吧，自己简单画一下就知道了）

所以本题的难点就在于求两个节点是否在同一个子树上，以及在同一个子树上的计数问题。

这两个问题一定要同时考虑，因为求两个节点在同一子树上的问题其实就是LCA（最近公共祖先）问题。而最近公共祖先有三种常见的解法：Tarjan（离线），倍增法（在线），RMQ（在线）。这三种方法中，只有倍增法记录了树上的路径，这对我们的计数非常用帮助。

倍增法的原理是这样的。对于每一个节点，我们都记录它的在树中的深度，然后用二分法向上枚举其公共祖先，进而找到最近公共祖先。向上枚举的过程可以通过预处理加速，我们记录每一个节点向上移动2^i步所到达的节点，这样每次枚举的时间复杂度是O(logn)。

预处理出移动到的节点的另一个好处在于计数。由于在计数中，我们需要将以A为根的子树中，将B所在的子树减去。此时，我们就可以从B节点向上走(depth_B - depth_A - 1)步，得到相应的节点后，减去该子树的节点数。就可以通过一个简单的乘法求出答案了。

所以本题就是LCA倍增法的一个经典应用。

推荐阅读：最近公共祖先

#include <cstring>
#include <iostream>
#include <cstdio>
#include <vector>

using namespace std;

const int maxn = 1e5 + 5;

vector<int>father;
vector<int>g[maxn];
vector<int>depth;
vector<int>cnt; // 记录每个节点的子节点个数
vector<int>lca_skip[24]; //lca_skip[i][v] 表示向上走2^i步到达顶点lca[i][v].

int n,m;

int dfs(int pre,int cur,int d) 
{

    int res = 0;  //统计子节点的个数
    depth[cur] = d;

    for (int i = 0; i < g[cur].size(); ++i) {
        int next = g[cur][i];
        if (next != pre) {  
            father[next] = cur;
            res += dfs(cur,next,d+1);
        }
    }

    cnt[cur] = res;

    return res + 1;
}

void init()
{

    for (int i = 1; i <= n; ++i) {
        lca_skip[0][i] = father[i];
    }

    for (int i = 1; i < 24; ++i) { // 倍增
        for (int j = 1; j <= n; ++j) {
            int u = lca_skip[i-1][j];
            if (u == -1) {
                lca_skip[i][j] = -1;
            }
            else {
                lca_skip[i][j] = lca_skip[i-1][u];
            }
        }
    }

}

int lca_move(int cur,int step) 
{

    for (int i = 0; i < 24; ++i) {
        if (step & (1 << i)) {
            cur = lca_skip[i][cur];
        }
    }

    return cur;

}

int lca_query(int a,int b)
{
    int da = depth[a];
    int db = depth[b];

    if (da > db) {
        swap(da,db);
        swap(a,b);
    }


    int l = 0;
    int r = da;
    while (l < r) {
        int mid = (l + r + 1) >> 1;
        int fa = lca_move(a, da - mid);
        int fb = lca_move(b, db - mid);

        if (fa == fb) {
            l = mid;
        } else {
            r = mid - 1;
        }
    }

    return lca_move(a, da - l);
}

int main()
{

    //freopen("input.txt", "r", stdin);

    cin >> n >> m;

    father = vector<int>(n + 1, -1);
    depth = vector<int>(n + 1);
    cnt = vector<int>(n + 1);

    for (int i = 0; i < 24; i++) {
        lca_skip[i].resize(n + 1);
    }

    int a,b;
    for (int i = 0; i < n-1; ++i) {
        cin >> a >>b;
        g[a].push_back(b);
        g[b].push_back(a);
    }

    dfs(-1,1,0);
    init();



    for (int i = 0; i < m; ++i) {
        cin >> a >> b;

        long long res = 0;

        if (depth[a] > depth[b]) {
            swap(a,b);
        }

        int f = lca_query(a,b);

        if (f == a || f == b) {
            int delta = depth[b] - depth[a];
            int u = lca_move(b,delta - 1);

            int tot = n - (cnt[u] + 1);

            res = (long long ) tot * (cnt[b] + 1);

        }
        else {

            int ca = cnt[a] + 1;
            int cb = cnt[b] + 1;

            res = (long long )ca * cb;

        }

        cout << res << endl;
    }


    return 0;
}