浅谈线段树

最新推荐文章于 2024-08-15 05:02:54 发布
最新推荐文章于 2024-08-15 05:02:54 发布
阅读量84 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/wxl-Ezio/p/8762943.html
版权

一直想学线段树，但因为懒，一直没有时间，今天终于AC了洛谷P3372 线段树1，写篇博客加强一下理解。

线段树是什么？

线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。时间复杂度为\(O(nlogn)\) ————百度百科

它有什么用？

线段树可以快速的处理一些可以“相加”的区间问题，它可以说是NOIp考纲里最强大的数据结构

既然它这么强，那现在就让我们来学习一下线段树吧！(>▽<)
线段树
线段树是用一个节点来保存一段区间，这样在我们查询区间的时候就不用一个一个枚举，而是直接查询对应的节点，比如上面的图，如果我们要查询编号为3~8的叶子节点，就只要查询3、(4~5)、(6~8)这三个节点就可以了，大大减少了时间复杂度。同时，线段树也支持区间修改，但为了保持线段树的高效性，它肯定不是一个一个枚举叶子节点，而是给要修改的节点打一个标记，俗称Lazy Tag，这样我们在修改的时候就可以直接调用Lazy Tag，而不是再查找一遍。

线段树的具体实现方法是这样的:

  • 左右两个儿子：因为线段树是一棵二叉树，所以我们可以直接用预处理方便的实现
#define ls(x) x<<1
#define rs(x) x<<1|1
  • push_up (用于维护父子关系，父节点=左儿子+右儿子)
void up(ll pos)
{
    tree[pos]=tree[ls(pos)]+tree[rs(pos)];
}
  • 递归建树
void build(ll pos,ll l,ll r)
{
    if(l==r)
    {
        tree[pos]=a[l];
        return ;
    }
    ll mid=(r+l)>>1;
    build(ls(pos),l,mid);
    build(rs(pos),mid+1,r);
    up(pos);
}
  • 处理Lazy Tag(据说加\(inline\)会有玄学优化)
inline void f(ll pos,ll l,ll r,ll k)
{
    tag[pos]+=k; tree[pos]+=k*(r-l+1);
}
  • push_down (下放Lazy Tag)
void down(ll pos,ll l,ll r)
{
    ll mid=(l+r)>>1;
    f(ls(pos),l,mid,tag[pos]);
    f(rs(pos),mid+1,r,tag[pos]);
    tag[pos]=0;
}
  • 然后是将以上几个函数结合起来的update
void update(ll nl,ll nr,ll l,ll r,ll pos,ll k)
{
    if(nl<=l&&r<=nr)
    {
        tree[pos]+=k*(r-l+1);
        tag[pos]+=k;
        return ;
    }
    down(pos,l,r);
    ll mid=(l+r)>>1;
    if(nl<=mid) update(nl,nr,l,mid,ls(pos),k);
    if(nr>mid) update(nl,nr,mid+1,r,rs(pos),k);
    up(pos);
}
  • ans(回答询问据说用dalao的名字会RP++)
ll ans(ll x,ll y,ll l,ll r,ll pos)
{
    ll rqy=0;
    if(x<=l&&r<=y) return tree[pos];
    ll mid=(l+r)>>1;
    down(pos,l,r);
    if(x<=mid) rqy+=ans(x,y,l,mid,ls(pos));
    if(y>mid) rqy+=ans(x,y,mid+1,r,rs(pos));
    return rqy;
}

最后是完整代码：

