线段树：CDOJ1591-An easy problem A （RMQ算法和最简单的线段树模板）

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。

二、

1. 这个还可以使用RMQ算法，即区间最值查询算法，这个算法就是在区间中使用动态规划对这个区间进行预处理，倍增思想。
2. 动态规划时创建一个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)区间的最大值（倍增算法的基础运用）。
3. 当要求在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]))）.
4. 其实仔细想想，线段数和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\n",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\n",max(dp[l][r1].Max,dp[l1][r1].Max)-min(dp[l][r1].Min,dp[l1][r1].Min));
        }
    }
    return 0;
}