浅谈线段树

最新推荐文章于 2024-10-14 09:00:00 发布
转载 最新推荐文章于 2024-10-14 09:00:00 发布 · 64 阅读 · 0 ·
CC 4.0 BY-SA版权
原文链接：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_73366312的博客
04-11 1608
几乎是算法竞赛最常用的数据结构了，它主要用于（要求满足结合律）。与树状数组相比，它可以实现的，还可以同时（加、乘），更具通用性。如题，已知一个数列，你需要进行下面两种操作：1.将某区间每一个数加上x2.求出某区间每一个数的和第一行包含两个整数N、M，分别表示该数列数字的个数和操作的总个数。第二行包含N个用空格分隔的整数，其中第i个数字表示数列第i项的初始值。
cogs 1672. [SPOJ 375] 难存的情缘 树链剖分套线段树 易错！ 全博客园最长最详细的题解...
weixin_30451709的博客
08-11 173
1672. [SPOJ 375] 难存的情缘 ★★★ 输入文件：qtree.in 输出文件：qtree.out简单对比时间限制：1 s 内存限制：256 MB 【题目描述】 一天机房的夜晚，无数人在MC里奋斗着。。。 大家都知道矿产对于MC来说是多么的重要，但由于矿越挖越少，勇士们不得不跑到更远的地方挖矿，但这样路途上就会花费相当大的时间，导致挖矿效率低下。 ...
线段树
destiny_balabala的博客
09-24 245
一、线段树简介 线段树是一种二叉树，与堆类似可以利用数组进行存储（下标从1开始）。线段树可以用于维护一个序列的某种属性，比如序列和、序列最大值、序列最小值等等。 二、举例说明 下面举例说明，线段树的结构以及一些操作。考虑这样一个序列：1、2、3、4、5、6、7。我们维护它的序列和。线段树结构如下图所示： 说明： 线段树的每个节点包含若干个数字。其中叶节点只包含一个数字 儿子节点的长度为父节点的一半。即：若当前序列为[L,R][L,R][L,R]，且R−L>0R-L>0R−L>0，则父节
线段树入门
森宝的博客
02-12 296
参考https://www.cnblogs.com/AC-King/p/7789013.html 一: 定义 线段树是一棵二叉树，树中的每一个结点表示了一个区间[a,b]。a,b通常是整数。 每一个叶子节点表示了一个单位区间。 对于每一个非叶子结点所表示的结点[a,b]， 其左儿子表示的区间为[a,(a+b)/2]，右儿 子表示的区间为[(a+b)/2 + 1,b]。 线段树适用于和区间统...
浅谈线段树——基础篇
jay_zai的博客
07-24 617
本文先讲解线段树的基础知识及其运用，更多进阶内容以后有时间再写（等我学会了再说 ）
BZOJ 2124 浅谈线段树动态维护双HASH判值域回文串
BerryKanry的博客
07-29 719
世界真的很大 哈希可以用来干很多事情，不光是判断存在性，还可以判断两个不太好比较的东西是不是相等，比如字符串 哈希也是具有可加减的性质的，使得动态维护哈希值成为可能，套上数据结构会更快 很多时候认真分析题目性质往往事半功倍 看起来很难写的东西认真写其实也没有那么难 也许我应该学学树状数组了233 还是算了吧 看题先： description：给一个1到N的排列{Ai}，询问是否存在1
BZOJ 3942 浅谈线段树维护哈希值+KMP优化暴力匹配
BerryKanry的博客
09-22 584
世界真的很大 这道题一开始就想了哈希，理论上是可以过的。。 提莫的这道题卡哈希 无可奈何写正解看题先：description：有一个S串和一个T串，长度均小于1,000,000，设当前串为U串， 然后从前往后枚举S串一个字符一个字符往U串里添加，若U串后缀为T，则去掉这个后缀继续流程。input：The first line will contain S. The second line wi
浅谈线段树标志下放
zamac1993的专栏
11-07 658
线段树不仅支持点修改，还可以支持区间更新，是一个非常实用的数据结构，关于点修改，基本不会涉及到标志下放的问题，这里不予讨论，而且这一类线段树问题一般来说也很简单，而涉及到区间操作往往会有标志下放的问题，而这个问题之前一直很困扰我，于是写一遍博客来警示自己。 首先举例一个问题： 有序列{A}，有以下三个操作： (1):add(L,R,v)，A[L]....A[R]每一个加v (2):
【学习笔记】线段树选做
cqbzlydd的博客
07-06 216
全是暴力一看这个线性递推关系显然是矩阵乘法码码码 。。。呼 。。写完了 。序列 hash ？毋宁称之为线段树维护序列 hash 值的好题类比 Permutation 。本质在于将复杂状态用一个整数表示，这样复杂度更优 。.....................
线段树/莫队杂题
baobi9210的博客
07-26 131
高速公路(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监控 鸽了 ...
【学习笔记】线段树详解（全）
aiauw80822的博客
05-20 436
【学习笔记】线段树详解（全） 和三个同学一起搞了接近两个月的线段树，头都要炸了T_T，趁心态尚未凉之前赶快把东西记下来。。。 【目录】 【基础】作者：\((Silent\)_\(EAG)\) 【懒标记】作者：\((Silent\)_\(EAG)\) 【扫描线】作者：\((IC\)_\(QQQ)\) 【权值线段树】作者：\((Xing\)_\(Ling)\) 【动态开点】作者：\((X...
数据结构编程实践20讲(Python版)—11线段树
最新发布
AnFany
10-14 991
数据结构编程实践20讲(Python版)—11线段树
linux 常用的命令ll,Linux常用命令（三）
weixin_42452892的博客
05-13 389
Linux基本命令(三)上两次博文中，讲述了linux命令关于文本操作命令和目录操作的相关命令，这一博文，我们讨论下怎么查看已经建立的文件、目录以及目录结构。今天总结了ls，ll，tree三个命令的总结。1 ls命令ls命令用于列出目前工作目录所包含的文件及其子目录，可以增加参数查看文件的权限(包括目录、文件夹、文件权限)，查看目录信息等等。1.1 语法ls[选项][目录名]ls命令就是list的...
Linux常用命令（三）
weixin_34405557的博客
04-15 118
Linux基本命令（三） 上两次博文中，讲述了linux命令关于文本操作命令和目录操作的相关命令，这一博文，我们讨论下怎么查看已经建立的文件、目录以及目录结构。今天总结了ls，ll，tree三个命令的总结。 1 ls命令 ls命令用于列出目前工作目录所包含的文件及其子目录，可以增加参数查看文件的权限(包括目录、文件夹、文件权限)，查看目录信息等等。 1.1 语法 ls[选项][目录名] ls命令就...
文件/目录操作（1）——ls、cd、pwd、tree；ll字段解释文件；文件颜色意义
醉解兰舟的博客
07-14 1214
Linux文件/目录操作命令之——文件、目录查看命令的总结： ls、cd、pwd、tree；ll字段解释文件；文件颜色意义
洛谷P1972 [SDOI2009]HH的项链 基础莫队+卡常/线段树离线
danzh
08-08 276
洛谷P1972 [SDOI2009]HH的项链 标签 基础莫队 卡常 前言 我的csdn和博客园是同步的，欢迎来访danzh-博客园~ 这才是最裸的莫队惹。然而数据加强了，莫队需要吸氧+卡常才能过，这篇文章就讲讲卡常吧~ 简明题意 给一个序列，支持两种操作： 查询[L,R]中有多少种不同的数字 将第i个数改为x 思路 这才是最裸的莫队惹。然而数据加强了，莫队需要吸氧+...
线段树详解
ling_wang的博客
08-12 7393
一.基本概念 1.线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。 （严格来说：二叉查找树（Binary Search Tree），（又：二叉搜索树，二叉排序树）它或者是一棵空树，或者是具有下列性质的二叉树： 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 若它的右子树不空，则右子树上所有结点的值均大于它的根结点...
线段树在信息学竞赛中的应用解析
"《浅谈线段树在信息学竞赛中的应用》武汉大学岳云涛" 线段树是一种高效的数据结构，尤其适用于处理区间查询和修改的问题。它基于分治的思想，将线段区间转化为树形结构，每个节点代表一个线段。线段树通常用于信息...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值