【lca && 线段树】URAL - 2109 Tourism on Mars

Problem Description

给你 n 个点，接下来 n-1 行，每行输入 u, v 代表 u 点和 v 点之间有一条无向边。
接下来输入 q，代表有 q 次询问。
u 到 v 的道路中，距离 1 点最近的点，是重要的点。
每次询问输入 u, v 问你。u 到 v 重要的点，u+1 到 v 重要的点…. v-1 到 v 重要的点，那个点距离 1 更近，输出这个点。

思路：

就是以 1 为根，求 lca(u, v), lca(u+1,v )… lca(v-1, v) 距离 1 最近的点。
lca(u,v) 代表u->v路径中，深度最低的点，也就是距离1最近的点。
2->3的路径 和 3->4的路径 和 4->5的路径 包含了 2->5的路径
假设我们求出 lca(2, 3), lca(3, 4)。那么我们就可以知道 2->4, 3->4那个点距离1更近， 也就可以知道询问u,v的结果。
所以预处理求出lca(1, 2), lca(2, 3), …, lca(n-1, n);
然后用线段树维护u,v结果。

#include
#include
using namespace std;
const int N = 2*1e5+100;
const int LOG_N = 30;
#define MID int mid = (l+r)>>1
#define lson root<<1
#define rson root<<1|1
struct node
{
    int depth, id;
};
node tree[4*N];
vector<int> G[N];
int parent[LOG_N][N];
int depth[N], lc[N];

void dfs(int v, int p, int d)
{
    parent[0][v] = p;
    depth[v] = d;
    for(int i = 0; i < G[v].size(); i++) {
        if(G[v][i] != p) dfs(G[v][i], v, d+1);
    }
}

void init(int V)
{
    dfs(1, -1, 0);
    for(int k = 0; k+1 < LOG_N; k++) {
        for(int v = 1; v <= V; v++) {
            if(parent[k][v] < 0) parent[k+1][v] = -1;
            else parent[k+1][v] = parent[k][parent[k][v]];
        }
    }
}

int lca(int u, int v)
{
    if(depth[u] > depth[v]) swap(u, v);
    for(int k = 0; k < LOG_N; k++) {
        if((depth[v] - depth[u]) >> k & 1) {
            v = parent[k][v];
        }
    }
    if(u == v) return u;
    for(int k = LOG_N - 1; k >= 0; k--)
    {
        if(parent[k][u] != parent[k][v]) {
            u = parent[k][u];
            v = parent[k][v];
        }
    }
    return parent[0][u];
}
void Merge(int root)
{
    if(tree[lson].depth > tree[rson].depth) tree[root].depth = tree[rson].depth, tree[root].id = tree[rson].id;
    else tree[root].depth = tree[lson].depth, tree[root].id = tree[lson].id;
}
void build(int root, int l, int r)
{
    if(l == r)
    {
        tree[root].id = lc[l];
        tree[root].depth = depth[lc[l]];
        return ;
    } else if(r > l) {//r > l是为了防止n是1的时候，l就是1, r就是0了。
    MID;
    build(lson, l, mid);
    build(rson, mid+1, r);
    Merge(root);
    }
}
int ansdepth, ansid;
void Query(int root, int l, int r, int ul, int ur)
{
    if(ul <= l && r <= ur)
    {
        if(tree[root].depth < ansdepth)
        ansdepth = tree[root].depth, ansid = tree[root].id;
        return ;
    }
    MID;
    if(mid >= ul) Query(lson, l, mid, ul, ur);
    if(mid < ur) Query(rson, mid+1, r, ul, ur);
}
int main()
{
    int n, u, v, q;
    scanf("%d", &n);
    for(int i = 1; i < n; i++)
    {
        scanf("%d %d", &u, &v);
        G[u].push_back(v);
        G[v].push_back(u);
    }
    init(n);
    for(int i = 1; i < n; i++) lc[i] = lca(i, i+1);
    build(1, 1, n-1);
    scanf("%d", &q);
    while(q--)
    {
        scanf("%d %d", &u, &v);
        if(u > v) swap(u, v);
        ansdepth = 0x3f3f3f3f, ansid = u;
        if(u != v) Query(1, 1, n-1, u, v-1);
        printf("%d\n", ansid);
    }

}