经典算法：Fenwick Tree

经典算法：Fenwick Tree
- 1. 算法简介
- 2. 原理介绍
- 3. 算法实现
- 4. 例题说明
  - 1. 解题思路
  - 2. 代码实现
- 5. 参考链接

1. 算法简介

Fenwick Tree又称为Binary Indexed Tree，也算是一种常见的数据结构了。

他其实某种意义上来说算是Segment Tree的一种变体，其主要的用途也是用于一些需要频繁对数组中元素进行变换以及范围内求和的数组的优化实现。

正如之前在Segment Tree的介绍博客（经典算法：Segment Tree）中说明的那样：数组的范围求和以及值更新事实上是两个比较难以兼顾的操作，往往在其中一个的时间复杂度是 $O (1)$ 时，另一个的时间复杂度就会变为 $O (N)$ 。

因此，如果需要频繁地改变数组中的值以及对数组中某一范围内的元素进行求和或者其他操作的话，整体的时间复杂度就会变为 $O(N^2)$ 。

而Segment Tree就是针对上述问题的一种解决方法，其核心思路是通过一个树结构来记录每一个分段当中元素的和/最大/最小值，从而使得元素的更新以及query的时间复杂度都退化为 $O (l o g N)$ ，进而优化整体的算法复杂度为 $O (Nl o g N)$ 。

但是，如前述博客当中所述，Segment Tree实现所需的最小空间复杂度是 $O (2 N)$ 。

而基于这方面，Fenwick Tree，或者说Binary Indexed Tree则可以进一步地对这部分内容进行优化。

它同样可以使用一个数组来快速对其进行实现，且较之Segment Tree，它所需的空间复杂度仅为 $O (N)$ ，且同样可以保持update以及query的单次时间复杂度为 $O (l o g N)$ 。

但是，需要注意的是，在Segment Tree当中，任意一段区间都可以表示为树当中某一些子区间的合集，因此，我们可以任意变换来求取某一子区间的和/最大值/最小值，只要这个特征的计算是无序的，它总是可以用Segment Tree来实现的。

而在Fenwick Tree当中，我们却无法将任意子区间拆分为树上面某一些节点所表示的区间的合集。事实上，对于Fenwick Tree，我们只能够求得任意前 $i$ 个元素的特征。因此，对于求前序和或者求分段区间内和的问题，我们还是可以通过Fenwick Tree来替换实现的，但是如果要求得任意区间的最大值或者最小值时，Fenwick Tree就爱莫能助了……

综上，我们简单介绍了：

Fenwick树是什么
Fenwick树的主要用途
与Segment Tree相比较，Fenwick Tree的优点与缺点

下面，我们就来看一下Fenwick Tree的具体原理和实现。

2. 原理介绍

Fenwick Tree的原理，或者用它的另一个名字会更好理解一点，即Binary Indexed Tree。

本质上来说，它和Segment Tree的原理是接近的，都是通过将原数组进行切分，得到一系列小的区间，然后每次update和query操作时，就将两者都变成对于这些区间的操作，使得两者都变为 $O (l o g N)$ 的算法复杂度，而不会像传统的方法中那样一个是 $O (1)$ 和另一个是 $O (N)$ 。

而具体的这个区分分割的方法就是Segment Tree和Fenwick Tree的唯一差别。

Segment Tree的方法直接trivial，就是通过二分法由顶向下地将原区间不断地拆分直到单元素。

而Fenwick Tree的思路则是相反的，它是由底向上地推过去，直到可以覆盖所有的数组区间。

具体来说，假设数组长度为 $n$ ，那么 $n$ 总可以用二进制进行表达，即： $2^{i_1} + \cdots 2^{i_k}$ ，其中，不妨设 $i_1 > i_2 > \cdots > i_k$ 。

此时，我们总可以将前 $2^{i_1}$ 个元素是为一组，然后其后的 $2^{i_2}$ 个元素视为一组，以此类推，然后分别进行表达。

具体我们可以用下图进行说明：

在这里插入图片描述

其中，每一个子节点的值都是其子树节点的元素之和。

特别地，我们给出一个13个元素的数组所构成的Fenwick Tree的结构如下：

在这里插入图片描述

其中，黑色节点为真实节点，灰色节点为虚节点，并不真实存在，但是为了方便理解还是画在了图中。

下面，我们只需要考察其数组的update和query方法即可。

很显然，如果要update某一个元素，只需要以该元素为起点，自下而上地更新该元素以及其父节点当中的元素即可。以上述Fenwick Tree为例，如果要更新节点3的值，那么就要依次更新节点3、4、8。

