Update 01.Segment-Tree.md

Author: itcharge

Contents/07.Tree/03.Segment-Tree/01.Segment-Tree.md

@@ -57,33 +57,34 @@ class TreeNode:
         self.left = -1                              # 区间左边界
         self.right = -1                             # 区间右边界
         self.val = val                              # 节点值（区间值）
-        self.lazy_tag = 0                           # 区间和问题的延迟更新标记
+        self.lazy_tag = None                        # 区间和问题的延迟更新标记
+        
 
 # 线段树类
 class SegmentTree:
     def __init__(self, nums, function):
         self.size = len(nums)
-        self.tree = [TreeNode() for _ in range(4 * self.size)] # 维护 TreeNode 数组
+        self.tree = [TreeNode() for _ in range(4 * self.size)]  # 维护 TreeNode 数组
         self.nums = nums                            # 原始数据
         self.function = function                    # function 是一个函数，左右区间的聚合方法
         if self.size > 0:
             self.__build(0, 0, self.size - 1)
-    
+            
     # 构建线段树，节点的存储下标为 index，节点的区间为 [left, right]
     def __build(self, index, left, right):
         self.tree[index].left = left
         self.tree[index].right = right
         if left == right:                           # 叶子节点，节点值为对应位置的元素值
             self.tree[index].val = self.nums[left]
             return
-        
+    
         mid = left + (right - left) // 2            # 左右节点划分点
         left_index = index * 2 + 1                  # 左子节点的存储下标
         right_index = index * 2 + 2                 # 右子节点的存储下标
-        self._build(left_index, left, mid)          # 递归创建左子树
-        self._build(right_index, mid + 1, right)    # 递归创建右子树
+        self.__build(left_index, left, mid)         # 递归创建左子树
+        self.__build(right_index, mid + 1, right)   # 递归创建右子树
         self.__pushup(index)                        # 向上更新节点的区间值
-        
+    
     # 向上更新下标为 index 的节点区间值，节点的区间值等于该节点左右子节点元素值的聚合计算结果
     def __pushup(self, index):
         left_index = index * 2 + 1                  # 左子节点的存储下标
@@ -125,9 +126,9 @@ class SegmentTree:
         mid = left + (right - left) // 2            # 左右节点划分点
         left_index = index * 2 + 1                  # 左子节点的存储下标
         right_index = index * 2 + 2                 # 右子节点的存储下标
-        if i <= mid:                                # 在左子树中更新
+        if i <= mid:                                # 在左子树中更新节点值
             self.__update_point(i, val, left_index, left, mid)
