区间最深LCA

求编号在区间[l, r]之间的两两lca的深度最大值。

例题。

解：口胡几种做法。前两种基于莫队，第三种是启发式合并 + 扫描线，第四种是lct + 线段树。

①：

有个结论就是这个答案一定是点集中DFS序相邻的两个点的lca。于是开个数据结构，以DFS序为key维护点集，找前驱后继，额外用一个数据结构维护所有lca的深度，取最大值即可。外面套莫队就做完了。

实现上这两个数据结构都可以用树状数组。

#include <bits/stdc++.h>

#define out(a) std::cerr << #a" = " << a << std::endl;

template <class T> inline void read(T &x) {
    x = 0;
    char c = getchar();
    while(c < '0' || c > '9') c = getchar();
    while(c >= '0' && c <= '9') {
        x = x * 10 + c - 48;
        c = getchar();
    }
    return;
}

const int N = 80010;

struct Edge {
    int nex, v;
}edge[N << 1]; int tp;

int e[N], pos[N], pos2[N], num, num2, fr[N], ans[N], id[N], ST[N << 1][20], d[N], pw[N << 1], n;
/*std::set<int> st; /// save pos 
std::set<int>::iterator it;*/
/*std::multiset<int> Ans;
std::multiset<int>::iterator it2;*/

namespace Ans {
    int ta[N], cnt;
    inline void add(int i) {
        ++cnt;
//        printf("Ans : add : %d 
", i);
        for(; i <= n; i += i & (-i)) {
            ta[i]++;
        }
        return;
    }
    inline void del(int i) {
        --cnt;
//        printf("Ans : del : %d 
", i);
        for(; i <= n; i += i & (-i)) {
            ta[i]--;
        }
        return;
    }
    inline int getMax() {
        int ans = 0, k = cnt, t = pw[n];
        while(t >= 0) {
            if(((ans | (1 << t)) <= n) && ta[ans | (1 << t)] < k) {
                k -= ta[ans | (1 << t)];
                ans |= (1 << t);
            }
            t--;
        }
        return ans + 1;
    }
}

namespace ta {
    int ta[N], cnt;
    inline void add(int i) {
        ++cnt;
//        printf("ta : add : %d 
", i);
        for(; i <= n; i += i & (-i)) {
            ta[i]++;
        }
        return;
    }
    inline void del(int i) {
        --cnt;
//        printf("ta : del : %d 
", i);
        for(; i <= n; i += i & (-i)) {
            ta[i]--;
        }
        return;
    }
    inline int getKth(int k) {
//        printf("ta : Kth %d : ", k);
        int ans = 0, t = pw[n];
        while(t >= 0) {
            if(((ans | (1 << t)) <= n) && ta[ans | (1 << t)] < k) {
                k -= ta[ans | (1 << t)];
                ans |= (1 << t);
            }
            t--;
        }
//        printf("%d  cnt = %d 
", ans + 1, cnt);
        return ans + 1;
    }
    inline int getSum(int i) {
        int ans = 0;
        for(; i; i -= i & (-i)) {
            ans += ta[i];
        }
        return ans;
    }
}

struct Ask {
    int l, r, id;
    inline bool operator <(const Ask &w) const {
        if(fr[l] != fr[w.l]) return l < w.l;
        return r < w.r;
    }
}ask[N];

inline void add(int x, int y) {
    tp++;
    edge[tp].v = y;
    edge[tp].nex = e[x];
    e[x] = tp;
    return;
}

void DFS_1(int x, int f) {
    d[x] = d[f] + 1;
//    printf("x = %d 
", x);
    pos[x] = ++num;
    id[num] = x;
    pos2[x] = ++num2;
    ST[num2][0] = x;
    for(int i = e[x]; i; i = edge[i].nex) {
        int y = edge[i].v;
        if(y == f) continue;
        DFS_1(y, x);
        ST[++num2][0] = x;
    }
    return;
}

