树状数组学习笔记

未完待续 ...

目录

• 1. 树状数组原理
  • 1. 引入
  • 2. 树状数组
• 2. 树状数组普通应用
  • 1. 单点修改单点查询
  • 2. 单点加区间求和
  • 3. 区间加单点查询
  • 4. 区间加区间求和
  • 5. 树状数组求逆序对
• 3. 优化
  • 1. \(O(n)\) 建树
  • 2. 时间戳优化
  • 3. 查询优化
  • 4. k 叉树状数组
    • 1. 整数叉树状数组
    • 2. \(\phi\) 叉树状数组
    • 3. 总结
• 4. 树状数组中级应用
  • 1. 单点加区间最值
  • 2. 静态区间最值
  • 3. 二维树状数组
• 5. 树状数组高级应用
  • 1. 树状数组加 lazytag
  • 2. 可持久化树状数组
  • 3. 树状数组实现 BST 的功能
• Reference

1. 树状数组原理

1. 引入

我们知道前缀和：

其中下面的为原数组 \(a\)，上面的为前缀和

\[S_i=\sum_{j=1}^i a_j=\begin{cases}a_1 & i=1\\S_{i-1}+a_i&i>1\end{cases} \]

我们知道，前缀和可以维护静态区间和，显然 \(\sum\limits_{i=l}^r a_i=S_r-S_{l-1}\) .

但是如果要维护单点修改，区间求和的话，每次修改就要把它后面的每个前缀和修改，复杂度 \(O(n)\) .

我们考虑将前缀和变为树形结构，使得其修改时只需要修改其祖先节点即可。

2. 树状数组

我们定义

\[C_i=\sum_{j=i-2^k+1}^i a_i \]

其中 \(k\) 为 \(i\) 二进制末尾 \(0\) 的个数 .

我们可以发现：

\(i\)	二进制表示	\(k\)	\(2^k\)	\(i-2^k+1\)	区间	\(C_i\)
\(1\)	\((1)_2\)	\(0\)	\(2^0=1\)	\(1\)	\([1,1]\)	\(a_1\)
\(2\)	\((10)_2\)	\(1\)	\(2^1=2\)	\(1\)	\([1,2]\)	\(C_1+a_2\)
\(3\)	\((11)_2\)	\(0\)	\(2^0=1\)	\(3\)	\([3,3]\)	\(a_3\)
\(4\)	\((100)_2\)	\(2\)	\(2^2=4\)	\(1\)	\([1,4]\)	\(C_2+C_3+a_4\)
\(5\)	\((101)_2\)	\(0\)	\(2^0=1\)	\(5\)	\([5,5]\)	\(a_5\)
\(6\)	\((110)_2\)	\(1\)	\(2^1=2\)	\(5\)	\([5,6]\)	\(C_5+a_6\)
\(\cdots\)	\(\cdots\)	\(\cdots\)	\(\cdots\)	\(\cdots\)	\(\cdots\)	\(\cdots\)

表的最后一列表示了它们的递推关系。

大概样子是这样的：

其中下面是数组 \(a\)，上面是数组 \(C\) .

不难发现，\(k\) 就是这棵树的树高，显然二进制中末尾 \(0\) 的个数不会超过这个二进制的位数，所以树高是 \(O(\log n)\) 的。

我们试着计算 \(\sum\limits_{i=1}^n a_i\)（前缀和）：

• \(1\) 到 \(6\) 求和：\(a_1+a_2+\cdots +a_6=C_6+C_4=C_{(110)_2}+C_{(100)_2}\)，\(6=(110)_2\) .
• \(1\) 到 \(7\) 求和：\(a_1+a_2+\cdots +a_7=C_7+C_6+C_4=C_{(111)_2}+C_{(110)_2}+C_{(100)_2}\)，\(7=(111)_2\) .

显然这个 \(C\) 的下标是每次 \(n\) 去掉末尾一个 \(1\) 后的值，这个值就是 n&(n-1) .

现在我们考虑 \(2^k\) 怎么计算。

先给结论：i&-i。

我们来验证一下：

• 显然当 \(x=0\) 时命题成立。
• 当 \(x\) 为奇数时：最后一位为 \(1\)，取反加 \(1\) 没有进位，故 \(x\) 和 \(-x\) 除最后一位外前面的位正好相反，所以结果为 \(1\)，正确。
• 当 \(x\) 为二的次幂时：令 \(x=2^m\)，\(m\) 为整数。
  显然 \(x\) 的二进制表示中只有最高位位是 \(1\)，故 \(x\) 取反加 \(1\) 后，从右到左第有 \(m\) 个 \(0\)，第 \(m+1\) 位及其左边全是 \(1\)。这样结果是 \(x\)，正确。
