线段树是一定要会线段树的 。线段树的精髓 ——板子+作用+详细注释+内容

最新推荐文章于 2023-03-19 21:20:49 发布
最新推荐文章于 2023-03-19 21:20:49 发布
阅读量1.2k 收藏 6
点赞数 5
分类专栏： 使用方法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Strawberry_595/article/details/81233454
版权

一：为什么需要线段树？

题目1：
10000个正整数，编号从1到10000，用A[1],A[2],A[10000]表示。
修改：1.将第L个数增加C （1 <= L <= 10000）
统计：1.编号从L到R的所有数之和为多少？ 其中1<= L <= R <= 10000.

上面的问题就是典型的线段树点修改。

线段树先将区间[1..10000]分成不超过4*10000个子区间，对于每个子区间，记录一段连续数字的和。

之后，任意给定区间[L,R]，线段树在上述子区间中选择约2*log2(R-L+1)个拼成区间[L,R]。

如果A[L]+=C ，线段树的子区间中，约有log2(10000)个包含了L，所以需要修改log2(10000)个。

 

于是，使用线段树的话，

A[L]+=C 需要修改log2(10000) 个元素

求和A[L...R]需要修改2*log2(R-L+1) <= 2 * log2(10000) 个元素。

log2(10000) < 14 所以相对来说线段树的修改和求和都比较快。

问题一：开始的子区间是怎么分的？

首先是讲原始子区间的分解，假定给定区间[L,R]，只要L < R ，线段树就会把它继续分裂成两个区间。

首先计算 M = (L+R)/2，左子区间为[L,M]，右子区间为[M+1,R]，然后如果子区间不满足条件就递归分解。

以区间[1..13]的分解为例，分解结果见下图：

 

 

问题二：给定区间【L,R】，如何分解成上述给定的区间？

对于给定区间[2,12]要如何分解成上述区间呢？

 

分解方法一：自下而上合并——利于理解

先考虑树的最下层，将所有在区间[2,12]内的点选中，然后，若相邻的点的直接父节点是同一个，那么就用这个父节点代替这两个节点（父节点在上一层）。这样操作之后，本层最多剩下两个节点。若最左侧被选中的节点是它父节点的右子树，那么这个节点会被剩下。若最右侧被选中的节点是它的父节点的左子树，那么这个节点会被剩下。中间的所有节点都被父节点取代。对最下层处理完之后，考虑它的上一层，继续进行同样的处理。

 

下图为n=13的线段树，区间[2,12]，按照上面的叙述进行操作的过程图：

由图可以看出：在n=13的线段树中，[2,12]=[2] + [3,4] + [5,7] + [8,10] + [11,12] 。

 

分解方法二：自上而下分解——利于计算

首先对于区间[1,13]，计算(1+13)/2 = 7，于是将区间[2,12]“切割”成了[2,7]和[8,12]。

其中[2,7]处于节点[1,7]的位置，[2,7] < [1,7] 所以继续分解，计算(1+7)/2 = 4, 于是将[2,7] 切割成[2,4]和[5,7]。

[5,7]处于节点[5,7]的位置，所以不用继续分解，[2,4]处于区间[1,4]的位置，所以继续分解成[2]和[3,4]。

最后【2】 < 【1,2】，所以计算(1+2)/2=1 ，将【2】用1切割，左侧为空，右侧为【2】

当然程序是递归计算的，不是一层一层计算的，上图只表示计算方法，不代表计算顺序。

 

 

问题三：如何进行区间统计？

假设这13个数为1,2,3,4,1,2,3,4,1,2,3,4,1. 在区间之后标上该区间的数字之和：

如果要计算[2,12]的和，按照之前的算法：

[2,12]=[2] + [3,4] + [5,7] + [8,10] + [11,12]

  29  = 2 + 7 + 6 + 7 + 7

计算5个数的和就可以算出[2,12]的值。

 

问题四：如何进行点修改？

假设把A[6]+=7 ,看看哪些区间需要修改？[6],[5,6],[5,7],[1,7],[1,13]这些区间全部都需要+7.其余所有区间都不用动。

于是，这颗线段树中，点修改最多修改5个线段树元素（每层一个）。

下图中，修改后的元素用蓝色表示。

问题五：存储结构是怎样的？

 

线段树是一种二叉树，当然可以像一般的树那样写成结构体，指针什么的。

