线段树的简单实现

/*
sample input:
6
1 7 2 5 6 3

sample output
7
9
9
*/

#include <iostream>

using namespace std;
//N is the maximum element number of an array
const int N = 51;
const int MAXNODES=2*N;

int a[N];
struct treeNode{
    int l,r,max_;
    int lazy;//lazy_tag;=
    int pid;//index of array
    int lson(){return pid<<1;}
    int rson(){return pid<<1|1;}
    void reset(int p,int l,int r);
    void updateByVal(int val);
    void mergeQuery(int p);
    void updateFromSon();
    void giveLazyToSon();
}nodes[MAXNODES];

void treeNode::reset(int p,int l,int r){
    pid = p;
    l=l,r=r;
    //only for the son nodes
    if(l==r)
        max_ = a[l];
}

void treeNode::updateByVal(int val){
    max_ = val;
    lazy = val;
}

void treeNode::mergeQuery(int p){
    max_ = max(max_,nodes[p].max_);
}

void treeNode::updateFromSon(){
    max_ = max(max_,nodes[lson()].max_);
    mergeQuery(rson());
}

void treeNode::giveLazyToSon(){
    if(lazy){
        nodes[lson()].updateByVal(lazy);
        nodes[rson()].updateByVal(lazy);
        lazy=0;
    }
}

//interval intersect or not
bool is_intersect(int l,int r,int x,int y){
    if(r<x||y<l)
        return false;
    return true;
}

//[x,y] contain [l,r]
bool is_contain(int l,int r,int x,int y){
    if(x<=l&&y>=r)
        return true;
    return false;
}

void segtree_build(int p,int l,int r){
    nodes[p].reset(p,l,r);

    if(l<r){
        int mid=(l+r)>>1;
        segtree_build(p<<1,l,mid);
        segtree_build(p<<1|1,mid+1,r);
        nodes[p].updateFromSon();
    }
}

void segtree_insert(int p,int l,int r,int x,int y,int val){
    if(!is_intersect(l,r,x,y))
        return;

    if(is_contain(l,r,x,y)){
        nodes[p].updateByVal(val);
        return;
    }

    nodes[p].giveLazyToSon();
    int mid = (l+r)>>1;
    segtree_insert(p<<1,l,mid,x,y,val);
    segtree_insert(p<<1|1,mid+1,r,x,y,val);
    nodes[p].updateFromSon();
}

void segtree_query(int p,int l,int r,int x,int y,treeNode &ans){
    if(!is_intersect(l,r,x,y))
        return;

    if(is_contain(l,r,x,y)){
        ans.mergeQuery(p);
        return;
    }

    nodes[p].giveLazyToSon();
    int mid = (l+r)>>1;
    segtree_query(p<<1,l,mid,x,y,ans);
    segtree_query(p<<1|1,mid+1,r,x,y,ans);
    nodes[p].updateFromSon();
}

int main()
{
    int n;
    cin>>n;
    for(int i=1;i<=n;++i)
        cin>>a[i];

    treeNode ans;
    segtree_build(1,1,n);

    ans.max_=0;
    segtree_query(1,1,n,1,4,ans);
    cout<<ans.max_<<endl;

    ans.max_=0;
    segtree_insert(1,1,n,1,3,9);
    segtree_query(1,1,n,1,4,ans);
    cout<<ans.max_<<endl;

    ans.max_=0;
    segtree_query(1,1,n,1,1,ans);
    cout<<ans.max_<<endl;

    return 0;
}