• 当 \(x\) 为偶数但不为二的次幂时：令 \(x=y\times 2^k\)，其中 \(y\) 为奇数（即其最低位为 \(1\)）。
  这时，\(x\) 的二进制表示最右边有 \(k\) 个 \(0\)，从右往左第 \(k+1\) 位为 \(1\)。当对 \(x\) 取反时，最右边的 \(k\) 个 \(0\) 变成 \(1\)，第 \(k+1\) 位变为 \(0\)；再加 \(1\)，最右边的 \(k\) 位就又变成了 \(0\)，第 \(k+1\) 位因为进位的关系变成了 \(1\)。左边的位因为没有进位，正好和 \(x\) 原来对应的位上的值相反。二者按位与得到第 \(k+1\) 位上为 \(1\)，左边右边都为 \(0\) 的二进制数，即 \(2^k\)，正确。

Q.E.D.

这个 \(2^k\) 其实也是 \(\rm lowbit\) 运算，即 \(2^k=\operatorname{lowbit}(i)\)，显然 \(C\) 的下标也是 \(n-\operatorname{lowbit}(n)\).

动图（来自 VisuAlgo）

代码：

const int N=500005;
int n,m,a[N];
template<typename T>
struct BIT // 树状数组
{
private:
	T s[N];
	inline T lowbit(T x){return x&-x;}
public:
	inline void build(T* arrb,T* arre){for (int i=0;arrb+i<arre;i++) add(i+1,*(arrb+i));} // 建立树状数组相当于 n 个单点修改
	inline void build(T* arr,int end){for (int i=0;i<end;i++) add(i+1,arr[i]);}
	inline void build(T* arr,int beg,int end){for (int i=beg;i<end;i++) add(i-beg+1,arr[i]);}
	inline T query(T x) // 下面的这些操作的注释在「不封装的写法」里有
	{
		T ans=0;
		while (x){ans+=s[x]; x-=lowbit(x);}
		return ans;
	}
	inline T query(T l,T r){return query(r)-query(l-1);}
	inline void add(int x,T now){if (x) while (x<=n){s[x]+=now; x+=lowbit(x);}}
};

// 不封装的写法：

const int N=500500;
typedef long long ll;
ll s[N];
int n,m;
inline int lowbit(int x){return x&(-x);} // lowbit
inline ll query(int x) // 区间查询，查询 1~x 的和，查询 l~r 的和时可以按照前缀和的方式减
{
	int ans=0;
	while (x){ans+=s[x]; x-=lowbit(x);} // ans 累加，x 每次去掉末位的 1
	return ans;
}
inline void add(int x,ll now){while (x<=n){s[x]+=now; x+=lowbit(x);}} // x 每次加上末位的 1 就可以寻找祖先了

这里 query 函数和 add 函数的时间复杂度均为 \(O(\log n)\) .

2. 树状数组普通应用

1. 单点修改单点查询

这个直接用普通数组就行（（（（（（（（

2. 单点加区间求和

• 洛谷 P3374 【模板】树状数组 1
• loj #130. 树状数组 1 ：单点修改，区间查询
  上面讲过了

3. 区间加单点查询

• 洛谷 P3368 【模板】树状数组 2
• loj #131. 树状数组 2 ：区间修改，单点查询
  对 \([l,r]\) 的区间修改时在树状数组的第 \(l\) 个位置加这个数，在 \(r+1\) 位置减这个数（差分）。

把这个数组做前缀和，\([l,r]\) 之间会加上这个数，到 \(r+1\) 的时候加减抵消，所以 \([r+1,n]\) 没有影响。

这就把区间修改单点查询变成了两个单点修改加上一个区间查询了。

Code：

BIT<int> s;
void update(int l,int r,int x){s.add(l,x); s.add(r+1,-x);} // 在 l 处加这个数，r+1 处减这个数
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++)
    {
        scanf("%d",a+i);
        s.add(i,a[i]-a[i-1]); // 建立
    } int opt,l,r,k;
    while (m--)
    {
        scanf("%d",&opt);
        if (opt==1){scanf("%d%d%d",&l,&r,&k); update(l,r,k);}
        else scanf("%d",&k),printf("%d\n",s.query(k)); // 查询时查询 1~k 的和即可
    }
    return 0;
}

4. 区间加区间求和

• 洛谷 P3372 【模板】线段树 1
• loj #132. 树状数组 3 ：区间修改，区间查询

考虑对于一个前缀和做区间加（不妨设是加 \(x\)），它会变成这样：

显然这个新的前缀和如下：

