poj 3246 Balanced Lineup (RMQ)

题目链接：点击打开链接

Description

For the daily milking, Farmer John's N cows (1 ≤ N ≤ 50,000) always line up in the same order. One day Farmer John decides to organize a game of Ultimate Frisbee with some of the cows. To keep things simple, he will take a contiguous range of cows from the milking lineup to play the game. However, for all the cows to have fun they should not differ too much in height.

Farmer John has made a list of Q (1 ≤ Q ≤ 200,000) potential groups of cows and their heights (1 ≤ height ≤ 1,000,000). For each group, he wants your help to determine the difference in height between the shortest and the tallest cow in the group.

Input

Line 1: Two space-separated integers, N and Q. 
Lines 2..N+1: Line i+1 contains a single integer that is the height of cow i 
Lines N+2..N+Q+1: Two integers A and B (1 ≤ A ≤ B ≤ N), representing the range of cows from A to B inclusive.

Output

Lines 1..Q: Each line contains a single integer that is a response to a reply and indicates the difference in height between the tallest and shortest cow in the range.

Sample Input

6 3
1
7
3
4
2
5
1 5
4 6
2 2

Sample Output

6
3
0

题意：有一个数组序列，长度为n ,有q次查询，每次查询给出数组的区间数，求出该区间的最大值和最小值只差．

ps:典型的RMQ,堆来建线段数会更易懂一些．用链表的话我想代码会短的多，因为可以在结构体中直接定义最大值和最小值，查询和建树都省略的一些．我用堆做的，以前接触过的，就用习惯的，但是对于区间和查询和修改就习惯用链表了．定义了两个数组，一个建区间最大值，一个建区间最小值，查询和建树都是两次，可能繁琐点，但对于我这种初学者的菜鸟来说比较好懂一些，更加直观一些．注意数组开大一点，RE了一次．

<span style="font-size:18px;">#include <iostream>
#include<cstring>
#include<cstdio>
using namespace std;
int A[500050];
int M[1000000];
int N[1000000];
void buildmin(int node,int b,int e,int M[],int A[])
{
    if(b==e)M[node]=A[b];
    else
    {
        buildmin(2*node,b,(b+e)/2,M,A);
        buildmin(2*node+1,(b+e)/2+1,e,M,A);
        if(M[2*node]<=M[2*node+1]) M[node]=M[2*node];
        else M[node]=M[2*node+1];
    }
}
void buildmax(int node,int b,int e,int N[],int A[])
{
    if(b==e)N[node]=A[b];
    else
    {
        buildmax(2*node,b,(b+e)/2,N,A);
        buildmax(2*node+1,(b+e)/2+1,e,N,A);
        if(N[2*node]>=N[2*node+1])N[node]=N[2*node];
        else N[node]=N[2*node+1];
    }
}
int querymin(int node,int b,int e,int M[],int A[],int i,int j)
{
    int p1,p2;
    if(i>e||j<b)return -1;
    if(b>=i&&e<=j)return M[node];
    p1=querymin(2*node,b,(b+e)/2,M,A,i,j);
    p2=querymin(2*node+1,(b+e)/2+1,e,M,A,i,j);
    if(p1==-1)return p2;
    if(p2==-1)return p1;
    if(p1>=p2)return p2;
    return p1;
}
int querymax(int node,int b,int e,int N[],int A[],int i,int j)
{
    int p1,p2;
    if(i>e||j<b)return -1;
    if(b>=i&&e<=j)return N[node];
    p1=querymax(2*node,b,(b+e)/2,N,A,i,j);
    p2=querymax(2*node+1,(b+e)/2+1,e,N,A,i,j);
    if(p1==-1)return p2;
    if(p2==-1)return p1;
    if(p1>=p2)return p1;
    return p2;
}
int main()
{
    int n,q;
    scanf("%d%d",&n,&q);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&A[i]);
    }
    buildmin(1,1,n,M,A);
    buildmax(1,1,n,N,A);
    int a,b;
    for(int i=0;i<q;i++)
    {
        scanf("%d%d",&a,&b);
        int smin=querymin(1,1,n,M,A,a,b);
        int smax=querymax(1,1,n,N,A,a,b);
        printf("%d\n",smax-smin);
    }
    return 0;
}
</span>