线段树入门 2021-3-1

呃我也开始学线段树了。。。

直接上例题吧：
最大数
这是一个线段树模版题，详解在代码备注中。
这个模版涉及建树，单点修改、查询。

/*
 帮助我理解的一些东西：
 建树的时候不一定插了元素
 线段树的逻辑就是递归解决问题
 线段树查询与修改复杂度都是logn
*/
const int maxn=200010;

struct node{
    int l,r;
    int max;//区间[l,r]中的最大值
}tr[4*maxn];

void pushup(int u)//由子节点计算父节点
{
    tr[u].max=max(tr[u<<1].max,tr[u<<1|1].max);
}

void build(int u,int l,int r){
    node th;
    th.l=l;th.r=r;
    tr[u]=th;
    if(l==r)return;//到达叶节点返回
    int mid=(l+r)>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
}

int query(int u,int l0,int r0)//[l0,r0]为所查询的区间
{
    if(tr[u].l>=l0 && tr[u].r<=r0){
        //节点包含与所查询的区间内，则直接return该节点的最大值
        return tr[u].max;
    }
    int mid=(tr[u].l+tr[u].r)>>1;
    int v=0;
    //所查询区间不完全包含节点
    if(l0<=mid){
        //l0比当前节点的mid小，则要继续查询该节点的左儿子
        v=query(u<<1,l0,r0);
    }
    if(r0>mid){
        //r0比当前节点的mid大，则要继续查询该节点的右儿子
        v=max(v,query(u<<1|1,l0,r0));
    }
    return v;//返回左右儿子中较大的那个
}

void modify(int u,int x,int v)//把编号为x的元素修改成v
{
    if(tr[u].l==x && tr[u].r==x){//如果到达叶节点，直接修改返回
        tr[u].max=v;
        return;
    }
    else{
        //此处逻辑同于查询，因为这里就是查询最小叶节点然后修改
        int mid=(tr[u].l+tr[u].r)>>1;
        if(x<=mid) modify(u<<1,x,v);
        else modify(u<<1|1,x,v);
        pushup(u);//修改完成后，要对整棵树都修改
    }
}

int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int m,d;
    cin>>m>>d;
    build(1,1,m);
    int t=0;
    int cnt=0;//目前序列中一共有多少个元素
    while(m--){
        char a;
        cin>>a;
        if(a=='Q'){
            int L;
            cin>>L;
            t=query(1,cnt-L+1,cnt);
            cout<<t<<endl;
        }
        if(a=='A'){
            int n;
            cin>>n;
            modify(1,cnt+1,(t+n)%d);//插入元素
            cnt++;
        }
    }
}

再来点：：
这个题看似排序，实则简单的区间修改

排序
以下为ac代码

const int maxn=50007;
int a[maxn];
/*这段代码涉及区间修改
 区间修改运用懒标记，这样可以节省时间
 懒标记是只在query等需要用到信息的时候才将其推下
*/
struct node{
    int l,r;
    int num;
    int lazy;//懒标记
}t[4*maxn];
void build(int u,int l,int r){
    t[u].l=l;
    t[u].r=r;
    t[u].lazy=-1;//这个题的懒标记可以初始化为-1
    if(l==r){
        t[u].num=a[l];
        return;
    }
    int mid=(l+r)>>1;
    build(u<<1,l,mid);
    build(u<<1|1,mid+1,r);
    t[u].num=t[u<<1].num+t[u<<1|1].num;//pushup
}

void pushdown(int u){
    //此处为懒标记的运用
    int l=t[u].l;
    int r=t[u].r;
    int mid=(r+l)>>1;
    //如果该区间无标记，即无需向下更新，则直接return
    if (t[u].lazy==-1)
        return ;
    t[u<<1].num=(mid-l+1)*t[u].lazy;
    t[u<<1|1].num=(r-(mid+1)+1)*t[u].lazy;
    t[u<<1].lazy=t[u].lazy;
    t[u<<1|1].lazy=t[u].lazy;
    //该区间信息已经下传，去掉懒标记
    t[u].lazy=-1;
}

void modify(int u,int l0,int r0,int v){//把区间[l,r]修改成v
    //区间修改运用懒标记，相当于直接对该区间以及一下的元素全部修改
    if (l0<=t[u].l&&t[u].r<=r0)
    {
        t[u].num=(r0-l0+1)*v;
        t[u].lazy=v;
        return;
    }
    int mid=(t[u].l+t[u].r)/2;
    pushdown(u);
    //跟查询非常像，因为懒标记修改只能改整个区间
    if (l0<=mid)
        modify(t[u].l,l0,r0,v);
    if (r0>mid)
        modify(t[u].r,l0,r0,v);
    t[u].num=t[u<<1].num+t[u<<1|1].num;
}
int query(int u,int l0,int r0){
    if(l0<=t[u].l&&t[u].r<=r0){
        return t[u].num;
    }
    pushdown(u);
    int ans=0;
    int mid=(t[u].l+t[u].r)>>1;
    if(l0<=mid){
        ans+=query(u<<1,l0,r0);
    }
    if(r0>mid){
        ans+=query(u<<1|1,l0,r0);
    }
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++){
        cin>>a[i];
    }
    while(m--){
        int x;
        cin>>x;
        int l0,r0;
        cin>>l0>>r0;
        int cnt=query(1,l0,r0);
        if(cnt!=r0-l0+1&&cnt!=0){
            if(x==0){
                //升序
                modify(1,l0,r0-cnt,0);
                modify(1,r0-cnt+1,r0,1);
            }
            if(x==1){
                //降序
                modify(1,l0,r0-cnt,1);
                modify(1,r0-cnt+1,r0,0);
            }
        }
    }
    for(int i=1;i<=n;i++){
        cout<<query(1,i,i)<<' ';
    }
    cout<<endl;
}