【进阶】树状数组 BIT

最新推荐文章于 2023-11-19 17:33:50 发布

置顶 Nekroz_

最新推荐文章于 2023-11-19 17:33:50 发布

阅读量273

点赞数

分类专栏： BIT 差分

本文链接：https://blog.csdn.net/Diogenes_/article/details/95774530

版权

BIT 同时被 2 个专栏收录

5 篇文章 0 订阅

订阅专栏

差分

2 篇文章 0 订阅

订阅专栏

之前我讲过最基本的树状数组，这里讲一讲它的”进阶形态“.

具有可加性的内容让树状数组来维护会显得很方便（比如说和），而不满足可加性的内容让树状数组来维护会有点麻烦（虽然已经有 dalao 给出了树状数组求最大值和 select 的程序，但我想这个时候还是老老实实写线段树或者平衡树吧）。

之前讲的是单点修改加区间查询，现在就从树状数组区间修改单点查询开始吧。

先丢一波单点修改区间查询的代码。

class BinaryIndexedTree {
private:
    long long c[N];
    inline int lowbit(int x) { return x & (-x); }
    inline long long query(int x) {
        long long ans = 0;
        for (int i = x; i > 0; i -= lowbit(i)) 
            ans += c[i];
        return ans;
    }
public:
    inline void update(int x, long long v) {
        for (int i = x; i <= n; i += lowbit(i)) 
            c[i] += v;
    }
    inline long long query(int l, int r) { 
        return query(r) - query(l - 1); 
    }
} BIT;

本来我想把它装在 namespace 里面的，但是好像把一个 query 放在 class 的 private 里面会保险得多，防止主程序中调用了出锅~

好了，回到区间修改区间查询，相信大多数人都会，因为这两个东西是配套学的，就是运用查分的思想，没什么好说的，直接上代码。

class BinaryIndexedTree {
private:
    long long c[N];
    inline long long lowbit(long long x) { return x & (-x); }
    inline void update(int x, long long v) {
        for (int i = x; i <= n; i += lowbit(i)) 
            c[i] += v;
    }
public:
    inline long long query(int x) {
        long long ans = 0;
        for (int i = x; i > 0; i -= lowbit(i)) 
            ans += c[i];
        return ans;
    }
    inline void update(int l, int r, long long v) {
        update(l, v);
        update(r + 1, -v);
    }
};

树状数组维护的操作只能是一个单点一个区间吗？No！它可以支持区间修改区间查询哦！

但是，这首先还是要用到差分，然后来推式子~
$\begin{aligned} \sum_{i = 1}^n a_i & = \sum_{i=1}^n\sum_{j=1}^ic_j \\ & = \sum_{j=1}^n\sum_{i=j}^nc_j \\ & = \sum_{i=1}^n\sum_{j=i}^nc_i \\ & = \sum_{i=1}^n(n-i+1)c_i\\ & = (n + 1)\sum_{i=1}^nc_i - \sum_{i=1}^nic_i \end{aligned}$
以上式子真心建议拿起笔来算一算，因为这个涉及到基础的求和符号及其运算（当然聪明的你肯定能从第一步直接跳到倒数第二步，虽然如此但我还是建议用上面的方法算一算，毕竟每一步都有运算定律支撑，是相当严谨的）。

这下可以看出来了我们该如何操作了：用一棵树状数组维护 $c_i$ ，用另外一棵树状数组维护 $ic_i$ 。问题得到了解决。

class BinaryIndexedTree {
private:
    long long c[2][N];
    inline int lowbit(int x) { return x & (-x); }
    inline void update(int x, long long v) {
        for (int i = x; i <= n; i += lowbit(i)) 
            c[0][i] += v, c[1][i] += x * v;
    }
    inline long long query(int x) {
        long long ans = 0;
        for (int i = x; i > 0; i -= lowbit(i)) 
            ans += (x + 1) * c[0][i] - c[1][i];
        return ans;
    }

public:
    inline void update(int l, int r, long long v) {
        update(l, v);
        update(r + 1, -v);
    }
    inline long long query(int l, int r) { 
        return query(r) - query(l - 1); 
    }
};

