求解逆序数问题

当某两个元素的先后次序与标准次序（从小到大的顺序）不同时，就说有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<iostream>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<string>
#include<queue>
#include<cmath>
#define ll long long
#define DB double
#define inf 214748360000
#define mod 1000000007
using namespace std;
const int N=1e5+90;
int n,a[N*60],b[N*60];
ll ans;//ans为逆序对个数 
void merge_sort(int l,int r)
{
    if(l==r) return;
    int mid=(l+r)/2,i,j,k;
    i=l;k=l;j=mid+1;
    merge_sort(l,mid);
    merge_sort(mid+1,r);
    while(i<=mid && j<=r)
    {
        if(a[i]<=a[j]) b[k++]=a[i++];
        else ans+=mid-i+1,b[k++]=a[j++]; 
    }
    while(i<=mid) b[k++]=a[i++];
    while(j<=r) b[k++]=a[j++];
    for(int o=l;o<=r;++o) a[o]=b[o];
}
int main()
{
    scanf("%d",&n);
    for(int i=1;i<=n;++i) scanf("%d",&a[i]);
    merge_sort(1,n);
    for(int i=1;i<=n;++i) printf("%d ",a[i]);
//    printf("%lld",ans);
    return 0;
}

 

#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;

}

原文：https://blog.csdn.net/acm_jl/article/details/51147010