线段树(模板)

建树：

const int MAXM=50000*4+1;
　　　　　　//定义 MAXM 为线段最大长度，树的空间大小为线段最大长度的四倍

void build(int v,int l,int r)
{
    //传入的参数为 v:当前需要建立的结点；l：当前需要建立的左端点；r：当前需要建立的右端点
    if(l==r)
    {
        //当左端点等于右端点即建立叶子结点时，直接给数组信息赋值
        scanf("%lld",&sum[v]);
        return ;
    }
    int mid=(l+r)/2;   // mid 为中间点，左儿子结点为 [l,mid] ，右儿子结点为 [mid+1,r]；
    build(v*2,l,mid);   //构建左儿子结点
    build(v*2+1,mid+1,r);   //构建右儿子结点
    sum[v]=sum[v*2]+sum[v*2+1];
    //递归返回时用儿子结点更新父节点，此处可进行更新最大值、最小值、区间和等操作
}

{
    　　　　　　　　　　　　　　　　　　　　　　　//在 main 函数中的语句
    build(1,1,n);
}

/**************************************************************************************/

单点修改：

void update(int v,int l,int r,int a,int b,int c)
{
    //v、l、r为当前更新到的结点、左右端点，a为需要修改的叶子结点左端点，c为需要修改成的值；
    if(l==r)
    {
        //若当前更新点的左右端点相等即到叶子结点时，直接更新信息并返回
        mp[v]=c;
        return ;
    }

    int mid=(l+r)/2;
    //若需要更新的叶子结点在当前结点的左儿子结点的范围内，则递归更新左儿子结点，否则更新右儿子结点
    if(a<=mid)
        update(v*2,l,mid,a,b,c);
    else
        update(v*2+1,mid+1,r,a,b,c);
    mp[v]=mp[v*2]+mp[v*2+1]; //递归回之后用儿子结点更新父节点
    return ;
}
{
    　　　　　　　　　　　　　　　　　//在main函数中的语句
    update(1,1,n,a,b,c);
}

/**************************************************************************************/

对应单点修改的区间查询：

int query(int v,int l,int r,int a,int b)
{
    //a,b为需要查询的区间左右端点
    if(l>=a && r<=b) //若当前结点的区间被需要查询的区间覆盖，则返回当前结点的信息
        return sum[v];
    if(lazy[v])  //更新节点
        pushdown(v,l,r);
    int mid=(l+r)/2;
    int sum=0;
    if(a<=mid)
        sum+=query(v*2,l,mid,a,b);
    if(b>mid)
        sum+=query(v*2+1,mid+1,r,a,b);
    return sum;//综合两个儿子结点的信息并返回
}
{
    　　　　//main函数中的语句
    printf("%d\n",query(1,1,n,a,b));
}

/**************************************************************************************/

区间修改用到了lazy的思想，即当一个区间需要更新时，只递归更新到那一层结点，并将其下层结点所需要更新的信息保存在数组中，然后返回，只有当下次遍历到那个结点（更新过程中或查询过程中），才将那个结点的修改信息传递下去，这样就避免了区间修改的每个值的修改
区间修改（包括区间加值和区间赋值）及相应查询：
区间加值：

void pushdown(int v,int l,int r)
{
    //pushdown函数，更新父亲节点，将更新信息传递给左右子节点
    int mid=(l+r)/2;
    sum[v*2]+=(mid-l+1)*lazy[v];  //更新v节点的左子节点
    lazy[2*v]+=lazy[v];  //标记v的左子节点
    sum[v*2+1]+=(r-mid)*lazy[v];  //同上
    lazy[2*v+1]+=lazy[v];   //同上
    lazy[v]=0;  //取消父节点v的更新信息
}
///
void update(int v,int l,int r,int a,int b,int c)
{
    //ql、qr为需要更新的区间左右端点，c为需要增加的值
    if(l>=a && b>=r)
    {
        //与单点更新一样，当当前结点被需要更新的区间覆盖时
        sum[v]+=(r-l+1)*c; //更新该结点信息
        lazy[v]+=c;
        　//更新该结点的所需更新信息
        return ;//根据lazy思想，由于不需要遍历到下层结点，因此不需要继续向下更新，直接返回
    }
    if(lazy[v]!=0)//将当前结点的所需更新信息传递到下一层（其左右儿子结点）
        pushdown(v,l,r);
   
    int mid=(l+r)/2;
    if(a<=mid)  //当需更新区间在当前结点的左儿子结点内，则更新左儿子结点
        update(v*2,l,mid,a,b,c);
    if(b>mid)
        update(v*2+1,mid+1,r,a,b,c);
    sum[v]=sum[v*2]+sum[v*2+1];
}
/
int query(int v,int l,int r,int a,int b)
{
    //a,b为需要查询的区间
    if(l>=a && r<=b)  //若当前结点覆盖区间即为需要查询的区间，则直接返回当前结点的信息
        return sum[v];
    if(lazy[v]) //将当前结点的更新信息传递给其左右子节点
        pushdown(v,l,r);
    int mid=(l+r)/2;
    int sum=0;
    if(a<=mid)
        sum+=query(v*2,l,mid,a,b);
    if(b>mid)
        sum+=query(v*2+1,mid+1,r,a,b);
    return sum;
}

/***************************************************************************************/

区间改值（其实只有pushdow函数和update中修改部分与区间加值不同）：

void pushdown(int v,int l,int r)
{
    //pushdown和区间加值不同，改值时修改结点信息只需要对修改后的信息求和即可，不用加上原信息
    int mid=(l+r)/2;
    sum[v*2]=(mid-l+1)*lazy[v];
    lazy[2*v]=lazy[v];
    sum[v*2+1]=(r-mid)*lazy[v];
    lazy[2*v+1]=lazy[v];
    lazy[v]=-1;
}

void update(int v,int l,int r,int a,int b,int c)
{
    if(l>=a && b>=r)
    {
        //同样更新结点信息和区间加值不同
        sum[v]=(r-l+1)*c;
        lazy[v]=c;
        return ;
    }
    if(lazy[v]!=-1)
        pushdown(v,l,r);
    int mid=(l+r)/2;
    if(a<=mid)
        update(v*2,l,mid,a,b,c);
    if(b>mid)
        update(v*2+1,mid+1,r,a,b,c);
    sum[v]=sum[v*2]+sum[v*2+1];
}

/*********************************************************************************************/