Balanced Lineup POJ

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 Ato 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

题意：给你长度不超过50000的数组，然后问你在指定区域内最大值于最小值的差是多少。

思路：由于要求区间类的操作，首先是线段树，而这个题就比较简单了，首先在线段树初始化时给每个节点设置两个值，分别是这个节点的最大值和最小值
。由于数据又不是很大，因此可以写两个区间求值方法，一个求最大值，一个求最小值，在相减一下就行了。

代码：

#include <cstdio>
#include <fstream>
#include <algorithm>
#include <cmath>
#include <deque>
#include <vector>
#include <queue>
#include <string>
#include <cstring>
#include <map>
#include <stack>
#include <set>
#include <sstream>
#include <iostream>
#define mod 998244353
#define eps 1e-6
#define ll long long
#define INF 0x3f3f3f3f
using namespace std;

struct node
{
    //l表示左边，r表示右边
    int l,r,mi,ma;

};
node no[500000];
int num[50000];

//初始化
//k表示当前节点的编号，l表示当前区间的左边界，r表示当前区间的右边界
void build(int k,int l,int r)
{
    no[k].l=l;
    no[k].r=r;
    //如果递归到最低点
    if(l==r)
    {
        no[k].mi=num[l];
        no[k].ma=num[l];
        return ;
    }
    //对半分
    int mid=(l+r)/2;
    //递归到左线段
    build(k*2,l,mid);
    //递归到右线段
    build(k*2+1,mid+1,r);
    //更新当前节点的值
    no[k].mi=min(no[k*2].mi,no[k*2+1].mi);
    no[k].ma=max(no[k*2].ma,no[k*2+1].ma);
}
//求区间内最小值
int querymi(int k,int l,int r)
{
    //到对应层时返回值
    if(no[k].l==l&&no[k].r==r)
    {
        return no[k].mi;
    }
    //取中值
    int mid=(no[k].l+no[k].r)/2;
    if(r<=mid)
    {
        return querymi(k*2,l,r);
    }
    else if(l>mid)
    {
        return querymi(k*2+1,l,r);
    }
    else
    {
        return min(querymi(k*2,l,mid),querymi(k*2+1,mid+1,r));
    }
}
//求区间内最大值
int queryma(int k,int l,int r)
{
    //到对应层时返回值
    if(no[k].l==l&&no[k].r==r)
    {
        return no[k].ma;
    }
    //取中值
    int mid=(no[k].l+no[k].r)/2;
    if(r<=mid)
    {
        return queryma(k*2,l,r);
    }
    else if(l>mid)
    {
        return queryma(k*2+1,l,r);
    }
    else
    {
        return max(queryma(k*2,l,mid),queryma(k*2+1,mid+1,r));
    }
}
int main()
{
    int q,n;
    scanf("%d %d",&n,&q);
    for(int i=1;i<=n;i++)
    {
        scanf("%d",&num[i]);
    }
    build(1,1,n);
    int a,b;
    for(int i=0;i<q;i++)
    {
        scanf("%d %d",&a,&b);
        printf("%d
",queryma(1,a,b)-querymi(1,a,b));
    }
}