线段树优化——lazytag

最新推荐文章于 2022-09-06 19:49:05 发布
最新推荐文章于 2022-09-06 19:49:05 发布
阅读量869 收藏 1
点赞数
分类专栏： noip 模板 文章标签： 优化
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yun_xing_/article/details/78286042
版权
noip 同时被 2 个专栏收录
14 篇文章 0 订阅
订阅专栏
模板
9 篇文章 1 订阅
订阅专栏

线段树嘛，NOIP的重点，手打模板理解一发（部分借鉴notonlysuccess的线段树，侵删）
题目：线段树模板——洛谷
前言
朴素线段树都是有以下几个操作：
1.query(区间求和)
代码如下

    int Query(int L,int R,int l,int r,int root)
    {
        if(L<=l&&R>=r) return tree[root];
        int mid=(l+r)>>1;
        int ret=0;
        if(L<=mid) ret+=Query(L,R,lson);
        if(R>mid) ret+=Query(L,R,rson);
        return ret;
    }

2.update（单点增减）

    void UpDate(int p,int add,int l,int r,int root)
    {
        if(l==r)
        {
            tree[root]+=add;
            return;
        }
        int mid=(l+r)>>1;
        if(p<=mid)  UpDate(p,add,lson);
        if(p>mid) UpDate(p,add,rson);
        Push_Up(root);
    }

当然树的初始化是必要的
1.建树

    void Build_Tree(int l,int r,int root)
    {
        if(l==r)
        {
            tree[root]=a[l];
            return;
        } 
        int mid=(l+r)>>1;
        Build_Tree(lson);
        Build_Tree(rson);
        Push_Up(root);
    }

2.权值的更新

    void Push_Up(int root)
    {
        tree[root]=tree[root<<1]+tree[root<<1|1];
    }

所以朴素线段树的代码如下

#include<cstdio>
#include<iostream>
#include<cstring>

#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1

using namespace std;

int a[5100];
int tree[22000];
char que[10];
int t,n;

void Push_Up(int root)
{
    tree[root]=tree[root<<1]+tree[root<<1|1];
}

void Build_Tree(int l,int r,int root)
{
    if(l==r)
    {
        tree[root]=a[l];
        return;
    } 
    int mid=(l+r)>>1;
    Build_Tree(lson);
    Build_Tree(rson);
    Push_Up(root);
}

int Query(int L,int R,int l,int r,int root)
{
    if(L<=l&&R>=r) return tree[root];
    int mid=(l+r)>>1;
    int ret=0;
    if(L<=mid) ret+=Query(L,R,lson);
    if(R>mid) ret+=Query(L,R,rson);
    return ret;
}

void UpDate(int p,int add,int l,int r,int root)
{
    if(l==r)
    {
        tree[root]+=add;
        return;
    }
    int mid=(l+r)>>1;
    if(p<=mid)  UpDate(p,add,lson);
    if(p>mid) UpDate(p,add,rson);
    Push_Up(root);
}

int main()
{
    scanf("%d",&t);
    for(int i=1;i<=t;i++)
    {
        printf("Case %d:\n",i);
        scanf("%d",&n);
        for(int j=1;j<=n;j++)
        {
            scanf("%d",&a[j]);
        }
        Build_Tree(1,n,1);
        while(scanf("%s",&que))
        {
            if(que[0]=='E') break;
            else
            {
                int a,b;
                scanf("%d%d",&a,&b);    
                if(que[0]=='Q')
                {
                    printf("%d\n",Query(a,b,1,n,1));
                }
                if(que[0]=='A') UpDate(a,b,1,n,1);
                if(que[0]=='S') UpDate(a,-b,1,n,1);
            }
        }
        return 0;
    }
}

正文
———————————————————————————
大多数线段树不一定是单点加/减权值，会在区间里集体增减。这样会使时间复杂度变得十分……
所以用了【懒惰标记】来优化
（下一段来自notonlysuccess）
成段更新(通常这对初学者来说是一道坎),需要用到延迟标记(或者说懒惰标记),简单来说就是每次更新的时候不要更新到底,用延迟标记使得更新延迟到下次需要更新or询问到的时候
具体操作代码如下（我也不是很懂，今晚听dalao讲QAQ）

void pushdown(int root,int mid)
{
    if(col[root])
    {
        col[root<<1]+=col[root];
        col[root<<1|1]+=col[root];
        tree[root<<1]+=col[root]*(mid-(mid>>1));
        tree[root<<1|1]+=col[root]*(mid>>1);
        col[root]=0;
    }
}

