动态开点线段树（C++实现）

已于 2022-09-17 12:29:00 修改
阅读量936 收藏 6
点赞数 1
分类专栏： 数据结构 文章标签： c++ 算法 数据结构
于 2022-09-10 21:02:50 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zsiming/article/details/126799018
版权

文章目录

09-17更新：针对评论区的错误，原来是在推懒标记的时候需要 += 而不是 =。提供了更新后的测试：

int main() {
	SegTree st; 
	st.upDate(st.root_, 0, 1e9, 5, 10, 2);
	st.upDate(st.root_, 0, 1e9, 2, 7, 3);
	cout << st.query(st.root_, 0, 1e9, 6, 6) << endl;
	cout << st.query(st.root_, 0, 1e9, 7, 7) << endl;
	cout << st.query(st.root_, 0, 1e9, 8, 8) << endl;
	cout << st.query(st.root_, 0, 1e9, 6, 8) << endl;
	cout << "-----------------------" << endl;

	
	cout << st.query(st.root_, 0, 1e9, 1, 1) << endl;
	cout << st.query(st.root_, 0, 1e9, 2, 2) << endl;
	cout << st.query(st.root_, 0, 1e9, 3, 3) << endl;
	cout << st.query(st.root_, 0, 1e9, 4, 4) << endl;
	cout << st.query(st.root_, 0, 1e9, 5, 5) << endl;
	cout << st.query(st.root_, 0, 1e9, 6, 6) << endl;
	cout << st.query(st.root_, 0, 1e9, 7, 7) << endl;
	cout << st.query(st.root_, 0, 1e9, 8, 8) << endl;
	cout << st.query(st.root_, 0, 1e9, 9, 9) << endl;
	cout << st.query(st.root_, 0, 1e9, 10, 10) << endl;
	cout << st.query(st.root_, 0, 1e9, 11, 11) << endl;

	return 0;
}

结果：

在这里插入图片描述

1. 问题背景

线段树主要是针对区间问题而生的一种数据结构。当频繁的对某个区间的元素（或者某个元素）进行加减后，再求某个区间的和就可以使用线段树来实现快速的查询。

在实现上，线段树一般使用二叉树来实现（即使是使用数组，也是模拟了完全二叉树）。假设我现在有数组如下：

nums=[3,5,1,1,2]。那么，根据这个数组可以拆分的区间，可以构造如下的二叉树：

在这里插入图片描述
每个结点都是维护了一个区间的性质（在上图里面表示一个区间的和），区间的最小长度为1，也就是这个区间有且仅有一个元素。

首先，我们先简单的看看这棵树是怎么工作的，然后再去实现这颗树。假设我要查询区间[2,4]之间的元素之和，那么这颗树要怎么计算这个和呢？

结果就是只用到了下图的红色结点：
在这里插入图片描述

正常来看的话，计算[2,4]区间的值可能会使用[2,2],[3,3],[4,4]，但是对于[3,3],[4,4]来说，只需要访问它们的父节点就可以知道区间的和是多少了，因此访问两个孩子结点的过程变成了访问一次父亲结点。

这样，在数据比较多，查询的区间比较长的时候，能极大的加快查询的速度，把区间O(n)的时间复杂度变成logn的时间复杂度。

下面主要讲怎么去实现这颗线段树，以及接口的封装。

2. 代码实现

首先，很多解法里面都是使用数组来实现线段树，但是这样的坏处就是需要提前开很大的空间（一般是4 * 数组长度），在这里，我们使用二叉树的方式进行实现。且对于一些没用到结点是不会创建的，由此称为动态开点。

首先实现树结点这个数据结构：

struct Node {
		Node () : left_(nullptr), right_(nullptr), val_(0), lazy_(0) {}
		int val_;
		int lazy_;
		Node* left_;
		Node* right_;
	};

（Tips:在讲到懒标记之前，我们先忽略所有跟lazy相关的变量和语句）

对于线段树，最核心的功能就是修改区间（给某个区间加上/减去一个数）和区间查询。我们首先考虑区间修改的接口：

