树状数组简介
树状数组(Binary Indexed Tree(B.I.T), Fenwick Tree)是一个查询和修改复杂度都为(log n)的数据结构。主要用于查询任意两位之间的所有元素之和，但是每次只能修改一个元素的值；经过简单修改可以在(log n)的复杂度下进行范围修改，但是这时只能查询其中一个元素的值(如果加入多个辅助数组则可以实现区间修改与区间查询)。
经过了如此一番看不懂的说明,或许你会直接绝望掉,But这东西贼重要,而且 这种东西竟然没有STL！！！气不气 QAQ
基础概念
假设数组(A_{1...n})，那么查询(sum_{j=1}^{i}A_j)的时间是(log)级别的，而且这是一个在线的数据结构，支持随时修改某个元素的值，复杂度也为(log)级别。
来观察这个图：
令这棵树的结点编号为(C_1,C_2,C_3......C_n)。令每个结点的值为这棵树的值的总和，那么容易发现：
C1 = A1
C2 = A1 + A2
C3 = A3
C4 = A1 + A2 + A3 + A4
C5 = A5
C6 = A5 + A6
C7 = A7
C8 = A1 + A2 + A3 + A4 + A5 + A6 + A7 + A8
这里有一个有趣的性质：
设节点编号为x，那么这个节点管辖的区间为(2^k)（其中k为x二进制末尾0的个数）个元素。
这样说是不是就要明确一些了?
根据这个性质,就有一个千古大罪人发明了树状数组
代码实现
大体结构
struct B_I_T{
int C[100001];
int n;
......//函数
};
lowbit
时间复杂度
(O(1))
实现
还记得上面说的那一个性质吗?借助C++强大的位运算,我们可以在O(1)时间内求出(2^k)
int lowbit(int x) { return x - ( x & (x - 1) ); }
还有一种更简单也更常用的方式,是这样的
int lowbit(int x) { return x & -x; }
struct B_I_T{
int C[100001];
int n;
inline int lowbit(int x) { return x & -x; }
......//函数
};
就可以在结构体中加入这样一个函数了.
不过,更常用的方法不是写在结构体里面,而是写在外面,否则不在结构体当中就只能用B_I_T::lowbit(x) 了,即
inline int lowbit(int x) { return x & -x; }
struct B_I_T{
int C[100001];
int n;
......//函数
};
其实还有一种实现方法，用宏定义：#define lowbit(x) (x & -x)
lowbit的作用
update
时间复杂度
(O(log n))
意义
(update(x,val)) => (A_x=A_x+val)
实现
void update(int x,int val) {
for(int i=x;i<=n;i+=lowbit(x)) C[x]+=val;
}
这种使用for循环的做法,和下面使用while循环的原理是一样的.
void update(int x,int val) {
while(x<=n) {
C[x]+=val;
x+=lowbit(x);
}
}
假设n=8,执行update(3,5),则有如下流程
x=3 C[3]+=5 x=3+lowbit(3)=4
x=4 C[4]+=5 x=4+lowbit(4)=8
x=8 C[8]+=5 x=8+lowbit(8)=16
x=16 退出
对照上文的图片 我也不知道有多上文 我们可以知道,每一次C数组中执行加操作的下标,刚好都包括了(A_3)！
作用
作用1——初始化
inline void init() {
scanf("%d",&n);
for(reg int i=1;i<=n;i++) {
scanf("%d",&a);
update(i,a);
}
}
作用2——改变单点的值 话说就是拿来干这件事的就不讲了
query
时间复杂度
(O(log n))
意义
(query(x)) => (A_1+A_2+……+A_x)
实现
int query(int x) {
int res=0;
for(reg int i=x;i;i-=lowbit(x)) res+=C[i];
return res;
}
这种使用for循环的做法,和下面使用while循环的原理是一样的.
int query(int x) {
int res=0;
while(x) {
res+=C[x];
x-=lowbit(x);
}
return res;
}
假设n=8,执行query(7),则有如下流程
res=0
x=7 res=C[7]
x=6 res=C[6]+C[7]
x=4 res=C[4]+C[6]+C[7]
x=0 退出
仍然对照上(?)表，可以知道(C_4=A_1+A_2+A_3+A_4)，(C_6=A_5+A_6)，(C_7=A_7)。所以(C_4+C_6+C_7=sum^7_{i=1}A_i)！
作用
作用1——求单点前缀和 不多赘述，直接(query(x))即可
作用2——求区间和 (Sum(l,r)=query(r)-query(l-1))，即r的前缀和减去l-1的前缀和，即为l->r的区间和
总结+代码
将以上的所有总结在一起，可以有如下代码
struct B_I_T{
int n;
int C[MAXN];
inline int lowbit(int x) {
return x & -x;
}
inline void update(int x,int val) {
for(register int i=x;i<=n;i+=lowbit(i))
C[i]+=val;
}
inline int query(int x) {
int s=0;
for(register int i=x;i;i-=lowbit(i))
s+=C[i];
return s;
}
inline void init() {
for(register int i=1;i<=n;i++) {
int a;
scanf("%d",&a);
update(i,a);
}
}
};
如此，我们就可以愉快地完成A+B problem了！
逆序对
话说这不一道归并的题吗?拿到B.I.T.这里来干哈的?
先无脑打上mergesort的代码一份
int n,a[500001];
int s[500001];
long long ans;
void mrg(int left,int right,int mid)
{
int i=left,j=mid+1,k=left;
while(i<=mid&&j<=right)
{
if(a[i]>a[j])
{
ans+=mid-i+1;
s[k++]=a[j++];
}
else s[k++]=a[i++];
}
while(i<=mid)
s[k++]=a[i++];
while(j<=right)
s[k++]=a[j++];
for(int i=left;i<=right;i++)
a[i]=s[i];
}
void mergesort(int left,int right)
{
if(left==right)return;
int mid=(left+right)/2;
mergesort(left,mid);
mergesort(mid+1,right);
mrg(left,right,mid);
}
离散化
喂喂喂，这又是什么鬼?又关这道题什么事?不要急，先听我说。
离散化是程序设计中一个常用的技巧，它可以有效的降低时间复杂度。
有些数据本身很大，自身无法作为数组的下标保存对应的属性。如果这时只是需要这堆数据的相对属性，那么可以对其进行离散化处理。当数据只与它们之间的相对大小有关，而与具体是多少无关时，可以进行离散化。比如当你数据个数n很小，数据范围却很大时（超过1e9）就考虑离散化更小的值，能够实现更多的算法。
Set an example：
方式
离散化常见的两种方式： 1、数组离散化 2、用STL+二分离散化
数组法
for(register int i=1;i<=n;i++)
{
cin>>a[i].val;
a[i].id = i;
}
sort(a+1,a+n+1);//定义结构体时按val从小到大重载
for(int i=1;i<=n;i++)
b[a[i].id]=i;//将a[i]数组映射成更小的值,b[i]就是a[i]对应的rank(顺序)值
STL+二分
//n原数组大小 num原数组中的元素 lsh离散化的数组 cnt离散化后的数组大小
int lsh[MAXN],cnt,num[MAXN],n;
for(int i=1;i<=n;i++)
{
scanf("%d",&num[i]);
lsh[i]=num[i];//复制一份原数组
}
sort(lsh+1,lsh+n+1);//排序,unique虽有排序功能,但交叉数据排序不支持，所以先排序防止交叉数据
//cnt就是排序去重之后的长度
cnt=unique(lsh+1,lsh+n+1)-lsh-1;//unique返回去重之后最后一位后一位地址-数组首地址-1
for(int i=1;i<=n;i++)
num[i]=lower_bound(lsh+1,lsh+cnt+1,num[i])-lsh;
//lower_bound返回二分查找在去重排序数组中第一个等于或大于num[i]的值的地址-数组首地址,从而实现离散化
实现
逆序对实际上就是统计当前元素的前面有几个比它大的元素的个数，然后把所有元素比它大的元素总数垒加就是逆序对总数。
代码
int n;
int C[500001];
long long ans;
int a[500001];
int rnk[500001];
inline int lowbit(int x) {
return x & -x;
}
inline int query(int x) {
int s=0;
while(x>0) {
s+=C[x];
x-=lowbit(x);
}
return s;
}
inline void update(int x,int val) {
while(x<=n) {
C[x]+=val;
x+=lowbit(x);
}
}
int main() {
for(reg int i=1;i<=n;i++) {
a[i]=rnk[i]=read<int>();
}
sort(a+1,a+n+1);
int cnt=unique(a+1,a+n+1)-a-1;
for(reg int i=1;i<=n;i++) {
rnk[i]=lower_bound(a+1,a+cnt+1,rnk[i])-a;
}
for(reg int i=1;i<=n;i++) {
update(rnk[i],1);
ans+=i-query(rnk[i]);
}
write(ans);
}
树状数组进阶
差分
如果你像我一样是个小白，那你也许看不懂这是什么东西。
好吧，先上万能的百度百科
差分，又名差分函数或差分运算，差分的结果反映了离散量之间的一种变化，是研究离散数学的一种工具，常用函数差近似导数。
有没有仍然看不懂？
那就直接来看一下差分的BIT吧
区间修改+单点查询
看起来有点正经的内容了
主要思想
令i~j的区间和为(a_i-a_{j-1}(i>j))，于是前缀和就为(a_i-a_0)。如果如此，那输入的时候就可以处理为(update(i,a_i-a_{i-1}))。
单点查询
想一想，如果这样，(A_i=a_i-a_{i-1},A_1+A_2+...+A_i=a_i-a_0)，就可以直接这样处理了。至于单点查询，可以很容易地想到，对于一个点i而言，因为a[0]=0，所以query(i)=a[i]
区间修改
直接上代码
inline void update(int x,int delta) {
......//同上
}
inline void update(int l,int r,int delta) {
update(l,delta); update(r+1,-delta);
}
想一想，如果(n=6)，([2-4])这个区间加上4，那么如下
id 1 2 3 4 5 6
A 0 4 4 4 0 0
C 0 4 0 0 -4 0
震惊！ 只有(C_2(+4))和(C_5(-4))改变了！
对于(C_3)的分析
C[3]=A[3]-A[2]
C'[3]=A'[3]-A'[2]=(A[3]+4)-(A[2]+4)=A[3]-A[2]=C[3]
所以，按这样推来，只需要改动(C_l)和(C_r)即可。
区间修改+区间查询
差分分析
我们同样引入上面的差分C数组。
(∵C_i=A_i-A_{i-1})
(∴A_i=C_1+C_2+C_3+......+C_i)
那么可以得到这一坨
( A_1+A_2+...+A_i)
(=C_1+(C_1+C_2)+...+(C_1+C_2+...+C_i))
(=i*C_1+(i-1)*C_2+...+C_i)
(=i*(C_i+C_2+...+C_i)-1*C_2-...-(i-1)*C_i)
所以，我们就可以再用一个毒瘤的差分数组(C1_i)来储存((i-1)*C_i)
接上面的公式
(=i*(C_1+C_2+C_3+......+C_i)-(C1_1+C1_2+C1_3+......+C1_i))
代码
typedef long long LL;
#define lowbit(x) (x & -x)
struct BIT{
int n;
LL C1[MAXN],C2[MAXN];
inline BIT(){}
inline void update(LL *C,int x,LL val) {
while(x<=n) {
C[x]+=val;
x+=lowbit(x);
}
}
inline void update(int l,int r,LL val) {
update(C1,l,val); update(C1,r+1,-val);
update(C2,l,val*(l-1)); update(C2,r+1,-val*r);
}
inline LL query(LL *C,int x) {
LL s=0;
while(x) {
s+=C[x];
x-=lowbit(x);
}
return s;
}
inline LL query(int l,int r) {
return (l-1)*query(C1,l-1)-query(C2,l-1)-(r*query(C1,r)-query(C2,r));
}
inline void init(int N=0) {
if(N) n=N;
else n=read<int>();
LL bef=0;
for(reg int i=1;i<=n;i++) {
LL num=read<LL>();
update(C1,i,num-bef);
update(C2,i,(num-bef)*(i-1));
bef=num;
}
}
};
2D树状数组
怎么会有这么毒瘤的题……
int n,m;
struct BIT2D{
int C[1001][1001];
......//函数
};
query
分析——放弃
代码——
inline int query(int x,int y) {
int res=0;
for(register int i=x;i;i-=lowbit(i)) {
for(register int j=y;j;j-=lowbit(j)) {
res+=C[i][j];
}
}
return res;
}
update
分析——同上
代码——
inline void update(int x,int y,int delta) {
for(register int i=x;i<=n;i+=lowbit(i)) {
for(register int j=y;j<=n;j+=lowbit(j)) {
C[i][j]+=delta;
}
}
}
区间修改+单点查询
一句话总结：(C_{i,j}=A_{i,j}-A_{i-1,j}-A_{i,j-1}+A_{i-1,j-1})
区间修改+区间查询
同样是一句话：维护(C_{i,j})和(i*C_{i,j})和(j*C_{i,j})和(i*j*C_{i,j})
时间复杂度
每一次操作为(O(log^2 n))
当然了，更高维的树状数组也可以此类推，每一次操作的时间复杂度为(O(log^k n))(k是树状数组的维度)
罗列例题
一维
- A+B problem(bushi)
- 统计和(比板题还板题的板题)
- Stars(大板题)
- 【模板】树状数组 1
- 逆序对
- 【模板】树状数组 2(推荐用 区间修改+单点查询 和 区间修改+区间查询 各做一遍)
- 上帝造题的七分钟2(很灵活，注意使用并查集优化常数...附上题解)
多维
- Mobile phones(简直就是二维的板题)
- Matrix
- 上帝造题的七分钟
- Cube(三维虚不虚)
完结撒花！！！！！！！！！