树状数组的经典应用-----逆序对问题

一.树状数组求逆序对的原理

1.首先何为逆序对

对于一个数组a,如果a[i] > a[j] && i < j,那么称(a[i],a[j])为一个逆序对

例如：a =  {5,4,2,6,3,1},逆序对个数就为11，我们可以枚举来求逆序对，但是时间复杂度高，所以一般常用的求逆序对的方法有归并排序和树状数组 + 离散化，下面我讲的是树状数组的解法

2.树状数组如何求逆序对

我们先来模拟一下一种求逆序对的方法

例如：a =  {5,4,2,6,3,1}

我们先定义一个b数组，我们遍历a数组令b[a[i]] = 1,逆序对数就为每次sumb(i + 1,n)的和，其实就是以a数组为下标在b数组中填1，对于a[i],如果b[i]之后已经出现1，那么后面1的下标均可与a[i]构成逆序对。

模拟：开始b都为0

1.b = {0，0，0，0，1，0}      sumb(6,6) = 0，后面没有一，说明还没有数与5构成逆序对

2.b = {0，0，0，1，1，0}      sumb(5,6) = 1，4与5构成了逆序对

3.b = {0，1，0，1，1，0}      sumb(3,6) = 2，2与4，5均构成了逆序对

4.b = {0，1，0，1，1，1}      sumb(7,6) 不存在

5.b = {0，1，1，1，1，1}      sumb(4,6) = 3，3与4，5，6均构成了逆序对

6.b = {1，1，1，1，1，1}      sumb(2,6) = 5，1与其他5个数都构成了逆序对

所以答案ans = 0+1+2+3+5 = 11

然后这一过程我们就可以用树状数组来操作，把b数组看成数组数组tree，令b[a[i]] = 1的过程我们就可以看成数状数组的更新操作，求sumb就可以看成区间查询操作，最后对每次区间查询求和即为逆序对的个数

代码大致可以这样写：

	for (int i = 1;i <= n; i++) {
		add(a[i],1); // add为更新操作
		ans += sum(n) - sum(a[i]); // sum为区间查询求逆序对数
	}

有时候题目数据量会很大，我们就要提前对数组进行离散化，因为求逆序对个数我们就只需要知道元素相对大小即可

二.例题

1.洛谷p1908逆序对

这题基本上就是求逆序对的模板题了，唯一一个要注意的就是题目中存在重复的数，所以我们在离散化时如果元素相等，那么将序号小的放到前面，避免重复的元素构成逆序对

ACcode

// 思路:对于一组数据a,新建一个数组b,令b[a[i]] = 1
//     每次操作b[i]之后1的个数的和即为逆序对数
#include <bits/stdc++.h>
using namespace std;

using ll = long long ;

const int N = 5e5 + 50;
struct node {
	int num,id;
	bool operator< (const node a) const { // 结构体的重载
		if (a.num == num) return id < a.id; // 值相同序号小在前
		return num < a.num;
	} 
}a[N];
int tree[N]; // 树状数组
int n;
int lowbit(int i) {return i&-i;}
void add(int x,int val) { // 更新操作
	while (x <= n) {
		tree[x] += val;
		x += lowbit(x);
	}
}

int sum(int i) { // 区间查询
	int ret = 0;
	while (i) {
		ret += tree[i];
		i -= lowbit(i);
	}
	return ret;
}

int main() {
	ll ans = 0;
    cin >> n;
	for (int i = 1;i <= n; i++) {
		cin >> a[i].num;
		a[i].id = i;
	}
	sort(a + 1,a + n + 1); // 离散化
	for (int i = 1;i <= n; i++) {
		add(a[i].id,1); 
		ans += sum(n) - sum(a[i].id);
	}
	cout << ans << '\n';
}

2.P1966 [NOIP2013 提高组] 火柴排队

题目要求的是令∑(ai​−bi​)^2最小的操作次数，那么也就是ai-bi要最小，就是当a中第i大的数与b中第i大的数两两相减时最小，可以看出答案只与a,b数组元素之间的相对大小有关，于是我们可以先对a,b进行离散化

当a=b时∑(ai​−bi​)^2最小，我们可以定义一个数组q,令q[a[i]] = b[i],要a = b，就等价于q[a[i]] = a[i]],即q[i] = i,操作次数就是使q[i] = i的最小交换次数，操作的过程不就是一个找逆序对的过程吗，于是该题就可以转化为求q中的逆序对个数，代码就很好写了

ACcode

// 思路:先将a,b离散化,离散化后a=b的情况结果是最小的
//      我们令q[a[i]] = b[i],若a = b,那么q[i] = i
//      最小操作次数不就是q数组中的逆序对数嘛

#include <bits/stdc++.h>
using namespace std;

using ll = long long ;
const int N = 1e5 + 50;
const int mod = 1e8 - 3;
struct node {
	int num,id;
	bool operator< (const node a) const {
		return num < a.num;
	}
}a[N],b[N];

int n;
int tree[N];
int lowbit(int i){return i&-i;}
void add(int x,int val) { // 更新函数
	while (x <= n) {
		tree[x] += val;
		x += lowbit(x);
	}
}

int sum(int i) { // 查询函数
	int ret = 0;
	while (i) {
		ret += tree[i];
		i -= lowbit(i);
	}
	return ret;
}

int main() {
	ll ans = 0;
	cin >> n;
	int q[n + 1];
	for (int i = 1;i <= n; i++) cin >> a[i].num,a[i].id = i;
	for (int i = 1;i <= n; i++) cin >> b[i].num,b[i].id = i;
	sort(a + 1,a + n + 1); // 离散化
    sort(b + 1,b + n + 1);
    for (int i = 1;i <= n; i++) q[a[i].id] = b[i].id;
    for (int i = 1;i <= n; i++) {
    	add(q[i],1);
    	ans = (ans + sum(n) - sum(q[i])) % mod;
    }
    cout << ans%mod;
}