但是它的优点是，它也可以用数组来实现树形结构，可以大大简化代码。

数组形式适合在编程竞赛中使用，在已经知道线段树的最大规模的情况下，直接开足够空间的数组，然后在上面建立线段树。
简单的记法： 足够的空间 = 数组大小n的四倍。 
实际上足够的空间 =  （n向上扩充到最近的2的某个次方）的两倍。
举例子：假设数组长度为5，就需要5先扩充成8，8*2=16.线段树需要16个元素。如果数组元素为8，那么也需要16个元素。
所以线段树需要的空间是n的两倍到四倍之间的某个数，一般就开4*n的空间就好，如果空间不够，可以自己算好最大值来省点空间。
 

怎么用数组来表示一颗二叉树呢？假设某个节点的编号为v,那么它的左子节点编号为2*v，右子节点编号为2*v+1。

然后规定根节点为1.这样一颗二叉树就构造完成了。通常2*v在代码中写成 v<<1 。 2*v+1写成 v<<1|1 。

 

代码如何实现呢：

建树：

using namespace std;
typedef long long LL;
const int maxn = 1e5 + 5;

int sum[maxn], a[maxn], n;

void pushup(int x)
{
	sum[x] = sum[x * 2] + sum[x * 2 + 1];
}
void build(int l , int r, int x) //建树   [l,r]表示当前节点区间， x表示当前节点的储存下标（其实是二分图的特性）；
{
	if(l == r){    //到达最后的叶子节点
		sum[x] = a[l];
		return ;
	}
	int mid = (l + r) / 2;   
	build(l , mid, x * 2);   //左儿子建树
	build(mid + 1, r, x * 2 + 1);   //右儿子建树
	pushup(x);    //下推更新
}

 单点更新：

void update(int L,int c,int l, int r, int x)  //单点修改    [l,r]表示当前节点区间， x表示当前节点的储存下标，L为修改点下标， c为a[L] += c;
{
	if(l == r) {
		sum[x] += c;    //找到最后的叶子节点
		return ;
	}
	int mid = (l + r) / 2;
	if(L <= m) update(L, c, l, mid, x * 2);    // 调用左儿子
	else update(L, c, mid + 1, r, x * 2 + 1);   //调用右儿子
	pushup(x);
}

区间查询：

int query(int L, int R,int l, int r, int x)   //区间查询   [l,r]表示当前节点区间， x表示当前节点的储存下标 ， [L, R]为你想要查询的区间
{
	if(L <= l && r <= R){
		return sum[x];      //[l, r] 完整的存在于[L,R] 是直接返回值；
	}
	int  mid = (l + r) / 2;
	int ans = 0;
	if(L <= m) ans += query(L, R, l, mid, x * 2);    //调用左儿子
	if(R > m) ans += query(L, R, mid + 1, r,x * 2 + 1);  //调用右儿子
	return ans;
}

下面用lazy的思想介绍一下区间修改：

 

区间成段更新

Lazy：正常来说，区间改值，当更改某个区间的值的时候，子区间也该跟着更改，这样容易TLE。

Lazy思想就是更新到某个区间的时候，就先给这个区间打上标记，标记内容是需要更新的值，并把子区间的值改为子区间对应的值，清除该区间的lazy标记；然后return，不去更新子区间。当下一次更新或查询等需要访问该区间的子区间的时候再把该区间的lazy和其他信息送回子区间。

 

举个简单粗暴的例子：

对应下面的那个图，假如目的是求和，现在要给[1,6] 的值都加2，那么我们从[1,12]->[1,6]，然后[1,6]的sum值加上区间长度[ (6-1+1)*2 ]，再把[1,6]的add[i]设置为2，就不再往下更新了【这里极大提高效率】。下一次更新/查询[1,6]的子区间时，我们将[1,6]原存的add值下传给[1,6]的两个直接子区间，再往下更新。假设在这种情况下，我们再更新[1,6]加3，则[1,6]的add值为2+3=5，然后我们查询[1,3]，则从上往下经过[1,6]时把[1,6]的add值给了子区间[1,3]和[4,6]，同时把sum[子区间]跟着子区间长度和add[父结点]改动，清除add[父节点]。【如果是查询间接子区间，则连续传递add值，也就是连续pushDown】

 

