HUDOJ-----1394Minimum Inversion Number

Minimum Inversion Number

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

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

 

Author

CHEN, Gaoli

 

Source

ZOJ Monthly, January 2003

 

       求逆序数，这道题花了我一下午的时间去看线代，不过还好总算做出了....切克闹，切脑壳...

下 面来详细讲讲过程吧...

        首先，我求出了 Simple output 给出的 序列的 逆序数为22 这是没有错的，但是输出却为16，当时我这个小脑袋呀，真是....泪崩了呀！. 

 然后我就在这里纠结呀...哎，由于英语不是很好，居然没有读懂这句话的意思.....这是啥情况 ，妈蛋呀！

     out of the above sequences.  ------>从上面的式子中找出最小的逆序数...

     明白了这句话，下面就好办了..

    最后就是一点要说的是... 对于逆序数，如果存在左右顶端对调，并且这个序列是连续的..

是可以总结出规律的,,

看代码就知道了。。

                             time   300+ms....   c++ 

 #include<stdio.h>
 #include<stdlib.h>
 #include<string.h>
 #define maxn 5000
 int a[maxn+];
 int bb[maxn+]; //存储单个元素的逆序数
 int main()
 {
     int n,i,j,tol;
     while(scanf("%d",&n)!=EOF)
     {
         memset(bb,,sizeof(bb));
         for(i=;i<n;i++)
         {
           scanf("%d",a+i);
           for(j=i-;j>=;j--)
           {
               if(a[i]>a[j]&&bb[j]==) break;
               if(a[i]<a[j])bb[i]++;
           }
         }
         tol=;
         for(i=;i<n;i++)  //求出逆序数
              tol+=bb[i];
              int res=tol;
         for(i=;i<n;i++)
         {
                 tol+=n-*a[i]- ;
                 if(res>tol)
                     res=tol;
         }
         printf("%d\n",res);
     }

     return ;
 }

运用递归调用版的归并排序

比如 5 4 3 2 1 《5 ，4》，《3 ，2》  --》+ 2

 4 5 2 3 1

4 5 2 3  ---》 2 +2=4；

2 3 4 5 1 --》 4

10

运用这个原理便可以得到结果，代码如下：

 #include<string.h>
 #include<stdlib.h>
 #include<stdio.h>
 #define maxn 5000
 int aa[maxn+];
 int bb[maxn+];
 int nn,tol=;
 void mergec(int low ,int mid ,int hight )
 {
     int i,j,k;
    int *cc = (int *)malloc(sizeof(int)*(hight-low+));
      i=low;
      j=mid;
      k=;
     while( i<mid&&j<hight )
     {
         if(aa[i]>aa[j])
         {
           cc[k++]=aa[j++];
           tol+=mid-i;
         }
        else
           cc[k++]=aa[i++];
     }
     for( ; i<mid ;i++)
        cc[k++]=aa[i];
     for( ; j<hight ; j++)
        cc[k++]=aa[j];
     k=;
     for(i=low;i<hight;i++)
        aa[i]=cc[k++];
       free( cc );
 }
 /*用递归求解归并排序无法求逆序数*/
 void merge_sort(int st,int en)
 {
     int mid;
     if(st+<en)
     {
         mid=st+(en-st)/;
         merge_sort(st,mid);
         merge_sort(mid,en);
         mergec(st,mid,en);
     }
 }
 int main()
 {
     int  i,res;
  // freopen("test.in","r",stdin);
     while(scanf("%d",&nn)!=EOF)
     {
           tol=;
         for(i=;i<nn;i++){
              scanf("%d",aa+i);
              bb[i]=aa[i];
          }
          merge_sort(,nn);
           res=tol;
        //printf("tol=%d\n",res);
          for(i=;i<nn-;i++)
          {
              tol+=nn-*bb[i]-;
              if(res>tol) res=tol;
          }
         printf("%d\n",res);
     }
     return ;
 }

接下来是非递归调用....版的归并排序

 #include<string.h>
 #include<stdlib.h>
 #include<stdio.h>
 #define maxn 5000
 int aa[maxn+];
 int bb[maxn+];
 int nn,tol=;
 void mergec(int low ,int mid ,int hight )
 {
     int i,j,k;
    int *cc = (int *)malloc(sizeof(int)*(hight-low+));
      i=low;
      j=mid;
      k=;
     while( i<mid&&j<hight )
     {
         if(aa[i]>aa[j])
         {
           cc[k++]=aa[j++];
           tol+=mid-i;
         }
        else
           cc[k++]=aa[i++];
     }
     for( ; i<mid ;i++)
        cc[k++]=aa[i];
     for( ; j<hight ; j++)
        cc[k++]=aa[j];
     k=;
     for(i=low;i<hight;i++)
        aa[i]=cc[k++];
       free( cc );
 }

 /*----------------------华丽丽的分割线--------------------------------*/
 void merge_sort( int st , int en )
 {
     int s,t,i;
     t=;
     while(t<=(en-st))
     {
         s=t;
         t=s*;    //表示两个s的长度
         i=st;
         while(i+t<=en){
             mergec(i,i+s,i+t);
             i+=t;
         }
      if(i+s<en)
          mergec(i,i+s,en);
     }
     if(s<en-st)
          mergec(st,st+s,en);
 }
 int main()
 {
     int  i,res;
 //  freopen("test.in","r",stdin);
     while(scanf("%d",&nn)!=EOF)
     {
           tol=;
         for(i=;i<nn;i++){
              scanf("%d",aa+i);
              bb[i]=aa[i];
          }
          merge_sort(,nn);
           res=tol;
        //printf("tol=%d\n",res);
          for(i=;i<nn-;i++)
          {
              tol+=nn-*bb[i]-;
              if(res>tol) res=tol;
          }
         printf("%d\n",res);
     }
     return ;
 }

 用树状数组...

代码：

 /*
 用树状数组求逆序数
 */
 #include<stdio.h>
 #include<string.h>
 #include<stdlib.h>
 #define maxn 5000
 int aa[maxn+];
 int bb[maxn+];
 int nn;
 int lowbit(int k)
 {
    return k&(-k);
 }
 void ope(int x)
 {
     while(x<=nn)
     {
       aa[x]++;
       x+=lowbit(x);
     }
 }
 int sum(int x)
 {
     int ans=;
     while(x>)
     {
         ans+=aa[x];
         x-=lowbit(x);
     }
     return ans;
 }
 int main()
 {

     int i,res,ans;
     //freopen("test.in","r",stdin);
     while(scanf("%d",&nn)!=EOF)
     {
        memset(aa,,sizeof(aa));
        res=;
        for(i=;i<nn;i++)
        {
          scanf("%d",&bb[i]);
          res+=sum(nn)-sum(bb[i]+);
          ope(bb[i]+);
        }
        ans=res;
        for(i=;i<nn;i++)
        {
            res+=nn--*bb[i];
            if(ans>res)
                   ans=res;
        }
        printf("%d\n",ans);
    }
   return ;
 }