1.题目基本信息
1.1.题目描述
有一幅细长的画，可以用数轴来表示。 给你一个长度为 n 、下标从 0 开始的二维整数数组 paint ，其中 paint[i] = [starti, endi] 表示在第 i 天你需要绘制 starti 和 endi 之间的区域。
多次绘制同一区域会导致不均匀，因此每个区域最多只能绘制 一次 。
返回一个长度为 n 的整数数组 worklog，其中 worklog[i] 是你在第 i 天绘制的 新 区域的数量。
1.2.题目地址
https://leetcode.cn/problems/amount-of-new-area-painted-each-day/description/
2.解题方法
2.1.解题思路
带懒标记的线段树 / 区间并查集
2.2.解题步骤
并查集思路：
将连续的区间放到同一个连通分量中，同时维护每个连通分量的根为区间最左侧的结点
线段树思路：
整体是一个求区间和的线段树，主要区别在于每个结点的非0即1，lazy标记区间中元素是否全为0；然后使用区间和求出区间中被填充的位置个数，间接求出空闲的位置，即需要绘画的区域长度
3.解题代码
Python代码【并查集版本】
python
class UnionFind():
def __init__(self):
self.roots = {}
self.setCnt = 0
self.rootSizes = {}
def add(self, x:int) -> None:
if x not in self.roots:
self.roots[x] = x
self.setCnt += 1
self.rootSizes[x] = 1
def find(self, x:int) -> int:
if x not in self.roots:
self.add(x)
return x
root = self.roots[x]
while root != self.roots[root]:
root = self.roots[root]
# 路径压缩
while x != root:
temp = self.roots[x]
self.roots[x] = root
x = temp
return root
def union(self, x:int, y:int) -> None:
rootx, rooty = self.find(x), self.find(y)
if rootx != rooty:
if rootx < rooty:
self.roots[rooty] = rootx
self.rootSizes[rootx] += self.rootSizes[rooty]
else:
self.roots[rootx] = rooty
self.rootSizes[rooty] += self.rootSizes[rootx]
self.setCnt -= 1
class Solution:
def amountPainted(self, paint: List[List[int]]) -> List[int]:
# 思路1：并查集（每个数字为一个结点，根结点为连续区间的首部位置，所以每次union时都是将大根连接到小根上）
uf = UnionFind()
result = []
for start, end in paint:
thisCnt = 0
rootStart, rootEnd = uf.find(start), uf.find(end)
while rootEnd != rootStart:
uf.union(rootEnd, rootEnd - 1)
rootEnd = uf.find(rootEnd)
thisCnt += 1
result.append(thisCnt)
return resultPython代码【线段树版本】
python
# ==> 带懒标记 求范围和 的线段树（数组中的元素非0即1）
class SegmentTreeToSumWithLazy():
def __init__(self, nums:list[int]):
# 初始化线段树的存储数组并进行构建二叉平衡线段树（这里采用平衡二叉树，也可以用最大堆进行构建）
self.n = len(nums)
self.tree = [0] * (self.n * 4) # 二叉平衡树的范围为4*n，如果使用最大堆的自底向上，则范围2*n即可；维护区间和
self.lazy = [0] * (self.n * 4) # 懒标记数组，lazy[node]如果为1，表示node对应对应区间全部为1，反之不确定为多少
self.build(nums, 0, 0, self.n - 1)
# 基础方法：构建树，在node树中，将nums[start:end+1]中的区间元素进行插入（node、start、end确定一个线段树结点）
def build(self, nums:list[int], node:int, start:int, end:int) -> None:
if start == end:
self.tree[node] = nums[start]
return
mid = (end - start) // 2 + start
# 构建左子树
self.build(nums, node * 2 + 1, start, mid)
# 构建右子树
self.build(nums, node * 2 + 2, mid + 1, end)
# 和形式的线段树；tree[node]记录nums[start:end+1]之间元素的和
self.tree[node] = self.tree[node * 2 + 1] + self.tree[node * 2 + 2]
# 结点懒标记向下推送（基础函数）：将node结点的懒标记推送到左右子结点中，并将自身的懒标记清空
def pushDown(self, node:int, start:int, end:int) -> None:
# 第一步，特殊判断。node结点的懒标记值为0，无需向下推送，直接退出
if self.lazy[node] == 0:
return
# 第二步，获取左右结点的结点编号和范围，更新左右结点的tree和lazy中的值
mid = (end - start) // 2 + start
leftChild = node * 2 + 1
rightChild = node * 2 + 2
self.tree[leftChild] = mid - start + 1
self.lazy[leftChild] = 1
self.tree[rightChild] = end - mid
self.lazy[rightChild] = 1
# 第三步，清空node对应的lazy值
self.lazy[node] = 0
# 区间修改（基础方法）：在结点node对应的[start,end]区间中，将其中[left,right]区间部分的原数组值全部增加value
def rangeUpdate(self, value:int, left:int, right:int, node:int, start:int, end:int) -> None:
# 第一步，递归退出条件
# 1.1.node结点区间[start,end]和目标区间[left,right]不存在交集时，直接退出
if left > end or right < start:
return
# 1.2.node结点区间[start,end]被目标区间[left,right]包含，直接更新lazy和tree数组。tree这种node结点对应值自增；在lazy数组中更新node结点的懒标记，lazy[node]自增value
if left <= start and right >= end:
self.tree[node] = end - start + 1
self.lazy[node] = 1
return
# 第二步，node区间和目标区间存在重叠的情况下，递归处理
# 2.1.由于需要分到两个子区间中进行递归操作，所以node对应的lazy值需要向下推送到子结点中；本质就是将node结点的lazy值分配到左右结点中，更新tree和lazy中对应的值
self.pushDown(node, start, end)
# 2.2.递归范围更新两个子树
leftChild, rightChild = node * 2 + 1, node * 2 + 2
mid = (end - start) // 2 + start
self.rangeUpdate(value, left, right, leftChild, start, mid)
self.rangeUpdate(value, left, right, rightChild, mid + 1, end)
# 第三步，更新当前结点的tree值（node中增加value的范围不确定，所以通过子结点来更新）
self.tree[node] = self.tree[leftChild] + self.tree[rightChild]
# 单点修改：调用区间函数rangeUpdate进行
def pointUpdate(self, index:int, value:int, node:int, start:int, end:int) -> None:
self.rangeUpdate(value, index, index, node, start, end)
# 区间查询（基础方法）：在结点node对应的[start,end]区间中，求[left,right]区间部分的原数组值的和
def rangeSum(self, left:int, right:int, node:int, start:int, end:int) -> int:
# 第一步，递归退出条件
# 1.1.node结点区间和目标区间[left,right]不存在交集时，直接退出
if left > end or right < start:
return 0
# 1.2.node结点区间被目标区间[left,right]包含，直接返回tree数组中node结点的值
if left <= start and right >= end:
return self.tree[node]
# 第二步，node区间和目标区间存在重叠的情况下，递归处理
# 2.1.由于需要分到两个子区间中进行递归操作，所以node对应的lazy值需要向下推送到子结点中；本质就是将node结点的lazy值分配到左右结点中，更新tree和lazy中对应的值
self.pushDown(node, start, end)
# 2.2.递归获取两个子树的范围和，相加进行返回
mid = (end - start) // 2 + start
return self.rangeSum(left, right, node * 2 + 1, start, mid) + self.rangeSum(left, right, node * 2 + 2, mid + 1, end)
class Solution:
def amountPainted(self, paint: List[List[int]]) -> List[int]:
# 思路2：带懒标记的线段树
# 参考：Leetcode 307. 区域和检索 - 数组可修改
maxVal = max([b for a, b in paint])
nums = [0] * (maxVal + 1)
segTree = SegmentTreeToSumWithLazy(nums)
result = []
for start, end in paint:
left, right = start, end - 1
fullCnt = segTree.rangeSum(left, right, 0, 0, maxVal)
result.append(right - left + 1 - fullCnt)
segTree.rangeUpdate(0, left, right, 0, 0, maxVal)
return result4.执行结果
