SDUT 3302——效率至上

效率至上
Time Limit: 5000 ms Memory Limit: 65536 KiB
Submit Statistic
Problem Description

题意很简单,给出一个数目为n的非有序序列,然后有m次查询.对于每次查询输入两个正整数l,r请输出区间[l,r]的最大值与最小值的差值
Input

第一行：输入两个正整数n,m (1<=n<=50000, 1<=m<=200000 )；
第二行：输入n个整数 大小范围为[1,100000];
接下来的m行,每次两个正整数l,r (1<=l<=r<=n);
Output

输出区间[l,r]最大值与最小值的差值.
Sample Input

6 3
1
7
3
4
2
5
1 5
4 6
2 2
Sample Output

6
3
0

**#include <iostream>
#include <bits/stdc++.h>
#define inf 9999999
using namespace std;

struct node
{
    int l,r;
    int ma,mi;
};
node tree[200000];
int n[200000];

void built(int l,int r,int t)
{
    tree[t].l=l;
    tree[t].r=r;
    if(l==r)
    {
        tree[t].ma=tree[t].mi=n[l];
    }
    else
    {
        int mid=(l+r)/2;
        built(l,mid,2*t);
        built(mid+1,r,2*t+1);
        tree[t].ma=max(tree[2*t].ma,tree[2*t+1].ma);
        tree[t].mi=min(tree[2*t].mi,tree[2*t+1].mi);
    }
}

int findmax(int l,int r,int t)
{
    int i=tree[t].l;
    int j=tree[t].r;
    if(i>r||j<l)
    {
        return 0;
    }
    l=max(i,l);
    r=min(r,j);
    if(i==l&&r==j)
    {
        return tree[t].ma;
    }
      return max(findmax(l,r,2*t),findmax(l,r,2*t+1));
}

int findmin(int l,int r,int t)
{
    int i=tree[t].l;
    int j=tree[t].r;
    if(i>r||j<l)
    {
        return inf;
    }
    l=max(i,l);
    r=min(r,j);
    if(i==l&&r==j)
    {
        return tree[t].mi;
    }
    return min(findmin(l,r,2*t),findmin(l,r,2*t+1));
}

int main()
{
    int a,b,c,d,i;
    cin >> a >> b;
    for(i=1;i<=a;i++)
    {
        cin >> n[i];
    }
    built(1,a,1);
    while(b--)
    {
        cin >> c >> d;
        cout << findmax(c,d,1)-findmin(c,d,1) << endl;
    }
    return 0;
}
**

**#include <iostream>
#define INF 999999
using namespace std;

struct node
{
    int l, r;
    int Max, Min;
};

int Begin[1000001];
struct node tree[1000001];

void Buildtree(int root, int l, int r)
{
    tree[root].l = l;
    tree[root].r = r;
    if(l == r)
    {
        tree[root].Max = tree[root].Min = Begin[l];
    }
    else
    {
        int mid = (l + r) / 2;
        Buildtree(2 * root, l, mid);
        Buildtree(2 * root + 1, mid + 1, r);
        tree[root].Max = max(tree[2*root].Max, tree[2*root+1].Max);
        tree[root].Min = min(tree[2*root].Min, tree[2*root+1].Min);
    }
}

int FindMax(int root, int l, int r)
{
    int i = tree[root].l, j = tree[root].r;
    if(i > r||j < l)
    {
        return 0;
    }
    l = max(l, i);
    r = min(r, j);
    if(i == l && j == r)
    {
        return tree[root].Max;
    }
    return max(FindMax(2*root, l, r), FindMax(2*root+1, l, r));
}

int FindMin(int root, int l, int r)
{
    int i = tree[root].l, j = tree[root].r;
    if(i > r || j < l)
    {
        return INF;
    }
    l = max(l, i);
    r = min(r, j);
    if(i == l && j == r)
    {
        return tree[root].Min;
    }
    return min(FindMin(2*root, l, r), FindMin(2*root+1, l, r));
}

int main()
{
    int i, n, m;
    cin >> n >> m;
    for(i=1; i<=n; i++)
    {
        cin >> Begin[i];
    }
    Buildtree (1, 1, n);
    while(m--)
    {
        int l, r;
        cin >> l >> r;
        cout << FindMax(1, l, r)-FindMin(1, l, r) << endl;;
    }
    return 0;
}
**