HDUnbsp;1754nbsp;nbsp;Inbsp;Hatenbsp;It（线段树模版…

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=1754

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。

　　对于线段树中的每一个非叶子节点[a,b]，它的左儿子表示的区间为[a,(a+b)/2]，右儿子表示的区间为[(a+b)/2+1,b]。因此线段树是平衡二叉树，最后的子节点数目为N，即整个线段区间的长度。

　　使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(logN)。而未优化的空间复杂度为2N，因此有时需要离散化让空间压缩。

　　线段树至少支持下列操作：

　　Insert(t,x)：将包含在区间 int 的元素 x 插入到树t中；

　　Delete(t,x)：从线段树 t 中删除元素 x；

　　Search(t,x)：返回一个指向树 t 中元素 x 的指针。

用了数组模拟 和 结构体建树两种方法，发现数组模拟代码效率明显提高了不少……

数组模拟代码：

#include<stdio.h>
#define MAX 200008
#define Max(a,b) a>b?a:b;

struct node{
    int left,right,max;
}tree[MAX * 3];
int map[MAX];

int Build(int l,int r,int root)
{
    int a,b,mid=(l+r)/2;
    tree[root].left=l;
    tree[root].right=r;
    if(l==r)
    {
        tree[root].max=map[l];
        return map[l];
    }
    a=Build(l,mid,root*2);
    b=Build(mid+1,r,root*2+1);
    tree[root].max=Max(a,b);
    return tree[root].max;
}

int Query(int a,int b,int root)
{
    int mid=(tree[root].left+tree[root].right)/2;
    if(a==tree[root].left && b==tree[root].right || tree[root].left==tree[root].right)
        return tree[root].max;
    if(b<=mid)
        return Query(a,b,root*2);
    else if(a>=mid+1)
        return Query(a,b,root*2+1);
    a=Query(a,mid,root*2);
    b=Query(mid+1,b,root*2+1);
    return Max(a,b);
}

int change(int a,int b,int root)
{
    int c,mid=(tree[root].left+tree[root].right)/2;
    if(tree[root].left==a && tree[root].right==a)
    {
        tree[root].max=b;
        return b;
    }
    if(a<=mid)
    c=change(a,b,root*2);
    else c=change(a,b,root*2+1);
    tree[root].max=Max(tree[root].max,c);
    return tree[root].max;
}

int main()
{
    char str[2];
    int m,n,i,a,b;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        for(i=1;i<=n;i++)
            scanf("%d",&map[i]);
        Build(1,n,1);
        for(i=1;i<=m;i++)
        {
            scanf("%s %d %d",str,&a,&b);
            if(str[0]=='Q')
                printf("%d\n",Query(a,b,1));
            else change(a,b,1);
        }
    }
    return 0;
} 

结构体建树代码：

#include<stdio.h>
#include<stdlib.h>
#define MAX 200002
#define Max(a,b) a>b?a:b

typedef struct node{
    int left,right,max;
    struct node *l,*r;
}*Tree,Node;
int map[MAX];//,ans=0;
Tree root;

Tree NEW()
{
    Tree p;
    p=(Tree)malloc(sizeof(Node));
    p->left=p->right=p->max=0;
    p->l=p->r=NULL;
//    ans++;
    return p;
}

int Build(int l,int r,Tree &p)
{
    int a,b;
    Tree s;
    if(!p){
        s=NEW();
        p=s;
    }
    if(l==r){p->left=p->right=p->max=map[l];return map[l];}
    int mid=(l+r)/2;
    p->left=l;p->right=r;
    a=Build(l,mid,p->l);b=Build(mid+1,r,p->r);
    p->max=Max(a,b);
    return p->max;
}

int Query(int l,int r,Tree p)
{
    int a,b;
    if(!p)return 0;
    if(p->left==p->right || (l==p->left&&r==p->right))return p->max;
    int mid=(p->left+p->right)/2;
    if(r<=mid)
        return Query(l,r,p->l);
    else if(l>=mid+1)
        return Query(l,r,p->r);
    a=Query(l,mid,p->l);b=Query(mid+1,r,p->r);
    return Max(a,b);
}

void change(int a,int b,Tree p)
{
    if(!p)return;
    if(p->left==p->right && p->left==a)
    {
        p->left=p->right=p->max=b;
        return;
    }
    int mid=(p->left+p->right)/2;
    if(a<=mid)
        change(a,b,p->l);
    else
        change(a,b,p->r);
    p->max=Max(p->max,b);
}

void init(Tree p)
{
    if(!p)return;
    if(p->l)
        init(p->l);
    if(p->r)
        init(p->r);
    free(p);
}

int main()
{
    char str[2];
    int n,m,i,a,b;
    while(scanf("%d%d",&n,&m)!=EOF)
    {
        init(root);
        root=NEW();
        for(i=1;i<=n;i++)
            scanf("%d",&map[i]);
        Build(1,n,root);
        for(i=0;i<m;i++)
        {
            scanf("%s %d %d",str,&a,&b);
            if(str[0]=='Q')
                printf("%d\n",Query(a,b,root));
            else change(a,b,root);
    //    printf("%d\n",ans);
        }
    }
    return 0;
}