线段树入门参考博客及例题汇集（更新中）

已于 2022-05-28 16:38:08 修改
阅读量177 收藏 1
点赞数
分类专栏： 线段树 文章标签： 算法
于 2020-03-14 13:49:13 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/h_bby/article/details/104851376
版权

线段树原理图文详解
博客1
博客2
注意博客1 “区间修改，单点查询” 第一段代码的sum应为num以作为标记（可能博主笔误
“进阶线段树” 一节push_down函数中的data应为sum（可能博主笔误
博客1已经学到第4部
博客2还未仔细看，博客2有线段树实现的证明
模板
建树模板

const int mn=1e5+10;
struct Tree
{
	int l,r;
	ll sum,add,lz;//add为“区间修改，单点查询”中的标记；简单线段树用不到lz
}tree[mn*4];//节点数比叶子数大 

void build(int i,int l,int r)//i为父节点序号，
{
	tree[i].l=l;tree[i].r=r;
	if(l==r){
		scanf("%lld",&tree[i].sum);
		 return ;
	}
	int mid=(l+r)/2;
	build(i*2,l,mid);
	build(i*2+1,mid+1,r);
	tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
}

简单线段树
单点修改 区间查询模板

int search(int i,int l,int r)//注意：数据大时函数类型用 long long 
{
	if(tree[i].l>=l && tree[i].r<=r){
		return tree[i].sum;
	}
	if(tree[i].r<l || tree[i].l>r){
		return 0;
	}
	int s=0;
	if(tree[i*2].r>=l) s+=search(i*2,l,r);
	if(tree[i*2+l].l<=r) s+=search(i*2+1,l,r);
	return s;
} 

void updata(int i,int pos,int k)//i为父节点，pos为修改位置下标，k为变化量 
{
	if(tree[i].l==tree[i].r){
		tree[i].sum+=k;//若单点修改变为单点覆盖，这一步则改为tree[i].sum=k 
		return ;
	} 
	if(pos<=tree[i*2].r) updata(i*2,pos,k);
	else updata(i*2+1,pos,k);
	tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
	return ;
}

区间修改，单点查询模板

void updata (int i,int l,int r,int k)
{
	if(tree[i].l>=l && tree[i].r<=r){
		tree[i].add+=k; 
		return ;
	}
	if(tree[i*2].r>=l) updata(i*2,l,r,k);
	if(tree[i*2+1].l<=r) updata(i*2+1,l,r,k);
}

void search(int i,int pos)
{
	ans+=tree[i].add;//注意ans为路径上add的和，修改后单点的数值为ans+tree[pos].sum 
	if(tree[i].l==tree[i].r) return;
	if(pos<=tree[i*2].r) search(i*2,pos);
	if(pos>=tree[i*2+1].l) search(i*2+1,pos);
}

若区间修改变为区间覆盖，即将一个区间内的数全部改为一个数，则可以用原add变量记录修改的序号，并用一个新数组记录每个序号对应的数值。在查询时记录路径上的序号的最大值，最大序号在新数组上对应的数值即为查询点的数值。

进阶线段树
pushdown函数

void pushdown(int i)//将lazytage向下传，加到子节点的lz上，同时更新子节点的sum用于区间修改、查询
{
	if(tree[i].lz!=0)
	{
		tree[i*2].lz+=tree[i].lz;
		tree[i*2+1].lz+=tree[i].lz;
		int mid=(tree[i].l+tree[i].r)/2;
		tree[i*2].sum+=tree[i].lz*(mid-tree[i*2].l+1);
		tree[i*2+1].sum+=tree[i].lz*(tree[i*2+1].r-mid);
		tree[i].lz=0;
	}
}

区间修改，区间查询

void updata (int i,int l,int r,int k)
{
	if(tree[i].r<=r && tree[i].l>=l)
	{
		tree[i].sum+=k*(tree[i].r-tree[i].l+1);
		tree[i].lz+=k;
		return ;
	}
	pushdown(i);
	if(tree[i*2].r>=l) updata(i*2,l,r,k);
	if(tree[i*2+1].l<=r) updata(i*2+1,r,k);
	tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
	return ;
}

