RMQ 学习笔记

转载自：http://hi.baidu.com/diannaochina/blog/item/48dfff33c3c36840ad4b5fb5.html

一、最近公共祖先(Least Common Ancestors)

对于有根树T的两个结点u、v，最近公共祖先LCA(T,u,v)表示一个结点x，满足x是u、v的祖先且x的深度尽可能大。另一种理解方式是把T理解为一个无向无环图，而LCA(T,u,v)即u到v的最短路上深度最小的点。

这里给出一个LCA的例子：
例一

对于T=<V,E>

V={1,2,3,4,5}

E={(1,2),(1,3),(3,4),(3,5)}

则有：

LCA(T,5,2)=1

LCA(T,3,4)=3

LCA(T,4,5)=3

二、RMQ问题(Range Minimum Query)

RMQ问题是指：对于长度为n的数列A，回答若干询问RMQ(A,i,j)(i,j<=n)，返回数列A中

下标在[i,j]里的最小值下标。这时一个RMQ问题的例子：

例二

对数列：5,8,1,3,6,4,9,5,7 有：

RMQ(2,4)=3

RMQ(6,9)=6


RMQ问题与LCA问题的关系紧密，可以相互转换，相应的求解算法也有异曲同工之妙。

下面给出LCA问题向RMQ问题的转化方法。

对树进行深度优先遍历，每当“进入”或回溯到某个结点时，将这个结点的深度存入数组

E最后一位。同时记录结点i在数组中第一次出现的位置(事实上就是进入结点i时记录的

位置)，记做R[i]。如果结点E[i]的深度记做D[i]，易见，这时求LCA(T,u,v)，就等价于求

E[RMQ(D,R[u],R[v])]，(R[u]<R[v])。例如，对于第一节的例一，求解步骤如下：

数列E[i]为：1,2,1,3,4,3,5,3,1

R[i]为：1,2,4,5,7

D[i]为：0,1,0,1,2,1,2,1,0

于是有：

LCA(T,5,2) = E[RMQ(D,R[2],R[5])] = E[RMQ(D,2,7)] = E[3] = 1

LCA(T,3,4) = E[RMQ(D,R[3],R[4])] = E[RMQ(D,4,5)] = E[4] = 3

LCA(T,4,5) = E[RMQ(D,R[4],R[5])] = E[RMQ(D,5,7)] = E[6] = 3



易知，转化后得到的数列长度为树的结点数的两倍加一，所以转化后的RMQ问题与LCA

问题的规模同次。

LCA转化为RMQ问题的实现：

int D[N], E[N], R[N];

class RMQ {
public:
    int Min[N][20];
    void build(int n) {
        int i, j, m;
        for(i = 1; i <= n; ++i) Min[i][0] = i;
        m = int(log(double(n))/log(2.0));
        FOR(j, 1, m) {
            FOR(i, 1, n - (1<<j) + 1) {
                if(D[Min[i][j-1]] < D[Min[i+(1<<(j-1))][j-1]]) {
                    Min[i][j] = Min[i][j-1];
                } else {
                    Min[i][j] = Min[i+(1<<(j-1))][j-1];
                }

            }
        }
    }

    int query(int s, int e) {
        int k = log(double(e - s + 1))/log(2.0);
        if(D[Min[s][k]] < D[Min[e-(1<<k) + 1][k]])   return  Min[s][k];
        else    return Min[e-(1<<k) + 1][k];
    }
} Q;

vector<int> g[N];

int in[N], cnt;
bool vis[N];

void init(int n) {
    CL(in, 0); CL(D, 0);
    CL(E, 0); CL(R, 0);
    CL(vis, 0); cnt = 1;
    for(int i = 1; i <= n; ++i) {
        g[i].clear();
    }
}

void dfs(int t, int dep) {
    if(!vis[t]) {
        R[t] = cnt;
        vis[t] = true;
    }

    D[cnt] = dep;
    E[cnt++] = t;
    for(int i = 0; i < int(g[t].size()); ++i) {
        dfs(g[t][i], dep + 1);
        D[cnt] = dep;
        E[cnt++] = t;
    }
}