详细例子：假设update()是区间改值，query()是求和，所有叶子区间的和都为1，则[7,8]和[7,9]在build()的时候就附上了值（图中绿色字体）。假设此时我们更新[7,9]的值，改为2，则线段树从[1,12]->[7,12]->[7,9]，然后把[7,9]打上值为2的标记，求和（求和直接用区间长度*此时更新的值），然后不去更新[7,8]和[9,9]了，他们值仍然是2和1，lazy值为0。

然后我们查询[7,8]，当遍历经过[7,9]时 

if(add[i])

pushDown(i);

 

成立，把[7,9]的lazy标记2传给子区间[7,8]和[9,9],分别求这2个子区间的和，把[7,9]的lazy标记去掉，然后继续遍历，到[7,8]的时候直接返回答案。

 

————————————————————————————————————————————————————————————
 
在此通俗的解释我理解的Lazy意思，比如现在需要对[a,b]区间值进行加c操作，那么就从根节点[1,n]开始调用update函数进行操作，如果刚好执行到一个子节点，它的节点标记为rt，这时tree[rt].l == a && tree[rt].r == b 这时我们可以一步更新此时rt节点的sum[rt]的值，sum[rt] += c * (tree[rt].r - tree[rt].l + 1)，注意关键的时刻来了，如果此时按照常规的线段树的update操作，这时候还应该更新rt子节点的sum[]值，而Lazy思想恰恰是暂时不更新rt子节点的sum[]值，到此就return，直到下次需要用到rt子节点的值的时候才去更新，这样避免许多可能无用的操作，从而节省时间 。
 
下面通过具体的代码来说明之。
 
在此先介绍下代码中的函数说明：
 
#define lson l,m,rt<<1
#define rson m+1,r,rt<<1|1
 

宏定义左儿子lson和右儿子rson，貌似用宏的速度要慢。
 
PushUp(rt)：通过当前节点rt把值递归向上更新到根节点
 
PushDown(rt)：通过当前节点rt递归向下去更新rt子节点的值
 
rt表示当前子树的根(root),也就是当前所在的结点

LL sum[N<<2],add[N<<2];
struct Node
{
    int l,r;
    int mid()
    {
        return (l+r)>>1;
    }
} tree[N<<2];
这里定义数据结构sum用来存储每个节点的子节点数值的总和，add用来记录该节点的每个数值应该加多少

tree[].l tree[].r分别表示某个节点的左右区间，这里的区间是闭区间
 
下面直接来介绍update函数，Lazy操作主要就是用在这里
void update(int c,int l,int r,int rt)//表示对区间[l,r]内的每个数均加c，rt是根节点
{
    if(tree[rt].l == l && r == tree[rt].r)
    {
        add[rt] += c;
        sum[rt] += (LL)c * (r-l+1);
        return;
    }
    if(tree[rt].l == tree[rt].r) return;
    PushDown(rt,tree[rt].r - tree[rt].l + 1);
    int m = tree[rt].mid();
    if(r <= m) update(c,l,r,rt<<1);
    else if(l > m) update(c,l,r,rt<<1|1);
    else
    {
        update(c,l,m,rt<<1);
        update(c,m+1,r,rt<<1|1);
    }
    PushUp(rt);
}
if(tree[rt].l == l && r == tree[rt].r) 这里就是用到Lazy思想的关键时刻 正如上面说提到的，这里首先更新该节点的sum[rt]值，然后更新该节点具体每个数值应该加多少即add[rt]的值，注意此时整个函数就运行完了，直接return，而不是还继续向子节点继续更新，这里就是Lazy思想，暂时不更新子节点的值。
 
那么什么时候需要更新子节点的值呢？答案是在某部分update操作的时候需要用到那部分没有更新的节点的值的时候，这里可能有点绕口。这时就掉用PushDown()函数更新子节点的数值。
void PushDown(int rt,int m)
{
    if(add[rt])
    {
        add[rt<<1] += add[rt];
        add[rt<<1|1] += add[rt];
        sum[rt<<1] += add[rt] * (m - (m>>1));
        sum[rt<<1|1] += add[rt] * (m>>1);
        add[rt] = 0;//更新后需要还原
    }
}
PushDown就是从当前根节点rt向下更新每个子节点的值，这段代码读者可以自己好好理解，这也是Lazy的关键。

接着就是update操作的三个if语句了