int search(int i,int l,int r)//数据大要改long long
{
	if(tree[i].l>=l && tree[i].r<=r) return tree[i].sum;
	if(tree[i].r<l || tree[i].l>r) return 0;
	pushdown(i);
	int s=0;
	if(tree[i*2].r>=l) s+=search(i*2,l,r);
	if(tree[i*2+1].l<=r) s+=search(i*2+1,l,r);
	return s;
}

乘法线段树
如果这个线段树只有乘法，那么直接加入lazytage变成乘，然后tree[i].sum*=k就好了。
但是，如果我们是又加又乘，那就不一样了。
当lz下标传递的时候，我们需要考虑，是先加再乘还是先乘再加。我们只需要对lz做这样一个处理。
lz分为两种，分别是加法的plz和乘法的mlz。
mlz很简单处理，pushdown时直接乘上父亲的就可以了，那么加法呢？
我们需要把原先的plz乘上父亲的mlz再加上父亲的plz.
新pushdown函数

void pushdown(long long i)//一般需要用long long 
{
	long long k1=tree[i].mlz,k2=tree[i].plz;
	tree[i*2].sum=(tree[i*2].sum*k1+k2*(tree[i*2].r-tree[i*2].l+1))%mod//一般数据很大需要取模 
	tree[i*2+1].sum=(tree[i*2+1].sum*k1+k2*(tree[i*2+1].r-tree[i*2+1].l+1))%mod;
	tree[i*2].mlz=(tree[i*2].mlz*k1)%mod;
	tree[i*2+1].mlz=(tree[i*2+1].mlz*k1)%mod;
	tree[i*2].plz=(tree[i*2].plz*k1+k2)%mod;
	tree[i*2+1].plz=(tree[i*2+1].plz*k1+k2)%mod;
	tree[i].plz=0;
	tree[i].mlz=1;
	return ;
}

模运算写法节省时间：

void pushdown(long long i)
{
    long long k1=tree[i].mlz,k2=tree[i].plz;
    tree[i<<1].sum=(tree[i<<1].sum*k1+k2*(tree[i<<1].r-tree[i<<1].l+1))%p;//
    tree[i<<1|1].sum=(tree[i<<1|1].sum*k1+k2*(tree[i<<1|1].r-tree[i<<1|1].l+1))%p;
    tree[i<<1].mlz=(tree[i<<1].mlz*k1)%p;
    tree[i<<1|1].mlz=(tree[i<<1|1].mlz*k1)%p;
    tree[i<<1].plz=(tree[i<<1].plz*k1+k2)%p;
    tree[i<<1|1].plz=(tree[i<<1|1].plz*k1+k2)%p;
    tree[i].plz=0;
    tree[i].mlz=1;
    return ;
}

区间加、乘修改模板
加：

void plus(int i,int l,int r,long long k)
{
	if(tree[i].r<=r && tree[i].l>=l)
	{
		tree[i].sum+=k*(tree[i].r-tree[i].l+1);
		tree[i].sum%=mod;
		tree[i].plz+=k;
		tree[i].plz%=k
		return ;
	}
	pushdown(i);
	if(tree[i*2].r>=l) plus(i*2,l,r,k);
	if(tree[i*2+1].l<=r) plus(i*2+1,l,r,k);
	tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
	return ;
}

乘：

void mul(int i,int l,int r,long long k)
{
	if(tree[i].r<=r && tree[i].l>=l)
	{
		tree[i].sum*=k;
		tree[i].sum%=mod;
		tree[i].mlz*=k;
		tree[i].mlz%=mod;
		tree[i].plz*=k;
		tree[i].plz%=mod;
		return ;
	}
	pushdown(i);
	if(tree[i*2].r>=l) mul(i*2,l,r,k);
	if(tree[i*2+1].l<=r) mul(i*2+1,l,r,k);
	tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
	return ;
}

例题
POJ3468
分析
模板题，直接套模板解题

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
typedef long long LL;

using namespace std;

const int maxn=100002;

struct Tree//树结构体
{
  	int l,r;
  	LL sum,lz;
 
}tree[4*maxn];

void build(int i,int l,int r)//递归建树模板，i为节点序号
{
 	tree[i].l=l;tree[i].r=r;
 	if(l==r)	//叶子节点
	 {
		  scanf("%lld",&tree[i].sum);
		  return;
	 }
	 int mid = (l + r) / 2;
	 build(i*2 , l , mid);
	 build(i*2+1 , mid+1 , r);
	 tree[i].sum = tree[i*2].sum + tree[i*2+1].sum;
}

