夜深人静写算法（十三）- 树状数组

一、前言

  目前本专栏正在进行优惠活动，在博主主页添加博主好友，可以获取 付费专栏优惠券。
  你怎么过一天，就会怎么过一辈子。
  其实是不是在打工不重要，关键是你怎么度过你工作的八小时，你是把自己当成一个出卖劳动力来获取工资的商品，还是当成一个在投资自己未来，而获取自我价值的人，这才是最重要的！
  有时候，每天一点一滴的积累，短期内看不到效果，但是我相信，只要坚持，总会有质变的一天，只要还活着，这一天终将到来，这，就是厚积薄发！

二、从图形学算法说起

1、Median Filter 概述

• Median Filter 在现代的图形处理中是非常基础并且广泛应用的算法 (翻译为 中值滤波），如图二-1-1，它是一种非线性平滑技术，它将每一像素点的值设置为该点某邻域窗口内的所有像素点的中值。用于去除图片上的一些噪点。
  ​​ 图二-1-1

2、r pixel-Median Filter 算法

• 中指滤波算法处理的是图片，对于一张宽为 W，高为 H 的图片，每个像素点存了一个颜色值，这里为了把问题简化，先讨论黑白图片，黑白图片的每个像素值可以认为是一个 $[0,255]$ 的整数，而对于彩色图片则是对 RGB 三个通道进行分别处理。

r pixel-Median Filter 算法描述如下：
  对于每个第 $i$ 行第 $j$ 列的像素点 $p(i,j)$，像四周扩展一个宽和高均为 $(2r+1)$ 的矩形区域，将矩形区域内的像素值按非降序排列后，用排在最中间的那个数字取代原来的像素点 $p(i,j)$ 的值( 边界的那圈不作考虑 )。

图二-2-1

• 如图二-2-1，下标从 0 计数，行优先，且 $r=1$，红框代表 $(2,3)$ 这个像素点所选取的 $2r+1$ 的矩形区域，将矩形中数字进行非降序排列后，得到 $[0,1,1,2,3,4,6,7,9]$，所以 $(2,3)$ 这个像素点的值将从 $6$ 变成 $3$。
• 这样就可以粗略得到一个时间复杂度为 $O(n^{4}lo{g}_n)$ 的算法：枚举每个像素点，对于每个像素点取矩形窗口元素排序后取中值。$n$ 代表了图片的尺寸，也就是当图片越大，这个算法的执行效率就越低，而且增长迅速。那么如何将这个算法进行优化呢？如果对于二维的情况不是很容易下手的话，不妨先从一维的情况进行考虑。

3、一维模型

• 我们可以尝试将问题进行降维处理，可以描述成如下的问题：

【例题1】给定 $n(n\le 10^5)$ 个范围在 $[0,255]$ 的数字序列 $a[i](1\le i\le n)$ 和一个值 $r(2r+1\le n)$，对于所有的 $a[k](r+1\le k\le n-r)$，将它变成 $a[k-r...k+r]$ 中的中位数。

朴素法求解过程

• 例如给出数组 $a[i]$，且 $r=2$，有：$$a[1...7]=(1,7,6,4,3,2,1)$$
• 计算中位数的过程如下：
• $d[3]=median([1,7,6,4,3])=4$
• $d[4]=median([7,6,4,3,2])=4$
• $d[5]=median([6,4,3,2,1])=3$
• 于是，原数组就会变成 $[1,7,4,4,3,2,1]$
• 以上需要计算中位数的元素为 $n-2r$，取这些元素的左右 $r$ 个元素的值需要 $2r+1$ 次操作，$(n-2r)\ast (2r+1)$ 当 $r=\frac{n-1}{4}$ 时取得最大值，为 $\frac{(n+1{)}^2}{4}$，再乘上排序的时间复杂度，所以最坏情况的时间复杂度为 $O(n^{2}lo{g}_n)$。$n$ 的范围不允许这么高复杂度的算法，尝试进行优化。

突破口

• 考虑第 $i$ 个元素的 $2r+1$ 区域 $a[i-r...i+r]$ 和第 $i+1$ 个元素的 $2r+1$ 区域 $a[i+1-r...i+1+r]$，后者比前者少了一个元素 $a[i-r]$，多了一个元素 $a[i+1+r]$，其它元素都是一样的，那么在计算第 $i+1$ 个元素的中位数时如何利用第 $i$ 个元素已经计算出来的结果就成了问题的关键。

4、数据结构的设计

• 我们现在假设有这样一种数据结构，也可以叫容器；

支持以下三种操作：
  1、插入操作(Insert)：将一个数字插入到该容器中；
  2、删除操作(Delete)：将指定数字从该容器中删除；
  3、询问操作(Query)：询问该容器中所有数字的中位数；

• 如果这三个操作都能在 $O(lo{g}_n)$ 或者 $O(1)$ 的时间内完成，那么这个问题就可以完美解决了。

算法分析

• 首先将 $a[1...2r+1]$ 这些元素都插入到该容器中，然后询问中位数后替换掉 $a[r+1]$，再删除容器中的 $a[1]$，插入 $a[2r+2]$，询问中位数替换掉 $a[r+2]$，以此类推，直到计算完第 $n-r$ 个元素。所有操作都在 $O(lo{g}_n)$ 时间内完成的话，总的时间复杂度就是 $O(nlo{g}_n)$。

数据结构分析

• 我们来看什么样的数据结构可以满足这三条操作都在 $O(lo{g}_n)$ 的时间内完成，考虑每个数字的范围是 $[0,255]$，如果我们将这些数字映射到一个哈希表中，插入和删除操作都可以做到 $O(1)$。
• 具体得，用一个辅助数组 $d[256]$，插入 $a[i]$ 执行的是 d[ a[i] ] ++，删除 $a[i]$ 执行的是 d[ a[i] ] --；询问操作是对d[...]数组进行顺序统计，顺序枚举 $i$，得到前缀和：$$sum(i)=\sum _{j=1}^{i}d[j]$$
• 找到第一个满足 $sum(i)\ge r+1$ 的 $i$ 就是所求的中位数，这样就得到了一个时间复杂度为 $O(Kn)$ 的算法，其中 $K$ 是数字的值域（这里讨论的问题值域是 256）。
• 相比朴素算法，这种方法已经前进了一大步，至少 $n$ 的指数下降了大于一个数量级，但是也带来了一个问题，如果数字的值域很大，复杂度还是会很大，所以需要更好的算法支持。

5、树状数组华丽登场

• 这里引入一种数据结构 - 树状数组 ( Binary Indexed Tree，BIT，二分索引树 )；

它只有两种基本操作：
  1、$add(i,x)(1\le i\le k)$：对第 $i$ 个元素的值加 $x$；
  2、$sum(i)(1\le i\le k)$：统计 $[1...i]$ 元素值的和；

• 试想一下，如果用哈希表来实现这两个函数，那么第1步的复杂度是 $O(1)$，而第2步的复杂度就是 $O(k)$ 了，而树状数组实现的这两个函数可以让两者的复杂度都达到 $O(lo{g}_k)$，具体的实现留到第二节着重介绍。
• 有了这两种操作，我们需要将它们转化成之前设计的数据结构的那三种操作，如下：
• 1、插入(Insert)，对应的是 $add(i,1)$，时间复杂度 $O(lo{g}_k)$
• 2、删除(Delete), 对应的是 $add(i,-1)$, 时间复杂度 $O(lo{g}_k)$
• 3、询问(Query), 由于 $sum(i)$ 能够统计 $[1...i]$ 元素值的和，换言之，它能够得到我们之前插入的数据中小于等于 $i$ 的数的个数，那么如果能够知道 $sum(i)\ge r+1$ 的最小的 $i$，那这个 $i$ 就是所有插入数据的中位数了。因为 $sum(i)$ 是关于 $i$ 的递增函数，所以基于单调性我们可以二分枚举 $i(1\le i\le k)$，得到最小的 $i$ 满足 $sum(i)\ge r+1$，每次的询问复杂度就是 $O(lo{g}_k\ast lo{g}_k)$。 $lo{g}_k$ 是二分枚举的复杂度，另一个 $lo{g}_k$ 是 $sum$ 函数求解的复杂度。
• 这样一来，一维的 Median Filter 模型的整体时间复杂度就降到了 $O(nlo{g}_{k}lo{g}_k)$，已经是比较高效的算法了。
• 接下来就是要来说说树状数组的具体实现了。

三、细说树状数组

1、树 or 数组 ？

• 名曰树状数组，那么究竟它是树还是数组呢？数组在物理空间上是连续的，而树是通过父子关系关联起来的，而树状数组正是这两种关系的结合，首先在存储空间上它是以数组的形式存储的，即下标连续；其次，对于两个数组下标 $x，y(x<y)$，如果满足：$$x+2^k=y(k等于x的二进制表示中末尾0的个数)$$，那么定义 $(y,x)$ 为一组树上的父子关系，其中 $y$ 为父结点，$x$ 为子结点。

图三-1-1

• 如图三-1-1所示，其中 A 为普通数组，C 为树状数组（C 在物理空间上和 A 一样都是连续存储的）。树状数组的第 4 个元素 $C_4$ 的父结点为 $C_8$ (4的二进制表示为 $(100{)}_2$，所以 $k=2$，那么 $4+2^2=8$)，$C_6$ 和 $C_7$ 同理。$C_2$ 和 $C_3$ 的父结点为 $C_4$，同样也是可以用上面的关系得出的，那么从定义出发，奇数下标一定是叶子结点。

2、结点的含义

• 然后我们来看树状数组上的结点 $C_i$ 具体表示什么，这时候就需要利用树的递归性质了。
• 我们定义 $C_i$ 的值为它的所有子结点的值 和 $A_i$ 的总和，之前提到当 $i$ 为奇数时 $C_i$ 一定为叶子结点，所以有 $C_i=A_i$ ( $i$ 为奇数 )。从图三-1-1中可以得出如下等式组：
  $$\{\begin{array}{l}{C}_1=A_1\\ C_2=C_1+A_2=A_1+A_2\\ C_3=A_3\\ C_4=C_2+C_3+A_4=A_1+A_2+A_3+A_4\\ C_5=A_5\\ C_6=C_5+A_6=A_5+A_6\\ C_7=A_7\\ C_8=C_4+C_6+C_7+A_8=A_1+A_2+A_3+A_4+A_5+A_6+A_7+A_8\end{array}$$
• 我们从上面的公式中可以发现，其实 $C_i$ 还有一种更加普适的定义，它表示的其实是一段原数组 $A$ 的区间和。根据定义，右区间的下标是很明显的，一定是 $i$，即 $C_i$ 表示的区间的最后一个元素一定是 $A_i$，那么接下来就是要求 $C_i$ 表示的左区间的下标是什么。从图中可以看出，其实就是顺着 $C_i$ 的最左儿子一直找直到找到叶子结点，那个叶子结点就是 $C_i$ 表示区间的第一个元素。
• 更加具体的，如果 $i$ 的二进制表示为 $(????1000{)}_2$，那么它最左边的儿子就是 $(????0100{)}_2$，这一步是通过结点父子关系的定义进行逆推得到，并且这条路径可以表示如下：$$(????1000{)}_2\to (????0100{)}_2\to (????0010{)}_2\to (????0001{)}_2$$
• 这时候，$(????0001{)}_2$ 已经是叶子结点了，所以它就是 $C_i$ 能够表示的第一个元素的下标，那么我们发现，如果用 $k$ 来表示 $i$ 的二进制末尾 0 的个数，$C_i$ 能够表示的 $A$ 数组的区间的元素个数为 $2^k$，又因为该区间的最后一个数一定是 $A_i$，所以有如下公式：$$C_i=\sum _{j=i-2^k+1}^i{A}_j$$
• 比较直观的理解就是，左区间的下标是通过 右区间下标 减去 $2^k$ 加上 1 得出。

3、求和操作

• 明白了 $C_i$ 的含义后，我们需要通过它来求 ${\sum }_{j=1}^i{A}_j$，也就是之前提到的 $sum(i)$ 函数。为了简化问题，用一个函数 $lowbit(i)$ 来表示 $2^k$ ( $k$ 等于 $i$ 的二进制表示中末尾 0 的个数)。那么：
  $$\begin{array}{rl}sum(i)& =A_1+A_2+...+A_i\\ & =A_1+A_2+A_{i-2^k}+A_{i-2^k+1}+...+A_i\\ & =A_1+A_2+A_{i-2^k}+C_i\\ & =sum(i-2^k)+C_i\\ & =sum(i-lowbit(i))+C_i\end{array}$$
• 由于 $C_i$ 已知，所以 $sum(i)$ 可以通过递归求解，递归出口为当 $i=0$ 时，返回 0。$sum(i)$ 函数的函数主体只需要一行代码：

int sum(int i) {
    return i ? C[i] + sum(i - lowbit(i)):0;
}

• 观察 i - lowbit(i)，其实就是将 $i$ 的二进制表示的最后一个 1 去掉，最多只有 $lo{g}_i$ 个 1，所以求 $sum(i)$ 的最坏时间复杂度为 $O(lo{g}_i)$。由于递归的时候常数开销比较大，所以一般写成迭代的形式更好，写成迭代形式的代码如下：

int sum(int i) {
    int s = 0;
    while (i >= 1) {
        s += c[i];
        i -= lowbit(i);
    }
    return s;
}

4、更新操作

• 更新操作就是之前提到的 $add(i,1)$ 和 $add(i,-1)$，更加具体得，可以推广到 $add(i,v)$，表示的其实就是 $A_i=A_i+v$。但是我们不能在原数组 $A$ 上操作，而是要像求和操作一样，在树状数组 $C$ 上进行操作。
• 从求和公式可以知道 $A_i$ 的改变只会影响 $C_i$ 及其祖先结点，即 $A_5$ 的改变影响的是 $C_5、C_6、C_8$；而 $A_1$ 的改变影响的是 $C_1、C_2、C_4、C_8$。
• 我们知道，树状数组上的父子关系 $(y,x)$ 满足 $x+2^k=y$，所以我们可以通过这个公式从叶子结点不断往上递归，直到 $y$ 超过最大值 $maxn$ 为止，祖先结点最多为 $lo{g}_{maxn}$ 个，$add(i,v)$ 的主体代码（去除边界判断）也只有一行代码：

const int maxn = 100000;

void add(int i, int v){
    if(i <= maxn){
        C[i] += v, add( i + lowbit(i), v);
    }
 }

• 和求和操作类似，递归的时候常数开销比较大，所以一般写成迭代的形式更好。写成迭代形式的代码如下：

const int maxn = 100000;

void add(int i, int v) {
    while (i <= maxn) {
        c[i] += v;
        i += lowbit(i);
    }
}

5、lowbit 函数 O(1) 实现

• 上文提到的两个函数 $sum(i)$ 和 $add(i,v)$ 都用到了一个函数叫 $lowbit(i)$，表示的是 $2^k$，其中 $k$ 为 $i$ 的二进制表示末尾 0 的个数，那么最简单的实现办法就是通过位运算的右移，循环判断最后一位是 0 还是 1，从而统计末尾 0 的个数，一旦发现 1 后统计完毕，计数器保存的值就是 $k$，当然这样的做法总的复杂度为 $O(lo{g}_i)$，一个32位的整数最多可能进行31次运算。
• 这里介绍一种 $O(1)$ 的方法计算 $2^k$ 的方法。

补码

• 来看一段补码小知识：清楚补码的表示的可以跳过这一段，计算机中的符号数有三种表示方法，即原码、反码和补码。三种表示方法均有符号位和数值位两部分，符号位都是用0表示“正”，用1表示“负”，而数值位，三种表示方法各不相同。这里只讨论整数补码的情况，在计算机系统中，数值一律用补码来表示和存储。原因在于，使用补码，可以将符号位和数值域统一处理；同时，加法和减法也可以统一处理。整数补码的表示分两种：
• 正数：正数的补码即其二进制表示；
• 例如一个 8 位二进制的整数 +5，它的补码就是 $(00000101{)}_2$；
• 负数：负数的补码即将其整数对应的二进制表示所有位取反(包括符号位)后加 1；
• 例如一个 8 位二进制的整数 -5，它的二进制表示是 $(00000101{)}_2$，取反后为 $(11111010{)}_2$，再加 1 就是 $(11111011{)}_2$，这就是它的补码了。
• 下面的等式可以帮助理解补码在计算机中是如何工作的：$$+5+(-5)=00000101+11111011=100000000(溢出了!!!)=0$$
• 这里的加法没有将数值位和符号位分开，而是统一作为二进制位进行计算，由于表示的是8进制的整数，所以多出的那个最高位的1会直接舍去，使得结果变成了0，而实际的十进制计算结果也是0，正确。

x & (-x)

• 补码复习完毕，那么来看下下面这个表达式的含义：

	x & (-x);

• 首先进行 & 运算，我们需要将 $x$ 和 $-x$ 都转化成补码，然后再看 & 之后会发生什么。
• 令 $x$ 的二进制表示为 $$(X_0{X}_1{X}_2\dots X_{n-2}{X}_{n-1}{)}_2$$ 这里的 $X_0$ 表示符号位，我们假设 $x$ 的二进制表示的末尾是连续的 $k$ 个 0，则有 $$(X_i=0|n-k\le i<n)$$
• $x$ 的补码就是由三部分组成（其中 $X_{n-k-1}=1$）：$$(符号位0)(X_1{X}_2\dots X_{n-k-1})(\underset{\mathrm{k}}{\underbrace{00...00}}{)}_2$$
• $-x$ 的补码也是由三部分组成（其中 $Y_{n-k-1}=1$）：$$(符号位1)(Y_1{Y}_2\dots Y_{n-k-1})(\underset{\mathrm{k}}{\underbrace{00...00}}{)}_2$$
• 根据补码的定义，可得 $X_i+Y_i=1(i\in [0,n-k-1))$；
• 那么 x & (-x)也就显而易见了，为 $(1\underset{\mathrm{k}}{\underbrace{00...00}}{)}_2$，表示成十进制为 $2^k$，正好是我们要求的 $lowbit(x)$ 。由于&的优先级低于-，所以代码可以这样写：

int lowbit(int x) {
    return x & -x;
}

6、小结

• 至此，树状数组的基础内容就到此结束了，三个函数就诠释了树状数组的所有内容，并且都只需要一行代码实现，单次操作的时间复杂度为 $O(lo{g}_n)$，空间复杂度为 $O(n)$，所以它是一种性价比非常高的轻量级数据结构。
• 下面会通过一些例子来具体阐述树状数组的经典模型和应用场景。

四、树状数组的经典模型

1、单点更新，成段求和

【例题2】一个长度为 $n(n\le 10^5)$ 的元素序列，一开始都为0，现给出三种操作：
  1、add x v : 给第 $x$ 个元素的值加上 $v$；
  2、sub x v : 给第 $x$ 个元素的值减去 $v$；
  3、sum x y： 询问第 $x$ 到第 $y$ 个元素的和；

• 这是树状数组最基础的模型，1 和 2 的操作就是对应的单点更新，3 的操作就对应了成端求和。
• 具体得，1 和 2 只要分别调用 $add(x,v)$ 和 $add(x,-v)$, 而 3 则是求 $sum(y)-sum(x-1)$ 的值。
• 如图四-1-1所示，区间和可以通过两个前缀和相减得到；
  图四-1-1

2、成段更新，单点求值

【例题3】一个长度为 $n(n\le 10^5)$ 的元素序列，一开始都为0，现给出两种操作：
  1、add x y v : 给第 $x$ 个元素到第 $y$ 个元素的值都加上 $v$；
  2、get x：询问第 $x$ 个元素的值；

• 这类问题对树状数组稍微进行了一个转化，但是还是可以用 $add$ 和 $sum$ 这两个函数来解决，对于操作 1 我们只需要执行两个操作，即 $add(x,v)$ 和 $add(y+1,-v)$；而操作 2 则是输出 $sum(x)$ 的值。
• 这样就把区间更新转化成了单点更新，单点求值转化成了区间求和。

五、树状数组的应用场景

1、逆序对

【例题4】给定 $n(n\le 10^5)$ 个数的排列 $a[i](1\le a[i]\le n)$，求满足 $i<j$ 且 $a[i]>a[j]$ 的数对 $(i,j)$ 的个数。

• 这个问题就是经典的逆序数问题，如果采用朴素算法，就是枚举 $i$ 和 $j$，并且判断 $a[i]$ 和 $a[j]$ 的值进行数值统计，如果$a[i]>a[j]$ 则计数器加一，统计完后计数器的值就是答案。 但是这么做的时间复杂度为 $O(n^2)$，对于这个问题来说时间复杂度太高。
• 我们可以考虑如果只枚举 $j$，那么如何在 $O(lo{g}_n)$ 的时间内，快速得到满足 $a[i]>a[j]$ 的 $i$ 的个数，就是我们要做的事。
• 考虑到所有数最大不会超过 $n$，所以每当枚举到 $j$ 时，我们可以把 $a[j]$ 插入树状数组中（即 调用 $add(a[j],1)$），同时利用求和函数 $sum(n)-sum(a[j])$ 可以得到树状数组中大于 $a[j]$ 的数有多少个，记为 $an{s}_j$，而这些数的下标正好是小于 $j$ 的，满足逆序数的要求，那么插入和查询都能做到 $O(lo{g}_n)$，扫描一遍以后，${\sum }_{j=1}^{n}an{s}_j$ 就是我们要求的答案了。时间复杂度 $O(nlo{g}_n)$。

2、K 大数

【例题5】有一种容器，支持两种操作 (操作总数 $\le 10^6$)：
  1、Insert $v$；对容器插入一个大小为 $v$ 的数，其中 $0<v\le 10^6$；
  2、Query $k$；询问容器中第 $k$ 大的数；

• 如果一个数是第 $k$ 大的，那么容器里的数 $v$，大于等于它的数记为 $x_v$，则 $x_v$ 是满足下述不等式中最小的：
  $$x_v\ge k$$
• 因为第 $k$ 大的数可能有多个，所以这里的符号是 ‘>=’ 而不是 ‘=’ ；

朴素思路

• 如果用数组作为容器来存储这些数字，数组元素为 $(v,c)$，其中 $v$ 代表值，$c$ 代表这个值出现了多少次。维护一个 $v$ 降序的数组，每次插入数据的时间复杂度是 $O(n)$；询问采用累加前缀和的方式，扫描数组并且累加数字出现的个数，对于某个数 $v$，大于等于它的数记为 $x_v$，如果满足 $x_v\ge k$ 则 $v$ 作为一个可行解，答案就是所有满足可行解里 $v$ 值最大的，询问的时间复杂度也是 $O(n)$。

优化思路

• 考虑到数的范围在 $[1,10^6]$, 我们可以尝试用哈希的方式来存储这些插入的数字，假设插入的数字有 6、5、4、1，数字有重复，分别出现次数为 2、3、4、1，映射到哈希数组后如下：

$i$	1	2	3	4	5	6	…	10^6
$hash[i]$	1	0	0	4	3	2	…	0

• $hash[i]$ 代表 $i$ 这个数在容器中有 $hash[i]$ 次。这样插入的时间复杂度为 $O(1)$。询问某个数是否是 $k$ 大的，采用倒序枚举的方式，假设当前第 $k$ 的数是 $i$，那么我们要求 $i$ 尽量大，且必须满足：
  $$\sum _{j=i}^{10^6}hash[j]\ge k$$
• 这里涉及到了成段求和，将上述式子进行一个转换，得到：
  $$sum(10^6)-sum(i-1)\ge k$$
• 其中 $sum(i)$ 代表 $hash[i]$ 的前缀和，并且是随着 $i$ 单调不降的，所以我们能够通过二分枚举 $i$ 来找到满足上面式子的最大的 $i$，而这个 $i$ 就是我们想要求的最大的数。而这一步求和操作正好对应了树状数组的成段求和。

最终方案

• 1）插入时，利用树状数组的单点更新来对数字 $v$ 进行插入操作；
• 2）询问时，二分枚举一个答案 $v$，利用树状数组的成段求和来统计树状数组中大于等于 $v$ 的数的个数 $x_v$，如果满足 $x_v\ge k$，则增大 $v$ 的值，否则减小 $v$ 的值，直到找到一个满足条件的最大的 $v$。总的时间复杂度为 $O(nlo{g}_{n}lo{g}_n)$。

3、离散化

【例题6】给定 $n(n\le 10^5)$ 个数的序列 $a[i](1\le a[i]\le 10^9)$，求满足 $i<j$ 且 $a[i]>a[j]$ 的数对 $(i,j)$ 的个数。

• 这个问题和 【例题4】 的逆序数问题差别在于数字的范围变大了，这样我们就无法映射到数组中了，但是有一点就是：我们并不关心 $a[i]$ 具体有多大，而只关心两个值 $a[i]$ 和 $a[j]$ 之间的相对关系，所以对于下面两个数组，他们的逆序数是一样的：
  图五-3-1
• 所以我们可以把所有出现过的数字进行排序，然后去掉重复的数，用每个数的下标去代替原数，这种将原本离散的数值转换成连续的下标，这一步操作就被称为 离散化。因为涉及到排序，所以离散化的时间复杂度为 $O(nlo{g}_{2}n)$。
• 我们已经把所有已经出现过的数都进行排序去重，所以就可以通过二分查找找到原数所在的下标的值，这一步操作是 $O(lo{g}_{2}n)$ 的。
• 离散化的排序去重代码实现如下：

sort(v, v + vsize);
int tmpvsize = 1;
for (int i = 1; i < vsize; ++i) {
    if (v[i] != v[tmpvsize - 1]) 
        v[tmpvsize++] = v[i];
}
vsize = tmpvsize;

• 数组v[i]的值需要在数据进行输入的时候进行收集。
• 二分查找原数在新数组的下标的过程实现如下：

int getIndex(int now) {
    int l = 0, r = vsize - 1;
    while (l <= r) {
        int mid = (l + r) >> 1;
        if (v[mid] == now) {
            return mid + 1;
        }else if (now < v[mid]) {
            r = mid - 1;
        }else {
            l = mid + 1;
        }
    }
}

• 这里需要注意的是，树状数组下标是从 1 开始的，所以如果离散化数组的下标从 0 开始的话需要进行一个偏移，也就是代码里面的 return mid + 1。

4、区间逆序对

【例题7】给定 $n(n\le 1000)$ 个数的序列 $a[i](1\le a[i]\le 2^{31}-1)$，然后给出 $Q(Q\le 10^5)$ 次询问 $(L,R)$，每次询问区间 $[L,R]$ 中满足 $L\le x<y\le R$ 且 $a[x]>a[y]$ 的下标 $(x,y)$ 的对数。

• 首先我们发现对于逆序对 $a[x]>a[y]$ 来说，如果确定 $x$，那么 $y$ 的取值为 $(x,R]$, 和 左区间 $L$ 并没有关系；
• 我们尝试将截止到某个区间右端点的数全部插入树状数组中，如下图所示，红色线段标记的区间为 $[L,R]$，蓝色框中的数都已经插入到树状数组了；
  图五-4-1
• 枚举区间 $[L,R]$ 内的数 $a[x](x\in [L,R])$，那么就是要求 $a[y]<a[x](y\in (x,R])$，图五-4-2中橙色框代表其中一个 $a[x]$；
  图五-4-2
• 那么我们尝试去树状数组中找比 $a[x]$ 小的数，但是树状数组中比 $a[x]$ 小的数中，下标 $y$ 有比 $x$ 小的，也有比 $x$ 大的，通俗点讲，就是它有可能分布在 $a[x]$ 的两边。如图五-4-3所示，黄色圈出来的数都满足 $a[y]<a[x]$，所以我们需要把 $y<x$ 的情况去掉，而 $a[y]<a[x]$ 且 $y<x$ 的情况我们可以通过在将 $a[x]$ 插入树状数组之前就通过询问 $sum(a[x]-1)$ 求出来，求出来以后可以保存在 $s[x]$ 供后续使用；
  图五-4-3

算法整理

• 1）对数据 $a[i]$ 进行离散化；
• 2）对所有区间按照右端点 $R$ 进行单调不降排序；
• 3）枚举所有区间，对于某个区间的右端点 $R$ 作为当前插入树状数组数据的截止点，将数据 $a[i](i\le R)$ 插入树状数组，确保每个数据 $a[i]$ 在树状数组中只插入一次，并且记录 $s[i]=sum(a[i]-1)$；
• 4）对当前枚举到的区间 $[L,R]$，枚举所有的 $x\in [L,R]$， 从树状数组中求出比 $a[x]$ 小的数 $sum(a[x]-1)$，如果这个区间在原输入数据中的下标为 index，则累加答案到 $ans[index]$ 上，即 $$ans[index]+=sum(a[x]-1)-s[x]$$
• 5）最后，按顺序输出 ans[…] 的值即可；

离线算法

• 上面的这个问题在对区间进行询问时没有当即做出计算，而是把所有询问都询问完毕后，再对区间排序后逐个求解的过程，被称为 离线算法；

5、树上逆序对

【例题8】给定 $n(n\le 10^5)$ 个结点的树，求每个结点的子树中结点编号比它小的数的个数。

• 这是一个树上的逆序对的问题，通过树的先序遍历可以将树转换成数组，令树上的某个结点 $u$，先序遍历到的顺序为 $id[u]$，$u$ 的子结点个数为 $s[u]$，则转换成数组后 $u$ 管辖的区间为 $[id[u],id[u]+s[u]-1]$，然后就可以转换成区间逆序对问题进行求解了。

6、再说 Median Filter

• 基于二分的一维 Median Filter 问题已经圆满解决了，那么最后让我们回到二维的 Median Filter 问题上来。
  
• 有了一维的基础，对于二维的情况，其实也是一样的，如图所示，图中红色的框为 (1, 1) 这个像素点的 $(2r+1)$ 矩形区域，橙色的框则是 (1, 2) 的，它们的差别其实只是差了两列；同样的，橙色框和黄色框也差了两列，于是，我们可以从左向右枚举，每次将这个矩形框向右推进一格，然后将"离开"框的那一列数据从树状数组中删除，将"进入"框的那一列数据插入到树状数组中，然后统计中位数。
• 当枚举到右边界时，将矩形框向下推进一格，然后迂回向左，同样按照之前的方案统计中位数，就这样呈蛇字型迂回前进（具体顺序如图所示的红、橙、黄、绿、青、蓝、紫），这样就得到了一个 $O(n3lo{g}_{2}klo{g}_{2}k)$ 的算法，比朴素算法下降了一个数量级。

六、树状数组的高维扩展

1、二维树状数组

• 树状数组扩展到二维时，可以用来求一个离散平面上的统计问题；
• 代码实现如下：

void add(int x, int y, int v, int xmax, int ymax) {
    while (x <= xmax) {
        int ty = y;
        while (ty <= ymax) {
            c[x][ty] += v;
            ty += lowbit(ty);
        }
        x += lowbit(x);
    }
}

int sum(int x, int y) {
    ll s = 0;
    while (x >= 1) {
        int ty = y;
        while (ty >= 1) {
            s += c[x][ty];
            ty -= lowbit(ty);
        }
        x -= lowbit(x);
    }
    return s;
}

2、三维树状数组

• 三维的情况和二维类似，嵌套循环从两次变成三层即可；

---

• 关于 树状数组 的内容到这里就结束了。
• 如果还有不懂的问题，可以 想方设法 找到作者的微信进行在线咨询。

---

• 本文所有示例代码均可在以下 github 上找到：github.com/WhereIsHeroFrom/Code_Templates

---

---

七、树状数组相关题集整理

题目链接	难度	解析
HDU 1166 敌兵布阵	★☆☆☆☆	单点更新
HDU 2689 Sort it	★☆☆☆☆	逆序数
PKU 2299 Ultra-QuickSort	★☆☆☆☆	逆序数
HDU 1394 Minimum Inversion Number	★☆☆☆☆	逆序数
HDU 2838 Cow Sorting	★☆☆☆☆	逆序数
HDU 1541 Stars	★☆☆☆☆	逆序数
HDU 1556 Color the ball	★☆☆☆☆	成段更新
HDU 1892 See you~	★☆☆☆☆	二维 + 单点更新
PKU 1195 Mobile phones	★☆☆☆☆	二维 + 单点更新
HDU 5480 Conturbatio	★☆☆☆☆	二维 + 前缀和
HDU 2443 Counter Strike	★★☆☆☆	逆序数
HDU 3743 Frosh Week	★★☆☆☆	逆序数 + 离散化
PKU 3067 Japan	★★★☆☆	转换成逆序数求解
PKU 2481 Cows	★★☆☆☆	区间问题转化成逆序求解
HDU 5775 Bubble Sort	★★☆☆☆	逆序数
HDU 4000 Fruit Ninja	★★☆☆☆	逆序数 + 补集计数
HDU 2492 Ping pong	★★☆☆☆	逆序数
PKU 1990 MooFest	★★☆☆☆	转化成求和
HDU 2892 Tunnel Warfare	★★☆☆☆	二分答案 + 前缀和统计
HDU 4907 Task schedule	★★☆☆☆	二分答案 + 前缀和统计
HDU 5147 Sequence II	★★☆☆☆	逆序数 + 前缀和统计
HDU 4970 Killing Monsters	★★☆☆☆	成段更新 + 离线算法
HDU 2385 Stock	★★★☆☆	排序 + 单点更新
HDU 5273 Dylans loves sequence	★★★☆☆	区间逆序数
PKU 3321 Apple Tree	★★★☆☆	树的先序遍历转换
HDU 3887 Counting Offspring	★★★☆☆	树的先序遍历转换
HDU 3465 Life is a Line	★★★☆☆	逆序数 + 计算几何
HDU 3030 Increasing Speed Limits	★★★☆☆	离散化 + 逆序数
HDU 3648 Median Filter	★★★☆☆	二维 + 蛇形更新
HDU 3333 Turing Tree	★★★☆☆	离散化 + 离线算法
HDU 3874 Necklace	★★★☆☆	前缀和 + 离线算法
HDU 4046 Panda	★★★☆☆	单点更新 + 成段求和
HDU 4339 Query	★★★☆☆	单点更新 + 成段求和 + 二分答案
HDU 4311 Meeting point-1	★★★☆☆	排序 + 前缀和统计
HDU 4417 Super Mario	★★★☆☆	降维思想
HDU 3758 Factorial Simplification	★★★☆☆	单点更新 + 因式分解
HDU 2227 Find the non sub	★★★☆☆	动态规划+树状数组
HDU 3450 Counting Sequences	★★★☆☆	动态规划+树状数组
HDU 4991 Ordered Subsequence	★★★☆☆	动态规划+树状数组
HDU 2836 Traversal	★★★☆☆	动态规划 + 树状数组
HDU 5542 The Battle of Chibi	★★★☆☆	动态规划+树状数组
HDU 1899 Sum the K-th’s	★★★☆☆	K大数问题 单点更新 + 二分答案
HDU 2852 KiKi’s K-Number	★★★☆☆	K大数问题 单点更新 + 二分答案
HDU 4006 The kth great number	★★★☆☆	K大数问题 单点更新 + 二分答案
HDU 5805 NanoApe Loves Sequence	★★★☆☆	K大数问题 + 单点更新 + 二分答案
HDU 5806 NanoApe Loves Sequence Ⅱ	★★★☆☆	K大数问题 双指针 + 单点更新 + 二分答案
HDU 2275 Kiki & Little Kiki 1	★★★☆☆	单点更新 + 二分模型
HDU 3015 Disharmony Trees	★★★☆☆	离散化 + 单点更新
HDU 6609 Find the answer	★★★☆☆	离散化 + 单点更新
PKU 2985 The k-th Largest Group	★★★☆☆	并查集 + 树状数组
PKU 2155 Matrix	★★★☆☆	二维 + 成段更新
PKU 2642 Stars	★★★☆☆	二维
HDU 5791 Two	★★★☆☆	二维 + LCS
HDU 3584 Cube	★★★☆☆	三维 + 成段更新
HDU 5057 Argestes and Sequence	★★★☆☆	离线算法 + 前缀和统计
HDU 5497 Inversion	★★★☆☆	区间逆序数
HDU 4358 Boring counting	★★★★☆	树的先序遍历转换数组
HDU 3303 Harmony Forever	★★★★☆	二分 + 单点更新
HDU 5021 Revenge of kNN II	★★★★☆	区间三分 + 单点更新
HDU 5032 Always Cook Mushroom	★★★★☆	极角排序 + 离线算法
HDU 4456 Crowd	★★★★★	二维 + 坐标变换
HDU 4312 Meeting point-2	★★★★★	二维 + 坐标变换
HDU 4605 Magic Ball Game	★★★★★	树状数组 + 主席树