// 更新区间值
	void upDate(Node* curNode, int curLeft, int curRight, int upDateLeft, int upDateRight, int addVal) {
		if (upDateLeft <= curLeft && upDateRight >= curRight) {
			// 如果需要更新的区间[upDateLeft, upDateRight] 包含了 当前这个区间[curLeft, curRight] 
			// 那么暂存一下更新的值
			// 等到什么时候用到孩子结点了，再把更新的值发放给孩子
			curNode->val_ += addVal * (curRight - curLeft + 1);
			curNode->lazy_ += addVal;
			return;
		}

		// 到这里说明要用到左右孩子了
		// 因此，要用pushDown函数把懒标签的值传递下去
		int mid = (curLeft + curRight) / 2;
		pushDown(curNode, mid - curLeft + 1, curRight - mid);

		// 说明在[curLeft, curRight]中，
		if (upDateLeft <= mid) { 
			upDate(curNode->left_, curLeft, mid, upDateLeft, upDateRight, addVal);
		} 
		if (upDateRight > mid) {
			upDate(curNode->right_, mid + 1, curRight, upDateLeft, upDateRight, addVal);
		}

		// 更新了子节点还需要更新现在的结点
		pushUp(curNode);
	}

我们看一下这段代码做了什么。

对于upDate这个接口的形参，curNode是当前结点，curLeft是当前结点所表示的左边界，curRight是当前结点表示的右边界。而upDateLeft 和 updateRight则表示是需要对区间[upDateLeft,updateRight]里面每个元素都加上addVal。

首先，当需改修改的区间包含了当前的区间，那么我们更新了当前结点的值，然后马上返回了。而不能覆盖的话，我们需要往左右孩子表示的区间去更新，为什么呢？我们再拿前面的例子说明：

在这里插入图片描述
对于上面的例子，要为[2,4]区间内的每个元素增加1，那么首先看区间[0,4]。区间[2,4]根本包不住区间[0,4]，那么只能往左右孩子看。对于左孩子[0,2],[2,4]也包不住[0,2]，因此只能再去看区间[2,2]。结果[2,4]能包住区间[2,2]，所以在这儿就停止了返回了。而[2,4]能包住[3,4]，因此在[3,4]也停止并返回了。

上面的代码，刚好包含了包得住马上返回、包不住找左孩子、包不住找右孩子的情况（3个if语句）。我们主要到还有pushDown 和 pushUp的操作。

我们先看代码：

// 把结点curNode的懒标记分发给左右孩子 然后自己的懒标记清零
	void pushDown(Node* curNode, int leftChildNum, int rightChildNum) {
		if (curNode->left_ == nullptr) curNode->left_ = new Node;
		if (curNode->right_ == nullptr) curNode->right_ = new Node;

		if (curNode->lazy_ == 0) return;

		curNode->left_->val_ += curNode->lazy_ * leftChildNum;
		curNode->left_->lazy_ += curNode->lazy_;  // 09-17更正 = ----> += 

		curNode->right_->val_ += curNode->lazy_ * rightChildNum;
		curNode->right_->lazy_ += curNode->lazy_;  // 09-17更正 = ----> += 

		curNode->lazy_ = 0;

		// 注意不需要递归再继续下推懒标签 
		// 每次只需要推一层即可
	}

// 一般是子节点因为要被用到了，所以需要更新值 因此也要同时更新父节点的值
	void pushUp(Node* curNode) {
		curNode->val_ = curNode->left_->val_ + curNode->right_->val_;
	}

对于pushDown这个操作其实是和懒标记息息相关的。所谓懒标记，就是把本区间一些增加的量给保留下来，等到需要用到左右结点的时候，才把这些增加的量分给左右孩子，让它们去更新自己区间的值。这样，多次增加的操作就可以变成一次，大大增加效率。所以，对于pushDown这个函数来说就是把之前在结点curNode上拦截下来的量分给左右孩子，让他们去更新区间的值。

  • 问：为什么需要用到左右孩子就需要pushDown？
  • 答：因为不pushDown的话，左右孩子的值都是没更新的。
  • 问：为啥没更新？
  • 答：因为如果能拦截的话，那么计算只用到了它们的父节点，只需要更新父节点就行了（第一个if语句括号内做的事情），所以子节点更不更新根本无所谓。但是现在要用到左右孩子了，必须更新了，因此要用pushDown这个操作把孩子结点的值更新为正确的值。

