树状数组求解逆序对个数（含树状数组的介绍）
在学习树状数组求解逆序对前。先简单学习一下树状数组，首先我们先探究4个问题。
1. 什么是树状数组？
见名知意，就是用数组来模拟树形结构。那么又衍生出一个问题，为什么不直接建树呢？这个问题的答案是没有必要，树状数组就可以解决的问题没必要建树。
2. 用来解决什么问题？
和线段树一样用来解决区间上的更新、求和等操作。
3.和线段树有什么区别
其实树状数组可以解决的问题线段树都可以解决，但是树状数组的系数要少很多。
4.优缺点
优点是：修改和查询的时间复杂度都是O(logN),系数要比线段树少许多，而且代码简短（主要是因为lowbit技术）。
缺点是：功能有限，复杂区间问题无法解决。
下面这幅图就是树状数组的树形结构图。显而易见，它比线段树的系数少了许多。
黑色代表树状数组（后文用c[i]代替）红色代表原数组（后文用a[i]代替）。
一.建立树状数组
1.单点更新，区间查询
那么在树状数组中，各节点之间的联系是怎么得到的呢？
c[1] = a[1]。
c[2] = a[1] + a[2]。
c[3] = a[3]。
c[4] = a[4] + c[3] + c[2] = a[1] + a[2] + a[3] + a[4]。
c[5] = a[5]。
c[6] = a[5] + a[6]。
c[7] = a[7]。
c[8] = c[4] + c[6] + c[7] + c[8] = a[1] + a[2] + a[3] + a[4] + a[5] + a[6] + a[7] + a[8]。
我们把上幅图的节点值转化为二进制
现在我们可以发现这颗树的规律：
c[i] = a[i - 2k + 1] + a[i - 2k + 2] + …… + a[i]。
这里的k的含义是i的二进制数从的最低位到第一个1出现时0的个数。
那么我们要实现求和应该是怎样的呢？
举个栗子：我们要找前7项得和那么 SUM7 = c[7] + c[6] + c[4]。
根据前面得到的k规律可以看出c[6] = c[7 - 2k1], c[4] = c[6 - 2k2]。
则从中我们又得到这样的规律：SUMi = c[i] + c[i - 2k1] + c[i - 2k1 - 2k2] + ……。
现在我们得到了求和的式子，但我们又有了新的问题，2k我们要怎么求呢？
首先我们肯定是想到每次都求出来当前i值的k值，但是这样明显效率很低，所以我们需要另辟蹊径。
前人已经找到了非常简单的方法来得到这个k值，这就是我之前提到的lowbit技术。
inline int Lowbit(int x)
{
return x & (-x);
}
是的没错，就这么短短一行便可以解决这个问题。
可以自行验证一下正确性。
接下来我们来看看为什么可以得到2k = i & (-i)。
这里利用了负数的存储特性，负数是以补码形式存储的，那么对于x & (-x)有四种情况：
- 当x等于0时，即0 & 0，结果为0。
- 当x为奇数时，则二进制数最后一位必定为1，取反加1，必然没有进位，则此时x与-x除最后一位外，其它皆相反，则结果x & (-x)结果为1。
- 当x为偶数，但不为2的n次方时。每个x都可以写成x = y * (2k)。实际上就是将一个奇数左移k位来得到。此时，x的二进制数最右边必定有k个0，而从右往左的第k + 1位则必定为1。那么当我们对x按位取反并加1时，最右边的k位都因为进位变成了1，而第k + 1位从1变为0后因为前面进位又变成了1。再左边的因为没有进位，就正好与x的对应位上的数相反。此时按位与的话，得到的就是第k + 1位为1，其它全为0。正好为2k。
- 当x为偶数且为2的n次方时。则x的二进制数只有一位为1（从右往左第n + 1位），右边有m个0，则按位取反再加1后，从右往左有m个0，剩下的都为1。则x & (-x) = 2k。
总结下来就是：x&(-x)，当x为0时结果为0；x为奇数时，结果为1；x为偶数时，结果为x中2的最大次方的因子。
这样我们就可以完成区间查询，接下来就看看单点更新。
上面提到c[i] = a[i - 2k + 1] + a[i - 2k + 2] + …… + a[i]，那么 如果更新了某个a[i]的值，则会影响到所有包含有a[i]的位置。同理，我们可以得到a[i]包含于c[i + 2k]、c[(i + 2 k) + 2k]、……。
下面是代码：
inline int Lowbit(int x)
{
return x & (-x);
}
inline void Add(int i，int k) //修改i点的值
{
while(i <= n)
{
c[i] += k;
i += Lowbit(i);
}
}
inline int Query(int i) //查询i的值
{
long long res = 0;
while(i > 0)
{
res += c[i];
i -= Lowbit(i);
}
return res;
}
2.区间更新，单点查询
当题目要求区间更新并查询单个点的值的时候，如果还用上面的树状数组，那么就必须把要求的区间内每个值都更新，这样时间复杂度肯定不行。
这样的话，我们就不能用值来建树了，我们使用差分的方法来建树。
我们规定a[0] = 0;
则可以得到a[i] = Σij=1d[j] (d[j] = a[j] - a[j - 1])，意思就是a[i]的值前面i项的差值和。例如下面这个数组：
a[] = 1 2 3 6 8 9
d[] = 1 1 1 3 2 1
如果我们把[2,5]区间加上2，则变成下面这样：
a[] = 1 4 5 8 10 9
d[] = 1 3 1 3 2 -1
我们可以发现，当某个区间[x,y]的值改变了，只有d[x]和d[y + 1]的值发生了改变，且d[x]为相同操作，d[y + 1]为相反操作。
我们就利用这个特性对d[]数组建立树状数组。
#include <iostream>
using namespace std;
int n, m;
int a[50010] = { 0 }, c[50010]; //a原数组和c树状数组, 记得原数组a[0] = 0
int Lowbit(int x)
{
return x & (-x);
}
void Update(int i, int k) //在i位置上加上k
{
while(i <= n)
{
c[i] += k;
i += Lowbit(i);
}
}
int Query(int i) //求d[1]到d[i]的和,即a[i]的值
{
int res = 0;
while(i > 0)
{
res += c[i];
i -= Lowbit(i);
}
return res;
}
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++)
{
scanf("%d",&a[i]);
Update(i, a[i] - a[i - 1]); //输入初值时也相当于更新了树状数组
}
while(m--)
{
int choose;
scanf("%d",&choose);
if(choose == 1) //修改x到y区间的值
{
int x, y, k;
scanf("%d%d%d",&x,&y,&k);
Update(x, k); //d[x]即a[x] - a[x - 1]加上k
Update(y + 1, -k); //d[y + 1]即a[y + 1] - a[y]减上k
}
if(choose == 2) //查询i的值
{
int i;
scanf("%d",&i);
printf("%d\n",Query(i));
}
}
}
这样我们就把原来更新一个区间的操作变为了更新两个点的操作。
3.区间更新，区间查询
上面已经介绍过的差值建树状数组，可以得到某个点的值，那如果既要区间更新，又要区间查询。是否还能利用差分呢？
由前面的知识可以得到：
Σni=1a[i] = Σni=1 Σij=1d[j]；
也就是a[1] + a[2] + …… + a[n]
= (d[1]) + (d[1] + d[2]) + …… + (d[1] + d[2] +…… + d[n])
= n * d[1] + (n - 1) * d[2] + …… + d[n]
= n * (d[1] + d[2] + …… + d[n]) - (0 * d[1] + 1 * d[2] + …… + (n - 1) * d[n])
则上式可变为Σni=1a[i] = n * Σni=1d[i] - Σni=1(d[i] * (i - 1))。
从这个式子来看，我们就需要维护两个树状数组了，
即sum1[i] = d[i], sum2[i] = d[i] * (i - 1)。
#include <iostream>
using namespace std;
int n, m;
int a[50010] = { 0 };
int sum1[50010]; //维护(d[1] + d[2] + …… + d[n])
int sum2[50010]; //维护(0 * d[1] + 1 * d[2] + …… + (n - 1) * d[n])
int Lowbit(int x)
{
return x & (-x);
}
void Update(int i, int k)
{
int x = i; //初始的i值不应该发生改变，用x来保存
while(i <= n)
{
sum1[i] += k;
sum2[i] += k * (x - 1);
i += Lowbit(i);
}
}
int Query(int i)
{
int res = 0, x = i;
while(i > 0)
{
res += x * sum1[i] - sum2[i];
i -= Lowbit(i);
}
return res;
}
int main()
{
cin >> n >> m;
for(int i = 1; i <= n; i++)
{
scanf("%d",&a[i]);
Update(i, a[i] - a[i - 1]);
}
while(m--)
{
int choose;
scanf("%d",&choose);
if(choose == 1)
{
int x, y, k;
scanf("%d%d%d",&x,&y,&k);
Update(x, k);
Update(y + 1, -k);
}
if(choose == 2)
{
int x, y;
scanf("%d%d",&x,&y);
int sum = Query(y) - Query(x - 1); //Query(y)的过程中将不需要的x之前的值也加了所以要减去
printf("%d\n",sum);
}
}
}
二.树状数组求解逆序对个数
1.逆序对是什么？
设 A 为一个有 n 个数字的有序集 (n>1)，其中所有数字各不相同。
如果存在正整数 i, j 使得 1 ≤ i < j ≤ n 而且 A[i] > A[j]，则 <A[i], A[j]> 这个有序对称为 A 的一个逆序对，也称作逆序数。
就是说假如有这么一串数：5 3 6 2 9
其中5和3，6和2，5和2，3和2就是逆序对。
2.怎么用树状数组实现呢？
要回答这个问题，我们首先要搞清除在这个问题中树状数组的含义。
我们要求解总逆序对个数可以分解成数组中的数一个一个放入得出当时的逆序对个数，然后相加。
也就是说，我们每加入一个数，都要得出此时数组中比这个数大的数的个数
。
那么变成每加入一个数，我们令比它小的数记录一次，这样之后遇到这个数，就可以知道前面比它大的数有多少个。这时我们的树状数组就有用处了。
没错，树状数组的含义在这里就是这个数在所处数组位置之前有几个数比它大。
要特别注意的是，我们在用树状数组求解逆序对个数时，常常会遇到量值过大的情况，这个时候需要进行离散化后在进行构建树状数组。
这样我们就可以的到树状数组求解逆序对个数的代码：
#include <iostream>
#include <algorithm>
#include <string.h>
using namespace std;
const int MAX = 5e5 +10;
int n;
int a[MAX],b[MAX],c[MAX];
bool cmp (int x, int y)
{
return a[x] < a[y];
}
inline int Lowbit(int x)
{
return x & (-x);
}
inline void Add(int pos)
{
while(pos <= n)
{
c[pos]++;
pos += Lowbit(pos);
}
}
inline int Query(int pos)
{
long long res = 0;
while(pos > 0)
{
res += c[pos];
pos -= Lowbit(pos);
}
return res;
}
int main()
{
cin >> n;
for(int i = 1; i <= n; i++)
{
scanf("%d",&a[i]);
b[i] = i; //给b数组初始化
}
stable_sort(b + 1, b + n + 1, cmp); //给b数组按a数组从大到小的顺序排序
long long sum = 0;
for(int i = 1; i <= n; i++)
{
a[b[i]] = i; //配合前面排序函数对a数组进行离散化
}
for(int i = n; i >= 1; i--)
{
sum += Query(a[i] - 1); //从后往前则是找此时数组中比这个数小的数的个数
Add(a[i]); //更新树状数组
}
cout << sum;
}
1857
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
