逆序数的几种求法
逆序数就是指比如：数组A={2,4,3,5}那么<4,3>就是一个逆序数。
一：暴力匹配
对于数组A中的元素，i从0到n-1，j从i+1到n, 判断每一个是否为逆序数，时间复杂度O(N^2)。太简单了，没写代码了。。。。。
二：归并
归并排序能解决逆序数主要在于：比如归并A1={2,4,5}, A2={1,3}，进行归并的时候，我们每次判断A1和A2中元素大小，这里有两种思路：(1)当A1[i] <=A2[j]，此时需要放入A1[i]了，我们可以计算已经放入的A2中的元素个数即为j-mid-1；思路(2)当A1[i] <=A2[j]，我们不管它，直接放入即可，但当A1[i] >A2[j],此时需要放入A2[j]，我们来计算A1中还有多少个元素没有放mid – i+1，它们A2[j]所对应的逆序数个数。思路一对于归并算法有两处需要修改，思路二只需一处修改就可以了。时间复杂度为O(NlgN)
思路(1)代码：
void mergeSortInverseNumber(int a[], int p, int q, int a1[], long long int &number){
if(p < q){
int r = (p+q)/2;
mergeSortInverseNumber(a, p, r, a1, number);
mergeSortInverseNumber(a, r+1, q, a1, number);
int i = p, j = r+1;
int k = p;
while(i <= r && j <= q){
if(a[i] <= a[j]){
a1[k++] = a[i++];
number += j - r -1; // 把a[i]放进来时 seq2中已有多少个数 就是逆序数
}
else
a1[k++] = a[j++];
}
if(i > r){
while(j <= q)
a1[k++] = a[j++];
}
else{
while(i <= r){
a1[k++] = a[i++];
number += j - r - 1; //// 这里也需要修改
}
}
for(int i = p; i <=q; i++)
a[i] = a1[i];
}
}
思路(2)代码：
void mergeSortInverseNumber2(int a[], int p, int q, int a1[], long long int &number){
if(p < q){
int r = (p+q)/2;
mergeSortInverseNumber(a, p, r, a1, number);
mergeSortInverseNumber(a, r+1, q, a1, number);
int i = p, j = r+1;
int k = p;
while(i <= r && j <= q){
if(a[i] <= a[j])
a1[k++] = a[i++];
else{
a1[k++] = a[j++];
number += r - i + 1; // 把a[j]放进来时 seq1中还有多少个元素没有放入 就是逆序数
}
}
if(i > r){
while(j <= q)
a1[k++] = a[j++];
}
else{
while(i <= r)
a1[k++] = a[i++];
}
for(int i = p; i <=q; i++)
a[i] = a1[i];
}
}
三：树状数组
树状数组解法挺难理解的，我也还没有理解，也不需要理解。这里给出网上的一份代码：
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <string.h>
using namespace std;
const int maxn=500005;
int n;
int aa[maxn]; //离散化后的数组
int c[maxn]; //树状数组
struct Node{
int v;
int order;
}in[maxn];
int lowbit(int x)
{
return x&(-x);
}
void update(int t,int value)
{
int i;
for(i=t;i<=n;i+=lowbit(i))
{
c[i]+=value;
}
}
int getsum(int x)
{
int i;
int temp=0;
for(i=x;i>=1;i-=lowbit(i))
{
temp+=c[i];
}
return temp;
}
bool cmp(Node a ,Node b)
{
return a.v<b.v;
}
int main()
{
int i,j;
while(scanf("%d",&n)==1 && n)
{
//离散化
for(i=1;i<=n;i++)
{
scanf("%d",&in[i].v);
in[i].order=i;
}
sort(in+1,in+n+1,cmp);
for(i=1;i<=n;i++) aa[in[i].order]=i;
//树状数组求逆序
memset(c,0,sizeof(c));
long long ans=0;
for(i=1;i<=n;i++)
{
update(aa[i],1);
ans+=i-getsum(aa[i]);
}
cout<<ans<<endl;
}
return 0;
}
既然由前面一篇blog我们知道凡是树状数组能解决的问题，线段树都能解决，为什么不用线段树来解决呢？
四：线段树
线段树解决逆序数的思路是：设数组的大小为N，元素也都是1~N之间的元素，那么此时我们可以建立一棵[1,N]的线段树。遍历数组中的每个元素x时，我们需要查询线段树中[x+1,N]之间含有已插入元素的个数，并且更新线段树，将区间[x,x]及所有包含x的区间都加1。建立线段树为O(N),获得逆序数为O(lgN).
当然这里前提是元素大小都为1~N之间，那么如果不在这个区间怎么办呢，这时我们可以将离散的数据进行压缩。看以下代码：
// 离散化的数据进行压缩
struct arrayExtend{
int val;
int index;
};
int N;
cin >> N;
int *a = new int[N+1];
// 通过一个结构体将数据进行压缩 压缩分范围为1~N之间 顺序保持不变
arrayExtend *a1 = new arrayExtend[N+1];
for(int i = 1; i <= N; i++){
cin >> a1[i].val;
a1[i].index = i;
}
sort(a1+1, a1+N+1, cmp); // 排序
a[a1[1].index] = 1;
for(int i = 2; i <= N; i++){
if(a1[i].val == a1[i-1].val){
a[a1[i].index] = a[a1[i-1].index]; // 相等的处理
}else
a[a1[i].index] = i; // 不相等的处理
}
完整代码：
/*功能：线段树来求逆序数*/
#include <iostream>
#include <algorithm>
#include <cmath>
using namespace std;
#define MAXSIZE 100000
#define M 300000
// 离散化的数据进行压缩
struct arrayExtend{
int val;
int index;
};
bool cmp(arrayExtend ae1, arrayExtend ae2){
return ae1.val < ae2.val;
}
// 线段树结点
struct node{
int left, right, sum;
}t[M];
void build(int root, int start, int end){
// 如果相等 则为叶子结点 返回
if(start == end){
t[root].sum = 0;
t[root].left = start;
t[root].right = end;
return;
}
int mid = (start+end) >> 1;
build(root*2+1, start, mid); // 创造左子树
build(root*2+2, mid+1, end); // 创造右子树
t[root].sum = 0;
t[root].left = start;
t[root].right = end;
}
long long int getSum(int root, int qstart, int end){
if(qstart > end) return 0;
// 如果查询区间大于待查区间 则返回其值
if(t[root].left >= qstart && t[root].right <= end) return t[root].sum;
int mid = (t[root].left + t[root].right) >> 1;
if(qstart > mid) return getSum(root*2+2, qstart, end);
else return getSum(root*2+1, qstart, end) + getSum(root*2+2, qstart, end);
}
// 值为index 此时将包含index的区间sum+1 表示该区间有多少个数
void update(int root, int index){
if(t[root].left == t[root].right){
t[root].sum += 1;
return;
}
int mid = (t[root].left + t[root].right) >> 1;
if(mid < index) update(root*2+2, index);
else update(root*2+1, index);
t[root].sum = t[root*2+1].sum + t[root*2+2].sum; // 回溯
}
int main(){
int N;
cin >> N;
int *a = new int[N+1];
// 通过一个结构体将数据进行压缩 压缩分范围为1~N之间 顺序保持不变
arrayExtend *a1 = new arrayExtend[N+1];
for(int i = 1; i <= N; i++){
cin >> a1[i].val;
a1[i].index = i;
}
sort(a1+1, a1+N+1, cmp); // 排序
a[a1[1].index] = 1;
for(int i = 2; i <= N; i++){
if(a1[i].val == a1[i-1].val){
a[a1[i].index] = a[a1[i-1].index]; // 相等的处理
}else
a[a1[i].index] = i; // 不相等的处理
}
build(0, 1, N);
long long int ans = 0;
for(int i = 1; i<= N; i++){
ans += getSum(0, a[i]+1, N); // 输入a[i] 即寻找【a[i]+1，N】之间元素个数
update(0, a[i]); // 更新线段树
}
cout << ans << endl;
delete []a1;
delete []a;
return 0;
}
注意存储一棵线段树所需要的结点树为满二叉树的结点个数为 2^(ceil(logN)+1)-1的个数。此外逆序数个数为long long 不然hihoCoder第三十九周只能得到80分。因为数据为10^5,逆序数个数可以达到5*10^9, 而int大小只有4*10^9多点。