RMQ问题-very easy-打印模板

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

主要方法及复杂度(处理复杂度和查询复杂度)如下: 
1.朴素（即搜索） O(n)-O(n) 
2.线段树(segment tree) O(n)-O(logn) 

3.ST（实质是动态规划） O(nlogn)-O(1)

ST算法（Sparse Table）:它是一种动态规划的方法。 
以最小值为例。a为所寻找的数组. 
用一个二维数组f(i,j)记录区间[i,i+2^j-1](持续2^j个)区间中的最小值。其中f[i,0] = a[i]; 
所以，对于任意的一组(i,j)，f(i,j) = min{f(i,j-1),f(i+2^(j-1),j-1)}来使用动态规划计算出来。 
这个算法的高明之处不是在于这个动态规划的建立，而是它的查询：它的查询效率是O(1). 
假设我们要求区间[m,n]中a的最小值，找到一个数k使得2^k<n-m+1.  // 求这个k值有自己的方法可以弄
这样，可以把这个区间分成两个部分：[m,m+2^k-1]和[n-2^k+1,n].我们发现，这两个区间是已经初始化好的. 
前面的区间是f(m,k)，后面的区间是f(n-2^k+1,k). 
这样，只要看这两个区间的最小值，就可以知道整个区间的最小值！ 

二维RMQ模板：

#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <set>
#include <map>

using namespace std;
const int maxn = 305;
double a[maxn][maxn],sqx[maxn][maxn],x[maxn][maxn],t[maxn],tsq[maxn];
double dp[maxn][maxn][9][9];
int m,n,q;

void rmq_2d(void)
{
    for(int row = 1 ; row <= m ; row++)
        for(int col = 1 ; col <= n ; col++)
            dp[row][col][0][0] = a[row][col];
    int t = log((double)n) / log(2.0);

    for(int i = 0 ; i <= t ; i++)
    {
        for(int j = 0 ; j <= t ; j++)
        {
            if(i == 0 && j == 0)
                continue;
            for(int row = 1 ; row+(1<<i)-1 <= m ; row++)
            {
                for(int col = 1 ; col+(1<<j)-1 <= n ; col++)
                {
                    if(i == 0)
                    {
                        dp[row][col][i][j] = max(dp[row][col][i][j-1] , dp[row][col+(1<<(j-1))][i][j-1]);
                    }
                    else
                    {
                        dp[row][col][i][j] = max(dp[row][col][i-1][j] , dp[row+(1<<(i-1))][col][i-1][j]);
                    }
                }
            }
        }
    }
}

int query_2d(int x1,int x2,int y1,int y2)
{
    int kx = log(double(x2 - x1 +1)) / log(2.0);
    int ky = log(double(y2 - y1 +1)) / log(2.0);
    double m1 = dp[x1][y1][kx][ky];
    double m2 = dp[x2-(1<<kx)+1][y1][kx][ky];
    double m3 = dp[x1][y2-(1<<ky)+1][kx][ky];
    double m4 = dp[x2-(1<<kx)+1][y2-(1<<ky)+1][kx][ky];
    double ans = max( max(m1,m2), max(m3,m4) );
    return ans;
}

void init()
{
    for(int i=1; i<=m; i++) for(int j=1; j<=n; j++) scanf("%lf",&a[i][j]);

    memset(sqx,0,sizeof(sqx));
    memset(x,0,sizeof(x));
    t[0] = tsq[0] = 0;
    for(int i=1; i<=m; i++)
    {
        for(int j=1; j<=n; j++)
        {
            t[j] = t[j-1] + a[i][j];
            tsq[j] = tsq[j-1] + a[i][j] * a[i][j];
        }
        for(int j=1; j<=n; j++)
        {
            sqx[i][j] = sqx[i-1][j] + tsq[j];
            x[i][j] = x[i-1][j] + t[j];
        }
    }
}

void Work()
{
    rmq_2d();
  //  cout << query_2d(2,4,2,4) << endl;
    scanf("%d",&q);
    while(q--)
    {
        int u,v;
        scanf("%d %d",&u,&v);
        double nn = ((double)u) * ((double)v) - 1;

        double ans = -1,tmp;
        int ansi,ansj;

        for(int i=u; i<=m; i++)
        {
            for(int j=v; j<=n; j++)
            {
                double hmax = query_2d(i-u+1,i,j-v+1,j);
                double tt = x[i][j] - x[i-u][j] - x[i][j-v] + x[i-u][j-v] - hmax;
                tmp = sqx[i][j] - sqx[i-u][j] - sqx[i][j-v] + sqx[i-u][j-v] - hmax * hmax;
                tmp -= tt * tt / nn;
                if(ans<0 || tmp<ans)
                {
                    ans = tmp;
                    ansi = i - u + 1;
                    ansj = j - v + 1;
                }
            }
        }

        printf("(%d, %d), %.2lf\n",ansi,ansj,ans/nn);
    }
}
int main()
{
    int ta = 1;
    while(scanf("%d%d",&m,&n) == 2)
    {
        printf("Case %d:\n",ta++);
        init();
        Work();
    }
    return 0;
}

#include<iostream>
#include<cmath>
#include<algorithm>
using namespace std;

#define M 100010
#define MAXN 500
#define MAXM 500
int dp[M][18];
/*
*一维RMQ ST算法
*构造RMQ数组 makermq(int n,int b[]) O(nlog(n))的算法复杂度
*dp[i][j] 表示从i到i+2^j -1中最小的一个值(从i开始持续2^j个数)
*dp[i][j]=min{dp[i][j-1],dp[i+2^(j-1)][j-1]}
*查询RMQ rmq(int s,int v)
*将s-v 分成两个2^k的区间
*即 k=(int)log2(s-v+1)
*查询结果应该为 min(dp[s][k],dp[v-2^k+1][k])
*/

void makermq(int n,int b[])
{
    int i,j;
    for(i=0;i<n;i++)
        dp[i][0]=b[i];
    for(j=1;(1<<j)<=n;j++)
        for(i=0;i+(1<<j)-1<n;i++)
            dp[i][j]=min(dp[i][j-1],dp[i+(1<<(j-1))][j-1]);
}
int rmq(int s,int v)
{
    int k=(int)(log((v-s+1)*1.0)/log(2.0));
    return min(dp[s][k],dp[v-(1<<k)+1][k]);
}

void makeRmqIndex(int n,int b[]) //返回最小值对应的下标
{
    int i,j;
    for(i=0;i<n;i++)
        dp[i][0]=i;
    for(j=1;(1<<j)<=n;j++)
        for(i=0;i+(1<<j)-1<n;i++)
            dp[i][j]=b[dp[i][j-1]] < b[dp[i+(1<<(j-1))][j-1]]? dp[i][j-1]:dp[i+(1<<(j-1))][j-1];
}
int rmqIndex(int s,int v,int b[])
{
    int k=(int)(log((v-s+1)*1.0)/log(2.0));
    return b[dp[s][k]]<b[dp[v-(1<<k)+1][k]]? dp[s][k]:dp[v-(1<<k)+1][k];
}

int main()
{
    int a[]={3,4,5,7,8,9,0,3,4,5};
    //返回下标
    makeRmqIndex(sizeof(a)/sizeof(a[0]),a);
    cout<<rmqIndex(0,9,a)<<endl;
    cout<<rmqIndex(4,9,a)<<endl;
    //返回最小值
    makermq(sizeof(a)/sizeof(a[0]),a);
    cout<<rmq(0,9)<<endl;
    cout<<rmq(4,9)<<endl;
    return 0;
}