线段树模板 （自用）

包括单点查询，单点更新，区间查询，区间更新，（Lazy标记应用）
代码包含注释如下

#include <iostream>
#include <algorithm>
#include <iostream>
#include <string>
#include <stdio.h>
#include <algorithm>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <math.h>
#include <climits>
#include <iomanip>
#include <queue>
#include<vector>
using namespace std;
const int maxn=99999999;

long long sum[maxn],add[maxn];//sum存储，add存储lazy标记

struct node
{
    int lef,rig;//左右孩子
    int value;//表示权值（最大值）
    int mid()
    {
        return (lef+rig)/2;//方便后续返回中间值
    }
}a[maxn];//区间数组

int father[maxn];//存储区间下标

void Pushup(int i)//从区间往上更新lazy标记
{
    sum[i]=sum[i/2]+sum[i/2]+1;
}

void Pushdown(int i,int m)//把lazy标记向下分散
{//m为总区间数
    if(add[i])//如果有lazy标记
    {
        add[i*2]+=add[i];//分散到左孩子
        add[i*2+1]+=add[i];//分散到右孩子
        sum[i*2]+=add[i]*(m-m/2);//左孩子区间合要加上lazy标记乘与区间数
        sum[i*2+1]+=add[i]*(m/2);//右孩子同上
        add[i]=0;//自身标记改为零(已分散到左右孩子)
    }
}

void Buildtree(int i,int l,int r)//建树
{
    add[i]=0;
    a[i].lef=l;
    a[i].rig=r;
    a[i].value=0;//上四步初始化
    if(l==r)//最小的孩子
    {
        father[l]=i;
        return;
    }
    Buildtree(i*2,l,(r+l)/2);//建左孩子
    Buildtree(i*2+1,(r+l)/2+1,r);//建右孩子
    Pushup(i);//向上更新和
}

void Updatetree1(int ri)//更新最大值
{
    if(ri==1) return;//等于1(祖父)时回溯
    int f=ri/2;//父节点
    int x=a[f*2].value;//左孩子的值
    int y=a[f*2+1].value;//右孩子的值
    a[f].value=max(x,y);//父节点的最大值为左右孩子取大
    Updatetree1(ri/2);//父节点往上更新
}

long long Query2(int l,int r,int i)//查询区间最大值
{
    if(l==a[i].lef&&r==a[i].rig) return sum[i];//找到区间
    Pushdown(i,a[i].rig-a[i].lef+1);//如果没有找到，把当前lazy标记分散
    int m=a[i].mid();//中间值
    long long res=0;//和
    if(r<=m) res+=Query2(l,m,i*2);//如果在左边，查询左孩子
    else if(l>m) res+=Query2(l,m+1,i*2+1);//同理，查询右孩子
    else//中间，查询左右孩子
    {
        res+=Query2(l,m,i*2);
        res+=Query2(l,m+1,i*2+1);
    }
    return res;//最后返回结果
}

void Updatetree2(int c,int l,int r,int ri)//更新区间和
{//c为区间需要添加的值
    if(a[ri].lef==l&&a[ri].rig==r)//找到区间
    {
        add[ri]+=c;//添加lazy标记
        sum[ri]+=(long long)c*(r-l+1);//更新和
        return;
    }
    if(a[ri].lef==a[ri].rig) return;
    Pushdown(ri,r-l+1);
    //如果没有到所要的区间，就把当前lazy表示分散到孩子
    int m=a[ri].mid();//m为l与r中间值
    if(r<=m) Updatetree2(c,l,r,ri*2);//如果比中间值小，更新左孩子
    else if(l>m) Updatetree2(c,l,r,ri*2+1);//如果比中间值大，更新右孩子
    else //如果在中间，更新左右孩子
    {
        Updatetree2(c,l,m,ri*2);
        Updatetree2(c,m+1,r,ri*2+1);
    }
    Pushup(ri);//把区间和更新
}

int Max=0;//区间最大值
//求区间合时，把Max改成res
void Query(int i,int l,int r)//查询最大值
{
    if(a[i].lef==l&&a[i].rig==r)//找到区间
    {
        Max=max(Max,a[i].value);//取最大值
        //res+=a[i].value;(区间求和)
        return;
    }
    int v=i*2;//查询左孩子
    if(l<=a[v].rig)
    {
        if(r<=a[v].rig)
            Query(v,l,r);
        else
            Query(v,l,a[v].rig);
    }
    v++;//查询右孩子
    if(r>=a[v].lef)
    {
        if(l>=a[v].lef)
            Query(v,l,r);
        else
            Query(v,a[v].lef,r);
    }
}

int main()
{
    int n,m;
    ios::sync_with_stdio(false);//关掉cin与stdio的同步
    while(cin>>n>>m)
    {
        Buildtree(1,1,n);//优先建树
        int k;
        for(int i=1;i<=n;i++)
        {
            cin>>k;
            a[father[i]].value=k;//输入权值
            sum[father[i]]=k;//和数组里更新节点值
            Updatetree1(father[i]);//更新最大值
        }
    }
    return 0;
}