同样的，如果要对query从起点到某一个位置为止的所有元素的前序和，只需要自右向左地累加所有子树的最上层父节点的值即可。同样以上述Fenwick Tree为例，如果要查询前11个元素的前序和，那么就要依次累加节点11、10、8当中的元素值。

因此，问题也就划归为怎么求取元素的父节点以及左邻接节点的值了。

而这个问题事实上也是Fenwick Tree当中最fancy的设计，我看了一下网上好多的博客，无论中文的还是英文的，感觉其实都没有说的很明白，但是代码不会唬人，看代码的话就还是挺明白的了。

首先，可以先定义一个叫做Last Set Bit(LSB)的东西，说白了就是任何一个数使用二进制表示之后最后一个1出现的位置。换用上述 $2^{i_1} + \cdots 2^{i_k}$ 的定义的话（ $i_1 > i_2 > \cdots > i_k$ ），其LSB就是 $2^{i_k}$ 。

更具体的例子来说， $5 (101)$ 的LSB就是 $1 (1)$ ， $10 (1010)$ 的LSB就是 $2 (10)$ ， $8 (1000)$ 的LSB就是 $8 (1000)$ 。

而LSB的具体代码实现则更加简单，由计算机负数存储方式的机制，我们很快就可以给出LSB的快速计算方式为：

def LSB(x):
    return x & (-x)

此时，我们不难发现：

求取一个元素的父节点：x = x + LSB(x)
求取一个元素的左邻接节点：x = x - LSB(x)

因此，上述问题也就搞定了，我们只需要将其翻译为代码语言即可得到Fenwick Tree的实现了。

3. 算法实现

基于上述原理介绍，我们可以给出python的算法实现如下：

class FenwickTree:
    def __init__(self, arr):
        self.length = len(arr)
        self.vals = [0 for _ in arr]
        self.tree = [0 for _ in range(self.length + 1)]
        for idx, val in enumerate(arr):
            self.update(idx, val)

    def update_vals(self, idx, val):
        change = val - self.vals[idx]
        self.vals[idx] = val
        return change

    def update_tree(self, idx, change):
        idx = idx + 1
        while idx <= self.length:
            self.tree[idx] += change
            idx += idx & (-idx)
        return

    def update(self, idx, val):
        change = self.update_vals(idx, val)
        self.update_tree(idx, change)
        return

    def query(self, idx):
        _sum = 0
        idx = idx + 1
        while idx > 0:
            _sum += self.tree[idx]
            idx -= idx & (-idx)
        return _sum

    def query_range(self, left, right):
        return self.query(right) - self.query(left-1)

4. 例题说明

最后，我们来用一道例题来给一个具体的使用例子：

Leetcode 2659. Make Array Empty

1. 解题思路

这一题的具体思路其实在之前Segment Tree当中我们已经给出了说明，这里就不再赘述了，可以直接参看之前的博客：

经典算法：Segment Tree

2. 代码实现

我们直接给出python代码实现如下：

class FenwickTree:
    def __init__(self, arr):
        self.length = len(arr)
        self.vals = [0 for _ in arr]
        self.tree = [0 for _ in range(self.length + 1)]
        for idx, val in enumerate(arr):
            self.update(idx, val)

    def update_vals(self, idx, val):
        change = val - self.vals[idx]
        self.vals[idx] = val
        return change

    def update_tree(self, idx, change):
        idx = idx + 1
        while idx <= self.length:
            self.tree[idx] += change
            idx += idx & (-idx)
        return

    def update(self, idx, val):
        change = self.update_vals(idx, val)
        self.update_tree(idx, change)
        return

    def query(self, idx):
        _sum = 0
        idx = idx + 1
        while idx > 0:
            _sum += self.tree[idx]
            idx -= idx & (-idx)
        return _sum

    def query_range(self, left, right):
        return self.query(right) - self.query(left-1)

class Solution:
    def countOperationsToEmptyArray(self, nums: List[int]) -> int:
        n = len(nums)
        index = [i for i in range(n)]
        index = sorted(index, key=lambda x: nums[x])

        status = [1 for _ in range(n)]
        fenwick_tree = FenwickTree(status)
        prev = 0
        res = 0
        for idx in index:
            if idx >= prev:
                res += fenwick_tree.query_range(prev, idx) - 1
            else:
                res += fenwick_tree.query_range(0, idx) + fenwick_tree.query_range(prev, n-1) - 1
            prev = idx
            fenwick_tree.update(idx, 0)
        return res + n