约束RMQ

不知道为什么网上找不到太多相关的资料，所以写一个小总结，并附有能用的代码，抛砖引玉。

约束RMQ，就是RMQ区间必须满足两项之差最大为1，采用ST表的话，这时候有O(n)建表，O(1)查询的优秀复杂度

求LCA，通过DFS把原树转化为深度序列，就等价于求区间最小值 (取到的位置)

由于DFS的性质，该序列两个数之间显然相差1，所以可以使用约束RMQ解决

先总体概括一下做法：把原序列分块，块内预处理，块间做ST表

分块大小定为L=log(n)/2，这样共分D=n/L块，对这D个数（块内最小值）做正常ST表，建表复杂度O(Dlog(D))=O((n/L)(log(n)-log(L))=O(n)

我们要保证每个步骤都是O(n)的，log(n)/2的块正好消去了ST建表时的log

但在此之前，我们得处理出块内的最小值，该怎么做呢？一个正常想法就是枚举每个数，一共是O(n)复杂度

但是，这样做虽然留下了每块的最小值以及其取到的位置，若考虑查询块的一个区间，而这个区间恰好取不到最小值，这时候只能暴力枚举，就破坏了查询O(1)了

至此我们仍没有使用其±1的特殊性质，现在考虑一下。

块内一共log(n)/2个数，由乘法原理可知，本质不同的块有U=2^(log(n)/2)=n^(1/2)个，我们不妨处理出每个这种块，复杂度Ulog(n)/2，这个函数增长是小于线性的，可以认为是O(n)

这样，处理出每个块内两元素的大小关系，就可以用01唯一表示一个块了，可以用二进制存下来，作为一个块的特征，这一步复杂度O(n)

这样有一个好处，即使查询块内一个区间，我们只需要提取这个区间对应的二进制数，就可以在预处理的数组中O(1)查询了

(怎么做呢？把这段二进制数提出来，移到最右边，由于我们规定0表示小于，1表示大于，所以会贪心地选取前面的数，查表减去偏移量就可以了)

查询时，类似分块，边角的块直接查表，中间部分ST表查询，查询是O(1)的。

至此我们完成了O(n)建表，O(1)查询的约束RMQ。

一般地，对于任何一个序列，可以在O(n)时间内建成一颗笛卡尔树，把查询该序列RMQ转化为求笛卡尔树LCA，就变成O(1)的了。

想进一步提高速度，可以使用更快的log

int MYLOG (unsigned int x) {
   static const int log_2[] = {
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
     ,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,,
   };
   int l = -;
   while (x >= ) { l += ; x >>= ; }
   return l + log_2[x];
} 

解决LCA的代码：

//drunk,fix later
#include<iostream>
#include<cstdio>
#include<cmath>
#define Re register
using namespace std;

const int MAXN=;

inline int rd() {
    int ret=,f=;
    char c;
    while(c=getchar(),!isdigit(c))f=c=='-'?-:;
    while(isdigit(c))ret=ret*+c-'',c=getchar();
    return ret*f;
}

int n,m,st;

struct Edge {
    int next,to;
} e[MAXN<<];
int ecnt,head[MAXN];
inline void add(int x,int y) {
    e[++ecnt].next = head[x];
    e[ecnt].to = y;
    head[x] = ecnt;
}

int appear[MAXN],elm[MAXN],dep[MAXN],tot;
void dfs(int x,int pre) {
    appear[x]=++tot;
    elm[tot]=x;
    dep[tot]=dep[appear[pre]]+;
    for(int i=head[x]; i; i=e[i].next) {
        int v=e[i].to;
        if(v==pre) continue;
        dfs(v,x);
        elm[++tot]=x;
        dep[tot]=dep[appear[x]];
    }
}

int blockLen,num,L[MAXN],R[MAXN],bl[MAXN];
int blockTyp[MAXN],f[MAXN][],g[MAXN][];
int lookUp[MAXN];
inline int computeType(int x) {
    int sum=;
    for(Re int i=L[x]; i<=R[x]-; i++)
        sum<<=,sum+=(dep[i+]>dep[i]);
    return sum;
}

inline void calcPos(int x) {
    int len=,po=,cnt=,mn=<<,mnid;
    len=blockLen;
    for(Re int i=len; i>=; i--) {
        po++;
        if((<<i)&x) cnt++;
        else cnt--;
        if(cnt<mn) mn=cnt,mnid=po;
    }
    lookUp[x]=mnid-;
}

void build() {
    blockLen=log2(tot)/;
    num=tot/blockLen;
    if(tot%blockLen) num++;
    for(Re int i=; i<=num; i++) {
        L[i]=(i-)*blockLen+;
        R[i]=i*blockLen;
    }
    for(Re int i=tot+; i<=R[num]; i++) dep[i]=(<<);
    for(Re int i=; i<=tot; i++)bl[i]=(i-)/blockLen+;
    for(Re int i=; i*i<=tot; i++) calcPos(i);
    for(Re int i=; i<=num; i++)blockTyp[i]=computeType(i);
    for(Re int i=; i<=num; i++) g[i][]=(i-)*blockLen+lookUp[blockTyp[i]],f[i][]=dep[g[i][]]; //offset!
    for(Re int j=; (<<j)<=num; j++)
        for(Re int i=; i<=num; i++)
            if(f[i][j-]<f[i+(<<(j-))][j-]) f[i][j]=f[i][j-],g[i][j]=g[i][j-];
            else f[i][j]=f[i+(<<(j-))][j-],g[i][j]=g[i+(<<(j-))][j-];
}

inline int inBlockQuery(int x,int y) {
    int u=blockTyp[bl[x]],v=(bl[x]-)*blockLen+lookUp[u];
    if(x<=v&&v<=y) return v;
    int sav=bl[x];
    x-=L[sav]-;y-=L[sav]-;
    u>>=(blockLen-y);
    u&=(~((-)<<(y-x)));
    return (sav-)*blockLen+lookUp[u]-(blockLen-y);
}

int query(int x,int y) {
    if(bl[x]==bl[y]) return inBlockQuery(x,y);
    int mn=<<,mnid,tmp;
    tmp=inBlockQuery(x,R[bl[x]]);
    if(dep[tmp]<mn) mn=dep[tmp],mnid=tmp;
    tmp=inBlockQuery(L[bl[y]],y);
    if(dep[tmp]<mn) mn=dep[tmp],mnid=tmp;
    int l=bl[x]+,r=bl[y]-,len;
    if((r-l+>))  len=log2(r-l+);
    else return mnid;
    if(f[l][len]<mn) mn=f[l][len],mnid=g[l][len];
    if(f[r-(<<len)+][len]<mn) mn=f[r-(<<len)+][len],mnid=g[r-(<<len)+][len];
    return mnid;
}

int main() {
    n=rd();m=rd();st=rd();
    int x,y;
    for(Re int i=; i<=n-; i++) {
        x=rd();y=rd();
        add(x,y);add(y,x);
    }
    dfs(st,);build();
    for(int i=; i<=m; i++) {
        x=rd();y=rd();
        if(appear[x]>appear[y]) swap(x,y);
        printf("%d\n",elm[query(appear[x],appear[y])]);
    }
    return ;
}