树状数组知识点总结

      树状数组也挺友好，感人++。跟着学长的ppt再加着看了大量有关这方面的博客，总算把这块搞得差不多了，我的目标就是写一篇所有像我一样的小白能看懂的博客，所以大家请放心食用，都是一些很好理解的内容

首先，我们需要知道的，什么是树状数组，树状数组的作用是什么？带着这两个问题，我们就可以进入下一个阶段了。

树状数组：

      此内容部分参考此篇博客所总结  https://blog.csdn.net/Small_Orange_glory/article/details/81290634  因为图真的太好了，很容易理解我就拿来用了嘿嘿嘿

 

A[ ]数组代表每个元素的值             C[ ]数组代表树状数组，即每个结点的权值之和 

如图可以彻底明白C[]的作用

C[1]=A[1];

C[2]=A[1]+A[2];

C[3]=A[3];

C[4]=A[1]+A[2]+A[3]+A[4];

C[5]=A[5];

C[6]=A[5]+A[6];

C[7]=A[7];

C[8]=A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7]+A[8];

1=(001)      C[1]=A[1];

2=(010)      C[2]=A[1]+A[2];

3=(011)      C[3]=A[3];

4=(100)      C[4]=A[1]+A[2]+A[3]+A[4];

5=(101)      C[5]=A[5];

6=(110)      C[6]=A[5]+A[6];

7=(111)      C[7]=A[7];

8=(1000)    C[8]=A[1]+A[2]+A[3]+A[4]+A[5]+A[6]+A[7]+A[8];

根据图片我们可以得到 C[i]=A[i-2^k+1]+ A[i-2^k+2]+...+A[i]           k为i的二进制中从最低位到高位连续零的长度,即从后往前数有几个0

 

下面我要引入一个lowbit(x)函数，即取x的二进制—>去反+1—>与原x的值做与运算 。（即取出x的最低位1）

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

  根据上面的内容，再结合二进制。我们可以得到C[i]表示为A[i-lowbit(i)+1]到A[i]的和，即C[i]=A[i-2^k+1]+ A[i-2^k+2]+...+A[i]

  知道了lowbit，接下来我们可以进行单点更新和区间查询

• 区间查询

int getsum(int x) {   //查询1~x区间的和    
    int ans = 0;
    for(int i=x; i>0;i-=lowbit(i))  //是一个逆过程
    ans += c[i];
    return ans;
}

• 单点更新

void add(int x, int y) {
    for(int i=x; i<=n;i+=lowbit(i))
	c[i] += y;
}

 

下面介绍树状数组的作用：

• 求区间和
• 求区间最值
• 求逆序数
• k-th大

   2.求区间最值

void updata(int x)
{
	int lx, i;
	while (x <= n)
	{
		c[x] = a[x];
		lx = lowbit(x);
		for (i=1; i<lx; i<<=1)
			c[x] = max(c[x], c[x-i]);
		x += lowbit(x);
	}		
}
int query(int l, int r) { //询问 
	int ans = 0;
	while(r >= l) {
		ans = max(a[r],ans);
		r--;
		for(; r-lowbit(r)>=l; r-=lowbit(r))
			ans = max(c[r],ans);
	}
	return ans;
}

3.求逆序对

     首先需要知道什么了解什么是逆序对，逆序对的个数和就是找每一个数的前面有几个比他的大的数，他们加起来的和就是逆序对的总数，线代讲过。其次我们需要借鉴桶排序思想，这里不做过多解释。此外我要引入一个离散化的概念，我们知道需要以“数值大小”作为A[i]标准来升序排，所以需要给C[ ]开元素最大可能值的内存。但万一输入的数据很大，那么C[ ]就会内存超限，但是如果用离散化，只需要给C[ ]开元素数量的内存。

离散化模板：

ll b[maxn];
ll t[maxn];
struct unt {
	ll val; //输入的数 
	ll id; //输入的顺序，即原序列的的下标 
}a[maxn];
bool cmp(unt a,unt b) {
	if(a.val == b.val)
		return a.id < b.id;
	return a.val < b.val;
}
for(ll i=1; i<=n; i++) {
	scanf("%lld",&a[i].val);
	a[i].id = i;
}
int  main {
	sort(a+1,a+n+1,cmp);  //元素值大小从小到大排序。反过来排序，即离散化 避免数据过大内存超限 
		
    	for(ll i=1; i<=n; i++) 
		b[i] = a[i].id; //离散化 将a的数值存储到b中，为了add()接受 

}

     依次把序列里的数放到树状数组中的b[i]上去（实际是以a[i]形式的插入函数），注意b[i]是以数值大小从小到大排列的。先插入的说明排在序列的前面，那么后插入的就可以看看之前插入的比你大的数有多少，即i-sum(i)，其实也就是看序列前面比你大的数有多少个，即找逆序对。

#include<algorithm> 
#include<cstdio>
#include<string.h>
#define maxn 510000
#define ll long long 
using namespace std;
ll n,result;
ll b[maxn];
ll t[maxn];
struct unt {
	ll val; //输入的数 
	ll id; //输入的顺序 
}a[maxn];
bool cmp(unt a,unt b) {
	if(a.val == b.val)
		return a.id < b.id;
	return a.val < b.val;
}
ll lowbit(ll x) {
	return x&(-x); 
}
void add(ll x)   //运用桶排序思想
{
    while(x <= maxn)
    {
        t[x]++; //这个数出现了几次 
        x += lowbit(x);
    }
}
ll sum(ll x)  //计算比x小的个数和
{
    ll ans=0;
    for ( ; x; x-=lowbit(x))
        ans += t[x];
    return ans;
}
void init() { //初始化 
    for(ll i=0;i<maxn;i++) {
	a[i].val=0;
	a[i].id=0;
}
    memset(b,0,sizeof(b));
    memset(t,0,sizeof(t));
}
int main() {
    for(ll i=1;i<=n;i++) {
        add(b[i]);
        result += i-sum(b[i]);  //减去比i小的数字，即得出来比它大的个数
    }
    printf("%lld\n",result);
}

4.k-th大 

下周补...

 

 

相关题目及总结   https://blog.csdn.net/Ven21959/article/details/97788844