我们还注意到，有个pushUp的操作。这个操作基本是和pushDown成对出现的。因为左右孩子的值更新了，所以本结点的值也要更新。pushUp做的就是这件事。

另一个重要的接口就是查询：

// 查询
	int query(Node* curNode, int curLeft, int curRight, int queryLeft, int queryRight) {
		if (queryLeft <= curLeft && queryRight >= curRight) {
			return curNode->val_;
		}
		// 用到左右结点力 先下推！
		int mid = (curLeft + curRight) / 2;
		pushDown(curNode, mid - curLeft + 1, curRight - mid);

		int curSum = 0;
		if (queryLeft <= mid) curSum += query(curNode->left_, curLeft, mid, queryLeft, queryRight);
		if (queryRight > mid) curSum += query(curNode->right_, mid + 1, curRight, queryLeft, queryRight);

		return curSum;
	}

在这个代码中，第一个if语句表示的就是拦截动作，直接返回本结点的结果：
在这里插入图片描述
而不能拦截的，则去左右孩子看一下能不能拦截（第2、3个if语句）。

至此，代码基本完成。

完整代码：

class SegTree {
private:
	struct Node {
		Node () : left_(nullptr), right_(nullptr), val_(0), lazy_(0) {}
		int val_;
		int lazy_;
		Node* left_;
		Node* right_;
	};

public:
	Node* root_;
	SegTree() { root_ = new Node(); }
	~SegTree() {}

	// 更新区间值
	void upDate(Node* curNode, int curLeft, int curRight, int upDateLeft, int upDateRight, int addVal) {
		if (upDateLeft <= curLeft && upDateRight >= curRight) {
			// 如果需要更新的区间[upDateLeft, upDateRight] 包含了 当前这个区间[curLeft, curRight] 
			// 那么暂存一下更新的值
			// 等到什么时候用到孩子结点了，再把更新的值发放给孩子
			curNode->val_ += addVal * (curRight - curLeft + 1);
			curNode->lazy_ += addVal;
			return;
		}

		// 到这里说明要用到左右孩子了
		// 因此，要用pushDown函数把懒标签的值传递下去
		int mid = (curLeft + curRight) / 2;
		pushDown(curNode, mid - curLeft + 1, curRight - mid);

		// 说明在[curLeft, curRight]中，
		if (upDateLeft <= mid) { 
			upDate(curNode->left_, curLeft, mid, upDateLeft, upDateRight, addVal);
		} 
		if (upDateRight > mid) {
			upDate(curNode->right_, mid + 1, curRight, upDateLeft, upDateRight, addVal);
		}

		// 更新了子节点还需要更新现在的结点
		pushUp(curNode);
	}
	

	// 把结点curNode的懒标记分发给左右孩子 然后自己的懒标记清零
	void pushDown(Node* curNode, int leftChildNum, int rightChildNum) {
		if (curNode->left_ == nullptr) curNode->left_ = new Node;
		if (curNode->right_ == nullptr) curNode->right_ = new Node;

		if (curNode->lazy_ == 0) return;

		curNode->left_->val_ += curNode->lazy_ * leftChildNum;
		curNode->left_->lazy_ += curNode->lazy_;

		curNode->right_->val_ += curNode->lazy_ * rightChildNum;
		curNode->right_->lazy_ += curNode->lazy_;

		curNode->lazy_ = 0;

		// 注意不需要递归再继续下推懒标签 
		// 每次只需要推一层即可
	}

	// 一般是子节点因为要被用到了，所以需要更新值 因此也要同时更新父节点的值
	void pushUp(Node* curNode) {
		curNode->val_ = curNode->left_->val_ + curNode->right_->val_;
	}

