POJ2299【树状数组】-CSDN博客

本文链接：https://blog.csdn.net/VecSun/article/details/49384341

/* 转载请注明出处，谢谢 */

目的：理解树状数组的设计思想。 /* 在写之前让我先膜拜一下，orz 。 */

1 楼祭图：

树状数组 ，最经典的应用就是 求区间和 [ l , r ] 的和 （支持修改操作），为了更好的理解，我们就以这个场景举例子。

比如 对于一个序列 { An } ，我们 用这样一个数组 C [ n ] 维护 :

C [ i ] = A [ i - 2^ k + 1 ] + A [ i - 2 ^ k + 2 ] + … + A [ 1 ] ; (A[n] 从下标1开始记)。

其中 k 表示 i 转换成二进制 后 末尾低位上连续 0 的个数 。比如 i = 6，即 1 1 0 (这个数据结构太6，我要报警啦) ， k = 1。

然后我们以 { An } ， n == 8 时为例，写出所有的 C[n]：

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];

然后，根据 C [ i ] 的定义定义，可知道每个 C [ i ] 所 “ 管辖 ” 的范围就是，是啥呢？这得换成二进制说，假设是 i 换成二进制是110100，110100 = 110000 + 100，然后所管辖的范围就是 110001 ~ 110100，这有什么好处呢？其实这就 类似与快速幂的思想，同样是利用了二进制

的性质 。

从求和过程观察其原理。下面我们举个栗子：

我们要算 区间 [ l , r ] 的和 ，那么我们首先转化问题：ans = sum[ r ] - sum[ l ]; 其中 sum[ i ] , 是指区间 [ 1 , i ] 的和。

那么我们只要考虑 sum[ i ] 怎么算就阔以了。

/*******************************************************************************************************************************************************************************

以 i = 10 举例解释吧：

1. sum = 0 初始化.

2. 我们先转化成二进制 i = 1010，k = 1. C[ i ] 管辖的是 {An} 中 1001 - 1010 的范围 . sum += C[ i ];

3. 然后我们把 i 管线的范围剔除，由上面定义和观察，我们已经知道 1010 管辖的是 1001 - 1010 总共 2 ^ k 大的范围，而且他的上限是 i，

下线是 i - 2 ^ k + 1。

4. 那我们删去 2^k 后就获得紧跟 i 先下限的的管线范围，即 i -= 2 ^ k , i = 1000, 这次 i 管辖的就是 0001 - 1000 了， sum += C[i];

5. 重复 4 操作，直到 i == 0，我们获得的就是[ 1 ，i ] 所有的数的和。

看到没！！每次操作最少就去掉一个 1 !! 。一个数 N ，转化成二进制最多有 LogN 个 1 吧！所以每次求和操作的复杂度是 O（LogN）！！

*********************************************************************************************************************************************************************************/

是不是跟快速幂有异曲同工之妙 ? !

请仔细思考上述求和操作，然后我们大概说一下点修改操作，类似于上面的操作。

大概就是对于 A[ i ] , C [ i + 2 ^k ] 以及 C[ ( i + 2 ^k ) + 2 ^ k' ] ,（这里是个迭代过程）都包含 A [ i ] ; 算了，不说了。上代码了。

POJ 2299:

求长度为 N 的乱序数列的逆序数，N <= 500000.

问题转化为求每个数之前的比它大的数的个数的和。

记录每个数的位置，按大小排序，然后按照大小插入他们原本的位置当中，即每次更新操作，令 a[ val[i].p ] = 1 。

接着转化，sum[i] 为 i 之前比 a[i] 小的数的个数（因为按从小到大插入，所以比 a[i] 小的数已经全部都插入位置了），i - 1为当前已插入自己位置的个数。

i - sum[i] - 1 就是在 i 之前的比 a[i ] 大的个数。

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
const int size = 500010;
int N;
struct Val
{
	int p, v;
}val[size];
int C[size];
int cmp(const Val &a, const Val &b)
{
    return a.v < b.v;
}
inline int lowBit(int x)
{
	return x & ( -x );
}
inline int sum(int x)
{
	int ret = 0;
	while(x > 0)
	{
		ret += C[x];
		x -= lowBit(x);
	}
	return ret;
}
inline void update(int x)
{
	while(x <= N)
	{
		C[x] += 1;
		x += lowBit(x);
	}
}
int main(int argc, char const *argv[])
{
	while(scanf("%d", &N) && N)
	{
		long long ans = 0, l , r;

		memset(C,0,sizeof(C));
		for(int i = 1; i <= N; i ++)
		{
			scanf("%d",&val[i].v);
			val[i].p = i;
		}
		sort(val + 1, val + N + 1,cmp);
		for(int i = 1; i <= N; i ++)
		{
		    l = sum(val[i].p);
			r = i - l - 1;
			ans += r;
 			update(val[i].p);
		}
		printf("%lld\n",ans);
	}
	return 0;
}