分治求逆序对算法

求逆序对是大学本科学习算法阶段经常遇到的一个比较经典的题目，不过一直没有好好地去想过，最近在看算法导论时在课后练习题中又看到了这个题目，于是花了点时间写了一下。

逆序对的定义是：在一个序列A中，假设存在下标i，j， i < j， 且 Ai > Aj， 则称{Ai,Aj} 是一对逆序对。而求逆序对的题目则是给出一个序列，求这个序列中存在的逆序对数量（也可能是要求输出有哪些逆序对）。

初看到这个题目时，可能会想，从序列的第一个数开始，对于每一个数，遍历下标在其后的序列中的数，根据遍历的数和待判断的数的大小关系即可知道是否是逆序对。显然，该方法的时间复杂度是O（n^2）的。实际上是存在更为高效的算法的，我们发现，对于该题目，我们可以将序列分成子序列，并分别求解各个子序列中存在的逆序对数量，然后将结果合并，即可求出整个序列的逆序对，也就是采用分治法能更加高效地解决这个问题。

本题中分治法的细节如下：对于一个序列，将其分解成两个等大的子序列，称其为左序列和右序列，那么逆序对存在于如下三处：1.左序列中的逆序对；2.右序列中的逆序对；3.由左序列中的元素和右序列中的元素构成的逆序对。情况1与情况2是易于解决的，只需递归求解左右序列中的逆序对即可；对于情况3，则涉及到分治法的合并步骤，在这个阶段，我们需要判断左序列中的元素和右序列中的元素构成的逆序对，易于想到对于右序列的每个元素，遍历左序列的所有元素，判断哪些能够构成逆序对。然而，这种方法与前述的遍历序列的方法实际上没有多大差别，假设大小为n，那么左右序列的大小分别为n/2，那么遍历的时间则为n/2 * n/2 = n^2 /4， 仍为O(n^2)。所以该合并方法并不能更加高效地求出逆序对。那么该如何合并分治的结果呢？

我开始观察左右序列存在什么特性。我想到，由于此处是考虑左序列的元素和右序列的元素构成的逆序对，那么，如果左序列预先是排好序的，那么对于右序列的任意一个元素，我只需要找到第一个比该元素大的元素，那么左序列中在该大元素后的所有元素都能与右序列中的目标元素构成逆序对。然而这还不够，遍历左序列寻找第一个大元素仍然是O(n)的。怎么办呢？我回到该想法的实现细节中，如果在每一次递归中，我只保证左序列是排好序的，那么在递归回溯时我就不能保证上层的左序列是排好序的。因此我要在合并步骤中保证合并后的序列是排好序的，似乎有点熟悉？没错，这就是归并排序。顺着该思路往下想，如果左右序列都是排好序的，在合并的过程中，我只需同时从左序列头和右序列头开始遍历两个序列，每次发现左序列的元素比右序列的元素大，就说明该左序列的元素及其后的元素都能与右序列的该元素构成逆序对，那么在逆序对的数量上加上这些元素的数量。遍历一次这样的左右序列的时间是O(n)的，而分解策略是将序列分成两个等大的子序列，分解的次数是logn， 故时间复杂度为O(nlogn)。

C++代码如下：

#include<iostream>
#include<fstream>
using namespace std;

int reversePair(int arr[], int temp[], int left, int right);

int merge(int arr[], int temp[], int left, int mid, int right);

int main(void) {
	fstream f("test.txt", fstream::in | fstream::out);
	int test[100];
	int t[100];//临时数组用于合并步骤，不在递归函数中开启数组，防止递归过程内存中同时存在大量数组
	int temp;
	int i = 0;
	while(f >> temp) {
		test[i] = temp;
		i++;
	}
	cout << reversePair(test, t, 0, i - 1) << endl;
	f.close();
	return 0;
}

int reversePair(int arr[], int temp[], int l, int r) {
	if(l == r)
		return 0;
	int m = (l + r) / 2;
	int ln = reversePair(arr, temp, l, m);//左序列逆序对数量
	int rn = reversePair(arr, temp, m + 1, r);//右序列逆序对数量
	int mn = merge(arr, temp, l, m, r);//左序列与右序列元素构成的逆序对数量
	return ln + rn + mn;
}

int merge(int arr[], int temp[], int l, int m, int r) {
	int count = 0, i, j;
	for(i = l; i <= r; i++)
		temp[i] = arr[i];
	int k = l;
	for(i = l, j = m + 1; i <= m && j <= r;k++) {
		if(temp[i] > temp[j]) {
			count += m - i + 1;//每次发现左序列元素比右序列元素大，逆序对数量增加，m-i+1即为该元素到左序列尾的元素数量
			//其余代码为归并排序的步骤 
			arr[k] = temp[j];
			j++;
		}
		else {
			arr[k] = temp[i];
			i++;
		}
	}
	if(i > m) {
		while(j <= r) {
			arr[k] = temp[j];
			j++;
			k++;
		}
	}
	else {
		while(i <= m) {
			arr[k] = temp[i];
			i++;
			k++;
		}
	}
	return count;
}

事实上该算法还有待优化，我想到的是与优化归并排序相同的做法，当分解出的子序列比较小时，比如说子序列只有10个元素，采用插入排序的做法，由于插入排序元素交换的次数与逆序对的数量是相同的，用这样的做法同样能求出逆序对的数量，并且速度要比纯粹使用归并排序要更快。