#include<iostream>
#include<cstdio>
#define ls(x) x<<1
#define rs(x) x<<1|1
#define ll long long 
using namespace std;
ll tree[100001*4],a[100001],tag[100001*4];
void up(ll pos)
{
    tree[pos]=tree[ls(pos)]+tree[rs(pos)];
}
void build(ll pos,ll l,ll r)
{
    if(l==r)
    {
        tree[pos]=a[l];
        return ;
    }
    ll mid=(r+l)>>1;
    build(ls(pos),l,mid);
    build(rs(pos),mid+1,r);
    up(pos);
}
inline void f(ll pos,ll l,ll r,ll k)
{
    tag[pos]+=k; tree[pos]+=k*(r-l+1);
}
void down(ll pos,ll l,ll r)
{
    ll mid=(l+r)>>1;
    f(ls(pos),l,mid,tag[pos]);
    f(rs(pos),mid+1,r,tag[pos]);
    tag[pos]=0;
}
void update(ll nl,ll nr,ll l,ll r,ll pos,ll k)
{
    if(nl<=l&&r<=nr)
    {
        tree[pos]+=k*(r-l+1);
        tag[pos]+=k;
        return ;
    }
    down(pos,l,r);
    ll mid=(l+r)>>1;
    if(nl<=mid) update(nl,nr,l,mid,ls(pos),k);
    if(nr>mid) update(nl,nr,mid+1,r,rs(pos),k);
    up(pos);
}
ll ans(ll x,ll y,ll l,ll r,ll pos)
{
    ll rqy=0;
    if(x<=l&&r<=y) return tree[pos];
    ll mid=(l+r)>>1;
    down(pos,l,r);
    if(x<=mid) rqy+=ans(x,y,l,mid,ls(pos));
    if(y>mid) rqy+=ans(x,y,mid+1,r,rs(pos));
    return rqy;
}
int main()
{
    ios::sync_with_stdio(false);
    ll n,m;
    cin>>n>>m;
    for(int i=1;i<=n;i++)
      cin>>a[i];
    build(1,1,n);
    for(int i=1;i<=m;i++)
    {
        int flag; cin>>flag;
        if(flag==1)
        {
            ll x,y,k; cin>>x>>y>>k;
            update(x,y,1,n,1,k);
            continue;
        }
        else
        {
            ll x,y; cin>>x>>y;
            cout<<ans(x,y,1,n,1)<<endl;
        }
    }
    return 0;
}

码风整改版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define lc(x) x<<1
#define rc(x) x<<1|1
#define mid ((l+r)>>1)
#define ll long long
using namespace std;
ll tree[100000<<2],a[100001],tag1[100000<<2],tag2[100000<<2];
inline void up(int p){
    tree[p]=tree[lc(p)]+tree[rc(p)];
}
void build(ll l,ll r,ll p){
    if(l==r){
        tree[p]=a[l];
        return ;    
    }
    build(l,mid,lc(p));
    build(mid+1,r,rc(p));
    up(p);
}
void down1(ll l,ll r,ll p){
    tag1[lc(p)]+=tag1[p]; tree[lc(p)]+=(mid-l+1)*tag1[p];
    tag1[rc(p)]+=tag1[p]; tree[rc(p)]+=(r-mid)*tag1[p];
    tag1[p]=0;
}
void update1(ll l,ll r,ll p,ll nl,ll nr,ll k){
    if(l>=nl&&r<=nr){
        tree[p]+=(r-l+1)*k; tag1[p]+=k;
        return ;
    }
    down1(l,r,p);
    if(nl<=mid)
      update1(l,mid,lc(p),nl,nr,k);
    if(nr>mid)
      update1(mid+1,r,rc(p),nl,nr,k);
    up(p);
}
ll ans(ll l,ll r,ll p,ll nl,ll nr){
    ll zzz=0;
    if(l>=nl&&r<=nr) return tree[p];
    down1(l,r,p);
    if(nl<=mid)
      zzz+=ans(l,mid,lc(p),nl,nr);
    if(nr>mid)
      zzz+=ans(mid+1,r,rc(p),nl,nr);
    return zzz;
}
ll read(){
    ll f=1,k=0; char c=getchar();
    for(;c<'0'||c>'9';c=getchar()) 
      if(c=='-') f=-1;
    for(;c>='0'&&c<='9';c=getchar())
      k=(k<<3)+(k<<1)+c-48;
    return k*f;
}
int main(){
    ll n=read(),m=read();
    for(ll i=1;i<=n;i++)  a[i]=read();
    build(1,n,1);
    for(ll i=1;i<=m;i++){
        ll t=read();
        if(t==1){
            ll x=read(),y=read(),k=read();
            update1(1,n,1,x,y,k);
        }
        else{
            ll x=read(),y=read();
            printf("%lld\n",ans(1,n,1,x,y));
        }
    }
    
    
    
    return 0;
}