void pushdown(int i)//pushdown函数用于区间修改和区间查询
{
 	if(tree[i].lz!=0)
    {
        tree[i*2].lz+=tree[i].lz;//左右儿子分别加上父亲的lz
        tree[i*2+1].lz+=tree[i].lz;
        int mid=(tree[i].l+tree[i].r)/2;
        tree[i*2].sum+=tree[i].lz*(mid-tree[i*2].l+1);//左右分别求和加起来
        tree[i*2+1].sum+=tree[i].lz*(tree[i*2+1].r-mid);
        tree[i].lz=0;//父亲lz归零
    }
    return ;
}

void add(int i,int l,int r,LL k)//区间修改函数
{
	 if(tree[i].r<=r && tree[i].l>=l)//若目前区间在目的区间内，则全部加上标记
	 {
		  tree[i].sum+=k*(tree[i].r-tree[i].l+1);
		  tree[i].lz+=k;
		  return ;
	 }
	 pushdown(i);
	 if(tree[i*2].r>=l) add(i*2,l,r,k);
	 if(tree[i*2+1].l<=r) add(i*2+1,l,r,k);
	 tree[i].sum=tree[i*2].sum+tree[i*2+1].sum;
	 return ;
}

LL search(int i,int l,int r)//区间查询函数
{
	 if(tree[i].l>=l && tree[i].r<=r) return tree[i].sum;
	 if(tree[i].r<l  || tree[i].l>r)  return 0;
	 pushdown(i);
	 LL s=0;
	 if(tree[i*2].r>=l) s+=search(i*2,l,r);
	 if(tree[i*2+1].l<=r) s+=search(i*2+1,l,r);
	 return s;
}

int main()
{
	  int N,Q;
	  scanf("%d%d",&N,&Q);
	  build(1,1,N);//建树
	  while(Q--)
	  {
		   char c;
		   getchar();
		   scanf("%c",&c);
		   if(c=='C'){
			    int a,b;
			    LL A;
			    scanf("%d%d%lld",&a,&b,&A);
			    add(1,a,b,A);
		   }
		   if(c=='Q'){
			    int a,b;
			    scanf("%d%d",&a,&b);
			    printf("%lld\n",search(1,a,b));
		   }
	  }
	  return 0;
}

区间修改，区间查询+状态压缩（位运算）
POJ2777
分析
线段树用来存颜色种类的状态，怎么存是关键。由于颜色数量较小，想到用一个“开关”数组来存一段区间（结点）各种颜色是否存在。比如颜色1在一段区间存在，那么turn[ 1 ] = 1，若颜色2不存在那么turn[ 2 ] = 0，之后每涂上颜色就将相应的“打开”或“关闭”，查询的时候对区间有的颜色进行合并统计即得出答案。这个方法理论上可以实行，但是过于麻烦。这时，我们看到“开关”数组和二进制十分类似，于是想到使用二进制和位运算来代替“开关数组”。
位运算参考博客
我们将第k种颜色表示为（2k-1)，这样第k种颜色用二进制表示时其从右到左第k位为1，对于不同的区间，若是涂改颜色，则直接对原颜色用新颜色进行覆盖，并用lazytage来记录新颜色（用于之后的pushdown）；若要查询区间有多少种颜色，则利用按位或运算对不同颜色进行合并并计算（按位或运算详见位运算参考博客，简单举个例子：二进制10001 | 01010 = 11011，这样就将不同颜色合并在了一起，只要将二进制中1的个数进行计算即可得出结果）
代码

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

typedef long long LL;

using namespace std;

const int maxn=100002;
int count(int k)//将第k种颜色转换为2^(k-1)
{
	 int res=1;
	 for(int i=1;i<k;i++) res*=2;
	 return res;
}

struct Tree
{
	  int l,r;
	  LL sum,lz;
}tree[4*maxn];