inline void prework() {
    register int i, j;
    for(i = 2; i <= num2; i++) pw[i] = pw[i >> 1] + 1;
    for(j = 1; j <= pw[num2]; j++) {
        for(i = 1; i + (1 << j) - 1 <= num2; i++) {
            if(d[ST[i][j - 1]] < d[ST[i + (1 << (j - 1))][j - 1]])
                ST[i][j] = ST[i][j - 1];
            else 
                ST[i][j] = ST[i + (1 << (j - 1))][j - 1];
         }
    }
    return;
}

inline int lca(int x, int y) {
    x = pos2[x];
    y = pos2[y];
    if(x > y) std::swap(x, y);
    int t = pw[y - x + 1];
    if(d[ST[x][t]] < d[ST[y - (1 << t) + 1][t]]) 
        return ST[x][t];
    else
        return ST[y - (1 << t) + 1][t];
}

inline void add(int x) {
//    std::cerr << "------------ add " << x << std::endl;
    ta::add(pos[x]);
//    std::cerr << "111 
";
    int rk = ta::getSum(pos[x]);
//    std::cerr << "222 
";
    int y = 0, z = 0;
    if(rk != 1) {
        y = id[ta::getKth(rk - 1)];
    }
    if(rk != ta::cnt) {
        z = id[ta::getKth(rk + 1)];
    }
//    std::cerr << "333 
";
//    out(y); out(z);
    if(y) Ans::add(d[lca(x, y)]);
    if(z) Ans::add(d[lca(x, z)]);
    if(y && z) Ans::del(d[lca(y, z)]);
    return;
}

inline void del(int x) {
//    std::cerr << "------------ del " << x << std::endl;
    int rk = ta::getSum(pos[x]);
    int y = 0, z = 0;
    if(rk != 1) {
        y = id[ta::getKth(rk - 1)];
    }
    if(rk != ta::cnt) {
        z = id[ta::getKth(rk + 1)];
    }
    if(y) Ans::del(d[lca(x, y)]);
    if(z) Ans::del(d[lca(x, z)]);
    if(y && z) Ans::add(d[lca(y, z)]);
    ta::del(pos[x]);
    return;
}