下面再解释query函数，也就是用这个函数来求区间和
__int64 query(int l,int r,int rt)
{
    if(l == tree[rt].l && r == tree[rt].r)
    {
        return sum[rt];
    }
    PushDown(rt,tree[rt].r - tree[rt].l + 1);
    int m = tree[rt].mid();
    LL res = 0;
    if(r <= m) res += query(l,r,rt<<1);
    else if(l > m) res += query(l,r,rt<<1|1);
    else
    {
       res += query(l,m,rt<<1);
       res += query(m+1,r,rt<<1|1);
    }
    return res;
}
第一个if还是区间的判断和前面update的一样，到这里就可以知道答案了，所以就直接return。

接下来的查询就需要用到rt子节点的值了，由于我们用了Lazy操作，这段的数值还没有更新，因此我们需要调用PushDown函数去更新之，满足if(add[rt])就说明还没有更新。

 

下面给出完整的代码：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <queue>
#include <vector>
#include <map>
#define debug(x) std::cerr << #x << " = " << (x) << std::endl 

using namespace std;
typedef long long LL;
const int maxn =  1e5;


struct Tree {
	int l, r;
	LL sum, lazy;
}tree[maxn * 4 + 5];
LL A[maxn + 5];
int n, Q;
void Build(int L, int R, int x) {
	tree[x].l = L, tree[x].r = R, tree[x].lazy = 0;
	if(L == R) {
		tree[x].sum = A[L];
		return ;
	}
	int mid = (L + R) / 2;
	Build(L, mid, x * 2);
	Build(mid + 1, R, x * 2 + 1);
	tree[x].sum = tree[x * 2].sum + tree[x * 2 + 1].sum;
}
void PushDown(int x) {
	if(tree[x].lazy) {
		tree[x * 2].lazy += tree[x].lazy;
		tree[x * 2 + 1].lazy += tree[x].lazy;
		tree[x * 2].sum += tree[x].lazy * (LL)(tree[x * 2].r - tree[x * 2].l + 1);
		tree[x * 2 + 1].sum += tree[x].lazy * (LL)(tree[x * 2 + 1].r - tree[x * 2 + 1].l + 1);
		tree[x].lazy = 0LL;
	}
}
void Update(int L, int R, LL add, int x) {
	if(L <= tree[x].l && tree[x].r <= R) {
		tree[x].sum += add * (LL)(tree[x].r - tree[x].l + 1);
		tree[x].lazy += (LL)add;
		return ;
	}
	PushDown(x);
	int mid = (tree[x].l + tree[x].r) / 2;
	if(L <= mid)Update(L, R, add, x * 2);
	if(R > mid)Update(L, R, add, x * 2 + 1);
	tree[x].sum = tree[x * 2].sum + tree[x * 2 + 1].sum;
}
LL Query(int L, int R, int x) {
	if(L <= tree[x].l && tree[x].r <= R)return tree[x].sum;
	PushDown(x);
	int mid = (tree[x].l + tree[x].r) / 2;
	LL res = 0LL;
	if(L <= mid)res += Query(L, R, x * 2);
	if(R > mid)res += Query(L, R, x * 2 + 1);
	return res;
}
int main() {
	scanf("%d%d", &n, &Q);
	for(int i = 1; i <= n; i++)scanf("%lld", &A[i]);
	Build(1, n, 1);
	for(int i = 1; i <= Q; i++) {
		char c; int l, r;
		scanf(" %c%d%d", &c, &l, &r);
		if(c == 'Q')printf("%lld\n", Query(l, r, 1));
		else {
			LL b; scanf("%lld", &b);
			Update(l, r, b, 1);
		}
	}
	return 0;
}


 

 

 

————————————————————————————————————————————————————————————

下面给出例题，可以练练手：

区间求和，区间改值

  POJ上3468 就是一道裸的线段树的板子题：

You have N integers, A1, A2, ... , AN. You need to deal with two kinds of operations. One type of operation is to add some given number to each number in a given interval. The other is to ask for the sum of numbers in a given interval.

Input

The first line contains two numbers N and Q. 1 ≤ N,Q ≤ 100000.
The second line contains N numbers, the initial values of A1, A2, ... , AN. -1000000000 ≤ Ai ≤ 1000000000.
Each of the next Q lines represents an operation.
"C a b c" means adding c to each of Aa, Aa+1, ... , Ab. -10000 ≤ c ≤ 10000.
"Q a b" means querying the sum of Aa, Aa+1, ... , Ab.