void build(int i,int l,int r)//建树模板
{
	 tree[i].l=l;tree[i].r=r;
	 if(l==r)
	 {
		  tree[i].sum=1; 
		  return;
	 }
	 int mid = (l + r) / 2;
	 build(i*2 , l , mid);
	 build(i*2+1 , mid+1 , r);
	 tree[i].sum = tree[i*2].sum | tree[i*2+1].sum;//这里为合并左右两子树的颜色
}
void push_down(int i)//pushdown函数
{
 if(tree[i].lz!=0)
    {
        tree[i*2].lz = tree[i].lz;//将父亲的lz即标记的颜色赋给左右儿子
        tree[i*2+1].lz = tree[i].lz;
        tree[i*2].sum = tree[i].lz;//左右儿子的颜色为父亲lz标记的颜色
        tree[i*2+1].sum = tree[i].lz;
        tree[i].lz = 0;//父亲lz归零
    }
    return ;
}
void add(int i,int l,int r,int k)
{
	 int K=count(k);
	 if(tree[i].r<=r && tree[i].l>=l)
	 {
		  tree[i].sum = K ;//覆盖颜色
		  tree[i].lz= K;//标记
		  return ;
	 }
	 push_down(i);
	 if(tree[i*2].r>=l) add(i*2,l,r,k);
	 if(tree[i*2+1].l<=r) add(i*2+1,l,r,k);
	 tree[i].sum=tree[i*2].sum | tree[i*2+1].sum;//合并左右两子树的颜色
	 return ;
}
int search(int i,int l,int r)
{
	 if(tree[i].l>=l && tree[i].r<=r) return tree[i].sum;
	 if(tree[i].r<l  || tree[i].l>r)  return 0;
	 push_down(i);
	 int s=0;
	 if(tree[i*2].r>=l) s= s | search(i*2,l,r);//合并区间上的颜色
	 if(tree[i*2+1].l<=r) s = s | search(i*2+1,l,r);
	 return s;
}
int main()
{
	  int L,T,O;
	  scanf("%d%d%d",&L,&T,&O);
	  build(1,1,L);
	  while(O--)
	  {
		   char c;
		   getchar();
		   scanf("%c",&c);
		   if(c=='C'){
			    int a,b,col;
			    scanf("%d%d%d",&a,&b,&col);
			    if(a>b){
				     int tmp=a;
				     a=b;b=tmp;
			    }
		    add(1,a,b,col);
		   }
		   if(c=='P'){
			    int a,b;
			    scanf("%d%d",&a,&b);
			    if(a>b){
				     int tmp=a;
				     a=b;b=tmp;
			    }
			    int sum=search(1,a,b);
			    int ans=0;
			    while(sum)
			    {
				     if(sum%2)ans++;
				     sum/=2;
			    }//转化二进制
			    printf("%d\n",ans);
		   }
	  }
  return 0;
}

单点更新，区间最大值
HDU1754
分析
模板题。
做的时候不知道有模板，就在原来区间修改区间查询的模板上进行套用。删去push_down函数（本题单点更新为从叶子节点到根节点，故不用push_down函数）
节点保存区间最大值，每次更新叶子节点，向上传递更新被包含节点（即所在区间）的最大值。
树的结构体数组开小了会TLE

代码

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

typedef long long LL;

using namespace std;

const int maxn=200002;
struct Tree
{
	  int l,r;
	  int H;
}tree[4*maxn];

void build(int i,int l,int r)//递归建树模板，i为节点序号
{
	  tree[i].l=l;tree[i].r=r;
	  if(l==r) //叶子节点
	  {
		    scanf("%d",&tree[i].H);
		    return;
	  }
	  int mid = (l + r) / 2;
	  build(i*2 , l , mid);
	  build(i*2+1 , mid+1 , r);
	  tree[i].H =max(tree[i*2].H , tree[i*2+1].H) ;
}

void add(int i,int num,int k)
{
	  if(tree[i].r==num && tree[i].l==num)
	 {
		  tree[i].H = k ;
		  return ;
	 }
	 if(tree[i*2].r>=num) add(i*2,num,k);
	 if(tree[i*2+1].l<=num) add(i*2+1,num,k);
	 tree[i].H=max(tree[i*2].H , tree[i*2+1].H);//已更新节点的上一个节点也要更新
	 return ;
}

