HDU 1394 Minimum Inversion Number 树状数组-优快云博客

本文介绍了一种算法，用于解决给定序列通过不同轮转方式得到的所有序列中逆序数最小的问题。采用树状数组优化查询与更新过程，实现高效求解。

Minimum Inversion Number

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

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

用一个数组num[i]保存读入的数值，另一个数组total[i]来记录以后输入的值的排名。可以一边输入，一边查询，然后切记要更新！

另一个难点是每次换队首的时候的值时，可以用公式求出换后的sum，sum = sum +(n-1) - 2*num[i] ;

解释下这个公式：（n-1）是先假设当第一个数到最后会增加（n-1）个符合的情况，然后减去换之前不成立的和换后不成立即为最后结果。

#include <cstdio>
#include <stdlib.h>
#include <algorithm>
#include <string.h>
using namespace std;
int num[5005] , total[5005];
int n;
int lowbit( int x )
{
    return x&(-x);
}

int query( int x )
{
    int ret = 0;
    x += 1;
    while( x <= n )
    {
          ret += total[x];
          x += lowbit(x);  
    }
    return ret ;
}

void update( int x )
{
     while( x > 0 )
     {
            total[x]++;
            x -= lowbit(x);       
     }
}

int main( )
{
    while( scanf("%d",&n) != EOF )    
    {
           memset( total , 0 , sizeof(total) );
           memset( num , 0 , sizeof(num) );
           int sum = 0;
           for( int i=0 ; i<n ; i++ ){
                scanf("%d",&num[i]);
                update( num[i]+1 );
                sum += query( num[i]+1 ); 
                //printf("%d\n",sum);
           }
          
           int k;
           int s = sum;
           for( int i=0 ; i<n ; i++ ){
                k = sum + n-1 - 2*num[i];
                sum = k;
                if( k < s )
                    s = k;     
           }
           printf("%d\n",s);
    }
    return 0;
}

上面的不理解的话，提供另一种解法，详细见代码

#include <iostream>
#include <math.h>
#include <algorithm>
using namespace std;
int n;
int small[5005];     //记录当前比small【i】小的数有多少个 
int num[5005];
int lowbit( int x )
{
    return x&(-x);    
}

int sum( int x )
{
    int ret = 0;
    while( x > 0 ){
           ret += small[x];
           x -= lowbit(x);
    }   
    return ret;
}

void update( int x )
{
     while( x <= n ){
            small[x]++;
            x += lowbit(x);
     }     
}

int main( )
{
    while( scanf("%d",&n) == 1 ) {
           int ans = 0;
           memset( small , 0 , sizeof(small) );
           memset( num , 0 , sizeof(num) );
           for( int i=0 ; i<n ; i++ ){
                scanf("%d",&num[i]);
                ans += sum( n ) - sum( ++num[i] );   //关键步骤
                //用比N小的数目-比I小的数目即为插入i后的逆序数 
                update( num[i] );
                //printf("%d\n",pos[i]);
           }
           int s = ans;
           for( int i=0 ; i<n-1 ; i++ ){
                ans += n + 1 - num[i] - num[i];
                //printf("%d\n",ans);
                if( ans < s )
                    s = ans;
           }
           printf("%d\n",s);
    }
    return 0;
}