Output

You need to answer all Q commands in order. One answer in a line.

Sample Input

10 5
1 2 3 4 5 6 7 8 9 10
Q 4 4
Q 1 10
Q 2 4
C 3 6 3
Q 2 4

Sample Output

4
55
9
15

Hint

The sums may exceed the range of 32-bit integers.

 

ac代码：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <queue>
#include <vector>
#include <map>
#define debug(x) std::cerr << #x << " = " << (x) << std::endl 

using namespace std;
typedef long long LL;


 
const int maxn = 1e5 + 5;
LL sum[maxn * 4],add[maxn * 4];
LL gg[maxn];
 
void pushUp(int x){
    sum[x] = sum[x * 2] + sum[x * 2 + 1];
}
 
void pushDown(int x,int l,int r){
    if(add[x]){
        int m = (l + r) / 2;
        add[x * 2] += add[x];
        add[x * 2 + 1] += add[x];
        sum[x * 2] += add[x] * (m - l + 1);
        sum[x * 2 + 1] += add[x] * (r - m);
        add[x] = 0;
    }
}
 
void build(int x,int l,int r){
    if(l == r){
    	sum[x] = gg[l];
        add[x] = 0;
        return ;
    }
    int m = (l + r) / 2;
    build(x * 2 ,l ,m);
    build(x * 2 + 1 ,m + 1 ,r);
    pushUp(x);
}
 
void update(int a,int b,LL v,int k,int l,int r){
    if(a <= l && r <= b){
        add[k] += v;
        sum[k] += v * (r - l + 1);
        return ;
    }
    pushDown(k ,l ,r);
    int m = (l + r) / 2;
    if(a <= m)
        update(a ,b ,v ,k * 2 ,l ,m);
    if(b > m)
        update(a ,b ,v ,k * 2 + 1 ,m + 1 ,r);
    pushUp(k);
}
 
LL ask(int a,int b,int x,int l,int r){
    if(a <= l && r <= b)
        return sum[x];
    pushDown(x ,l ,r);
    int m = (l + r) / 2;
    LL ans = 0;
    if(a <= m)
        ans += ask(a ,b ,x * 2 ,l ,m);
    if(b > m)
        ans += ask(a ,b ,x * 2 + 1 ,m + 1 ,r);
    pushUp(x);
    return ans;
}
 
int main()
{
    int i,j,n,q,a,b;
    char c;
    scanf("%d %d",&n ,&q);
    for(int i = 1;i <= n;i++) scanf("%lld",&gg[i]);
    build(1,1,n);
    while(q--)
    {
        scanf(" %c%d%d",&c,&a,&b);
        if(c =='C'){
            LL v;
            scanf("%lld",&v);
            update(a,b,v,1,1,n);
        }
        else{
            printf("%lld\n",ask(a,b,1,1,n));
        }
    }
    return 0;
}

还有另一种AC代码：

#include <cstdio>
#include <cmath>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <string>
#include <queue>
#include <vector>
#include <map>
#define debug(x) std::cerr << #x << " = " << (x) << std::endl 

using namespace std;
typedef long long LL;
const int maxn =  1e5;


