RMQ

先百度一段..,

RMQ (Range Minimum/Maximum Query)问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中下标在i,j里的最小(大）值，也就是说，RMQ问题是指求区间最值的问题。

主要方法及复杂度如下：
1、朴素（即搜索），O(n)-O(qn) online。
2、线段树，O(n)-O(qlogn) online。
3、ST（实质是动态规划），O(nlogn)-O(q) online。
ST算法（Sparse Table），以求最大值为例，设d[i,j]表示[i,i+2^j-1]这个区间内的最大值，那么在询问到[a,b]区间的最大值时答案就是max(d[a,k], d[b-2^k+1,k])，其中k是满足2^k<=b-a+1(即长度)的最大的k,即k=[ln(b-a+1)/ln(2)]。
d的求法可以用动态规划，d[i, j]=max(d[i, j-1],d[i+2^(j-1), j-1])。
4、RMQ标准算法：先规约成LCA（Lowest Common Ancestor），再规约成约束RMQ，O(n)-O(q) online。
首先根据原数列，建立笛卡尔树，从而将问题在线性时间内规约为LCA问题。LCA问题可以在线性时间内规约为约束RMQ，也就是数列中任意两个相邻的数的差都是+1或-1的RMQ问题。约束RMQ有O(n)-O(1)的在线解法，故整个算法的时间复杂度为O(n)-O(1)。这个以后在谈，主要想谈谈神奇的ST算法

线段树的方法比较简单，O(n)建树，然后维护最大值,logn查询。

然后是神奇的ST算法，个人觉得这个方法和在线倍增LCA有点类似，事实上和LCA是可以规约到RMQ问题的，用序列建立笛卡尔树，则RMQ就成了LCA。

ST实质是动态规划，上面的百科已经描述的比较详细了，poj3264就是一个裸的RMQ，可以用ST来解决

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <math.h>
using namespace std;
const int maxn = 50050;
const double eps = 1e-5;

int maxx[maxn][20],minn[maxn][20],num[maxn];

int main()
{
    int n,q,u,v,l,r;
    while(~scanf("%d%d",&n,&q)){
        for(int i = 1;i <= n;i++) scanf("%d",&num[i]);
        for(int i = 1;i <= n;i++) maxx[i][0] = minn[i][0] = num[i];
        for(int j = 1;j < 20;j++){
                int k = 1<<(j-1);
            for(int i = 1;i <= n;i++){
                if(i + (k<<1) - 1 <= n){    //如果在范围之内
                maxx[i][j] = max(maxx[i][j-1],maxx[i+k][j-1]);
                minn[i][j] = min(minn[i][j-1],minn[i+k][j-1]);
                }
                else break;
            }
        }
        while(q--){
            scanf("%d%d",&u,&v);
            int k = v - u + 1;
            k = log((double)k)/log((double)2) + eps;
            l = min(minn[u][k],minn[v-(1<<k)+1][k]);
            r = max(maxx[u][k],maxx[v-(1<<k)+1][k]);
            cout<<r - l<<endl;
        }
    }
    return 0;
}

其实ST核心思想在于将区间长度分为了最接近它的长度的2的次幂和另外一个比较小的数字，所以只要区间的值具有能够合并的特点都可以使用这样的思想，例如维护区间段的LCA，LCA的特点在于它一定是两段各自LCA的父节点或本身。例如hdu5266

#pragma comment(linker, "/STACK:102400000,102400000")
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;

const int N = 3e5+5;
typedef long long LL;

int n, q;
int head[N], cnt;
struct Edge {
    int v, next;
}edge[N<<1];

int par[N][30];
int dep[N];
int d[N];
int rmq[N][30];

void init() {
    memset(head, -1, sizeof(head));
    cnt = 0;
}

Edge t;
void addEdge(int u, int v) {
    t.v = v, t.next = head[u];
    edge[cnt] = t;
    head[u] = cnt++;
}

void dfs(int u, int p, int d) {
    dep[u] = d; par[u][0] = p;
    for(int i = head[u];i != -1; i = edge[i].next) {
        int v = edge[i].v;
        if(v == p) continue;
        dfs(v, u, d+1);
    }
}
    
int lca(int u, int v) {
    if(dep[u] > dep[v]) swap(u, v);
    for(int i = 0;i < 20; i++) {
        if(((dep[v]-dep[u])>>i) & 1)
            v = par[v][i];
    }
    if(u == v) return v;
    for(int k = 20;k >= 0; k--)
        if(par[v][k] != par[u][k]) {
            u = par[u][k];
            v = par[v][k];
        }
    return par[u][0];
}

int query(int l, int r) {
    int len = r-l+1;
    int k = 0;
    while((1<<(k+1)) <= len) k++;
    return lca(rmq[l][k], rmq[r-(1<<k)+1][k]);
}
    
int main() {
    while(scanf("%d", &n) != EOF) {
        init();
        int u, v;
        for(int i = 0;i < n-1; i++) {
            scanf("%d%d", &u, &v);
            addEdge(u, v);
            addEdge(v, u);
        }

        dfs(1, -1, 0);
        for(int i = 0;i+1<20; i++) {
            for(int u = 1;u <= n; u++) {
                if(par[u][i] < 0) par[u][i+1] = -1;
                else par[u][i+1] = par[par[u][i]][i];
            }
        }
        for(int i = 1;i <= n; i++) rmq[i][0] = i;
        for(int k = 0;k < 20; k++) 
            for(int i = 1;i <= n; i++) {
                if(i+(1<<(k+1))-1 > n) break;
                rmq[i][k+1] = lca(rmq[i][k], rmq[i+(1<<k)][k]);
                //cout<<rmq[i][k+1]<<endl;
            }
        //cout<<rmq[2][2]<<endl;
        scanf("%d", &q);
        int l, r;
        while(q--) {
            scanf("%d%d", &l, &r);
            printf("%d\n", query(l, r));
        }
    }
    return 0;
}