	// 查询
	int query(Node* curNode, int curLeft, int curRight, int queryLeft, int queryRight) {
		if (queryLeft <= curLeft && queryRight >= curRight) {
			return curNode->val_;
		}
		// 用到左右结点力 先下推！
		int mid = (curLeft + curRight) / 2;
		pushDown(curNode, mid - curLeft + 1, curRight - mid);

		int curSum = 0;
		if (queryLeft <= mid) curSum += query(curNode->left_, curLeft, mid, queryLeft, queryRight);
		if (queryRight > mid) curSum += query(curNode->right_, mid + 1, curRight, queryLeft, queryRight);

		return curSum;
	}
};

实战：

Leetcode729：

在这里插入图片描述
很明显，这道题就是在制定某个形成区间前，查一下这个区间是不是有安排了（有的话这个区间的和大于1，没有的话等于0，每次制定一个行程区间都是为这个区间的所有元素+1）。

题解：

class MyCalendar {
public:
    MyCalendar() { root_ = new Node(); }
    ~MyCalendar() { delete root_; }
private:
	struct Node {
		Node () : left_(nullptr), right_(nullptr), val_(0), lazy_(0) {}
		int val_;
		int lazy_;
		Node* left_;
		Node* right_;
	};

public:
	Node* root_;

	// 更新区间值
	void upDate(Node* curNode, int curLeft, int curRight, int upDateLeft, int upDateRight, int addVal) {
		if (upDateLeft <= curLeft && upDateRight >= curRight) {
			// 如果需要更新的区间[upDateLeft, upDateRight] 包含了 当前这个区间[curLeft, curRight] 
			// 那么暂存一下更新的值
			// 等到什么时候用到孩子结点了，再把更新的值发放给孩子
			curNode->val_ += addVal * (curRight - curLeft + 1);
			curNode->lazy_ += addVal;
			return;
		}

		// 到这里说明要用到左右孩子了
		// 因此，要用pushDown函数把懒标签的值传递下去
		int mid = (curLeft + curRight) / 2;
		pushDown(curNode, mid - curLeft + 1, curRight - mid);

		// 说明在[curLeft, curRight]中，
		if (upDateLeft <= mid) { 
			upDate(curNode->left_, curLeft, mid, upDateLeft, upDateRight, addVal);
		} 
		if (upDateRight > mid) {
			upDate(curNode->right_, mid + 1, curRight, upDateLeft, upDateRight, addVal);
		}

		// 更新了子节点还需要更新现在的结点
		pushUp(curNode);
	}
	

	// 把结点curNode的懒标记分发给左右孩子 然后自己的懒标记清零
	void pushDown(Node* curNode, int leftChildNum, int rightChildNum) {
		if (curNode->left_ == nullptr) curNode->left_ = new Node;
		if (curNode->right_ == nullptr) curNode->right_ = new Node;

		curNode->left_->val_ += curNode->lazy_ * leftChildNum;
		curNode->left_->lazy_ = curNode->lazy_;

		curNode->right_->val_ += curNode->lazy_ * rightChildNum;
		curNode->right_->lazy_ = curNode->lazy_;

		// 注意不需要递归再继续下推懒标签 
		// 每次只需要推一层即可
	}

	// 一般是子节点因为要被用到了，所以需要更新值 因此也要同时更新父节点的值
	void pushUp(Node* curNode) {
		curNode->val_ = curNode->left_->val_ + curNode->right_->val_;
	}

	// 查询
	int query(Node* curNode, int curLeft, int curRight, int queryLeft, int queryRight) {
		if (queryLeft <= curLeft && queryRight >= curRight) {
			return curNode->val_;
		}
		// 用到左右结点力 先下推！
		int mid = (curLeft + curRight) / 2;
		pushDown(curNode, mid - curLeft + 1, curRight - mid);

		int curSum = 0;
		if (queryLeft <= mid) curSum += query(curNode->left_, curLeft, mid, queryLeft, queryRight);
		if (queryRight > mid) curSum += query(curNode->right_, mid + 1, curRight, queryLeft, queryRight);

		return curSum;
	}
    
    bool book(int start, int end) {
		if (query(root_, 0, 1e9, start, end)) return false;
		upDate(root_, 0, 1e9, start, end, 1);
		return true;
	}
};

