树状数组相关应用之逆序对问题

求逆序对

一元逆序对问题：POJ-2299


此题本质是一个求逆序对问题，对于一个无序数列，我们按照其顺序依次输入，并在每次输入时通过树状数组对已输入数列在其后方的序列进行个数求和，即可得到逆序数（先输入却比他大，在其后方）
需要注意的是数列的值可能相差较大，如果按值更新树状数组会浪费很多空间，对于此问题我们可以利用数据的离散化来处理

#include <iostream>
#include <cstring>
#include <algorithm>

#define MAXSIZE 500002

using namespace std;   //使用名称空间std


struct Node
{
	int va;         //下标（用于数据离散化的顺序复原）
	int number;     //数字
};

bool cmp(Node a, Node b)
{
	return a.number < b.number;
}

int main()
{
	int lowbit(int x);
	void update(int val[], int i, int cal, int arry_num);
	int sum_pre(int val[], int i);
	int sum_between(int val[], int pre, int last);

	Node arry[MAXSIZE];       //原数组
	int val[MAXSIZE];        //树状数组
	int aa[MAXSIZE];        //离散化数组
	memset(val, 0, sizeof(val));
	memset(arry, 0, sizeof(arry));
	//树状数组初始化完毕  

	int n;
	int i;
	long long ans;                          //逆序数对数可能较大，需用long long存储
	while (cin >> n)
	{
		if (!n)    break;
		ans = 0;                            //逆序数存储器初始化
		for (i = 1;i <= n;i++)
		{
			cin >> arry[i].number;
			arry[i].va = i;
		}
		//原数组初始化完成
		sort(arry + 1, arry + n + 1, cmp);    //按数值从小到大排序
		for (i = 1;i <= n;i++)                //按之前的元素下标进行顺序复原
			aa[arry[i].va] = i;
		//对应数组离散化完成

		//树状数组求逆序数
		memset(val, 0, sizeof(val));         //树状数组初始化
		for (i = 1;i <= n;i++)
		{
			update(val, aa[i], 1, n);
			ans +=sum_between(val, aa[i]+1,n);   //对其后方进行求和得到该数对应逆序数个数
		}
		cout << ans << endl;


	}
	return 0;
}

int lowbit(int x)
{//返回二进制数最低位的1对应的数值
	return x & (-x);      //与运算
}


void update(int val[], int i, int cal,int arry_num)
{//原数组第i个元素加上cal，更新树状数组相关元素,arry_num为原数组的长度
 //可直接用于树状数组的建立
	for(;i<=arry_num;i+=lowbit(i))
		val[i]+=cal;
}

int sum_pre(int val[],int i)
{//求arry数组的前i项和
 //val为树状数组地址
	int sum = 0;
	for (;i > 0;i -= lowbit(i))       //从后向前每次跳一个lowbit
		sum += val[i];
	return sum;
}

int sum_between(int val[],int pre, int last)
{//求原数组arry在区间[pre-last]的和
	return sum_pre(val, last) - sum_pre(val, pre - 1);
}

接下来我们来看一道树状数组求逆序对的变形题：
二元逆序对问题：POJ-3067


题意：

日本有N个城市在东边，从北至南编号为1 2 3，，，N，M个城市在西边，从北至南编号为1 2 ，，，，M，K条高速公路将被建造

高速公路的一端在西边，一端在东边

输入有多组样例，

每组样例第一行为

n m k

接下来有k行，分别为高速公路的端点

求高速公路的交点有多少个，不包括以城市为相交点

解决方法：

对Ax,Ay和Bx,By两条高速公路，有相交点必须（Ax-Bx）*(Ay-By)<0（本质仍是求逆序对）
做法：先对这些线段做双关键字排序，以x为主关键字升序排列，x相同时再以y为次关键字升序排列，再逐一插入这些线段，求出在它之前插入的线段中y大于当前线段的y的线段数目，把它累加到答案中，最终就可以得出答案。因为我们知道，如果两条线段有交点，那么必有一条线段的x小于另一条线段的x，而y大于另一条线段的y，又因为我们已经对x做了排序，所以只用求出y大于当前线段的y的线段数目即可。另外，由于答案可能会很大，所以需要使用long long

#include <iostream>
#include <cstring>
#include <stdio.h>
#include <algorithm>

#define MAXSIZE 1005

using namespace std;   //使用名称空间std

struct road
{
	int left;
	int right;
};

road line[MAXSIZE*MAXSIZE];        //路

int main()
{
	bool cmp(road a, road b);
	int lowbit(int x);
	void update_1(int val[], int i, int cal, int arry_num);
	long long sum_pre_1(int val[], int i);
	long long sum_between_1(int val[], int pre, int last);
	int val[MAXSIZE];       //树状数组
	
	int flag, temp=1;         
	int N, M, K;
	long long num;                //交叉点数（long long是个坑）
	scanf("%d", &flag);
	while (temp<=flag)
	{
		num = 0;
		memset(val, 0, sizeof(val));
		scanf("%d %d %d", &N, &M, &K);
		for (int i = 0;i < K;i++)
			scanf("%d %d", &line[i].left, &line[i].right);
		sort(line, line + K, cmp);
		for (int i = 0;i < K;i++)
		{
			update_1(val, line[i].right, 1, M);
			num += sum_between_1(val, line[i].right+1, M);          //求逆序对
		}
		printf("Test case %d: %lld\n", temp, num);
		temp++;
	}
	return 0;
}

bool cmp(road a, road b)
{//将左端小的放在前，如果左端相等，将右端小的放在前
	if (a.left != b.left)
		return a.left < b.left;
	else
		return a.right < b.right;
}

int lowbit(int x)
{//返回二进制数最低位的1对应的数值
	return x & (-x);      //与运算
}

//一维树状数组
void update_1(int val[], int i, int cal, int arry_num)
{//原数组第i个元素加上cal，更新树状数组相关元素,arry_num为原数组的长度
 //可直接用于树状数组的建立
	for (;i <= arry_num;i += lowbit(i))
		val[i] += cal;
}

long long sum_pre_1(int val[], int i)
{//求arry数组的前i项和
 //val为树状数组地址
	long long sum = 0;
	for (;i > 0;i -= lowbit(i))       //从后向前每次跳一个lowbit
		sum += val[i];
	return sum;
}

long long sum_between_1(int val[], int pre, int last)
{//求原数组arry在区间[pre-last]的和
	return sum_pre_1(val, last) - sum_pre_1(val, pre - 1);
}