-        else:                                       # 在右子树中更新
+        else:                                       # 在右子树中更新节点值
             self.__update_point(i, val, right_index, mid + 1, right)
         self.__pushup(index)                        # 向上更新节点的区间值
 ```
@@ -158,7 +159,9 @@ class SegmentTree:
             return self.tree[index].val             # 直接返回节点值
         if right < q_left or left > q_right:        # 节点所在区间与 [q_left, q_right] 无关
             return 0
-        
+    
+        self.__pushdown(index)
+    
         mid = left + (right - left) // 2            # 左右节点划分点
         left_index = index * 2 + 1                  # 左子节点的存储下标
         right_index = index * 2 + 2                 # 右子节点的存储下标
@@ -216,36 +219,42 @@ class SegmentTree:
     def __update_interval(self, q_left, q_right, val, index, left, right):
 
         if left >= q_left and right <= q_right:     # 节点所在区间被 [q_left, q_right] 所覆盖
+            interval_size = (right - left + 1)      # 当前节点所在区间大小
+            self.tree[index].val = interval_size * val # 当前节点所在区间每个元素值改为 val
             self.tree[index].lazy_tag = val         # 将当前节点的延迟标记为区间值
-            self.tree[index].val = val              # 更新当前节点所在区间值
             return
         if right < q_left or left > q_right:        # 节点所在区间与 [q_left, q_right] 无关
             return 0
-        
-        if self.tree[index].lazy_tag:               # 需要向下更新节点所在区间的左右子节点的值和懒惰标记
-            self.__pushdown(index)
-            
+    
+        self.__pushdown(index)
+    
         mid = left + (right - left) // 2            # 左右节点划分点
         left_index = index * 2 + 1                  # 左子节点的存储下标
         right_index = index * 2 + 2                 # 右子节点的存储下标
         if q_left <= mid:                           # 在左子树中更新区间值
-            self._update_interval(q_left, q_right, val, left_index, left, mid)
+            self.__update_interval(q_left, q_right, val, left_index, left, mid)
         if q_right > mid:                           # 在右子树中更新区间值
-            self._update_interval(q_left, q_right, val, right_index, mid + 1, right)
+            self.__update_interval(q_left, q_right, val, right_index, mid + 1, right)
+        
         self.__pushup(index)
 
     # 向下更新下标为 index 的节点所在区间的左右子节点的值和懒惰标记
     def __pushdown(self, index):
         lazy_tag = self.tree[index].lazy_tag
+        if not lazy_tag:
+            return
+        
         left_index = index * 2 + 1                  # 左子节点的存储下标
         right_index = index * 2 + 2                 # 右子节点的存储下标
-
-        self.tree[left_index].lazy_tag = lazy_tag   # 更新左子节点懒惰标记
-        self.tree[left_index].val = lazy_tag        # 更新左子节点值
-        
-        self.tree[right_index].lazy_tag = lazy_tag  # 更新右子节点懒惰标记        
-        self.tree[right_index].val = lazy_tag       # 更新右子节点值
 
+        self.tree[left_index].lazy_tag = lazy_tag   # 更新左子节点懒惰标记
+        left_size = (self.tree[left_index].right - self.tree[left_index].left + 1)
+        self.tree[left_index].val = lazy_tag * left_size    # 更新左子节点值
+
+        self.tree[right_index].lazy_tag = lazy_tag  # 更新右子节点懒惰标记
+        right_size = (self.tree[right_index].right - self.tree[right_index].left + 1)
+        self.tree[right_index].val = lazy_tag * right_size  # 更新右子节点值
+
         self.tree[index].lazy_tag = None            # 更新当前节点的懒惰标记
 ```
 
@@ -264,40 +273,56 @@ class SegmentTree:
     def __update_interval(self, q_left, q_right, val, index, left, right):
 
         if left >= q_left and right <= q_right:     # 节点所在区间被 [q_left, q_right] 所覆盖
-            self.tree[index].lazy_tag += val        # 将当前节点的延迟标记增加 val
+#            interval_size = (right - left + 1)      # 当前节点所在区间大小
+#            self.tree[index].val = interval_size * val # 当前节点所在区间每个元素值改为 val
+#            self.tree[index].lazy_tag = val         # 将当前节点的延迟标记为区间值
+        
+            if self.tree[index].lazy_tag:
+                self.tree[index].lazy_tag += val    # 将当前节点的延迟标记增加 val
+            else:
+                self.tree[index].lazy_tag = val     # 将当前节点的延迟标记增加 val
             interval_size = (right - left + 1)      # 当前节点所在区间大小
-            self.tree[index].val += val * interval_size # 当前节点所在区间每个元素值增加 val
+            self.tree[index].val += val * interval_size  # 当前节点所在区间每个元素值增加 val
             return
         if right < q_left or left > q_right:        # 节点所在区间与 [q_left, q_right] 无关
             return 0
-        
-        if self.tree[index].lazy_tag:               # 需要向下更新节点所在区间的左右子节点的值和懒惰标记
-            self.__pushdown(index)
-            
+    
+        self.__pushdown(index)
+    
         mid = left + (right - left) // 2            # 左右节点划分点
         left_index = index * 2 + 1                  # 左子节点的存储下标
         right_index = index * 2 + 2                 # 右子节点的存储下标
         if q_left <= mid:                           # 在左子树中更新区间值
-            self._update_interval(q_left, q_right, val, left_index, left, mid)
+            self.__update_interval(q_left, q_right, val, left_index, left, mid)
         if q_right > mid:                           # 在右子树中更新区间值
-            self._update_interval(q_left, q_right, val, right_index, mid + 1, right)
+            self.__update_interval(q_left, q_right, val, right_index, mid + 1, right)
+        
         self.__pushup(index)
 
     # 向下更新下标为 index 的节点所在区间的左右子节点的值和懒惰标记
     def __pushdown(self, index):
         lazy_tag = self.tree[index].lazy_tag
+        if not lazy_tag:
+            return
+        
         left_index = index * 2 + 1                  # 左子节点的存储下标
         right_index = index * 2 + 2                 # 右子节点的存储下标
 