接下来是拓展到高维的时候了，同学们只要编过就知道，树状数组拓展到高维的代码量几乎是所有可拓展的数据结构中最简单的。当然前两种操作我就不再赘述了，其实这两个操作比起讲还是看代码来得轻松（前置技能是二维前缀和，其实就是容斥原理，实在不懂就画个图）。

二维树状数组单点修改区间查询·

class BinaryIndexedTree2D {
private:
    long long c[N][N];
    inline int lowbit(int x) { return x & -x; }
    inline long long query(int x, int y) {
        long long ans = 0;
        for (int i = x; i > 0; i -= lowbit(i))
            for (int j = y; j > 0; j -= lowbit(j))
                ans += c[i][j];
        return ans;
    }
public:
    inline void update(int x, int y, int v) {
        for (int i = x; i <= n; i += lowbit(i))
            for (int j = y; j <= m; j += lowbit(j)) 
                c[i][j] += v;
    }
    inline long long query(int x, int y, int z, int w) {
        return query(z, w) - query(z, y - 1) - query(x - 1, w) + query(x - 1, y - 1);
    }
};

二维树状数组区间修改单点查询（额，好像没有这种东西吧。。。有的话类比一下）

二维树状数组区间修改区间查询

不得不说是恶心呐（推式子比较繁琐），但是相较写个二维线段树已经是相当轻松了。

这回使用之前的方法肯定是可行的，但是我太懒了，就跳个几步（饶了我吧），~~虽然我知道你们都不用想那被省略的几步就可以推得出来~~
$\begin{aligned} \sum_{i = 1}^n\sum_{j=1}^n a_{j} & = \sum_{i=1}^n\sum_{j=1}^n(n-i+1)(m-j+1)c_j \\ & = \sum_{i=1}^n\sum_{j=1}^n[(n+1)(m+1)-(m+1)i-(n+1)j+ij]c_{ij} \\ & = (n+1)(m+1)\sum_{i=1}^n\sum_{j=1}^nc_{ij}-(m+1)\sum_{i=1}^n\sum_{j=1}^nic_{i,j}-(n+1)\sum_{i=1}^n\sum_{j=1}^njc_{ij}+\sum_{i=1}^n\sum_{j=1}^nijc_{ij} \end{aligned}$
这下明白了，需要建四棵树状数组，分别维护双 $\sum$ 里面的信息。

class BinaryIndexedTree2D {
private:
    long long c[4][N][N];
    inline int lowbit(int x) { return x & (-x); }
    inline void update(int x, int y, long long v) {
        for (int i = x; i <= n; i += lowbit(i))
            for (int j = y; j <= m; j += lowbit(j))
                c[0][i][j] += v, c[1][i][j] += x * v, c[2][i][j] += y * v, c[3][i][j] += x * y * v;
    }
    inline long long query(int x, int y) {
        long long ans = 0;
        for (int i = x; i > 0; i -= lowbit(i))
            for (int j = y; j > 0; j -= lowbit(j))
                ans += (x + 1) * (y + 1) * c[0][i][j] - (y + 1) * c[1][i][j] - (x + 1) * c[2][i][j] + c[3][i][j];
        return ans;
    }
public:
    inline void update(int x, int y, int z, int w, long long v) {
        update(x, y, v);
        update(x, w + 1, -v);
        update(z + 1, y, -v);
        update(z + 1, w + 1, v);
    }
    inline long long query(int x, int y, int z, int w) {
        return query(z, w) - query(x - 1, w) - query(z, y - 1) + query(x - 1, y - 1);
    }
};

式子比较长，就容忍一下吧，还是不得不说，这么写比写两重线段树好受多了。

P.S.不知道什么时候 $C S D N$ 支持 $K a t e x$ 了，但是为什么 $K a t e x$ 不认识 $a l i g n$ 呢？？？但实话实说 $K a t e x$ 是真的快。。