区间修改区间查询问题的基于树状数组数据结构的算法简述

区间修改区间查询问题

单点修改区间查询问题（问题 1）：给定数组 $A_{\mathrm{1..}n}$，$m$ 次操作为修改或查询二者之一，修改操作是给定下标 $p$ 和增量 $q$ 将 $A_p$ 修改为 $A_p+q$，查询操作是给定下标 $l,r(l\le r)$ 查询当前数组区间和 ${\sum }_{i=l}^r{A}_i=A_l+...+A_r$。

算法 1-1：维护原数组 $A_{\mathrm{1..}n}$，修改操作和查询操作无特别策略。

算法 1-2：维护前缀和数组 $S_{\mathrm{1..}n}$，构造时满足 $S_0=0,S_k={\sum }_{i=1}^k{A}_i=A_1+...+A_{k-1}+A_k=S_{k-1}+A_k$，修改操作即迭代修改 $S_p,S_{p+1},...,S_n$ 为 $S_p+q,S_{p+1}+q,...,S_n+q$，查询操作即计算 $S_r-S_{l-1}$。

算法 1-3：维护原数组的树状数组（Indexed Binary Tree）。树状数组可以看作是一种特殊的前缀和数组，能实现原数组上的单点修改和前缀和查询问题，与前缀和数组相比通过牺牲查询效率去换取较平衡的修改效率。

算法	构造时间复杂度	修改时间复杂度	查询时间复杂度
1-1	$O(1)$	$O(1)$	$O(n)$
1-2	$O(n)$	$O(n)$	$O(1)$
1-3	$O(n)$	$O(\log n)$	$O(\log n)$

区间修改单点查询问题（问题 2）：给定数组 $A_{\mathrm{1..}n}$，$m$ 次操作为修改或查询二者之一，修改操作是给定下标 $l,r(l\le r)$ 和增量 $q$ 将 $A_l,A_{l+1},...,A_r$ 修改为 $A_l+q,A_{l+1}+q,...,A_r+q$，查询操作是给定下标 $p$ 查询当前数组值 $A_p$。

算法 2-1：维护原数组 $A_{\mathrm{1..}n}$，修改操作和查询操作无特别策略。

算法 2-2：维护差分数组 $D_{\mathrm{1..}n}$，构造时令 $A_0=0$，满足 $D_k=A_k-A_{k-1}$（$D$ 是 $A$ 的差分数组等价于 $A$ 是 $D$ 的前缀和数组），修改操作即令 $D_l=D_l+q,D_{r+1}=D_{r+1}-q$，查询操作即迭代求和 $A_p={\sum }_{i=1}^p{D}_i=D_1+D_2+...+D_p$。

算法 2-3：维护差分数组的树状数组。因为经过以上推导，原数组上的问题 2 转化为了差分数组上的问题 1。

算法	构造时间复杂度	修改时间复杂度	查询时间复杂度
2-1	$O(1)$	$O(n)$	$O(1)$
2-2	$O(n)$	$O(1)$	$O(n)$
2-3	$O(n)$	$O(\log n)$	$O(\log n)$

区间修改区间查询问题（问题 3）：给定数组 $A_{\mathrm{1..}n}$，$m$ 次操作为修改或查询二者之一，修改操作是给定下标 $l,r(l\le r)$ 和增量 $q$ 将 $A_l,A_{l+1},...,A_r$ 修改为 $A_l+q,A_{l+1}+q,...,A_r+q$，查询操作是给定下标 $l,r(l\le r)$ 查询当前数组区间和 ${\sum }_{i=l}^r{A}_i=A_l+...+A_r$。

算法 3-1：维护原数组 $A_{\mathrm{1..}n}$，修改操作和查询操作无特别策略。

算法 3-2：维护差分数组 $D_{\mathrm{1..}n}$，构造同上，修改操作同上，查询操作即迭代求和 ${\sum }_{k=l}^r{A}_k={\sum }_{k=l}^r{\sum }_{i=1}^k{D}_i=(r-l+1){\sum }_{i=1}^{l-1}{D}_i+{\sum }_{i=l}^r(r-i+1)D_i$。