线段树2

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define lc(x) x<<1
#define rc(x) x<<1|1
#define mid ((l+r)>>1)
#define ll long long
using namespace std;
ll tree[100000<<2],a[100001],tag1[100000<<2],tag2[100000<<2],b;
inline void up(ll p){
    tree[p]=(tree[lc(p)]%b+tree[rc(p)]%b)%b;
}
void build(ll l,ll r,ll p){
    tag2[p]=1;
    if(l==r){
        tree[p]=a[l];
        return ;
    }
    build(l,mid,lc(p));
    build(mid+1,r,rc(p));
    up(p);
}
//惊天地泣鬼神的pushdown
void down(ll l,ll r,ll p){
    tree[lc(p)]=(tree[lc(p)]*tag2[p]+(mid-l+1)*tag1[p])%b;
    tree[rc(p)]=(tree[rc(p)]*tag2[p]+(r-mid)*tag1[p])%b;
    tag2[lc(p)]=(tag2[lc(p)]*tag2[p])%b;
    tag2[rc(p)]=(tag2[rc(p)]*tag2[p])%b;
    tag1[lc(p)]=(tag1[lc(p)]*tag2[p]+tag1[p])%b;
    tag1[rc(p)]=(tag1[rc(p)]*tag2[p]+tag1[p])%b;
    tag1[p]=0;
    tag2[p]=1;
}
void update2(ll l,ll r,ll p,ll nl,ll nr,ll k){
    if(l>=nl&&r<=nr){
        tree[p]=(tree[p]*k)%b; tag2[p]=(tag2[p]*k)%b;
        tag1[p]=(tag1[p]*k)%b;
        return ;
    }
    down(l,r,p);
    if(nl<=mid)
      update2(l,mid,lc(p),nl,nr,k);
    if(nr>mid)
      update2(mid+1,r,rc(p),nl,nr,k);
    up(p);
}
void update1(ll l,ll r,ll p,ll nl,ll nr,ll k){
    if(l>=nl&&r<=nr){
        tree[p]=(tree[p]+(r-l+1)*k)%b; tag1[p]=(tag1[p]+k)%b;
        return ;
    }
    down(l,r,p);
    if(nl<=mid)
      update1(l,mid,lc(p),nl,nr,k);
    if(nr>mid)
      update1(mid+1,r,rc(p),nl,nr,k);
    up(p);
}
ll ans(ll l,ll r,ll p,ll nl,ll nr){
    ll zzz=0;
    if(l>=nl&&r<=nr) return tree[p];
    down(l,r,p);
    if(nl<=mid)
      zzz=(zzz+ans(l,mid,lc(p),nl,nr))%b;
    if(nr>mid)
      zzz=(zzz+ans(mid+1,r,rc(p),nl,nr))%b;
    return zzz%b;
}
ll read(){
    ll f=1,k=0; char c=getchar();
    for(;c<'0'||c>'9';c=getchar()) 
      if(c=='-') f=-1;
    for(;c>='0'&&c<='9';c=getchar())
      k=(k<<3)+(k<<1)+c-48;
    return k*f;
}
int main(){
    ll n=read(),m=read(); b=read();
    for(ll i=1;i<=n;i++) a[i]=read();
    build(1,n,1);
    for(ll i=1;i<=m;i++){
        ll t=read();
        if(t==1){
            ll x=read(),y=read(),k=read();
            update2(1,n,1,x,y,k);
        }
        if(t==2){
            ll x=read(),y=read(),k=read();
            update1(1,n,1,x,y,k);
        }
        if(t==3){
            ll x=read(),y=read();
            cout<<(ans(1,n,1,x,y))%b<<endl;
        }
    }
    
    
    
    
    return 0;
}