\[S'_i=\begin{cases}S_i & 1\le i< l \\ S_i+(i-l+1)x & l\le i\le r\\ S_i+(r-l+1)x & r<i\le n\end{cases} \]

我们维护两个数组 \(A,B\)，每次区间修改就只需要执行 \(A_l=-x(l-1)\)，\(B_l=x\)，\(A_r=xr\)，\(B_r=-x\)（用差分）

这样 \(S'_i\) 就是 \(\sum\limits_{j=1}^iA_j+i\sum\limits_{j=1}^iB_j\) 了。

直接推比较困难，我们可以验证一下它的正确性：

• \(1\le i<l\)：显然正确
• \(l\le i\le r\)：此时

\[\begin{aligned}\sum\limits_{j=1}^iA_j+i\sum\limits_{j=1}^iB_j&=-x(l-1)+xi\\&=(i-l+1)x\end{aligned} \]

• \(r< i\le n\)：此时

\[\begin{aligned}\sum\limits_{j=1}^iA_j+i\sum\limits_{j=1}^iB_j&=xr-x(l-1)+(-x+x)i\\&=(r-l+1)x\end{aligned} \]

故正确。

Code：

BIT<ll> A,B; // 不开 long long 见祖宗
void update(int l,int r,int x){A.add(l,x*(1-l)); A.add(r+1,x*r); B.add(l,x); B.add(r+1,-x);}
int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++){scanf("%d",a+i); A.add(i,a[i]);}
    int opt,l,r,k;
    while (m--)
    {
        scanf("%d",&opt);
        if (opt==1){scanf("%d%d%d",&l,&r,&k); update(l,r,k);}
        else 
        {
            scanf("%d%d",&l,&r);
            ll ans=A.query(r)+r*B.query(r)-A.query(l-1)-B.query(l-1)*(l-1); // 计算时的式子比较长
            printf("%lld\n",ans);
        }
    }
    return 0;
}

5. 树状数组求逆序对

• 洛谷 P1908 逆序对

首先先把数都丢到桶里，然后一个个从小到大加入树状数组，每次的前缀和就是比它小的数的数量，用 \(i\) 减一下就是逆序对的数量，累加一下即可。

Code：

ll ans;
void init()
{
	for (int i=0;i<n;i++) tmp[i]=a[i];
	sort(tmp,tmp+n); int c=unique(tmp,tmp+n)-tmp;
	for (int i=0;i<n;i++)
		a[i]=lower_bound(tmp,tmp+c,a[i])-tmp+1;
}
int main()
{
	scanf("%d",&n);
	for (int i=0;i<n;i++) scanf("%d",a+i); init();
	for (int i=0;i<n;i++) s.add(a[i],1),ans+=i-s.query(a[i]);
	printf("%lld",ans);
	return 0;
}

3. 优化

1. \(O(n)\) 建树

树状数组的 \(O(n)\) 建树思想简单来说就是把所有 \(j+\operatorname{lowbit}(j)=i\) 的节点 \(c_j\)（\(j<\operatorname{lowbit}(i)\)） 累加到 \(c_i\) 中 .

Code 1（填表法）：

for (int i=1;i<=n;i++)
{
	scanf("%lld",s+i);
	for (int j=1;j<lowbit(i);j*=2) s[i]+=s[i-j];
}

Code2（刷表法）:

for (int i=1;i<=n;i++)
{
    scanf("%lld",&x); s[i]+=x;
    if (i+lowbit(i)<=n) s[i+lowbit(i)]+=s[i];
}

2. 时间戳优化

对付多组数据很常见的技巧。

如果每次输入新数据时都暴力清空树状数组，就可能会造成超时。

因此使用 \(tag\) 标记，存储当前节点上次使用时间（即最近一次是被第几组数据使用）。每次操作时判断这个位置 \(tag\) 中的时间和当前时间是否相同，就可以判断这个位置应该是 \(0\) 还是数组内的值。

3. 查询优化

树状数组查询区间和的方式是求前缀和，然后减，但是这种方法有些被重复计算了，并且和答案还没影响（因为被消掉了）。

稍微改改 query 即可优化：

int query(int l,int r)
{
	l--; int sum=0;
	while (r>l) sum+=a[r],r-=lowbit(r);
	while (l>r) sum-=a[l],l-=lowbit(l);
	return sum;
}

4. k 叉树状数组

1. 整数叉树状数组

比对：

\(\quad\)	二叉树状数组	三叉树状数组	\(\cdots\)	\(k\) 叉树状数组
单点修改	\(\log_2 n\)	\(\log_3 n\)	\(\cdots\)	\(\log_k n\)
区间查询	\(\log_2n\)	\(2\log_3n\)	\(\cdots\)	\((k-1)\log_k n\)