-        self.tree[left_index].lazy_tag += lazy_tag  # 更新左子节点懒惰标记
+        if self.tree[left_index].lazy_tag:
+            self.tree[left_index].lazy_tag += lazy_tag  # 更新左子节点懒惰标记
+        else:
+            self.tree[left_index].lazy_tag = lazy_tag
         left_size = (self.tree[left_index].right - self.tree[left_index].left + 1)
         self.tree[left_index].val += lazy_tag * left_size   # 左子节点每个元素值增加 lazy_tag
 
-        self.tree[right_index].lazy_tag += lazy_tag # 更新右子节点懒惰标记
+        if self.tree[right_index].lazy_tag:
+            self.tree[right_index].lazy_tag += lazy_tag # 更新右子节点懒惰标记
+        else:
+            self.tree[right_index].lazy_tag = lazy_tag
         right_size = (self.tree[right_index].right - self.tree[right_index].left + 1)
         self.tree[right_index].val += lazy_tag * right_size # 右子节点每个元素值增加 lazy_tag
 
-        self.tree[index].lazy_tag = None            # 更新当前节点的懒惰标记
+       	self.tree[index].lazy_tag = None            # 更新当前节点的懒惰标记
 ```
 
 ## 4. 线段树的常见题型
@@ -343,6 +368,152 @@ class SegmentTree:
 
 这类问题通常坐标跨度很大，需要先对每条扫描线的坐标进行离散化处理，将 `y` 坐标映射到 `0, 1, 2, ...` 中。然后将每条竖线的端点作为区间范围，使用线段树存储每条竖线的信息（`x` 坐标、是左竖线还是右竖线等），然后再进行区间合并，并统计相关信息。
 
+## 5. 线段树的拓展
+
+### 5.1 动态开点线段树
+
+在有些情况下，线段树需要维护的区间很大（例如 $[1, 10^9]$），在实际中用到的节点却很少。
+
+如果使用之前数组形式实现线段树，则需要 $4 * n$ 大小的空间，空间消耗有点过大了。
+
+这时候我们就可以使用动态开点的思想来构建线段树。
+
+动态开点线段树的算法思想如下：
+
+- 开始时只建立一个根节点，代表整个区间。
+- 当需要访问线段树的某棵子树（某个子区间）时，再建立代表这个子区间的节点。
+
+动态开点线段树实现代码如下：
+
+```Python
+# 线段树的节点类
+class TreeNode:
+    def __init__(self, left=-1, right=-1, val=0):
+        self.left = left                            # 区间左边界
+        self.right = right                          # 区间右边界
+        self.mid = left + (right - left) // 2
+        self.leftNode = None                        # 区间左节点
+        self.rightNode = None                       # 区间右节点
+        self.val = val                              # 节点值（区间值）
+        self.lazy_tag = None                        # 区间问题的延迟更新标记
+        
+        
+# 线段树类
+class SegmentTree:
+    def __init__(self, function):
+        self.tree = TreeNode(0, int(1e9))
+        self.function = function                    # function 是一个函数，左右区间的聚合方法
+            
+    # 向上更新 node 节点区间值，节点的区间值等于该节点左右子节点元素值的聚合计算结果
+    def __pushup(self, node):
+        leftNode = node.leftNode
+        rightNode = node.rightNode
+        if leftNode and rightNode:
+            node.val = self.function(leftNode.val, rightNode.val)
+            
+    # 单点更新，将 nums[i] 更改为 val
+    def update_point(self, i, val):
+        self.__update_point(i, val, self.tree)
+        
+    # 单点更新，将 nums[i] 更改为 val。node 节点的区间为 [node.left, node.right]
+    def __update_point(self, i, val, node):
+        if node.left == node.right:
+            node.val = val                          # 叶子节点，节点值修改为 val
+            return
+        
+        if i <= node.mid:                           # 在左子树中更新节点值
+            if not node.leftNode:
+                node.leftNode = TreeNode(node.left, node.mid)
+            self.__update_point(i, val, node.leftNode)
+        else:                                       # 在右子树中更新节点值
+            if not node.rightNode:
+                node.rightNode = TreeNode(node.mid + 1, node.right)
+            self.__update_point(i, val, node.rightNode)
+        self.__pushup(node)                         # 向上更新节点的区间值
+        
+    # 区间查询，查询区间为 [q_left, q_right] 的区间值
+    def query_interval(self, q_left, q_right):
+        return self.__query_interval(q_left, q_right, self.tree)
+    
+    # 区间查询，在线段树的 [left, right] 区间范围中搜索区间为 [q_left, q_right] 的区间值
+    def __query_interval(self, q_left, q_right, node):
+        if node.left >= q_left and node.right <= q_right:   # 节点所在区间被 [q_left, q_right] 所覆盖
+            return node.val                         # 直接返回节点值
+        if node.right < q_left or node.left > q_right:  # 节点所在区间与 [q_left, q_right] 无关
+            return 0
+                                  
+        self.__pushdown(node)                       # 向下更新节点所在区间的左右子节点的值和懒惰标记
+        
+        res_left = 0                                # 左子树查询结果
+        res_right = 0                               # 右子树查询结果
+        if q_left <= node.mid:                      # 在左子树中查询
+            if not node.leftNode:
+                node.leftNode = TreeNode(node.left, node.mid)
+            res_left = self.__query_interval(q_left, q_right, node.leftNode)
+        if q_right > node.mid:                      # 在右子树中查询
+            if not node.rightNode:
+                node.rightNode = TreeNode(node.mid + 1, node.right)
+            res_right = self.__query_interval(q_left, q_right, node.rightNode)
+        return self.function(res_left, res_right)   # 返回左右子树元素值的聚合计算结果
+    
+    # 区间更新，将区间为 [q_left, q_right] 上的元素值修改为 val
+    def update_interval(self, q_left, q_right, val):
+        self.__update_interval(q_left, q_right, val, self.tree)
+        
+    # 区间更新
+    def __update_interval(self, q_left, q_right, val, node):
+        if node.left >= q_left and node.right <= q_right:  # 节点所在区间被 [q_left, q_right] 所覆盖
+            if node.lazy_tag:
+                node.lazy_tag += val                # 将当前节点的延迟标记增加 val
+            else:
+                node.lazy_tag = val                 # 将当前节点的延迟标记增加 val
+            interval_size = (node.right - node.left + 1)    # 当前节点所在区间大小
+            node.val += val * interval_size         # 当前节点所在区间每个元素值增加 val
+            return
+        if node.right < q_left or node.left > q_right:  # 节点所在区间与 [q_left, q_right] 无关
+            return 0
+    
+        self.__pushdown(node)                       # 向下更新节点所在区间的左右子节点的值和懒惰标记
+    
+        if q_left <= node.mid:                      # 在左子树中更新区间值
+            if not node.leftNode:
+                node.leftNode = TreeNode(node.left, node.mid)
+            self.__update_interval(q_left, q_right, val, node.leftNode)
+        if q_right > node.mid:                      # 在右子树中更新区间值
+            if not node.rightNode:
+                node.rightNode = TreeNode(node.mid + 1, node.right)
+            self.__update_interval(q_left, q_right, val, node.rightNode)
+            
+        self.__pushup(node)
+    
+    # 向下更新 node 节点所在区间的左右子节点的值和懒惰标记
+    def __pushdown(self, node):
+        lazy_tag = node.lazy_tag
+        if not node.lazy_tag:
+            return
+        
+        if not node.leftNode:
+            node.leftNode = TreeNode(node.left, node.mid)
+        if not node.rightNode:
+            node.rightNode = TreeNode(node.mid + 1, node.right)
+            
+        if node.leftNode.lazy_tag:
+            node.leftNode.lazy_tag += lazy_tag      # 更新左子节点懒惰标记
+        else:
+            node.leftNode.lazy_tag = lazy_tag       # 更新左子节点懒惰标记
+        left_size = (node.leftNode.right - node.leftNode.left + 1)
+        node.leftNode.val += lazy_tag * left_size   # 左子节点每个元素值增加 lazy_tag
+        
+        if node.rightNode.lazy_tag:
+            node.rightNode.lazy_tag += lazy_tag     # 更新右子节点懒惰标记
+        else:
+            node.rightNode.lazy_tag = lazy_tag      # 更新右子节点懒惰标记
+        right_size = (node.rightNode.right - node.rightNode.left + 1)
+        node.rightNode.val += lazy_tag * right_size # 右子节点每个元素值增加 lazy_tag
+        
+        node.lazy_tag = None                        # 更新当前节点的懒惰标记
+```
+
 ## 参考资料
 
 - 【书籍】ACM-ICPC 程序设计系列 - 算法设计与实现 - 陈宇 吴昊 主编