HDU - 1394 _Minimum Inversion Number（归并排序求逆序数）

Description

The inversion number of a given number sequence a1, a2, …, an is the number of pairs (ai, aj) that satisfy i < j and ai > aj.

For a given sequence of numbers a1, a2, …, an, if we move the first m >= 0 numbers to the end of the seqence, we will obtain another sequence. There are totally n such sequences as the following:

a1, a2, …, an-1, an (where m = 0 - the initial seqence)

a2, a3, …, an, a1 (where m = 1)

a3, a4, …, an, a1, a2 (where m = 2)

…

an, a1, a2, …, an-1 (where m = n-1)

You are asked to write a program to find the minimum inversion number out of the above sequences.

Input

The input consists of a number of test cases. Each case consists of two lines: the first line contains a positive integer n (n <= 5000); the next line contains a permutation of the n integers from 0 to n-1.

Output

For each case, output the minimum inversion number on a single line.

Sample Input

10

1 3 6 9 0 8 5 7 4 2

Sample Output

16

题意：数组 0-(n-1)，每次把第一个元素放到最后一个，求所有的排列中逆序数的最小值

即：

数组a[]：其根据题意移动产生的序列有

3 4 1 2 0 逆序数：8

4 1 2 0 3 逆序数：6

1 2 0 3 4 逆序数：2

2 0 3 4 1 逆序数：4

所以最小逆序数为2

分析：先利用递归排序把起初的逆序数个数解出来，在利用递推—->>>如果求出第一种情况的逆序列，其他的可以通过递推来求出来，一开始是b[0],b[1],b[2]….b[n-1]它的逆序列个数是N个，如果把b[0]放到b[n-1]后面，逆序列个数会减少b[0]个，相应会增加N-(b[0]+1)个。

先求解一开始的数组的逆序数个数，在此基础上再进行加减操作，根据递归操作，得出最小的逆序数个数。

代码：

#include <iostream>
#include <cstdio>
using namespace std;
int n;
int inf = 99999999;
int a[500005],b[500005];
int L[500005],R[500005];
int Merge(int a[],int n,int left,int mid,int right)
{
int i,j,k;
int cnt = 0;
int n1 = mid-left;
int n2 = right-mid;
for(i=0;i<n1;i++)
L[i] = a[left+i];
for(j=0;j<n2;j++)
R[j] = a[mid+j];
L[n1] = R[n2] = inf;
i = j = 0;
for(k=left;k<right;k++)
{
if(L[i] <= R[j])
{
a[k] = L[i++];
}
else
{
a[k] = R[j++];
cnt = cnt + n1-i;  //只要左边第 i个元素大于右边第 j 个元素，则左边剩下的元素一定大于右边第 j 个元素，所以直接把他们都加了就好
}
}
return cnt;
}
int MergeSort(int a[],int n,int left,int right)
{
int mid;
int u,v,w;
if(left+1 < right)
{
mid = (left+right)/2;
u = MergeSort(a,n,left,mid);
v = MergeSort(a,n,mid,right);
w = Merge(a,n,left,mid,right);
return u+v+w;   //
}
else
return 0;
}
int main()
{
while(scanf("%d",&n)!=EOF)
{
int ans = 0;
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
b[i] = a[i];
}

ans = MergeSort(a,n,0,n);

//printf("%d\n",ans);
int minx = inf;
if(ans < minx)
minx = ans;
for(int i=0;i<n;i++)
{
ans = ans - b[i] + n - 1 - b[i];
if(minx > ans )
minx = ans;
}
printf("%d\n",minx);
}
return 0;
}

#include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int ans;
int inf = 99999999;
int a[5050],b[5050];

void Merge(int left,int mid,int right)
{
int i,j,cnt=0;
int *p;
i = left;
j = mid + 1;
p = (int *)malloc(sizeof(int )*(right-left+1));
while(i <= mid && j <= right)
{
if(a[i] <= a[j])
{
p[cnt++] = a[i];
i++;
}
else
{
p[cnt++] = a[j];
j++;
ans = ans + mid - i + 1;
}
}
while(i<=mid)
{
p[cnt++] = a[i++];
}
while(j<=right)
{
p[cnt++] = a[j++];
}
cnt = 0;
for(i=left;i<=right;i++)
a[i] = p[cnt++];
free(p);
}

void MergeSort(int left,int right)
{
if(left < right)
{
int mid = (left + right)/2;
MergeSort(left,mid);
MergeSort(mid+1,right);
Merge(left,mid,right);
}
}

int main()
{
int n;
while(scanf("%d",&n)!=EOF)
{
for(int i=0;i<n;i++)
{
scanf("%d",&a[i]);
b[i] = a[i];
}
ans = 0;
MergeSort(0,n-1);
int minx = inf;
if(ans < minx)
minx = ans;
for(int i=0;i<n;i++)
{
ans = ans - b[i] + n - 1 - b[i];
if(minx > ans )
minx = ans;
}
printf("%d\n",minx);
}
}