求解逆序数问题

当某两个元素的先后次序与标准次序（从小到大的顺序）不同时，就说有1个逆序。一个排列中所有逆序总数叫做这个排列的逆序数。

方法一：利用归并排序求解

归并排序的主要思想是将整个序列分成两部分，分别递归将这两部分排好序之后，再和并为一个有序的序列。

在合并的过程中是将两个相邻并且有序的序列合并成一个有序序列，如以下两个有序序列

Seq1：3  4  5

Seq2：2  6  8  9

合并成一个有序序:

Seq：2  3  4  5  6  8  9

对于序列seq1中的某个数a[i],序列seq2中的某个数a[j]，如果a[i]<a[j],没有逆序数，如果a[i]>a[j]，那么逆序数为seq1中a[i]后边元素的个数(包括a[i])，即len1-i+1,

这样累加每次递归过程的逆序数，在完成整个递归过程之后，最后的累加和就是逆序的总数

求逆序数

时间限制： 2000 ms  |  内存限制： 65535 KB

难度： 5

描述

在一个排列中，如果一对数的前后位置与大小顺序相反，即前面的数大于后面的数，那么它们就称为一个逆序。一个排列中逆序的总数就称为这个排列的逆序数。

现在，给你一个N个元素的序列，请你判断出它的逆序数是多少。

比如 1 3 2 的逆序数就是1。

输入

第一行输入一个整数T表示测试数据的组数（1<=T<=5)
每组测试数据的每一行是一个整数N表示数列中共有N个元素（2〈=N〈=1000000）
随后的一行共有N个整数Ai(0<=Ai<1000000000)，表示数列中的所有元素。

数据保证在多组测试数据中，多于10万个数的测试数据最多只有一组。

输出

输出该数列的逆序数

样例输入

2
2
1 1
3
1 3 2

样例输出

0
1

#include <stdio.h>
#define max 1000001
long long a[max],b[max];
long long count;
void Merge(long long a[], int start, int mid , int end)  //归并排序的合并部分
{
	int i = start,j = mid + 1,k = start;
	while(i <= mid&&j <= end)
	{
		if(a[i] <= a[j])
		{
			b[k++] = a[i++];
		}
		else
		{
			count += j - k;//统计逆序数对
			b[k++] = a[j++];
		}
	}
	while(i <= mid)
	{
		b[k++] = a[i++];
	}
	while(j <= end)
	{
		b[k++] = a[j++];
	}
	for(int i = start; i <= end; i++)
	{
		a[i] = b[i];
	}
}

void MergeSort(long long a[], int start, int end)  //归并排序
{
	if(start < end)
	{
		int mid = (start + end)/2;
		MergeSort(a,start,mid);     // 将前半部分排序
		MergeSort(a,mid+1,end);     // 将后半部分排序
		Merge(a,start,mid,end);     // 合并前后两个部分
	}
}
int main(int argc, char const *argv[])
{
	int n,m;
	scanf("%d",&n);
	while(n--)
	{
		scanf("%d",&m);
		count = 0;
		for(int i = 0; i < m; i++)
		{
			scanf("%d",a+i);
		}
		MergeSort(a,0,m-1);
		printf("%lld\n",count);
	}
	return 0;
}

方法二：树状数组求解

树状数组实际上还是一个数组，只不过它的每个元素保存了跟原来数组的一些元素相关的结合值。

若A为原数组，定义数组C为树状数组。C数组中元素C[ i ]表示A[ i –lowbit( i ) + 1]至A[ i ]的结合值。

lowbit(i)是i的二进制中最后一个不为零的位数的2次方，可以这样计算

lowbit(i)=x&(-x)

lowbit(i)=x&(x^(x-1))

当想要查询一个sum(n)时，可以依据如下算法即可：

step1:　令sum = 0，转第二步；
step2:　假如n <= 0，算法结束，返回sum值，否则sum = sum + Cn，转第三步；
step3:  令n = n – lowbit(n)，转第二步。

n = n – lowbit(n)这一步实际上等价于将n的二进制的最后一个1减去。而n的二进制里最多有log(n)个1，所以查询效率是log(n)的。

修改一个节点，必须修改其所有祖先，最坏情况下为修改第一个元素，最多有log(n)的祖先。所以修改算法如下（给某个结点i加上x）：

step1: 当i > n时，算法结束，否则转第二步；
step2: Ci = Ci + x， i = i + lowbit(i)转第一步。

i = i +lowbit(i)这个过程实际上也只是一个把末尾1补为0的过程。

求逆序的思路：

可以把数一个个插入到树状数组中， 每插入一个数， 统计比他小的数的个数，对应的逆序为 i- getsum( data[i] )，其中 i 为当前已经插入的数的个数， getsum( data[i] ）为比 data[i] 小的数的个数，i- getsum( data[i] ) 即比 data[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;
}