Minimum Inversion Number（HDU 1394）

Minimum Inversion Number

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 10642    Accepted Submission(s): 6556

Problem 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
  
  

本题求最小逆序数。我用了3种方法（当然第3种是学别人的 ==）暴力、归并、树状数组。。当然也可用线段树，不过我不熟==。。注意本题求出最开始的逆序数后，可通过ans += (n-1-a[i])-a[i] 从0~n-1遍历求最小值即可（n为长度、a[i] 指每次变幻后的第一个数）。因为，首先要注意数字是0~n-1 ！！所以把a[i]放到最后面时，相当于后面有a[i]个数比a[i]小、有n-1-a[i]个数比a[i]大，结合起来就相当于增加了(n-1-a[i])-a[i]个逆序数，于是一直这样操作后就可求出最小逆序数。

1.暴力：

#include<stdio.h>
int main()
{
    int n, i, j, A[5010];

    while(~scanf("%d", &n))
    {
        for(i=0; i<n; i++)
            scanf("%d", A+i);
        int cnt = 0;
        for(i=0; i<n; i++)
        {
            int t = 0;
            for(j=i+1; j<n; j++)
                if(A[i] > A[j]) t++;
            cnt += t;
        }
        int minn = cnt;
        for(i=0; i<n; i++)
        {
            cnt += (n-1-A[i])-A[i];
            if(cnt < minn) minn = cnt;
        }
        printf("%d\n", minn);
    }
    return 0;
}

2.利用归并排序：

#include<stdio.h>
int cnt;
void merge_sort(int* A, int x, int y, int* temp)
{
    if(y-x > 1)
    {
        int m = x+(y-x)/2; //划分
        int p = x, q = m, i = x;
        merge_sort(A, x, m, temp); //递归求解
        merge_sort(A, m, y, temp); //递归求解
        while(p < m || q < y)
        {
            if(q >= y || (p < m && A[p] <= A[q])) temp[i++] = A[p++]; 
            else temp[i++] = A[q++], cnt += m-p; //当取右边的数时，即此时左边的数比A[q]都小
        }
        for(i=x; i<y; i++) A[i] = temp[i];
    }
}

int main()
{
    int n, i, j, A[5010], temp[5010], B[5010];

    while(~scanf("%d", &n))
    {
        for(i=0; i<n; i++) //由于A、temp数组在归并后都会改变，所以需要B数组。
            scanf("%d", A+i), B[i] = A[i];
        cnt = 0;
        merge_sort(A, 0, n, temp);
        int minn = cnt;
        for(i=0; i<n; i++)
        {
            cnt += (n-1-B[i])-B[i];
            if(cnt < minn) minn = cnt;
        }
        printf("%d\n", minn);
    }
    return 0;
}

3.树状数组:

首先，由于要用到树状数组，故需从1开始到n。所以也有A[i]++ 。分析所给数据序列中的5，它本来所在下标为6，现在为7。那么sum[i]代表前面比5小的数的个数，前面共有7-1个数，故前面比5大的个数为i-1-sum[i]，即3个；于是再将A[i]当下标加到树状数组里去；

#include<stdio.h>
#include<string.h>
int n, c[5010];

int lowbit(int x) {return x&(-x);}
void add(int i,int w)
{
    while(i <= n)
    {
        c[i] += w;
        i += lowbit(i);
    }
}
int sum(int i)
{
    int s = 0;
    while(i > 0)
    {
        s += c[i];
        i -= lowbit(i);
    }
    return s;
}

int main()
{
    int i, A[5010];

    while(~scanf("%d", &n))
    {
        memset(c, 0, sizeof(c));
       // memset(A, 0, sizeof(A));
        int ans = 0;
        for(i=1; i<=n; i++)
        {
            scanf("%d", A+i);
            A[i]++;
            //ans+=sum(n)-sum(A[i]);
            ans += i-1-sum(A[i]);
            add(A[i],1);
        }
        int minn = ans;
        for(i=1; i<=n; i++)
        {
            ans += n-A[i]-(A[i]-1); //注意上面序列++给这里带来的影响
            if(ans < minn) minn = ans;
        }
        printf("%d\n", minn);
    }
    return 0;
}