完整代码如下

#include<iostream> 
#include<cstdio>

#define lson l,mid,root<<1
#define rson mid+1,r,root<<1|1
using namespace std;


long long a[110000],tree[410000],col[410000];
int n,m;

void pushup(int root)
{
    tree[root]=tree[root<<1]+tree[root<<1|1];
}

void pushdown(int root,int mid)
{
    if(col[root])
    {
        col[root<<1]+=col[root];
        col[root<<1|1]+=col[root];
        tree[root<<1]+=col[root]*(mid-(mid>>1));
        tree[root<<1|1]+=col[root]*(mid>>1);
        col[root]=0;
    }
}

void buildtree(int l,int r,int root)
{
    col[root]=0;
    if(l==r)
    {
        tree[root]=a[l];
        return;
    } 
    int mid=(l+r)>>1;
    buildtree(lson);
    buildtree(rson);
    pushup(root);
}

void update(int L,int R,int add,int l,int r,int root)
{
    if(L<=l&&r<=R)
    {
        col[root]+=add;
        tree[root]+=(long long)add*(r-l+1);
        return;
    }
    pushdown(root,r-l+1);
    int mid=(l+r)>>1;
    if(L<=mid)  update(L,R,add,lson);
    if(R>mid) update(L,R,add,rson);
    pushup(root); 
}

long long query(int L,int R,int l,int r,int root)
{
    if(L<=l&&R>=r) return tree[root];
    pushdown(root,r-l+1);
    int mid=(l+r)>>1;
    long long ret=0;
    if(L<=mid) ret+=query(L,R,lson);
    if(R>mid) ret+=query(L,R,rson);
    return ret;
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>a[i];
    }
    buildtree(1,n,1);
    char p;
    for(int i=1;i<=m;i++)
    {
        cin>>p;
        int b,c,d;
        if(p=='1')
        {
            cin>>b>>c>>d;
            update(b,c,d,1,n,1);
        }
        if(p=='2')
        {
            cin>>b>>c;
            printf("%lld\n",query(b,c,1,n,1));
        }
    }
    return 0;
}

最后补一发ZYHdalao的线段树模板orz

#include<cstdio>
#include<iostream>
#include<cstring>
#include<string>
#include<algorithm>

using namespace std;
const int N=400000;
long long f[N],opt,n,m,k,opy,opx,opr,opl,ans,a[N],tag[N],size[N];
inline long long F()
{
    register long long aa,bb;register char ch;
    while(ch=getchar(),(ch<'0'||ch>'9')&&ch!='-');ch=='-'?aa=bb=0:(aa=ch-'0',bb=1);
    while(ch=getchar(),ch>='0'&&ch<='9')aa=(aa<<3)+(aa<<1)+ch-'0';return bb?aa:-aa;
}
void build(long long x,long long l,long long r)
{
    if (l==r)
    {
        f[x]=a[l];
        size[x]=1;
        return;
    }
    int mid=(l+r)>>1;
    build(x<<1,l,mid);
    build(x<<1|1,mid+1,r);
    f[x]=f[x<<1]+f[x<<1|1];
    size[x]=size[x<<1]+size[x<<1|1];
}

void down(int x)
{
    if (tag[x]!=0)
    {
        tag[x<<1]+=tag[x];
        tag[x<<1|1]+=tag[x];
        f[x<<1]+=size[x<<1]*tag[x];
        f[x<<1|1]+=size[x<<1|1]*tag[x];
        tag[x]=0;
    }
}
void calc(long long x,long long l,long long r)//1??,0?? 
{
    if (opl<=l&&opr>=r)
    {
        if (opt)ans+=f[x];
        else tag[x]+=opy,f[x]+=size[x]*opy;
        return ;
    }
    int mid=(l+r)>>1;
    down(x);
    if (opl<=mid)calc(x<<1,l,mid);
    if (opr>mid)calc(x<<1|1,mid+1,r);
    f[x]=f[x<<1]+f[x<<1|1];
}
int main()
{
    cin>>n>>m;
    for (int i=1;i<=n;i++)a[i]=F();
    build(1,1,n);
    int op;
//  for (int i=1;i<=n;i++)
//  cout<<f[i]<<' ';
    while(m--)
    {
        op=F();
        if (op==1)
        {
            opt=0;
            opl=F(),opr=F(),opy=F();
            calc(1,1,n);
        }
        else if (op==2)
        {
            opt=1;
            ans=0;
            opl=F(),opr=F();
            calc(1,1,n);
            cout<<ans<<endl;
        }
    }
    return 0;
}

