poj_3264_Balanced Lineup(线段树)

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

题目大意:求区间中最大值和最小值之间的差；

题目思路：用线段树，开一个域用来存储该区间的最大值和最小值

题目：

Balanced Lineup

Time Limit: 5000MS		Memory Limit: 65536K
Total Submissions: 25981		Accepted: 12134
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

代码：用结构体g++会超时，C++不会超时：
结构体：

#include<iostream>
#include<stdio.h>
using namespace std;
struct Node
{
int   left,right;  //区间左右值
Node   *leftchild;
Node   *rightchild;
int minn;
int maxx;
};
Node   *build(int   l ,  int r ) //建立二叉树
{
Node   *root = new Node;
root->left = l;
root->right = r;     //设置结点区间
root->leftchild = NULL;
root->rightchild = NULL;
if(l==r)
{
int tmp;
scanf("%d\n",&tmp);
root->minn=root->maxx=tmp;
return root;
}
if ( l +1<=r )
{
int  mid = (r+l) >>1;
root->leftchild = build ( l , mid ) ;
root->rightchild = build ( mid+1  , r) ;
}
root->maxx=max(root->leftchild->maxx,root->rightchild->maxx);
root->minn=min(root->leftchild->minn,root->rightchild->minn);
return   root;
}
int querymax(int l,int r,int low,int high,Node *root)
{
if(low<=l&&r<=high)
{
return root->maxx;
}
int mid=(l+r)>>1;
int m=0;
if(low<=mid)
m=max(m,querymax(l,mid,low,high,root->leftchild));
if(high>mid)
m=max(m,querymax(mid+1,r,low,high,root->rightchild));
return m;
}
int querymin(int l,int r,int low,int high,Node *root)
{
if(low<=l&&r<=high)
{
return root->minn;
}
int mid=(l+r)>>1;
int m=1000005;
if(low<=mid)
m=min(m,querymin(l,mid,low,high,root->leftchild));
if(high>mid)
m=min(m,querymin(mid+1,r,low,high,root->rightchild));
return m;
}
int main()
{
int n,q;
int s,e;
scanf("%d%d",&n,&q);
Node *root=build(1,n);
for(int i=1;i<=q;i++)
{
scanf("%d%d",&s,&e);
printf("%d\n",querymax(1,n,s,e,root)-querymin(1,n,s,e,root));
}
return 0;
}

数组：

#include<stdio.h>
#include<iostream>
using namespace std;
int ma[200005];
int mi[200005];//数组开到4倍
void build(int l,int r,int rt)
{
if(l==r)
{
scanf("%d",&ma[rt]);
mi[rt]=ma[rt];
return ;
}
int m=(l+r)>>1;
build(l,m,rt<<1);
build(m+1,r,rt<<1|1);
ma[rt]=max(ma[rt<<1],ma[rt<<1|1]);
mi[rt]=min(mi[rt<<1],mi[rt<<1|1]);
}
int queryma(int L,int R,int l,int r,int rt)
{
if(L<=l&&R>=r)
return ma[rt];
int m=(l+r)>>1;
int ret=0;
if(L<=m)
ret=max(ret,queryma(L,R,l,m,rt<<1));
if(R>m)
ret=max(ret,queryma(L,R,m+1,r,rt<<1|1));
return ret;
}
int querymi(int L,int R,int l,int r,int rt)
{
if(L<=l&&R>=r)
return mi[rt];
int m=(l+r)>>1;
int ret=1000005;
if(L<=m)
ret=min(ret,querymi(L,R,l,m,rt<<1));
if(R>m)
ret=min(ret,querymi(L,R,m+1,r,rt<<1|1));
return ret;
}
int main()
{
int n,m,s,e;
scanf("%d%d",&n,&m);
build(1,n,1);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&s,&e);
printf("%d\n",queryma(s,e,1,n,1)-querymi(s,e,1,n,1));
}
return 0;
}
/*
6 3
1
7
3
4
2
5
1 5
4 6
2 2
*/