int main() {
    //freopen("data.in", "r", stdin);

    int t, i, n, x, y;
    scanf("%d", &t);
    while(t--) {

        scanf("%d", &n);
        init(n);
        REP(i, n - 1) {
            scanf("%d%d", &x, &y);
            g[x].push_back(y);
            in[y]++;
        }
        FOR(i, 1, n) {
            if(in[i] == 0)  {
                dfs(i, 0);
                break;
            }
        }
        cnt--;
        Q.build(cnt);

        scanf("%d%d", &x, &y);
        x = R[x], y = R[y];
        if(x > y)   swap(x, y);
        printf("%d\n", E[Q.query(x, y)]);
    }
    return 0;
}

RMQ问题以及ST算法
        RMQ(Range Minimum/Maximum Query)问题是求区间最值问题。你当然可以写个O(n)的（怎么写都可以吧=_=),但是万一要询问最值1000000遍，估计你就要挂了。这时候你可以放心地写一个线段树（前提是不写错）O（logn)的复杂度应该不会挂。但是，这里有更牛的算法，就是ST算法，它可以做到O(nlogn)的预处理，O(1)！！！地回答每个询问。
        来看一下ST算法是怎么实现的(以最大值为例）：
       
        首先是预处理，用一个DP解决。设a[i]是要求区间最值的数列，f[i,j]表示从第i个数起连续2^j个数中的最大值。例如数列3 2 4 5 6 8 1 2 9 7 ,f[1，0]表示第1个数起，长度为2^0=1的最大值，其实就是3这个数。f[1，2]=5，f[1，3]=8，f[2，0]=2，f[2，1]=4……从这里可以看出f[i,0]其实就等于a[i]。这样，Dp的状态、初值都已经有了，剩下的就是状态转移方程。我们把f[i，j]平均分成两段（因为f[i，j]一定是偶数个数字），从i到i+2^(j-1)-1为一段，i+2^(j-1)到i+2^j-1为一段(长度都为2^（j-1）)。用上例说明，当i=1，j=3时就是3,2,4,5 和 6,8,1,2这两段。f[i，j]就是这两段的最大值中的最大值。于是我们得到了动规方程F[i,j]=max（F[i，j-1],F[i+2^(j-i)，j-1]）.
     
接下来是得出最值，也许你想不到计算出f[i，j]有什么用处，一般毛想想计算max还是要O(logn)，甚至O(n)。但有一个很好的办法，做到了O（1）。还是分开来。如在上例中我们要求区间[2，8]的最大值，就要把它分成[2,5]和[5,8]两个区间，因为这两个区间的最大值我们可以直接由f[2，2]和f[5，2]得到。扩展到一般情况，就是把区间[l，r]分成两个长度为2^n的区间（保证有f[i，j]对应）。直接给出表达式：
k:=trunc(l(r-l+1)/ln(2));
ans:=max(F[l，k],F[r-2^k+1,k]);

我的RMQ模板 POJ 3264:

#include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <stack>
#include <cmath>
#include <algorithm>


#define CL(arr, val)    memset(arr, val, sizeof(arr))
#define REP(i, n)       for(i = 0; i < n; ++i)
#define FOR(i, l, h)    for(i = l; i <= h; ++i)
#define FORD(i, h, l)   for(i = h; i >= l; --i)
#define L(x)    x << 1
#define R(x)    x << 1 | 1
#define MID(l, r)  (l + r) >> 1
typedef long long LL;

using namespace std;

const int N = 50010;

int Max[N][20];
int Min[N][20];
int num[N], n;

void init() {
    int i, j, m;
    FOR(i, 1, n) {
        Max[i][0] = num[i];
        Min[i][0] = num[i];
    }
    m = int(log(double(n))/log(2.0));
    FOR(j, 1, m){
        FOR(i, 1, n - (1<<j) + 1) {
            Max[i][j] = max(Max[i][j-1], Max[i+ (1<<(j-1))][j-1]);
            Min[i][j] = min(Min[i][j-1], Min[i+ (1<<(j-1))][j-1]);
        }
    }
}

int solve(int s, int e) {
    int k = log(double(e - s + 1))/log(2.0);
    int x = max(Max[s][k], Max[e - (1<<k) + 1][k]);
    int y = min(Min[s][k], Min[e - (1<<k) + 1][k]);
    return x - y;
}

int main() {
    //freopen("data.in", "r", stdin);

    int q, i, a, b;
    CL(Max, 0);
    CL(Min, 0);
    scanf("%d%d", &n, &q);
    FOR(i, 1, n)    scanf("%d", num + i);
    init();
    while(q--) {
        scanf("%d%d", &a, &b);
        printf("%d\n", solve(a, b));
    }
    return 0;
}