int search(int i,int l,int r)
{
	 if(tree[i].l>=l && tree[i].r<=r) return tree[i].H;
	 if(tree[i].r<l  || tree[i].l>r)  return -1;
	 int s=-1;
	 if(tree[i*2].r>=l) s=max(s , search(i*2,l,r));//比较所涉及区间保存的最大值并记录
	 if(tree[i*2+1].l<=r) s =max(s , search(i*2+1,l,r));
	 return s;
}
int main()
{
	  int N,M;
	  while(~scanf("%d%d",&N,&M))
	  {
		  build(1,1,N);
		  while(M--)
		  {
			   char s[5];
			   scanf("%s",s);
			   if(s[0]=='U'){
				    int a,b;
				    scanf("%d%d",&a,&b);
				    add(1,a,b);
			   }else{
				    int a,b;
				    scanf("%d%d",&a,&b);
				    int ans=search(1,min(a,b),max(a,b));
				    printf("%d\n",ans);
			   }
		  }
	  }
	  return 0;
}
hobby_Z
关注
专栏目录
线段树 例题
ZCY的博客
07-30 291
A - 敌兵布阵 C国的死对头A国这段时间正在进行军事演习，所以C国间谍头子Derek和他手下Tidy又开始忙乎了。A国在海岸线沿直线布置了N个工兵营地,Derek和Tidy的任务就是要监视这些工兵营地的活动情况。由于采取了某种先进的监测手段，所以每个工兵营地的人数C国都掌握的一清二楚,每个工兵营地的人数都有可能发生变动，可能增加或减少若干人手,但这些都逃不过C国的监视。 中央情报局要研究敌人...
线段树模版（比较基本的线段树以及例题模板）
11-01
关于一些典型的线段树的例题，大家可以看一看，给一个评价，这些内容，后续我也会在博客上慢慢更新。希望大家多多的支持作者，谢谢！ 这篇内容主要包含了一些我写的线段树的代码，可以帮助大家更好的理解线段树建树...
线段树习题集
天亮说晚安
02-17 3855
线段树习题集 大部分来源于@NotOnlySuccess  一、点修改 最最基础的线段树,只更新叶子节点,然后把信息用PushUp(int rt)这个函数更新上来 hdu1166 敌兵布阵 线段树功能:update:单点增减 query:区间求和 解题报告 hdu1754 I Hate It 线段树功能:update:单点替换 query:区间最值 解
线段树的例题
默的博客
11-29 371
文章目录影子的宽度区间平方和问题：区间开根号问题stars逆序对 影子的宽度 题目描述 桌子上零散地放着若干个盒子，盒子都平行于墙。桌子的后方是一堵墙。如图所示。现在从桌子的前方射来一束平行光， 把盒子的影子投射到了墙上。问影子的总宽度是多少？ 输入 第1行：3个整数L，R，N。-100000 <=L<=R<= 100000，表示墙所在的区间；1<=N<=100000，表示盒子的个数 接下来N行，每行2个整数BL, BR，-100000 <=BL<=BR<=
线段树（例题）
CUCUC1的博客
07-11 218
线段树tq（巨佬太强了）l 题目链接 1、hdu1166敌兵布阵 最基础的线段树应用，这里没有用上区间修改，但是这个题可以当个板子 /*递归方法*/ #include <iostream> #include <cstring> #include <string> #include <cstdio> using namespace std; const int maxn = 50000 + 5;//元素总个数 int p[4 * maxn],add[4 *
权值线段树和主席树入门
09-25
权值线段树和主席树入门PPT，权值线段树，顾名思义就是记录权值的线段树，普通的线段树直接以坐标为l，r建树，而权值线段树是以大小来建树，树上寸的信息是该权值的数量，而通过建树时二分从小到大的性质，可以用这...
线段树（模板+例题——郭神）
02-17
线段树，有时也被称为区间树，是一种高效的数据结构，主要用于处理区间查询和区间更新的问题。它通过将一个大的区间划分为若干个较小的、互不重叠的子区间来实现这一功能。下面我们将详细介绍线段树的基本定义及其...
线段树入门
08-05
线段树入门资料，有利于初学者学习，让他们详细了解线段树。
线段树入门学习(三）懒操作(兼解POJ1823) JAVA
04-14
在本篇博文中，我们将深入探讨线段树的概念，以及如何实现懒惰更新（Lazy Propagation）策略，同时结合POJ1823问题进行实战应用。懒惰更新是优化线段树性能的关键技巧，它避免了频繁地对每个节点进行更新，从而减少...
线段树例题
Tom~~~
08-16 699
线段树是一种二叉搜索树，将原始数据都存在叶节点，依次表示出每个叶节点的根节点。 一般数组开到叶节点数量的4倍。 关于线段树的例题 。HDU1166 敌兵布阵 按照指示来就可以 代码 #include &lt;stdio.h&gt; #include &lt;algorithm&gt; #include &lt;iostream&gt; #include &lt;string&gt; u...
【例题】【线段树】
ANG
07-08 1082
NKOJ 1321 数列操作问题 时间限制 : 10000 MS 空间限制 : 165536 KB 问题描述 假设有一列数{Ai}(1≤i≤n)，支持如下两种操作： 将Ak的值加D。（k, D是输入的数） 输出As+As+1+…+At。（s, t都是输入的数，S≤T）输入格式 第一行一个整数n， 第二行为n个整数，表示{Ai}的初始值≤10000。 第三行为一个整数m
线段树例题 题解
日居月诸的博客
09-11 474
文章目录T1题目链接解题思路详细代码T2题目链接解题思路详细代码T3题目链接解题思路详细代码 T1 题目链接 LOJ#10128. 「一本通 4.3 练习 2」花神游历各国 解题思路 首先，由于是区间问题，我们很容易想到使用线段树来维护区间和，完成区间修改操作。 但是区间修改操作并不好处理。如果对于区间里每个数都暴力地开平方，这一次操作的时间复杂度可是会退化成为O(n)O(n)O(n)的！ 怎么办...
基本线段树以及相关例题
最新发布
2301_80475191的博客
04-04 901
线段树是一种，也就是对于一个线段，我们会用一个二叉树来表示。这个其实就是一个线段树，我们会将其每次从中间分开，其左孩子就是左边的集合的和，其右孩子就是右边集合的和；我们可以用一个结构体tree去表示线段树的结点，tree.L代表线段树左边界,tree.R代表线段树的右边界；因此我们可以得到一个结论，对于一个节点编号为i的结点，其左孩子的编号为i*2，其右孩子编号为i*2+1；那么首先写出我们的建树代码。
线段树及经典习题
weixin_42034081的博客
04-04 1143
线段树（Segment Tree） 首先我们知道二叉树，balanced 二叉树可以保证查找的复杂度是logn的复杂度。理解起来十分直观：大概这样子： 如你所见，底层的就是单个的元素，每往上走一层，就会根据底层的元素做一个范围查询（rangeQuery）操作，这个操作可以是求和，求最小，求最大，同时上一层就会cover all the union of the children's range there are four operations in total: build(start,e
线段树的各种题目
A_Thinking_Reed_的博客
03-16 803
目录 类型：单点更新、区间查询 题目：敌兵布阵——https://vjudge.net/contest/285952#problem/A 题目：I hate it——https://vjudge.net/contest/285952#problem/B 题目：Balanced Lineup——https://vjudge.net/contest/285952#problem/E 类型...
蓝桥杯 操作格子（线段树例题）
sinat_37478202的博客
04-08 341
http://www.tudou.com/programs/view/ek_xh3IaBWw/?qq-pf-to=pcqq.group 线段树视频讲解 http://blog.csdn.net/x314542916/article/details/7837276 博客讲解 #include int Testmax(int a,int b)//判断大小的函数 {return a>b?a:
线段树练习题一
闲人请进
04-14 267
线段树练习题一 Description 桌子上零散地放着若干个盒子，桌子的后方是一堵墙。如右图所示。现在从桌子的前方射来一束平行光， 把盒子的影子投射到了墙上。问影子的总宽度是多少？  分析：给线段树每个节点增加一个域cover。cover=1表示该结点所对应的区间被完全覆盖，cover=0表示该结点所对应的区间未被完全覆盖，最后统计一下。 代码   const   max
线段树入门详解：区间加法与高效查询
算法艺术-线段树入门教程首先介绍了线段树的基本概念，指出其主要目的是解决动态统计问题，如给定一个包含n个整数的数组A，需要支持对单个元素的修改、区间内元素之和的修改，以及查询某个区间内的元素和。...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值