2018/6/9更新：

线段树维护最长连续子段

每个节点存三个量：\(l、r、m\)，\(l\)表示以该节点所存的左端点为起始点的最长连续子段，\(r\)表示以该节点所存的右端点为终止点的最长连续子段，\(m\)表示被该节点包含的最长连续子段。这样，我们就能通过拼接小区间来得知大区间的最长连续子段了。

inline void up(int l,int r,int p){
    tree[p].l=tree[ls(p)].l; //大区间的左端点开始的连续子段最小是左区间里以左区间左端点开头的连续子段
    if(tag[mid]!=tag[mid+1]&&mid-l+1==tree[ls(p)].l)  //如果左区间整个都是连读的
      tree[p].l+=tree[rs(p)].l;  //再将右区间的以右区间开头的连续子段长度加上，下同
    tree[p].r=tree[rs(p)].r;
    if(tag[mid]!=tag[mid+1]&&r-mid==tree[rs(p)].r)
      tree[p].r+=tree[ls(p)].r;
    tree[p].m=max(tree[ls(p)].m,tree[rs(p)].m);
    if(tag[mid]!=tag[mid+1])
      tree[p].m=max(tree[p].m,tree[ls(p)].r+tree[rs(p)].l); 左右区间拼接
}

我们也可以用这种方法来维护最大子段和

裸题，不多BB

#include<iostream>
#include<cstdio>
#include<algorithm>
#define ls(x) x<<1
#define rs(x) x<<1|1
#define mid ((l+r)>>1)
using namespace std;
struct zzz{
    int l,r,m;
}tree[20001<<2];
bool tag[20001];
inline void up(int l,int r,int p){
    tree[p].l=tree[ls(p)].l;
    if(tag[mid]!=tag[mid+1]&&mid-l+1==tree[ls(p)].l)
      tree[p].l+=tree[rs(p)].l;
    tree[p].r=tree[rs(p)].r;
    if(tag[mid]!=tag[mid+1]&&r-mid==tree[rs(p)].r)
      tree[p].r+=tree[ls(p)].r;
    tree[p].m=max(tree[ls(p)].m,tree[rs(p)].m);
    if(tag[mid]!=tag[mid+1])
      tree[p].m=max(tree[p].m,tree[ls(p)].r+tree[rs(p)].l);
}
void build(int l,int r,int p){
    if(l==r){
        tree[p].l=1; tree[p].r=1;
        tree[p].m=1;
        return ;
    }
    build(l,mid,ls(p));
    build(mid+1,r,rs(p));
    up(l,r,p);
}
void update(int l,int r,int p,int nn){
    if(l==r&&l==nn){
        tag[l]^=1;
        return ;
    }
    if(nn<=mid) update(l,mid,ls(p),nn);
    if(nn>mid) update(mid+1,r,rs(p),nn);
    up(l,r,p);
}
int read(){
    int k=0; char c=getchar();
    for(;c<'0'||c>'9';) c=getchar();
    for(;c>='0'&&c<='9';c=getchar())
      k=(k<<3)+(k<<1)+c-48;
    return k;
}
int main(){
    int n=read(),m=read();
    build(1,n,1);
    for(int i=1;i<=m;i++){
        int x=read();
        update(1,n,1,x);
        printf("%d\n",max(tree[1].l,max(tree[1].m,tree[1].r)));
    }
    
    return 0;
}

本校dalao的线段树博客(写得比我好多了，强烈推荐!!!):pks && zzc

转载于:https://www.cnblogs.com/wxl-Ezio/p/8762943.html

