An easy problem A
Time Limit: 1000/1000MS (Java/Others) Memory Limit: 65535/65535KB (Java/Others)
Problem Description
N个数排成一列，Q个询问，每次询问一段区间内的数的极差是多少。
Input
第一行两个整数N(1≤N≤50000),Q(1≤Q≤200000)。接下来一行N个整数a1 a2 a3 ….an,(1≤ai≤1000000000)。接下来Q行，每行两个整数L,R(1≤L≤R≤N)。
Output
对于每个询问输出一行，一个整数表示区间内的极差。
Sample Input
5 3
3 2 7 9 10
1 5
2 3
3 5
Sample Output
8
5
3
解题心得：
一、线段树
1. 这是一个最简单的线段树的模板，主要是入门理解线段树。当数据量比较大，需要多次询问，多次修改维护数据时，就需要使用到线段树的数据结构。线段树的每个节点代表的是一段线段，每次修改这个线段，就可以由此对每个区间进行维护，缩减时间复杂度和空间复杂度。
2. 一般线段树的空间复杂度是O(4n)，建立线段树时间复杂度是O(logn)，向上更新的时间复杂度是O(logn),询问的时间复杂度是O(logn)，如果不使用线段树就遍历硬怼时间复杂度是O(n^2)。线段树是根节点将根节点代表的线段均分为两个线段，分别是左子节点和右子节点，然后一直分下去直到一个线段的长度为1（只有一个数）对该点进行初始赋值，然后向上维护得到每一个线段的需要得到值，线段树就是尽量避免对单个的点进行操作，而是对区间进行维护，这个就避免一个点一个点的去比较，可以直接从区间上面进行操作，树形结构可以很方便的进行维护操作。
3. 就本题来说就是将整个数列按照完美二叉树的样子直接分下去，一直分到区间长度为1，这时这个节点的最大值和最小值都是他自己，然后再向上更新，向上更新的时候父节点的最大值和最小值又他的两个子节点得到，一直向上更新，时间复杂度是nlogn。
二、
- 这个还可以使用RMQ算法，即区间最值查询算法，这个算法就是在区间中使用动态规划对这个区间进行预处理，倍增思想。
- 动态规划时创建一个dp[i][j]，代表以I为起点长度为2^j次方的区间最值，它的转移方程式是dp[I][j] = max(dp[i][j-1],dp[i+2^(j-1)][j-1]),它的意思是从i开始长度为2^j区间的最大值和i+2^(j-1)和长度为2^(j-1)区间的最大值（倍增算法的基础运用）。
- 当要求在I到j的最大值的时候可以用i到i + 2 ^ x（i+ 2 ^ x < j ) 和 j - 2 ^ x到j中的最大值。（MAX = max(max(num[i],num[I+2^x]),max(num[j-2^x],num[j]))）.
- 其实仔细想想，线段数和RMQ的算法是相似的，只是实现的方法不一样，但是思想是一样的（一个二分，一个倍增）。都是将点联系起来用区间来表示。
线段树代码
#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e4+100;
struct node
{
int l,r,Max,Min;
}tree[4*maxn];//经计算生成线段树消耗的空间小于4n
int n,m,num[maxn];
//向上更新
void pushup(int root)
{
tree[root].Max = max(tree[root*2].Max,tree[root*2+1].Max);
tree[root].Min = min(tree[root*2].Min,tree[root*2+1].Min);
}
//生成线段树
void build_tree(int l,int r,int root)
{
int mid;
tree[root].l = l;
tree[root].r = r;
if(l == r)
{
tree[root].Min = tree[root].Max = num[l];
return ;
}
mid = (l+r)/2;
build_tree(l,mid,root*2);//左孩子
build_tree(mid+1,r,root*2+1);//右孩子
pushup(root);//在线段树已经建成了之后开始向上更新
}
//得到最大值
int queryMax(int l,int r,int root)
{
int mid;
if(tree[root].l == l && tree[root].r == r)
return tree[root].Max;
mid = (tree[root].l + tree[root].r) / 2;
if(r <= mid)
return queryMax(l,r,root*2);
else if(l > mid)
return queryMax(l,r,root*2+1);
else return max(queryMax(l,mid,root*2),queryMax(mid+1,r,root*2+1));
}
//得到最小值
int queryMin(int l,int r,int root)
{
int mid;
if(tree[root].l == l && tree[root].r == r)
return tree[root].Min;
mid = (tree[root].l + tree[root].r) / 2;
if(r <= mid)
return queryMin(l,r,root*2);
else if(l > mid)
return queryMin(l,r,root*2+1);
else return min(queryMin(l,mid,root*2),queryMin(mid+1,r,root*2+1));
}
int main()
{
while(scanf("%d%d",&n,&m) != EOF)
{
for(int i=1;i<=n;i++)
scanf("%d",&num[i]);
build_tree(1,n,1);
while(m--)
{
int a,b;
scanf("%d%d",&a,&b);
`
printf("%d
",queryMax(a,b,1)-queryMin(a,b,1));
}
}
}RMQ算法
#include<bits/stdc++.h>
using namespace std;
const int maxn = 5e4+100;
int num[maxn];
int n,m;
struct Dp
{
int Min;
int Max;
} dp[maxn][20];
void DP()
{
for(int j=0; j<20; j++)
{
for(int i=1; i<=n; i++)
{
if(j == 0)
{
dp[i][j].Max = dp[i][j].Min = num[i];//当就只有一个数的时候最大值和最小值都是这个数
continue;
}
if(i + (1<<(j - 1)) > n)//不能超出限制
continue;
int k = 1<<(j-1);
dp[i][j].Max = max(dp[i][j-1].Max,dp[i+k][j-1].Max);//状态转移方程式
dp[i][j].Min = min(dp[i][j-1].Min,dp[i+k][j-1].Min);
}
}
}
int main()
{
while(scanf("%d%d",&n,&m) != EOF)
{
memset(dp,0,sizeof(dp));
for(int i=1; i<=n; i++)
scanf("%d",&num[i]);
DP();
while(m--)
{
int l,r,l1,r1;
scanf("%d%d",&l,&r);
//这是将要求的区间化成两重合的可以用dp[i][j]的区间来表示，求最大值
r1 = log2(r-l+1);
l1 = r - (1<<r1) + 1;
printf("%d
",max(dp[l][r1].Max,dp[l1][r1].Max)-min(dp[l][r1].Min,dp[l1][r1].Min));
}
}
return 0;
}