P4092 [HEOI2016/TJOI2016]树（树链剖分+倍增LCA）（直接暴力好像最快）

题目描述

在 2016 年，佳媛姐姐刚刚学习了树，非常开心。现在他想解决这样一个问题：给定一颗有根树，根为 11 ，有以下两种操作：

1. 标记操作：对某个结点打上标记。（在最开始，只有结点 11 有标记，其他结点均无标记，而且对于某个结点，可以打多次标记。）

2. 询问操作：询问某个结点最近的一个打了标记的祖先。（这个结点本身也算自己的祖先）

你能帮帮她吗?

输入格式

第一行两个正整数 NN 和 QQ 分别表示节点个数和操作次数。

接下来 N-1N−1 行，每行两个正整数 u,v \,\, (1 \leqslant u,v \leqslant n)u,v(1⩽u,v⩽n) 表示 uu 到 vv 有一条有向边。

接下来 QQ 行，形如 oper num ，oper 为 C 时表示这是一个标记操作, oper 为 Q 时表示这是一个询问操作。

输出格式

输出一个正整数，表示结果

题解：

线段树维护的是每个区间被标记的最深的节点，然后每次查询就先确定1到这个节点的路径上被标记的最深的节点的位置，再用倍增LCA往上跳即可。

有一个很重要的剪枝就是用树链剖分查询的时候如果ans已经大于-1了直接返回。

#include<bits/stdc++.h>
using namespace std;
const int maxn=1e6+100;
typedef long long ll;
int n,m;
vector<int> g[maxn];

int son[maxn];
int id[maxn];
int fa[maxn];
int cnt;
int dep[maxn];
int size[maxn];
int top[maxn];
int w[maxn];
int wt[maxn];

int father[20][maxn];

struct node {
    int l,r;
    int sum;
    int lazy;
}segTree[maxn*4];
void build (int i,int l,int r) {
    segTree[i].l=l;
    segTree[i].r=r;
    if (l==r) {
        segTree[i].sum=-1;
        return;
    }
    int mid=(l+r)>>1;
    build(i<<1,l,mid);
    build(i<<1|1,mid+1,r);
    segTree[i].sum=max(segTree[i<<1].sum,segTree[i<<1|1].sum); 
}
void update (int i,int t) {
    if (segTree[i].l==t&&segTree[i].r==t) {
        segTree[i].sum=wt[t];
        return;
    }
    int mid=(segTree[i].l+segTree[i].r)>>1;
    if (t<=mid)
        update(i<<1,t);
    if (t>mid)
        update(i<<1|1,t);
    segTree[i].sum=max(segTree[i<<1].sum,segTree[i<<1|1].sum);
} 
int query (int i,int l,int r) {
    if (l<=segTree[i].l&&r>=segTree[i].r)
        return segTree[i].sum;
    int mid=(segTree[i].l+segTree[i].r)>>1;
    int ans=-1;
    if (l<=mid)
        ans=max(ans,query(i<<1,l,r));
    if (r>mid)
        ans=max(ans,query(i<<1|1,l,r));
    return ans;
}

int qRange (int x,int y) {
    int ans=-1;
    while (top[x]!=top[y]) {
        if (dep[top[x]]<dep[top[y]]) swap(x,y);
        ans=max(ans,query(1,id[top[x]],id[x]));
        if (ans>=0) return ans;
        x=fa[top[x]];
    }
    if (dep[x]>dep[y]) swap(x,y);
    ans=max(ans,query(1,id[x],id[y]));
    return ans;
}
void upRange (int x) {
    update(1,id[x]);
}
void dfs1 (int x,int f,int deep) {
    dep[x]=deep;
    fa[x]=f;
    father[0][x]=f;
    size[x]=1;
    int maxson=-1;
    for (int y:g[x]) {
        if (y==f) continue;
        dfs1(y,x,deep+1);
        size[x]+=size[y];
        if (size[x]>maxson) son[x]=y,maxson=size[y];
    }
}
void dfs2 (int x,int topf) {
    id[x]=++cnt;
    wt[cnt]=dep[x];
    top[x]=topf;
    if (!son[x]) return;
    dfs2(son[x],topf);
    for (int y:g[x]) {
        if (y==fa[x]||y==son[x]) continue;
        dfs2(y,y);
    }
}
int main () {
    scanf("%d%d",&n,&m);
    for (int i=1;i<n;i++) {
        int x,y;
        scanf("%d%d",&x,&y);
        g[x].push_back(y);
        g[y].push_back(x);
    }
    dfs1(1,0,1);
    dfs2(1,1);
    build(1,1,n);
    for (int i=1;i<=17;i++)
        for (int j=1;j<=n;j++)
            father[i][j]=father[i-1][father[i-1][j]];
    upRange(1);
    while (m--) {
        char s;
        int x;
        cin>>s;
        scanf("%d",&x);
        if (s=='C')
            upRange(x);
        else {
            int tt=qRange(1,x);
            for (int i=17;i>=0;i--)
                if (dep[x]-tt>>i) x=father[i][x];
            printf("%d\n",x);
            
        } 
    }
}