struct Tree {
	int l, r;
	LL sum, lazy;
}tree[maxn * 4 + 5];
LL A[maxn + 5];
int n, Q;
void Build(int L, int R, int x) {
	tree[x].l = L, tree[x].r = R, tree[x].lazy = 0;
	if(L == R) {
		tree[x].sum = A[L];
		return ;
	}
	int mid = (L + R) / 2;
	Build(L, mid, x * 2);
	Build(mid + 1, R, x * 2 + 1);
	tree[x].sum = tree[x * 2].sum + tree[x * 2 + 1].sum;
}
void PushDown(int x) {
	if(tree[x].lazy) {
		tree[x * 2].lazy += tree[x].lazy;
		tree[x * 2 + 1].lazy += tree[x].lazy;
		tree[x * 2].sum += tree[x].lazy * (LL)(tree[x * 2].r - tree[x * 2].l + 1);
		tree[x * 2 + 1].sum += tree[x].lazy * (LL)(tree[x * 2 + 1].r - tree[x * 2 + 1].l + 1);
		tree[x].lazy = 0LL;
	}
}
void Update(int L, int R, LL add, int x) {
	if(L <= tree[x].l && tree[x].r <= R) {
		tree[x].sum += add * (LL)(tree[x].r - tree[x].l + 1);
		tree[x].lazy += (LL)add;
		return ;
	}
	PushDown(x);
	int mid = (tree[x].l + tree[x].r) / 2;
	if(L <= mid)Update(L, R, add, x * 2);
	if(R > mid)Update(L, R, add, x * 2 + 1);
	tree[x].sum = tree[x * 2].sum + tree[x * 2 + 1].sum;
}
LL Query(int L, int R, int x) {
	if(L <= tree[x].l && tree[x].r <= R)return tree[x].sum;
	PushDown(x);
	int mid = (tree[x].l + tree[x].r) / 2;
	LL res = 0LL;
	if(L <= mid)res += Query(L, R, x * 2);
	if(R > mid)res += Query(L, R, x * 2 + 1);
	return res;
}
int main() {
	scanf("%d%d", &n, &Q);
	for(int i = 1; i <= n; i++)scanf("%lld", &A[i]);
	Build(1, n, 1);
	for(int i = 1; i <= Q; i++) {
		char c; int l, r;
		scanf(" %c%d%d", &c, &l, &r);
		if(c == 'Q')printf("%lld\n", Query(l, r, 1));
		else {
			LL b; scanf("%lld", &b);
			Update(l, r, b, 1);
		}
	}
	return 0;
}

 

 