weixin_30716141
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
线段树 与 信息学竞赛 pdf 非常有用 acm
04-28
通过解决一系列精心挑选的练习题目，如《浅谈线段树在信息学竞赛中的应用》一文中推荐的练习题，可以进一步巩固理论知识，提升实战能力。在信息学竞赛的舞台上，线段树不仅是解决问题的利器，更是展现个人算法功底和...
IOI国家集训队论文集1999-2019
09-20
+ [线段树](#线段树) + [单调队列](#单调队列) + [哈希表](#哈希表) + [Splay](#splay) * [图论](#图论) + [图论](#图论-1) + [模型建立](#模型建立) + [网络流](#网络流) + [最短路](#最短路) + [欧拉路]...
cogs 1672. [SPOJ 375] 难存的情缘 树链剖分套线段树 易错！ 全博客园最长最详细的题解...
weixin_30451709的博客
08-11 138
1672. [SPOJ 375] 难存的情缘 ★★★ 输入文件：qtree.in 输出文件：qtree.out简单对比时间限制：1 s 内存限制：256 MB 【题目描述】 一天机房的夜晚，无数人在MC里奋斗着。。。 大家都知道矿产对于MC来说是多么的重要，但由于矿越挖越少，勇士们不得不跑到更远的地方挖矿，但这样路途上就会花费相当大的时间，导致挖矿效率低下。 ...
线段树
destiny_balabala的博客
09-24 186
一、线段树简介 线段树是一种二叉树，与堆类似可以利用数组进行存储（下标从1开始）。线段树可以用于维护一个序列的某种属性，比如序列和、序列最大值、序列最小值等等。 二、举例说明 下面举例说明，线段树的结构以及一些操作。考虑这样一个序列：1、2、3、4、5、6、7。我们维护它的序列和。线段树结构如下图所示： 说明： 线段树的每个节点包含若干个数字。其中叶节点只包含一个数字 儿子节点的长度为父节点的一半。即：若当前序列为[L,R][L,R][L,R]，且R−L>0R-L>0R−L>0，则父节
线段树入门
森宝的博客
02-12 251
参考https://www.cnblogs.com/AC-King/p/7789013.html 一: 定义 线段树是一棵二叉树，树中的每一个结点表示了一个区间[a,b]。a,b通常是整数。 每一个叶子节点表示了一个单位区间。 对于每一个非叶子结点所表示的结点[a,b]， 其左儿子表示的区间为[a,(a+b)/2]，右儿 子表示的区间为[(a+b)/2 + 1,b]。 线段树适用于和区间统...
【学习笔记】线段树选做
cqbzlydd的博客
07-06 173
全是暴力一看这个线性递推关系显然是矩阵乘法码码码 。。。呼 。。写完了 。序列 hash ？毋宁称之为线段树维护序列 hash 值的好题类比 Permutation 。本质在于将复杂状态用一个整数表示，这样复杂度更优 。.....................
线段树/莫队杂题
baobi9210的博客
07-26 91
高速公路(road) 如果直接维护一个点到其它点的距离，维护起来很困难。 不妨转换思路，考虑每个点对答案的贡献， 设询问区间为$l,r$， 则点$i$的贡献为$(i-l)*(r-i)*w[i]=(-i^2+(l+r)*i-l*r)*w[i]$。 对于$i^2*w[i],i*w[i],w[i]$分别维护，再乘上只与$l,r$有关的系数即可。 CPU监控 鸽了 ...
动态序列与动态树问题——浅谈几种常用数据结构_莫凡.pdf
09-14
"动态序列与动态树问题——浅谈几种常用数据结构" 本文主要讨论了动态序列问题和动态树问题的解决方法，通过介绍了几种常用的平衡二叉树型数据结构来解决这些问题。动态序列问题是指在一个序列上执行一系列在线操作...
ACM必备书籍
05-20
《浅谈线段树在信息学竞赛中的应用》是ACM竞赛的必读书籍，由岳云涛所著，武汉大学出版于2012年。这本书涵盖了线段树在信息学竞赛中的应用的基础知识，包括线段树、算法设计、编程实现等内容。 《ACM/ICPC代 码 库...
Linux常用命令（三）
weixin_34405557的博客
04-15 83
Linux基本命令（三） 上两次博文中，讲述了linux命令关于文本操作命令和目录操作的相关命令，这一博文，我们讨论下怎么查看已经建立的文件、目录以及目录结构。今天总结了ls，ll，tree三个命令的总结。 1 ls命令 ls命令用于列出目前工作目录所包含的文件及其子目录，可以增加参数查看文件的权限(包括目录、文件夹、文件权限)，查看目录信息等等。 1.1 语法 ls[选项][目录名] ls命令就...
文件/目录操作（1）——ls、cd、pwd、tree；ll字段解释文件；文件颜色意义
醉解兰舟的博客
07-14 1129
Linux文件/目录操作命令之——文件、目录查看命令的总结： ls、cd、pwd、tree；ll字段解释文件；文件颜色意义
linux 常用的命令ll,Linux常用命令（三）
weixin_42452892的博客
05-13 339
Linux基本命令(三)上两次博文中，讲述了linux命令关于文本操作命令和目录操作的相关命令，这一博文，我们讨论下怎么查看已经建立的文件、目录以及目录结构。今天总结了ls，ll，tree三个命令的总结。1 ls命令ls命令用于列出目前工作目录所包含的文件及其子目录，可以增加参数查看文件的权限(包括目录、文件夹、文件权限)，查看目录信息等等。1.1 语法ls[选项][目录名]ls命令就是list的...
洛谷P1972 [SDOI2009]HH的项链 基础莫队+卡常/线段树离线
danzh
08-08 224
洛谷P1972 [SDOI2009]HH的项链 标签 基础莫队 卡常 前言 我的csdn和博客园是同步的，欢迎来访danzh-博客园~ 这才是最裸的莫队惹。然而数据加强了，莫队需要吸氧+卡常才能过，这篇文章就讲讲卡常吧~ 简明题意 给一个序列，支持两种操作： 查询[L,R]中有多少种不同的数字 将第i个数改为x 思路 这才是最裸的莫队惹。然而数据加强了，莫队需要吸氧+...
线段树详解
ling_wang的博客
08-12 7050
一.基本概念 1.线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 （严格来说：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点...
linux 树型显示文件 tree ls tree 命令
笔记
07-27 8717
yum install tree tree www │?? │?? │?? └── xml.test │?? │?? └── valgrind.supp │?? ├── README │?? ├── scripts │?? │?? └── mysql_install_db │?? ├── share │?? │?? ├── aclocal │?? │?? │?? └──
线段树 从入门到进阶（超清晰，简单易懂）
热门推荐
繁凡さん的博客
02-12 8万+
目录第一部 概念引入第二部 简单（无pushdown）的线段树1、单点修改，区间查询2、区间修改，单点查询第三部 进阶线段树第四部 乘法（根号）线段树1、乘法线段树2、根号线段树模板题与代码：单点修改，区间查询：洛谷树状数组模板1区间修改，单点查询：洛谷树状数组模板2区间加法，洛谷线段树模板1区间乘法：洛谷线段树模板2区间根号，bzoj3211 线段树是什么？？线段树怎么写？？ 如果你在考提高组前...
C语言 | Leetcode C语言题解之第337题打家劫舍III
最新发布
m0_59237910的博客
08-15 195
C语言 | Leetcode C语言题解之第337题打家劫舍III
线段树在信息学竞赛中的高效应用与实例解析
《浅谈线段树在信息学竞赛中的应用》是一篇由武汉大学的岳云涛撰写的论文，针对信息学竞赛中常见的区间问题提供了一种高效的解决方案。线段树是该文中讨论的核心数据结构，它是基于分治思想设计的二叉树形结构，特别...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值