To be continue…

yun_xing_
关注
专栏目录
线段树及Lazy-Tag
iBilllee
01-17 2165
一：线段树 线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。使用线段树可以快速的查找某一个节点在若干条线段中出现的次数，时间复杂度为O(log2N）。 线段树的每个节点都表示一个区间[L, R]，对于一个线段树的区间： 若L < R，则必能被分为[L, M]和[M+1, R]，其中M = (L + R) / 2。 若L = R，则为
Dijkstra算法的线段树优化
十甫-Blogs
08-26 1897
目录 Dijkstra算法 算法简介 实现方法 利用线段树的优化 时间复杂度 Dijkstra算法 算法简介 Dijkstra算法是由荷兰计算机科学家Dijkstra于1959年提出的，因此又叫Dijkstra算法。是从一个顶点到其余各顶点的最短路径算法，解决的是有向图中最短路径问题。Dijkstra算法主要特点是以起始点为中心向外层层扩展，直到扩展到终点为止。 （来自百度百科...
线段树Lazy-tag
ZigZagK的博客
03-17 1291
由来线段树求区间极值的时候，每次都需要修改包含在插入区间的所有节点，这样是不可能承受的！于是lazy思想也就是Lazy-tag是一个非常不错的优化。实现lazy思想的含义就是“要做的时候再做，不然不做”。这听起来不太可能，但实际上根据树的性质，这是可以实现的，只需要使用Lazy-tag： 对于一个节点，我们记录一个tag表示还没有传递下去的值（也就是操作时到这个节点停止了，后面没有遍历过），然后
线段树_lazytag
一只懒猫的博客
08-01 643
1.lazytag是个结点的标记。 2.当需要使用线段树进行区间修改的时候，利用线段树存储区间信息的特点，在修改【L,R】区间时，如果区间【a，b】完全包括在【L,R】区间内，就给这个结点打上tag标记同时更新这个结点的值，tag标记的值就是区间需要修改的值。 3.当需要用到线段树进行区间查询的时候，如果查询到的结点有tag标记。就将tag标记分给子节点并更新子节点的值，同时清空自己的tag标记。 #include<iostream> using namespace std; const..
线段树lazy标记优化
ChangeW fafa的博客
03-20 152
线段树：优雅的分块暴力 区间修改（单点修改），区间查询 POJ3468 #include<iostream> #include<cstdio> #include<cstring> #include<string> const int maxn = 1e6+10; using namespace std; typedef long long ll; ...
线段树应用——扫描线
Lucas_FC_的博客
07-25 2307
扫描线（难的批爆）
线段树（模板+例题——郭神）
02-17
### 线段树（Segment Tree）：概念与应用 #### 一、线段树的基本概念 线段树，有时也被称为区间树，是一种高效的数据结构，主要用于处理区间查询和区间更新的问题。它通过将一个大的区间划分为若干个较小的、互不...
线段树优化建图
weixin_43823476的博客
11-17 1456
前置知识 1.线段树 2.了解什么是图 3.了解什么是树 内容 在某些奇奇怪怪的题目中，会有一个区间中的每个点向另一个区间中的每个点连边，如果暴力搞就是很慢的，但是由于是区间问题，考虑可不可以用数据结构维护一下 那么就有线段树优化建图了，可以维护两个线段树A,B，分别记录连向这个区间的边与从这个区间向外连的边，也就是入树与出树，然后线段树的入树的每个点向其出树的对应点连边，边权设为0，表示进入这颗子树后就可以访问这颗子树所连的那些点了。同时A树的父亲向儿子连边，B树的儿子向父亲连边，这样初始化就
线段树例题分析——————
05-31
几个方便理解的线段树例子··················
Luogu-P3372 (Lazy_tag 线段树模板)
hehepig的博客
04-26 723
题目链接： * 就是个区间修改（都增加某个值），区间查询的简单线段树模板分析… 程序中线段树用了个结构体封装了起来，存起来。打网络赛时可以复制下来，依题意稍作修改就能用了。程序#include <cstdio> #define INF 100005 int n,m,du,k,k1,k2,k3;struct segment_tree{ #define X tr[x] #define
2016多校8 HDU 5828 Rikka with Sequence 线段树优化
P.H.S
08-13 709
2016多校联合训练#8HDU 5828 Rikka with Sequence线段树优化 传送门：HDU 题意很明确是线段树，需要三种操作：区间更新(加值)，区间开根号，区间求和。区间开根号就是区间内部每一个值开根号。思路先膜吧：我和这个大佬的代码风格很像，所以看的很舒服，大佬思路也很详细清晰，适合我这种咸鱼看。膜膜膜。区间更新和求和直接套线段树板子，问题就在于区间开跟。开跟没有什么特别好的性
数据--dp，线段树优化
weixin_30276935的博客
10-11 125
题目描述 Mr_H 出了一道信息学竞赛题，就是给 n 个数排序。输入格式是这样的：试题有若干组数据。每组数据的第一个是一个整数 n，表示总共有 n 个数待排序；接下来 n 个整数，分别表示这 n 个待排序的数。 例如：3 4 2 –1 4 1 2 3 4，就表示有两组数据。第一组有 3 个数(4,2,-1)，第二组有 4个数(1,2,3,4)。可是现在 Mr_H 做的输入数...
线段树优化DP
tanjunming2020的博客
09-06 980
在动态规划中，如果决策点是一段或若干段区间的最值，一般可以用线段树来快速求出决策点，将转移的时间复杂度从O(n)优化到O(logn)细节不必多讲，以下是例题，内附代码，以及题目来源的链接。
浅析线段树(使用lazy tag）
hkr04的博客
08-26 2475
这是百度百科上的图，线段树定义可以看这里-&amp;amp;amp;gt;定义戳我 任何一个区间都能被分成两个小区间，从而能够把对于大区间的查询转换为对几个小区间和小小区间和小小小区间……的查询。 这是我对线段树的朴素理解。 从图上也可以明显地看出任意一个长度大于1的区间都由两个小的子区间组成，子区间再往下分，直到区间内只有一个元素无法再分。**因此，对于每一个长度大于1的区间[l,r]，有mid=(l+r...
Lazy Salesgirl-线段树优化
Julyana_Lin_夜
08-06 1100
参考http://www.cnblogs.com/wuyiqi/archive/2012/04/28/2474672.html的，加上自己的一些理解。 话说上面这个人，我一看到他的线段树就觉得亲切，因为跟我的写法是一样的。 再仔细一看他的博客，发觉我的kmp是跟着他做的。 再看一眼，发觉他跟我的方向一样，都是线段树。真是相见恨晚啊！ 这题应该仔细理解排序那里（相当于离散化）和三棵线段树那里
[CodeVS 4927] 线段树练习5：两个Lazy Tag的线段树
chrt's blog
11-13 682
题意：维护一个长为n（n<=100000）的数列，支持区间加减、区间赋值两种修改，区间最小值、区间最大值、区间求和三种查询。 发现自己记不清线段树区间赋值怎么写了，而且感觉自己的写法和刘汝佳老师的蓝书上的代码不一样，于是做一做这道题。 刘汝佳老师定义赋值标记的优先级高于累加标记，于是同时有两个标记的时候需要先考虑赋值标记，再加上累加标记的值。我的写法略有不同。
线段树优化
bvb的博客
05-22 265
开通博客后就写过一篇，现在翻翻看也觉得写的幼稚。打算以后每周日写一篇博客，记录自己一周的收获。希望这次能够坚持下来。 POJ1769 Description The company Chris Ltd. is preparing a new sorting hardware called Maximizer. Maximizer has n inputs numbered from
线段树--segment_tree--lazy_tag
萍水相逢，尽是他乡之客
11-17 429
经过3天的努力，终于解决了lazy_tag的一系列错误，终于可以发篇博客了~ lazy_tag是用来区间查询和修改的一种快速的方法，是线段树一种比较快速的操作。(虽然有些可以用树状数组来解决). 至于它的思想，可以去看刘汝佳的蓝书。这里只贴代码~/* begin，end都是需要查询的区间。 */ #define lt (node<<1) #define rt (node<<1|1) struct
线段树优化算法：高效处理区间操作
"线段树是一种高效的数据结构，用于处理区间查询和更新问题。它通过分治策略优化了对大规模数据的处理效率，尤其在解决动态区间统计问题时展现出强大性能。线段树常用于竞赛编程（如ACM/ICPC）和算法设计中，能够...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值