温暖会追上来的.
关注
  • 5
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
线段树的各种板子
I‘m F
12-17 1259
很明显不是刚刚写的线段树线段树是什么呢？线段树啊… 大概就是一颗可爱的二叉树… 它的每一个节点代表着一个区间的一个性质… (比如说最大值最小值还有和之类的…) 然后因为是二叉树所以有很多奇奇怪怪的东西都来了… 至于有什么也不打算细讲。 一个点x的左儿子就是x*2呀，右儿子就是x*2+1呀 还有在线段树里面 叶儿子或者说叶节点 所代表的区间是1呀。 想象成初中历史书上的周朝等级制度图就
线段树板子
bunny_1024的博客
01-19 304
题目链接： 【模板】线段树 1 - 洛谷 【模板】线段树 2 - 洛谷 代码： 线段树1 #include <iostream> #include <algorithm> #include <vector> #include <queue> #include <cstring> #include <string> #define int long long using namespace std; const int m
线段树详解（附图解，模板及经典例题分析）
qq_63786973的博客
10-31 2709
线段树是一种常用来维护区间信息的数据结构 ​ 可以在 O(logn) 的时间复杂度内实现单点修改、区间修改、区间查询（区间求和，求区间的最大值，求区间的最小值）等操作 ​ 如下图所示，线段树是建立在区间基础上的树，树的每个节点都代表着一段区间【L，R】
线段树模板(史上最简单易懂的数据结构)
weixin_54442315的博客
04-19 2910
什么是线段树？ 线段树言下之意就是将线段分解为一颗树，并且这颗树是一颗二叉树，树上的每一个节点都具有某些性质。 线段树有什么用？ 线段树主要能够在O(logn)的时间复杂度上解决区间上的问题。 题目引入：AcWing243.一个简单的整数问题2 本题目就是很简单的线段树的板子题，可以用来当做模板来使用。 线段树的几个重要操作： 1.tree[]数组的建立： struct node{ int l;//表示左端点 int r;//表示右端点 int v;//表示区间内的...
线段树（模板+例题——郭神）
02-17
线段树（模板+例题——郭神） 私用，随意拿！
线段树（单点查询+区间求和）无lazy标记
01-20
在“线段树（单点查询+区间求和）无lazy标记”这个题目中，主要涉及到线段树的基本操作，包括如何构建线段树、单点修改以及区间求和。 1. **线段树的构建**： - `build`函数是线段树的初始化过程。它从根节点开始...
LDUOJ 时间锁链 （状压+线段树 ）
01-06
时间锁链 时间限制: 1 Sec 内存限制: 128 MB [命题人:admin] [ Edit] [ TestData] 题目描述 当墨老师找到封闭时间环中最小的逆序对数后，他就可以将时间环展开成一个长L的时间锁链（我们可以将之看成是一根很长的...
CodeForces_1348EF – Phoenix and Memory 贪心+线段树找区间最小值
01-03
这题如果没有输出2个解就很简单。 是个之前做过的类型： 把所有限制按R排序， 然后每次取出R最小的，然后从其L开始选，尽量选能选的中最小的。 这样选如果能选完，就说明有解。 贪心正确性显然：R大的至少可以选则R...
线段树模版（比较基本的线段树以及例题模板）
最新发布
11-01
关于一些典型的线段树的例题，大家可以看一看，给一个评价，这些内容，后续我也会在博客上慢慢更新。希望大家多多的支持作者，谢谢！ 这篇内容主要包含了一些我写的线段树的代码，可以帮助大家更好的理解线段树建树...
线段树模板（Java）
Easenyang的博客
12-06 2432
  线段树是一种二叉搜索树，与区间树相似，它将一个区间划分成一些单元区间，每个单元区间对应线段树中的一个叶结点。它的主要优势是对于区间求和、区间求最大值、区间修改和单点修改的速度快，时间复杂度能达到O(logN)O(logN)O(logN)。   若以常规的方法在数组中进行区间求和等操作，时间复杂度会达到O(n)O(n)O(n)，若操作的次数量非常大，那么就很容易超时。线段树的优势就体现出来了   线段树的实现基于一维数组，用数组下标 2∗k+12 * k +12∗k+1 的元素代表左儿子，用下标 2∗k+
线段树模板
听取WA声一片
10-28 1911
线段树 打标记
线段树详解(超详细)
Yuanzili2的博客
03-19 345
这篇文章，应该是我写的到目前为止最难也应该是最长的，(也不能说最难吧，反正也不知道怎么说)的一篇文章。其实线段树吧，你之前可能听说过，是一种很难的算法。但是学过之后，又觉得不是那么难(反正我是这样的)。树(数据结构)(必修)位运算(必修)树状数组(选修)好的那么废话不多说我们开始吧。
刘汝佳 线段树模板
远古小山的专栏
08-20 9991
一、线段树（点修改） update
【线段树】 个人对线段树的特点、作用以及实现的理解（从为什么要用到怎么用）
待到山花烂漫时
02-28 1695
今天刚接触这种数据结构，学完后把自己的思路整理一下，这篇博客就当做总结吧，有错误日后发现了修改。 分界线 为什么要用这种数据结构？ 现在，就当我们还没听过这种数据结构，也不知道它的作用是什么，我们来思考以下几个问题。 现在我有一串数组，我要实现下面两个操作： 1.查询：我想知道L–R区间内的元素的和是多少。 2.更新：我要实现更新某一下标对应元素的值。 以上两个步骤会交叉进行多次。 那么，以我们现...
【学习笔记】线段树的扩展（线段树的合并与分裂、可持久化线段树）
changle_cyx
12-02 6309
感觉最近研究数据结构，我的对拍能力和输出调试能力得到了显著提升…… 本篇文章介绍关于线段树的一些经典扩展操作。 有关线段树的经典问题（势能线段树、李超线段树、线段树维护单调子序列）的总结请看神仙 xyz32768xyz32768xyz32768 的这篇文章：[学习笔记]线段树骚操作选讲 1. 线段树的合并与分裂 1.1 BZOJ2212 我们考虑一道经典问题：BZOJ2212 题目大意：...
线段树分裂与合并 学习笔记
weixin_45590210的博客
09-27 266
线段树是很基本的一种数据结构,也是一种很强大的数据结构,它的衍生有权值线段树,可持久化线段树(主席树).还有现在要介绍的分裂合并版本的线段树.为了方便,下面的文章都用合并树来代替这一长串的称呼. 这种线段树的一般套路都是维护权值,而不是维护序列.一般来说,合并树的基本操作就以下两种: add: void add(int &now,int l,int r,int p,int v){ if(!now) now = ++tot; tree[now].sum += v; if(l &
学习笔记--线段树合并与分裂
weixin_30530939的博客
10-09 916
前言 集训时侯讲了一道线段树神题,看题解时FA现需要一个叫"线段树合并"的前置技能点,于是就补了这个坑顺便了解一下线段树的分裂 需要前置技能点: 线段树 动态开点权值线段树 参考链接 https://wenku.baidu.com/view/88f4e134e518964bcf847c95.html https://www.cnblogs.com/Mychael/p/8665589.htm...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值