题目链接

题目

题目描述

小A这次来到一个景区去旅游，景区里面有N个景点，景点之间有N-1条路径。小A从当前的一个景点移动到下一个景点需要消耗一点的体力值。但是景区里面有两个景点比较特殊，它们之间是可以直接坐观光缆车通过，不需要消耗体力值。而小A不想走太多的路，所以他希望你能够告诉它，从当前的位置出发到他想要去的那个地方，他最少要消耗的体力值是多少。

输入描述

第一行一个整数N代表景区的个数。
接下来N-1行每行两个整数u,v代表从位置u到v之间有一条路径可以互相到达。
接下来的一行两个整数U,V表示这两个城市之间可以直接坐缆车到达。
接下来一行一个整数Q，表示有Q次询问。
接下来的Q行每行两个整数x,y,代表小A的位置在x，而他想要去的地方是y。

输出描述

对于每个询问下x,y输出一个结果，代表x到y消耗的最少体力对于每个询问下x,y输出一个结果，代表x到y消耗的最少体力对于每个询问下x,y输出一个结果，代表x到y消耗的最少体力

示例1

输入

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

输出

1
0

备注

\(1\leq N \leq 5e5， \space1 \leq Q\leq2e6\)

题解

方法一

知识点：倍增，LCA。

考虑用倍增LCA，有三种情况：

1. \(u \to v\) 。
2. \(u \to x \to y \to v\) 。
3. \(u \to y \to x \to v\) 。

取最小值即可。

时间复杂度 \(O(n+q\log n)\)

空间复杂度 \(O(n\log n)\)

方法二

知识点：DFS序，LCA，ST表。

LCA也可以由欧拉序+ST表实现。

时间复杂度 \(O(n\log n + q)\)

空间复杂度 \(O(n\log n)\)

代码

方法一

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

const int N = 5e5 + 7;
vector<int> g[N];
int dep[N], f[27][N];

void dfs(int u, int fa) {
    f[0][u] = fa;
    dep[u] = dep[fa] + 1;
    for (int i = 1;i <= 20;i++)  f[i][u] = f[i - 1][f[i - 1][u]];
    for (auto v : g[u]) {
        if (v == fa) continue;
        dfs(v, u);
    }
}

int LCA(int u, int v) {
    if (dep[u] < dep[v]) swap(u, v);
    for (int i = 20;i >= 0;i--) {
        if (dep[f[i][u]] >= dep[v]) u = f[i][u];
        if (u == v) return u;
    }
    for (int i = 20;i >= 0;i--) {
        if (f[i][u] != f[i][v]) {
            u = f[i][u];
            v = f[i][v];
        }
    }
    return f[0][u];
}

int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[LCA(u, v)]; }

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n - 1;i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    dfs(1, 0);

    int x, y;
    cin >> x >> y;

    int q;
    cin >> q;
    while (q--) {
        int u, v;
        cin >> u >> v;
        cout << min({ dist(u, v),dist(u,x) + dist(y,v),dist(u,y) + dist(x,v) }) << '\n';
    }
    return 0;
}

方法二

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

template<class T>
class ST {
    vector<vector<T>> node;
public:
    ST() {}
    ST(const vector<T> &src) { init(src); }

    void init(const vector<T> &src) {
        assert(src.size());
        int n = src.size() - 1;
        int sz = log2(n);
        node.assign(sz + 1, vector<T>(n + 1));
        for (int i = 1;i <= n;i++) node[0][i] = src[i];
        for (int i = 1;i <= sz;i++)
            for (int j = 1;j + (1 << i) - 1 <= n;j++)
                node[i][j] = node[i - 1][j] + node[i - 1][j + (1 << i - 1)];
    }

    T query(int l, int r) {
        int k = log2(r - l + 1);
        return node[k][l] + node[k][r - (1 << k) + 1];
    }
};

const int N = 5e5 + 7;
vector<int> g[N];

int eulcnt;
int pos[N], eul[N << 1], dep[N];
void dfs(int u, int fa) {
    eul[++eulcnt] = u;
    pos[u] = eulcnt;
    dep[u] = dep[fa] + 1;
    for (auto v : g[u]) {
        if (v == fa) continue;
        dfs(v, u);
        eul[++eulcnt] = eul[pos[u]];
    }
}

struct T {
    int mi;
    friend T operator+(const T &a, const T &b) { return { dep[a.mi] < dep[b.mi] ? a.mi : b.mi }; }
};

ST<T> st;
int LCA(int u, int v) {
    u = pos[u], v = pos[v];
    if (u > v) swap(u, v);
    return st.query(u, v).mi;
}

int dist(int u, int v) { return dep[u] + dep[v] - 2 * dep[LCA(u, v)]; }

int main() {
    std::ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    int n;
    cin >> n;
    for (int i = 1;i <= n - 1;i++) {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }

    dfs(1, 0);
    vector<T> eul_src(eulcnt + 1);
    for (int i = 1;i <= eulcnt;i++) eul_src[i] = { eul[i] };
    st.init(eul_src);

    int x, y;
    cin >> x >> y;

    int q;
    cin >> q;
    while (q--) {
        int u, v;
        cin >> u >> v;
        cout << min({ dist(u, v),dist(u,x) + dist(y,v),dist(u,y) + dist(x,v) }) << '\n';
    }
    return 0;
}