算法 3-3：通过前缀和 $S_k$ 简化差分数组查询表达式如下：
$$\begin{gathered} S_k=\sum _{i=1}^k{A}_i=\sum _{i=1}^k\sum _{j=1}^i{D}_j=k{D}_1+(k-1)D_2+...+D_k \\ =(k+1)(D_1+D_2+...+D_k)-(D_1+2D_2+...+k{D}_k) \\ =(k+1)\sum _{i=1}^k{D}_i-\sum _{i=1}^{k}i{D}_i \\ \sum _{k=l}^r{A}_k=S_r-S_{l-1}=\left[(r+1)\sum _{i=1}^r{D}_i-l\sum _{i=1}^{l-1}{D}_i\right]-\sum _{i=l}^{r}i{D}_i \end{gathered}$$
设差分下标积数组 $M_{\mathrm{1..}n}$，满足条件 $M_k=k{D}_k$，当修改操作令 $D_l=D_l+q,D_{r+1}=D_{r+1}-q$ 时，同步令 $M_l=M_l+l\ast q,M_{r+1}=M_{r+1}-(r+1)\ast q$。同步维护差分数组 $D$ 的树状数组和差分下标积数组 $M$ 的树状数组，查询操作即计算
$$\begin{gathered} \sum _{k=l}^r{S}_k=(k+1)\sum _{i=1}^k{D}_i-\sum _{i=1}^k{M}_i \\ \sum _{k=l}^r{A}_k=S_r-S_{l-1} \end{gathered}$$

算法	构造时间复杂度	修改时间复杂度	查询时间复杂度
3-1	$O(1)$	$O(n)$	$O(n)$
3-2	$O(n)$	$O(1)$	$O(n)$
3-3	$O(n)$	$O(\log n)$	$O(\log n)$

算法 3-3 代码如下：

#define FD(A, i) (A[i] - ((i) > 1 ? A[(i) - 1] : 0))
#define FM(A, i) ((i) * FD(A, i))
void Construct(int *D, int *M, int *A, int n)
{
	IBT_Construct(D, A, n, FD);
	IBT_Construct(M, A, n, FM);
}
void Modify(int *D, int *M, int n, int l, int r, int q)
{
	IBT_Modify(D, n, l, q);
	IBT_Modify(D, n, r + 1, -q);
	IBT_Modify(M, n, l, l * q);
	IBT_Modify(M, n, r + 1, -(r + 1) * q);
}
int Query(int *D, int *M, int l, int r)
{
	int s0, s1;
	s0 = l * IBT_Query(D, l - 1) - IBT_Query(M, l - 1);
	s1 = (r + 1) * IBT_Query(D, r) - IBT_Query(M, r);
	return s1 - s0;
}

该问题也可以用线段树解决，但常数较大，且代码量过大，在此不做深入讨论。

树状数组的定义和性质

令 $T_{\mathrm{1..}n}$ 为 $A_{\mathrm{1..}n}$ 上的树状数组，则 ∀ k ∈ { 1 , . . . , n } , T k = ∑ i = 0 l o w b i t ( k ) − 1 A k − i \forall k \in \{1, ..., n\}, T_k = \sum_{i = 0}^{lowbit(k) - 1} A_{k - i} ∀k∈{1,...,n},Tk​=∑i=0lowbit(k)−1​Ak−i​，其中 $lowbit(x)=xand(-x)$，$and$ 表示按位与运算。为了更直观地解释 $lowbit(x)$ 与 $x$ 之间的关系，将 $x$ 转为二进制补码表示（设 $x$ 长四字节并且 $x>0$）$x=\overline{b_{31}...b_1{b}_0}$，其中 b i ∈ { 0 , 1 } b_i \in \{0, 1\} bi​∈{0,1}。不妨设 $b_0=b_1=...=b_{k-1}=0,b_k=1$，则有
$$x=(b_{31}...b_{k+1}\mathrm{100...0}{)}_2$$
由于补码表示下 $-x=(notx)+1$（$not$ 表示按位取反），令 $b_i^{\prime }=1-b_i$，则
$$\begin{gathered} notx=(b_{31}^{\prime }...b_{k+1}^{\prime }\mathrm{011...1}{)}_2 \\ -x=(b_{31}^{\prime }...b_{k+1}^{\prime }\mathrm{100...0}{)}_2 \end{gathered}$$
而由于 $b_{i}and{b}_i^{\prime }=0$，故
$$lowbit(x)=xand(-x)=(\mathrm{00...0100..0}{)}_2=2^k$$
于是得出以下三条性质：
第一，$lowbit(x)$ 是 $2$ 的自然数幂；
第二，$xmodlowbit(x)=0$；
第三，$xmod(2\ast lowbit(x))\ne 0$。