int main() {
    
    freopen("lca.in", "r", stdin);
    freopen("lca.out", "w", stdout);
    
    register int i;
    int m;
    read(n); read(m); 
    for(int i = 1, x, y; i < n; i++) {
        read(x); read(y);
        add(x, y); add(y, x);
    }
    DFS_1(1, 0);
    prework();
    int T = n / sqrt(m);
    for(i = 1; i <= n; i++) {
        fr[i] = (i - 1) / T + 1;
    }
    for(i = 1; i <= m; i++) {
        read(ask[i].l); read(ask[i].r);
        ask[i].id = i;
    }
    std::sort(ask + 1, ask + m + 1);
    int l = 1, r = 1; ta::add(1);
    for(i = 1; i <= m; i++) {
        /*if(i % 1 == 0) {
            std::cerr << "i = " << i << std::endl;
        }*/
//        printf("i = %d [%d %d] ask [%d %d] 
", i, l, r, ask[i].l, ask[i].r);
        while(ask[i].l < l) {
            add(--l);
        } 
        while(r < ask[i].r) {
            add(++r);
        }
        while(l < ask[i].l) {
            del(l++);
        }
        while(ask[i].r < r) {
            del(r--);
        }
//        printf("Ans = %d 
", Ans::getMax());
        ans[ask[i].id] = Ans::getMax();
    }
    for(i = 1; i <= m; i++) {
        printf("%d
", ans[i]);    
    }
    return 0;
}

②：

换反回滚莫队(只有删除)，第一个数据结构换成链表。可以发现每次删掉一些节点然后按照原顺序插回来的话，可以做到O(1)前驱后继。然后第二个数据结构换成值域分块，可以O(1)修改√查询。

③：

这是一个nlog²n的做法。

考虑点x何时会被作为lca，显然就是在合并子树的时候，两个子树中各有一个点被选。

这个启发式一下，枚举小的那个子树，于是对于枚举到的每个点y，在另一棵子树中每个点被选都会导致x成为一次lca。

考虑到查询的编号总是连续的，于是只要在另一个子树中找到y的前驱后继即可。如果别的点和y有贡献，那么前驱和后继也一定有贡献。

于是我们有了O(nlogn)个点对和m个询问，全部按照左端点排序，从大到小枚举左端点，然后把点对加入。

开一个数据结构维护右端点恰为i的答案。于是答案就是一段前缀的最大值，树状数组即可。

#include <bits/stdc++.h>

using namespace std;

const int maxn = 80010;
int n,m,head[maxn],to[maxn * 2],nextt[maxn * 2],tot = 1,deep[maxn],cnt,ans[maxn],c[maxn];
set<int> S[maxn];

struct node
{
    int x,y,v;
}e[2000010],q[2000010];

inline int read()
{
    int x = 0;
    char ch = getchar();
    while (ch < '0' || ch > '9')
        ch = getchar();
    while (ch >= '0' && ch <= '9')
    {
        x = (x << 3) + (x << 1) + ch - '0';
        ch = getchar();
    }
    return x;
}

inline void add(int x,int y)
{
    to[tot] = y;
    nextt[tot] = head[x];
    head[x] = tot++;
}

inline void Merge(int x,int y)
{
    if (S[x].size() < S[y].size())
        S[x].swap(S[y]);
    for (set<int>::iterator it = S[y].begin(); it != S[y].end(); ++it)
    {
        int temp = (*it);
        S[x].insert(temp);
        set<int>::iterator it2 = S[x].find(temp);
        if (it2 != S[x].begin())
        {
            --it2;
            ++cnt;
            e[cnt].x = (*it2);
            e[cnt].y = temp;
            e[cnt].v = deep[x];
        }
        it2 = S[x].find(temp);
        ++it2;
        if (it2 != S[x].end())
        {
            ++cnt;
            e[cnt].x = temp;
            e[cnt].y = (*it2);
            e[cnt].v = deep[x];
        }
    }
    S[y].clear();
}

void dfs(int u,int faa)
{
    deep[u] = deep[faa] + 1;
    S[u].insert(u);
    for (register int i = head[u];i;i = nextt[i])
    {
        int v = to[i];
        if (v == faa)
            continue;
        dfs(v,u);
        Merge(u,v);
    }
}

inline void Add(int x,int v)
{
    while (x <= n)
    {
        c[x] = max(c[x],v);
        x += x & (-x);
    }
}

inline int Query(int x)
{
    int res = 0;
    while (x)
    {
        res = max(res,c[x]);
        x -= x & (-x);
    }
    return res;
}

inline bool cmp(node a,node b)
{
    return a.x > b.x;
}

int main()
{
    freopen("lca.in","r",stdin);
    freopen("lca.out","w",stdout);
    n = read(),m = read();
    for (register int i = 1; i < n; i++)
    {
        int x,y;
        x = read(),y = read();
        add(x,y);
        add(y,x);
    }
    dfs(1,0);
    for (register int i = 1; i <= m; i++)
    {
        q[i].x = read(),q[i].y = read();
        q[i].v = i;
    }
    sort(q + 1,q + 1 + m,cmp);
    sort(e + 1,e + 1 + cnt,cmp);
    int cur = 1;
    for (register int i = 1; i <= m; i++)
    {
        while (cur <= cnt && e[cur].x >= q[i].x)
        {
            Add(e[cur].y,e[cur].v);
            cur++;
        }
        ans[q[i].v] = Query(q[i].y);
    }
    for (register int i = 1; i <= m; i++)
        printf("%d
",ans[i]);
    
    return 0;
}

可以用树套树做到在线。

④：

这是一个上界nlog²n的做法。参考资料。