我们看出，三叉树状数组的查询理论上比二叉树状数组慢，但修改更快一些。而在实际使用时，除了修改与查询一样多的题目，更多的是查询比修改多（毕竟只有查询有输出）。

所以，如果有 \(k\) 叉树状数组（\(k<2\)），那么就能做到查询比二叉树状数组快。

这样，只能考虑 \(k\) 不为整数的情况。

2. \(\phi\) 叉树状数组

区间树在某种意义上也可以构造出这样的结构：

这就是一棵以黄金分割（斐波那契数列）为基础的树状数组，\(k=\phi=0.618\cdots\) .

虽然这样的树层数增多，影响修改的效率，但如果查询比修改多，这样的树状数组就能拥有理论上更小的常数。

3. 总结

我们也得到了这样的结论：

对于 \(k\) 叉树状数组，\(k\) 越大，查询越慢，修改越快；\(k\) 越小，查询越快，修改越慢。

当然，实际应用中还是最好用二叉树状数组，由于有位运算，所以二叉树状数组的代码量最少，而且实际常数往往更小。

而其他树状数组只能通过预处理一个数组来实现它们的类 lowbit 运算。

我们也同时发现树状数组和很多数据结构都有联系，其他很多数据结构实质是树状数组的变体，或树状数组是一些其他数据结构的结合：

• \(k=n\)：暴力
• \(k=\sqrt n\)：分块
• \(k=1\)：普通前缀和

4. 树状数组中级应用

1. 单点加区间最值

先建树：

for (int i=1;i<=n;i++)
{
	cin>>a[i]; int pos=i;
	while (pos<=n) c[pos]=max(c[pos],a[i]),pos+=lowbit(pos);
}

树状数组相当于一个前缀和，求和时可以用 \(S_r-S_{l-1}\)，但是最值没有这种减法的性质，所以这种建树每次查询前都必须初始化，时间复杂度难以接受，让我们换一种写法试一试：

for (int i=1;i<=n;i++)
{
	cin>>c[i]; int t=lowbit(i);
	for (int j=1;j<t;j*=2) c[i]=max(c[i],c[i-j]);
}

嗯，\(O(n)\) 建树的写法。

现在更新完某个数，之前的元素的值都是正确的了。

换了一种建树的方式就是为了维护 c 数组的正确性，修改同样也要保证 c 数组的正确性，那么在更新父亲节点时，我们就需要查询它所有的儿子节点，代码如下：

void add(int pos,int x)
{
	a[pos]=x;
	while (pos<=n)
	{
		c[pos]=x; int t=lowbit(pos); 
		for (int j=1;j<t;j<<=1) c[pos]=max(c[pos],c[pos-j]);
		pos+=lowbit(pos);
	}
}

这个 add 的时间复杂度是 \(O(\log^2 n)\) 的 .

查询操作：

假设当前查询的区间是 \([l,r]\)，那么我们从 \(r\) 到 \(l\) 对每一个 \(c\) 数组的元素所控制的叶子节点进行判断。假设现在进行到了第 \(i\) 项，那么显然易得：该数控制的 \(a\) 数组的元素是 \([i-\operatorname{lowbit}(i)+1,i]\) . 设 \(L=i-\operatorname{lowbit}(i)+1,R=i\)。如果 \(l\le L\le r\) 那么就将 \(c_L\) 加入最值的判断中，接着 \(L\gets L-1\) \(\cdots\)，否则的话就只对第 \(R\) 个元素加入，然后 \(R\gets R-1\) \(\cdots\)，代码如下：

int query(int l,int r)
{
	int ans=a[r];
	while (true)
	{
		ans=max(ans,a[r]); if (r==l) break; --r;
		while (r-l>=lowbit(r)) ans=max(ans,c[r]),r-=lowbit(r);
	}
	return ans;
}

这个 query 也是 \(O(\log^2 n)\) 的。

2. 静态区间最值

见 https://www.zhihu.com/question/27919834/answer/39925959

3. 二维树状数组

加一维即可，EZ

5. 树状数组高级应用

1. 树状数组加 lazytag

毒瘤，咕咕咕

2. 可持久化树状数组

毒瘤，咕咕咕

3. 树状数组实现 BST 的功能

2022.1.18，更新了 .

和权值线段树做法本质相同吧 .

upd 2022/2/22. 好像不太一样

Reference

• 树状数组详解 - Xenny
• 浅谈树状数组的优化及拓展 - 逆流之时
• 可以代替线段树的树状数组?——树状数组进阶(1) - Chanis
• 可以代替平衡树的树状数组?——树状数组进阶(2) - Chanis
• 树状数组 - OI Wiki