• 简单理解线段树(日常头疼-QAQ)


    最近一直在断断续续的学习线段树,也看了好多博客,个人推荐这个博客来从头到尾学习一遍(讲的很详细):https://www.cnblogs.com/TheRoadToTheGold/p/6254255.html

    下面来说说我对线段树的理解:线段树是为了快速实现对一个大区间某一段区间的多次修改和查询。

    一、基本概念

      1、线段树是一颗搜索树,他储存的是是一段区间的信息。

      2、线段树的需要维护的几个信息:区间左端点,右端点以及区间信息

      3、基本思想:二分。

    二、基础操作

    1、节点

    struct node
    {
           int l,r,w,f;//l,r分别表示区间左右端点,w表示区间和,f为lazy标记
    }tree[4*n+1];

    2、建树

    void build(int l,int r,int k)
    {
        tree[k].l=l;tree[k].r=r;
        if(l==r)//叶子节点 
        {
            scanf("%d",&tree[k].w);
            return ; 
        }
        int m=(l+r)/2;
        build(l,m,k*2);//左孩子 
        build(m+1,r,k*2+1);//右孩子 
        tree[k].w=tree[k*2].w+tree[k*2+1].w;//状态合并,此结点的w=两个孩子的w之和 
    }

    3、单点查询

    void ask_point(int k)
    {
        if(tree[k].l==tree[k].r) //当前结点的左右端点相等,是叶子节点,是最终答案 
        {
            ans=tree[k].w;
            return ;
        }
        int m=(tree[k].l+tree[k].r)/2;
        if(x<=m) ask(k*2);//目标位置比中点靠左,就递归左孩子 
        else ask(k*2+1);//反之,递归右孩子 
    }

    二分查找来递归左右子树,当左右两端的值相等的是,对应的节点值就是要查询的值。

    4、单点修改

    void add(int k)
    {
        if(tree[k].l==tree[k].r)//找到目标位置 
        {
            tree[k].w+=y;
            return;
        }
        int m=(tree[k].l+tree[k].r)/2;
        if(x<=m) add(k*2);
        else add(k*2+1);
        tree[k].w=tree[k*2].w+tree[k*2+1].w;//所有包含结点k的结点状态更新 
    }

    5、区间查询

    void sum(int k)
    {
        if(tree[k].l>=x&&tree[k].r<=y) //当前节点左右端点在查询的区间之内,直接返回区间的值
        {
            ans+=tree[k].w;
            return;
        }
        int m=(tree[k].l+tree[k].r)/2;
        if(x<=m) sum(k*2);//查询区间全在当前区间的左边
        if(y>m) sum(k*2+1);//查询区间全在当前区间的右边
    //否则都走
    }

    6、区间修改

    void add_qu(int k)
    {
        if(tree[k].l>=a&&tree[k].r<=b)//当前区间全部对要修改的区间有用 
        {
            tree[k].w+=(tree[k].r-tree[k].l+1)*x;//(r-1)+1区间点的总数
            tree[k].f+=x;
            return;
        }
        if(tree[k].f) down(k);//懒标记下传。只有不满足上面的if条件才执行,所以一定会用到当前节点的子节点 
        int m=(tree[k].l+tree[k].r)/2;
        if(a<=m) add(k*2);
        if(b>m) add(k*2+1);
        tree[k].w=tree[k*2].w+tree[k*2+1].w;//更改区间状态 
    }
    void down(int k)
    {
        tree[k*2].f+=tree[k].f;
        tree[k*2+1].f+=tree[k].f;
        tree[k*2].w+=tree[k].f*(tree[k*2].r-tree[k*2].l+1);
        tree[k*2+1].w+=tree[k].f*(tree[k*2+1].r-tree[k*2+1].l+1);
        tree[k].f=0;
    }

    区间修改的精髓:lazy标记

    对于和查询无关的区间,我们不需要改动,而对于需要改动的区间,我们只需要该到该区间就可以了(同时下放lazy标记),该区间下面的节点不需要更改,以此来减少耗时。lazy标记记录的是你在当前区间要修改或增加的值(具体情况根据题意来)

    五种操作

    #include<cstdio>
    using namespace std;
    int n,p,a,b,m,x,y,ans;
    struct node
    {
        int l,r,w,f;
    }tree[400001];
    inline void build(int k,int ll,int rr)//建树 
    {
        tree[k].l=ll,tree[k].r=rr;
        if(tree[k].l==tree[k].r)
        {
            scanf("%d",&tree[k].w);
            return;
        }
        int m=(ll+rr)/2;
        build(k*2,ll,m);
        build(k*2+1,m+1,rr);
        tree[k].w=tree[k*2].w+tree[k*2+1].w;
    }
    inline void down(int k)//标记下传 
    {
        tree[k*2].f+=tree[k].f;
        tree[k*2+1].f+=tree[k].f;
        tree[k*2].w+=tree[k].f*(tree[k*2].r-tree[k*2].l+1);
        tree[k*2+1].w+=tree[k].f*(tree[k*2+1].r-tree[k*2+1].l+1);
        tree[k].f=0;
    }
    inline void ask_point(int k)//单点查询
    {
        if(tree[k].l==tree[k].r)
        {
            ans=tree[k].w;
            return ;
        }
        if(tree[k].f) down(k);
        int m=(tree[k].l+tree[k].r)/2;
        if(x<=m) ask_point(k*2);
        else ask_point(k*2+1);
    }
    inline void change_point(int k)//单点修改 
    {
        if(tree[k].l==tree[k].r)
        {
            tree[k].w+=y;
            return;
        }
        if(tree[k].f) down(k);
        int m=(tree[k].l+tree[k].r)/2;
        if(x<=m) change_point(k*2);
        else change_point(k*2+1);
        tree[k].w=tree[k*2].w+tree[k*2+1].w; 
    }
    inline void ask_interval(int k)//区间查询 
    {
        if(tree[k].l>=a&&tree[k].r<=b) 
        {
            ans+=tree[k].w;
            return;
        }
        if(tree[k].f) down(k);
        int m=(tree[k].l+tree[k].r)/2;
        if(a<=m) ask_interval(k*2);
        if(b>m) ask_interval(k*2+1);
    }
    inline void change_interval(int k)//区间修改 
    {
        if(tree[k].l>=a&&tree[k].r<=b)
        {
            tree[k].w+=(tree[k].r-tree[k].l+1)*y;
            tree[k].f+=y;
            return;
        }
        if(tree[k].f) down(k);
        int m=(tree[k].l+tree[k].r)/2;
        if(a<=m) change_interval(k*2);
        if(b>m) change_interval(k*2+1);
        tree[k].w=tree[k*2].w+tree[k*2+1].w;
    }
    int main()
    {
        scanf("%d",&n);//n个节点 
        build(1,1,n);//建树 
        scanf("%d",&m);//m种操作 
        for(int i=1;i<=m;i++)
        {
            scanf("%d",&p);
            ans=0;
            if(p==1)
            {
                scanf("%d",&x);
                ask_point(1);//单点查询,输出第x个数 
                printf("%d",ans);
            } 
            else if(p==2)
            {
                scanf("%d%d",&x,&y);
                change_point(1);//单点修改 
            }
            else if(p==3)
            {
                scanf("%d%d",&a,&b);//区间查询 
                ask_interval(1);
                printf("%d
    ",ans);
            }
            else
            {
                 scanf("%d%d%d",&a,&b,&y);//区间修改 
                 change_interval(1);
            }
        }
    }

    附:我之前的做的一道题。

    http://acm.hdu.edu.cn/showproblem.php?pid=1698

     
    #include <cstdio>
    #include<bits/stdc++.h>
    #include<iostream>
    #include<cstdio>
    using namespace std;
    int n,p,a,b,m,x,y;
    int ans;
    struct node
    {
        int l,r,w,f;
    }tree[800001];
    inline void build(int k,int ll,int rr)//建树
    {
        tree[k].l=ll,tree[k].r=rr;
        if(tree[k].l==tree[k].r)
        {
            tree[k].w=1;
            return;
        }
        int m=(ll+rr)/2;
        build(k*2,ll,m);
        build(k*2+1,m+1,rr);
        tree[k].w=tree[k*2].w+tree[k*2+1].w;
    }
    inline void down(int k)//标记下放
    {
        tree[k*2].f=tree[k].f;
        tree[k*2+1].f=tree[k].f;
        tree[k*2].w=tree[k].f*(tree[k*2].r-tree[k*2].l+1);
        tree[k*2+1].w=tree[k].f*(tree[k*2+1].r-tree[k*2+1].l+1);
        tree[k].f=0;
    }
    inline void ask_interval(int k)//区间查询
    {
        if(tree[k].l>=1&&tree[k].r<=n)
        {
            ans+=tree[k].w;
            return;
        }
        if(tree[k].f) down(k);
        int m=(tree[k].l+tree[k].r)/2;
        if(a<=m) ask_interval(k*2);
        if(b>m) ask_interval(k*2+1);
    }
    inline void change_interval(int k)//区间修改
    {
        if(tree[k].l>=a&&tree[k].r<=b)
        {
            tree[k].w=(tree[k].r-tree[k].l+1)*y;
            tree[k].f=y;
            return;
        }
        if(tree[k].f) down(k);
        int m=(tree[k].l+tree[k].r)/2;
        if(a<=m) change_interval(k*2);
        if(b>m) change_interval(k*2+1);
        tree[k].w=tree[k*2].w+tree[k*2+1].w;
    }
    int main()
    {
        int t,j=1;
        cin>>t;
        while(t--)
        {
            memset(tree,0,sizeof(tree));
            scanf("%d",&n);
        build(1,1,n);
        scanf("%d",&m);
        for(int i=1;i<=m;i++)
        {
                 ans=0;
                 scanf("%d%d%d",&a,&b,&y);
                 change_interval(1);
        }
    
        printf("Case %d: The total value of the hook is %d.
    ",j++,tree[1].w);
        }
    
        return 0;
    }
    View Code
  • 相关阅读:
    全方位讲解 Nebula Graph 索引原理和使用
    一首古诗带来的图数据库大冒险
    Nebula Graph 在众安保险的图实践
    springioc源码
    leetcode原地删除系列283移除0
    leetcode21单链表问题
    20天备考初级会计
    leetcode原地删除系列27
    leetcode 在排序数组中查找元素的第一个和最后一个位置
    内置后置处理器要理解的问题
  • 原文地址:https://www.cnblogs.com/kayiko/p/10815386.html
Copyright © 2020-2023  润新知