/**
 * Your MyCalendar object will be instantiated and called as such:
 * MyCalendar* obj = new MyCalendar();
 * bool param_1 = obj->book(start,end);
 */
zsiming
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
线段树动态问题
07-17
如何解决动态范围求和问题，如何简单地了解线段树。 附有模板以及习题
动态开点线段树
qq_41673789的博客
10-29 9186
学了一个小知识点——动态开点。感觉挺有意思，对于线段树的短板：空间，有挺好的补足作用。 前置知识: 熟练掌握的[线段树]，最好了解一点点的[权值线段树] 线段树动态开点 在一些计数问题中，线段树用于维护值域(一段权值范围)，这样的线段树也称为权值线段树。为了降低空间复杂度，我们可以不建出整棵线段树的结构，而是在最初只建立一个根节点，代表整个区间，当需要访问线段树的某棵子树(某个子区间)时，再建立...
线段树应用——动态开点
Lucas_FC_的博客
07-28 1340
动态开点线段树
线段树的一种实现
12-25
一种简单的线段树的实现 ，基础功能比较完善
线段树.pdf
12-05
线段树完全版，涉及到线段树的所有用法。 包括单点更新（增减，替换），区间求和，区间最值。 区间求最大值的位置。 成段更新（延迟标记，增减）。 离散化 扫描线
C++用红黑树实现线段的重叠问题
06-08
本程序使用C++，红黑树实现线段重叠问题的查找，程序中有详细的注释，方便阅读。
数据结构实现（C++版）
11-28
线段树 3.16.Trie ......................................... 字典树 3.17.QuickFind ............................ 并查集_基于数组实现 3.18.QuickUnion ......................... 并查集_基于树思想实现
线段树模板__模板
12-26
用c语言写的很好的线段树代码，供新手使用.
点节点更新线段树
05-18
可移植代码，用于单点更新，内有代码移植及运用的详解
线段树总结[经典、权值、动态开点]
Xm_wy的博客
05-11 908
ps:这是本蒟蒻的第一篇数据类型博客。   线段树，这是一种非常常用、普遍的信息统计技术。其基本思想是分治（二分），该数据类型本质上是一个储存区间数据二叉树
11.1.1 蓝桥杯树形数据结构之线段树之动态开点
最新发布
tang7mj的博客
02-13 334
动态开点是指在线段树的使用过程中，只有当需要访问一个节点时，才创建这个节点。这与传统的线段树（静态线段树）不同，后者在建树时就创建了所有可能用到的节点。动态开点技术能够大大节省内存空间，特别是在处理大规模数据或区间范围非常大时非常有效。动态开点线段树是解决大规模区间问题的强大工具，尤其适用于蓝桥杯等算法竞赛中的复杂问题。通过按需创建节点，它能够有效地节省内存空间，同时保持线段树操作的高效性。掌握动态开点技术，将在处理复杂数据结构问题时为你提供更多的灵活性和效率。
动态开点线段树（P1908/洛谷1908）
shadiao.的博客
09-16 1216
什么是动态开点线段树： 假设操作次数为q，维护区间大小为m 普通的线段树会先把所有可能需要的节点开辟出来 需要的空间为O（4*m） 这样可以： 1.方便的通过节点下标所引导对应的左右儿子节点 2.所有需要的节点都已经有了，不必在额外创建新节点 动态开点线段树则是只开辟需要的节点，因此每个节点左右儿子都要记录 需要的空间为O（q*logm） 这样可以： 1.很明显可以节省空...
详解C++区间题之线段树（动态开点）框架代码(附加一个有趣的差分有序集合方法)
小黑同学的博客
06-22 999
详解C++的线段树（动态开点）框架代码——别怕区间叠加（附加一个有趣的差分有序集合方法)。不仅仅介绍关于动态开点的线段树的c++模板，还介绍了其是如何秒杀三道困难题(lc中的715、699、732)的！..................
用C++实现一个线段树
05-15
下面是一个基本的线段树的实现（以区间求和为例）： ```cpp #include using namespace std; const int MAXN = 100010; int n, m, a[MAXN]; struct SegmentTree { int l, r; long long sum; } t[MAXN * 4]; ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值