OI退役笔记-022：数据结构（二）树状数组

树状数组本质上就是普通的数组，只不过以树形来存储数据。用于解决对序列的多次单点&区间修改、单点&区间求值的问题。
本篇博文以代码及注释形式呈现，其中的公式图片在代码后面。

#include <cstdio>

// 树状数组：单点修改 + 区间求值 

// 初始化
// 对于数列第 i 个数 a，updateV(i, a) 即可 
int n, c[100010];

// lowbit(int)
// 返回整型数字二进制末尾有多少个 0
// lowbit(x) = x & (~x + 1) = x & (-x) 
inline int lowbit(int _x)
  { return _x & -_x; }

// sum__(int)
// 返回从 1 到 x 所有数的和 
// c[x] 存储从 x - lowbit(x) + 1 到 x 的所有数的和 
// 复杂度：O(nlogn) 
int sum__(int _x)
{
	int _sum = 0;
	while (_x)
	{
		_sum += c[_x];
		_x -= lowbit(_x);
	}
	
	return _sum;
}

// getsum(int, int)
// 求区间 [_l, _r] 所有数的和
// 类似前缀和，getsum(l, r) = sum__(r) - __sum(l - 1) 
// 复杂度：O(nlogn) 
inline int getsum(int _l, int _r)
  { return sum__(_r) - sum__(_l - 1); }

// updateV(int, int)
// 更新点的值
// 对于任意点 x，其值若改变，则 c[x] += x
// 同时 c[x + lowbit(x)] 的值也会改变
// 以此类推，直到推到 n 时结束
// 复杂度：O(nlogn) 
// 注意：update() 函数不能处理 x = 0 时的数，因此要特殊处理 
void updateV(int _x, int _v)
{
	while (_x <= n)
	{
		c[_x] += _v;
		_x += lowbit(_x);
	}
}

//****************************
// 树状数组的扩展：区间修改 + 单点求值 + 区间求值 
//****************************

// 思路：用树状数组维护差分 
// 初始化
// 将数列存到 q 数组内（不调用 updateV()）
int q[100010];

// updateL(int, int, int)
// 修改某区间内所有点的值

// 对于区间 [_l, _r]，只需使 [_l, n] 中所有数加上 _v，
// 再使 [_r + 1, n] 中所有数加上 -_v 
inline void updateL(int _l, int _r, int _v)
  { updateV(_l, _v), updateV(_r + 1, -_v); }

// getsum(int)
// 返回单点的值 
// 对于 x ∈ [l, r]，若 [l, r] 每个数都加上 v
// 则 x 的值也会加上 v 
// 最后的结果就是 x + sum__(x) 
// 即：本身加上本身之前差分的和 
inline void getsum(int _x)
  {return q[_x] + sum__(_x); }

// 区间查询

// 另一个树状数组
// 用于维护 q[i] * i 
// 思路：正常维护树状数组求 ∑q[i]，
// 同时维护另一个树状数组求 ∑q[i] * i
// 详细推理见公式图片 
long long c2[100010];

// updateV2(int, int)
// 更新点的值
// 同时更新 c2[] 
void updateV2(int _x, int _v)
{
	int _t = _x;
	while (_x)
	{
		c[_x] += _v;
		c2[_x] += (long long)_t * _v;
		
		_x -= lowbit(_x);
	}
}

// sum2__(int)
// 返回从 1 到 x 所有数的和 
// 特殊处理 
long long sum2__(int _x)
{
	long long ans = 0, _t = _x;
	while (_x)
	{
		ans += ((_t + 1) * c[_x] - c2[_x]);
 		_x -= lowbit(_x);
	}

	return ans;
} 


// 另一种求区间和的方法： 
// （灵感来源：【一本通提高篇树状数组】校门外的树）
// 对于每一个修改区间 [l, r] 和值 v，用两个树状数组分别存左右端点的值：
// update_l(l, v), update_r(r, v)
// 每次查询时的值 sum(l, r) = sum_l(r) - sum_r(l) 即可 

补充：树状数组求逆序对：

#include <cstdio>
#include <algorithm>

int c[1000010], n;
  
struct Node
{
	int val, id;
	bool operator < (const Node& n2) const {
		return (this->val < n2.val) || (this->val == n2.val && this->id < n2.id);
	}        
} a[1000010];

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

long long update(int x, int v)
{
	while(x <= n) {
		c[x] += v;
		x += lowbit(x);
	}
}

int sum(int x)
{
	int ans = 0;
    while (x) {
		ans += c[x];
		x -= lowbit(x);
	}

	return ans;
}

int main()
{
	scanf("%d", &n);           
	for (int i = 1; i <= n; ++i)
		scanf("%d", &a[i].val), a[i].id = i;

	std::sort(a + 1, a + n + 1); 
 
	long long ans = 0;
	for (int i = 1; i <= n; ++i)
	{ 
		update(a[i].id, 1);
		ans += a[i].id - sum(a[i].id);
	}
	
    printf("%lld", ans);
	return 0;
}

作者：Rotch
日期：2021-05-24
修改：2021-05-24
[2021-05-27]：加入了树状数组求逆序对个数的算法