POJ3246-Balanced Lineup,好经典的题，做法和HDU-I hate it 一样~~

Balanced Lineup

Time Limit: 5000MS		Memory Limit: 65536K
Case Time Limit: 2000MS

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

Source

USACO 2007 January Silver

     看到很多PPT博客啥的都将这题作为例题，然后，，，看了看样例，没忍住把它A了，这应该算是线段数简单区间查询题了，做过HDU-I hate it 这道题问题就不大；题意就是给你N 个数，Q次查询，每次输入两个数代表区间，问区间内最大值与最小值的差，大概就是这样，没看题，看样例然后就。。。。。A了；

      上代码：

            

#include<cstdio>
#include<algorithm>
#include<iostream>
#include<cstring>
#include<cmath>
using namespace std;
const int N=50000+10;
struct node
{
    int l,r;
    int maxx,minn;//存放最大值与最小值；
} a[N<<2];
void build(int l,int r,int k)
{
    if(l==r)
    {
        a[k].r=a[k].l=l;
        a[k].maxx=a[k].minn=0;初始化；
        return ;
    }
    int mid=(l+r)/2;
    a[k].r=r,a[k].l=l;
    build(l,mid,2*k);//左子树；
    build(mid+1,r,2*k+1);//右子树；
}
void insert(int d,int n,int k)
{
    if(a[k].l==a[k].r&&a[k].l==d)
    {
        a[k].maxx=n;
        a[k].minn=n;//叶节点最大值与最小值就是本身，然后重要的在下面的回溯里；
        return ;
    }
    int mid=(a[k].l+a[k].r)/2;
    if(d<=mid) insert(d,n,2*k);
    else  insert(d,n,2*k+1);
    a[k].maxx=max(a[k*2].maxx,a[k*2+1].maxx);
    a[k].minn=min(a[k*2].minn,a[k*2+1].minn);//回溯使得父亲节点分别存储最大最小值；
}
int qmax(int l,int r,int k)
{
    if(a[k].l==l&&a[k].r==r)
        return a[k].maxx;
    int mid=(a[k].l+a[k].r)/2;
    if(r<=mid) return qmax(l,r,2*k);
    if(l>mid) return qmax(l,r,2*k+1);
    return max(qmax(l,mid,2*k),qmax(mid+1,r,2*k+1));
}
int qmin(int l,int r,int k)
{
    if(a[k].l==l&&a[k].r==r)
        return a[k].minn;
    int mid=(a[k].l+a[k].r)/2;
    if(r<=mid) return qmin(l,r,2*k);
    if(l>mid) return qmin(l,r,2*k+1);
    return min(qmin(l,mid,2*k),qmin(mid+1,r,2*k+1));
}
int main()
{
    int n,m,q,i;
    scanf("%d%d",&n,&q);
    build(1,n,1);
    for(i=1; i<=n; i++)
    {
        scanf("%d",&m);
        insert(i,m,1);
    }
    int x,y;
    while(q--)
    {
        scanf("%d%d",&x,&y);
        if(x==y)
            printf("0\n");//节约点时间特判了一下<img alt="大笑" src="http://static.blog.csdn.net/xheditor/xheditor_emot/default/laugh.gif" />
        else
        printf("%d\n",qmax(x,y,1)-qmin(x,y,1));//查询是可以放在一个函数的，不过没用void
    }
    return 0;
}

转载于:https://www.cnblogs.com/nyist-TC-LYQ/p/7208269.html