树状数组 $T_{\mathrm{1..}n}$ 上的每一项都是原数组 $a_{\mathrm{1..}n}$ 上的一段区间和，其中任一项 $T_k$ 对应区间右端点为 $k$，区间长度为 $lowbit(k)$。举个例子，因为 $lowbit(12)=4$，故 $T_{12}=A_9+A_{10}+A_{11}+A_{12}$。于是按照 $lowbit(k)$ 将树状数组 $T_{\mathrm{1..}n}$ 划分成不同层次，第 $i$ 层是所有使得 $lowbit(k)=2^i$ 的 $T_k$ 项。具体来说，第 $0$ 层是所有下标模 $2$ 余 $1$ 的项，第 $1$ 层是所有下标模 $4$ 余 $2$ 的项，第 $2$ 层是所有下标模 $8$ 余 $4$ 的项，以此类推。设 $F_k^j={\sum }_{i=0}^{2^j-1}{A}_{k-i}(kmod{2}^j=0)$，则有
$$F_k^j=\{\begin{array}{rlr}& F_k^{j-1}+F_{k-2^j}^{j-1}& j>0\\ & A_k& j=0\end{array}$$
而由于 $T_k=F_k^{{\log }_{2}lowbit(k)}$，故有
$$\begin{gathered} T_k=\{\begin{array}{rlr}& F_k^{{\log }_{2}lowbit(k)-1}+T_{k-lowbit(k)}& lowbit(k)>1\\ & A_k& lowbit(k)=1\end{array} \\ {F}_k^{{\log }_{2}j}=\{\begin{array}{rlr}& F_k^{{\log }_{2}j-1}+T_{k-j}& j>1\\ & A_k& j=1\end{array} \end{gathered}$$

$A_{\mathrm{1..12}}$	$A_1$	$A_2$	$A_3$	$A_4$	$A_5$	$A_6$	$A_7$	$A_8$	$A_9$	$A_{10}$	$A_{11}$	$A_{12}$
$L_0$	$T_1$	$F_2^0$	$T_3$	$F_4^0$	$T_5$	$F_6^0$	$T_7$	$F_8^0$	$T_9$	$F_{10}^0$	$T_{11}$	$F_{12}^0$
$L_1$		$T_2$		$F_4^1$		$T_6$		$F_8^1$		$T_{10}$		$F_{12}^1$
$L_2$				$T_4$				$F_8^2$				$T_{12}$
$L_3$								$T_8$

对于以上有关 $T_k$ 和 $F_k^j$ 的定义式，若其形式为 $X=Y+Z$，则令 $X$ 为 $Y$ 和 $Z$ 的父节点。如此，$T\cup F$ 构成了由若干棵大小互不相同的满二叉树组成的森林。当 $n$ 为 $2$ 的自然数次幂时，森林退化成一棵满二叉树。这是该数据结构名为树状数组的原因。在实际代码实现中，$F$ 作为树状数组 $T$ 构造过程的中间结果而不另外保存。而任一 $A_k$ 值的修改，对应着满二叉树结构上某一叶节点值的变化，最多造成满二叉树结构上 $O(\log n)$ 个节点值的变化（即从叶节点到根节点唯一路径上的节点）。此即树状数组的修改逻辑。

关于原数组 $A_{\mathrm{1..}n}$ 的前缀和数组 $S_{\mathrm{1..}n}$ 和树状数组 $T_{\mathrm{1..}n}$ 之间的关系，由于有 $T_k={\sum }_{i=0}^{lowbit(k)-1}{A}_{k-i}=S_k-S_{k-lowbit(k)}$，故要通过 $T_{\mathrm{1..}n}$ 求出 $S_k$，可以利用递推式 $S_0=0,S_k=S_{k-lowbit(k)}+T_k$，而又由于 $lowbit(k)\in [1,k]$，保证了递推式下标的合法性和递推式的有穷性。

事实上，如果仅关注 $T_{\mathrm{1..}n}$ 的内部结构，可以惊讶地发现规模相同的树状数组和二项堆的结构是同构的（但是需要注意，二项堆不能像树状数组一样用数组实现，因为二项堆通过指针形式保证 $O(\log n)$ 的堆合并时间复杂度，而数组形式仅复制就已经是 $O(n)$ 了）。维护数组区间和的树状数组与维护可合并堆最值的二项堆的同构性表现了二进制思想在数据结构领域的优美应用。

树状数组的代码实现和复杂度分析

构造代码如下：

#define IBT_Construct(T, A, n, f) \
	for(int i = 1; i <= n; i++) \
		T[i] = f(A, i); \
	for(int i = 2; i <= n; i <<= 1) \
		for(int j = i; j <= n; j += i) \
			T[j] += T[j - (i >> 1)];

构造时间复杂度 $O(n)$。表面上看似乎代码里有二层循环，但以数学形式表示构造过程时间函数
$$\begin{gathered} T_C(n)=n+\lfloor \frac{n}{2}\rfloor +\lfloor \frac{n}{4}\rfloor +...+\lfloor \frac{n}{2^{\lfloor {\log }_{2}n\rfloor }}\rfloor \\ \le n+\frac{n}{2}+\frac{n}{4}+...+\frac{n}{\lfloor {\log }_{2}n\rfloor } \\ =n\left[1+\frac{1}{2}+\frac{1}{4}+...+\frac{1}{\lfloor {\log }_{2}n\rfloor }\right] \\ <2n=O(n) \end{gathered}$$
计算得出构造过程总时间复杂度是线性的。

另一种构造方法是逐项构造，即初始清零后用 $n$ 次修改操作，时间复杂度 $O(n\log n)$，虽然略劣于正规构造方法，但节省了部分代码量，也可接受。

关于逐项构造的时间复杂度可能会不太显然，因为与其同构的二项堆采用逐项插入的方法构造，虽然单元素插入时间复杂度为 $O(\log n)$，但经过摊还分析后总构造时间复杂度为 $O(n)$。是什么造成二者时间复杂度上的不同？直观来说，设 $n$ 为 $2$ 的自然数次幂，对于一棵规模为 $n$ 的二项树构造，只需要把两棵规模为 $\frac{n}{2}$ 的二项树之间添加一条边即可（前 $\frac{n}{2}$ 次插入和后 $\frac{n}{2}$ 次插入除了最后一步合并，其它操作都是独立的）；而对于 $T_n$ 的计算，树结构上从 $T_{\frac{n}{2}}$ 到 $T_n$ 的边实际上走过了 $\frac{n}{2}$ 次，因为 $A_1,A_2,...,A_{\frac{n}{2}}$ 在修改算法中均通过 $T_{\frac{n}{2}}$ 到 $T_n$。以 $n=8$ 为例，设 $Modify(A_k)$ 为修改 $A_k$ 所涉及的树状数组项的集合，即 M o d i f y ( A k ) = { T i ∣ i − l o w b i t ( i ) < k ≤ i } Modify(A_k) = \{T_i | i - lowbit(i) < k \leq i\} Modify(Ak​)={Ti​∣i−lowbit(i)<k≤i}，则有
M o d i f y ( A 1 ) = { T 1 , T 2 , T 4 , T 8 ‾ } M o d i f y ( A 2 ) = { T 2 , T 4 , T 8 ‾ } M o d i f y ( A 3 ) = { T 3 , T 4 , T 8 ‾ } M o d i f y ( A 4 ) = { T 4 , T 8 ‾ } M o d i f y ( A 5 ) = { T 5 , T 6 , T 8 } M o d i f y ( A 6 ) = { T 6 , T 8 } M o d i f y ( A 7 ) = { T 7 , T 8 } M o d i f y ( A 8 ) = { T 8 } \begin{aligned} & Modify(A_1) = \{T_1, T_2, \underline{T_4, T_8}\} \\ & Modify(A_2) = \{T_2, \underline{T_4, T_8}\} \\ & Modify(A_3) = \{T_3, \underline{T_4, T_8}\} \\ & Modify(A_4) = \{\underline{T_4, T_8}\} \\ & Modify(A_5) = \{T_5, T_6, T_8\} \\ & Modify(A_6) = \{T_6, T_8\} \\ & Modify(A_7) = \{T_7, T_8\} \\ & Modify(A_8) = \{T_8\} \\ \end{aligned} ​Modify(A1​)={T1​,T2​,T4​,T8​​}Modify(A2​)={T2​,T4​,T8​​}Modify(A3​)={T3​,T4​,T8​​}Modify(A4​)={T4​,T8​​}Modify(A5​)={T5​,T6​,T8​}Modify(A6​)={T6​,T8​}Modify(A7​)={T7​,T8​}Modify(A8​)={T8​}​
故以数学形式表示树状数组和二项堆的逐项构造过程时间函数
$$\begin{gathered} T_C^{\prime }(n)=2T^{\prime }(\frac{n}{2})+\frac{n}{2} \\ {T}_C^{\prime \prime }(n)=2T^{\prime \prime }(\frac{n}{2})+1 \end{gathered}$$
计算得出树状数组逐项构造时间复杂度 $T_C^{\prime }(n)=O(n\log n)$，二项堆逐项构造时间复杂度 $T_C^{\prime \prime }(n)=O(n)$。

修改操作令 $A_p=A_p+q$，查询操作返回前缀和 $S_p={\sum }_{i=1}^p{A}_i$，代码如下：

#define lowbit(x) (x & -(x))
#define IBT_Modify(T, n, p, q) \
	for(int i = p; i <= n; i += lowbit(i)) \
		T[i] += q;
#define IBT_Query(T, p) \
({ \
	int r = 0; \
	for(int i = p; i > 0; i -= lowbit(i)) \
		r += T[i]; \
	r; \
})

修改时间复杂度 $O(\log n)$，查询时间复杂度 $O(\log n)$。修改操作经过上文分析，得出至多修改 $O(\log n)$ 个树状数组项，由此分析出时间复杂度。查询操作利用上文前缀和递推式 $S_k=S_{k-lowbit(k)}+T_k$，而二进制补码形式下 $k-lowbit(k)$ 相比 $k$ 实际上是将权值最小的 $1$ 改为 $0$，故查询操作迭代次数等于 $k$ 的二进制补码形式下 $1$ 的个数，由此分析出时间复杂度。

最后，树状数组的另一应用场景是求数组的逆序对数，算法大致是按值从大到小顺序，在对应下标位置统计当前前缀和，并插入值 $1$，最后求和即为总逆序对数。不过对于大多数情形而言，区间求和问题有更泛用的线段树，逆序对问题用归并排序解决一石二鸟（树状数组求逆序对需要先排序并记下各项在原数组中的下标，而归并排序求逆序对只需要在排序过程中统计即可），树状数组的优势似乎只有常数小而已了（不得不说，线段树和归并的常数确实大）。