poj 3264 Balanced Lineup(线段树、RMQ)

题目链接: http://poj.org/problem?id=3264

思路分析：

典型的区间统计问题,要求求出某段区间中的极值，可以使用线段树求解。

在线段树结点中存储区间中的最小值与最大值；查询时使用线段树的查询

方法并稍加修改即可进行查询区间中最大与最小值的功能。

代码(线段树解法)：

#include <limits>
#include <cstdio>
#include <iostream>
using namespace std;
 
const int MAX_N = ;
const int N_VAL =  + ;
struct SegTreeNode
{
    int valMin, valMax;
};
 
SegTreeNode segTree[MAX_N];
int val[N_VAL];
int valMax, valMin;
 
int Max(int a, int b) { return a > b ? a : b; }
int Min(int a, int b) { return a > b ? b : a; }
void Build(int root, int nbegin, int nend, int arr[])
{
    if (nbegin == nend)
    {
        segTree[root].valMax = arr[nbegin];
        segTree[root].valMin = arr[nbegin];
    }
    else
    {
        int mid = (nbegin + nend) / ;
 
        Build( * root, nbegin, mid, arr);
        Build( * root + , mid + , nend, arr);
        segTree[root].valMax = Max(segTree[ * root].valMax, segTree[ * root + ].valMax);
        segTree[root].valMin = Min(segTree[ * root].valMin, segTree[ * root + ].valMin);
    }
}
 
void Query(int root, int nbegin, int nend, int qbegin, int qend)
{
    if (nbegin > qend || nend < qbegin)
        return;
    if (qbegin <= nbegin && qend >= nend)
    {
        if (valMax < segTree[root].valMax)
            valMax = segTree[root].valMax;
        if (valMin > segTree[root].valMin)
            valMin = segTree[root].valMin;
        return;
    }
 
    int mid = (nbegin + nend) / ;
 
    Query( * root, nbegin, mid, qbegin, qend);
    Query( * root + , mid + , nend, qbegin, qend);
}
 
int main()
{
    int qbegin, qend;
    int count = , N, Q;
 
    scanf("%d%d", &N, &Q);
    while (count++ < N)
        scanf("%d", &val[count]);
 
    Build(, , N, val);
    while (Q--)
    {
        valMax = INT_MIN, valMin = INT_MAX;
        scanf("%d%d", &qbegin, &qend);
        Query(, , N, qbegin, qend);
        printf("%d\n", valMax - valMin);
    }
 
    return ;
}

代码(RMQ解法)：

#include <cstdio>
#include <cmath>
#include <iostream>
using namespace std;
 
const int MAX_L = ;
const int MAX_N =  + ;
int height[MAX_N];
int max_h[MAX_N][MAX_L], min_h[MAX_N][MAX_L];
 
void RmqMaxInit(int n)
{
    for (int j = ; j < MAX_L; ++j)
    {
        for (int i = ; i < n; ++i)
        {
            if (j == )
                max_h[i][j] = height[i];
            else
            {
                max_h[i][j] = max_h[i][j - ];
                int p = i + ( << (j - ));
                if (p < n)
                {
                    if (max_h[p][j - ] > max_h[i][j])
                        max_h[i][j] = max_h[p][j - ];
                }
            }
        }
    }
}
 
int RmqMaxQuery(int l, int r)
{
    if (l > r)
    {
        int temp = l;
        l = r;
        r = temp;
    }
    int k = log(r - l + ) / log();
    return max_h[l][k] > max_h[r - ( << k) + ][k] ?
        max_h[l][k] : max_h[r - ( << k) + ][k];
}
 
void RmqMinInit(int n)
{
    for (int j = ; j < MAX_L; ++j)
    {
        for (int i = ; i < n; ++i)
        {
            if (j == )
                min_h[i][j] = height[i];
            else
            {
                min_h[i][j] = min_h[i][j - ];
                int p = i + ( << (j - ));
                if (p < n)
                {
                    if (min_h[p][j - ] < min_h[i][j])
                        min_h[i][j] = min_h[p][j - ];
                }
            }
        }
    }
}
 
int RmqMinQuery(int l, int r)
{
    if (l > r)
    {
        int temp = l;
        l = r;
        r = temp;
    }
 
    int k = log(r - l + ) / log();
    return min_h[l][k] < min_h[r - ( << k) + ][k] ?
        min_h[l][k] : min_h[r - ( << k) + ][k];
}
 
int main()
{
    int num_len, query_num;
 
    scanf("%d %d", &num_len, &query_num);
    for (int i = ; i < num_len; ++i)
        scanf("%d", &height[i]);
    RmqMaxInit(num_len);
    RmqMinInit(num_len);
 
    for (int i = ; i < query_num; ++i)
    {
        int l = , r = ;
        int min_height = , max_height = ;
 
        scanf("%d %d", &l, &r);
        max_height = RmqMaxQuery(l - , r - );
        min_height = RmqMinQuery(l - , r - );
        printf("%d\n", max_height - min_height);
    }
 
    return ;
}