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): 16585 Accepted Submission(s): 10093

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

题目意思在这了就不多做解释了。

有两种方法求逆序对：

第一种，暴力枚举。因为这n个数是从0到n-1。先暴力求出原本的序列的逆序对，然后每移一个数字到最后面的话，用x表示现在序列的逆序对数，用y表示下一个序列的逆序对用ai表示移动的数字，那么可以得到以下的关系。原先序列的逆序对减少了ai个，变出来的序列增加（n-ai-1）个逆序对，(这个规律只对从0到n-1的连续数字使用，对别的逆序对问题不合适）,y=x-ai-ai+n-1。

下面是AC代码：

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;

int a[5005];
int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        int ans=99999999;
        for(int i=0; i<n; i++)
        {
            scanf("%d",&a[i]);
        }
        int sum=0;
        for(int i=0; i<n; i++)
        {
            for(int j=i+1; j<n; j++)
            {
                if(a[i]>a[j])
                {
                    sum++;
                }
            }
        }
        if(ans>sum)
        {
            ans=sum;
        }
        for(int i=0; i<n; i++)
        {
            sum=sum-a[i]-a[i]-1+n;
            if(ans>sum)
            {
                ans=sum;
            }
        }
        printf("%d\n",ans);
    }
    return 0;
}

下面是线段树的AC代码：

先写上有时间再来解释。

#include<cstdio>
#include<cstring>
#include<queue>
#include<stack>
#include<algorithm>
using namespace std;
const int maxn=5550;
struct node
{
    int left,right,val;
} c[maxn*3];

void Pushup(int root)
{
    c[root].val=c[root*2].val+c[root*2+1].val;
}

void build_tree(int l,int r,int root)
{
    c[root].left=l;
    c[root].right=r;
    if(l==r)
    {
        return ;
    }
    int mid=(l+r)/2;
    build_tree(l,mid,root*2);
    build_tree(mid+1,r,root*2+1);
}

void update_tree(int pos,int root)
{
    if(c[root].left==c[root].right)
    {
        c[root].val++;
        return ;
    }
    int mid=(c[root].left+c[root].right)/2;
    if(pos<=mid)
    {
        update_tree(pos,root*2);
    }
    else
    {
        update_tree(pos,root*2+1);
    }
    Pushup(root);
}

int search_tree(int L,int R,int root)
{
    if(L==c[root].left&&R==c[root].right)
    {
        return c[root].val;
    }
    int ret=0;
    int mid=(c[root].left+c[root].right)/2;
    if(R<=mid)
    {
        return search_tree(L,R,root*2);
    }
    else if(L>mid)
    {
        return search_tree(L,R,root*2+1);
    }
    else
    {
        return search_tree(L,mid,root*2)+search_tree(mid+1,R,root*2+1);
    }
}

int x[maxn];

int main()
{
    int n;
    while(~scanf("%d",&n))
    {
        memset(c,0,sizeof(c));
        build_tree(0,n-1,1);
        int sum=0;
        for(int i=0; i<n; i++)
        {
            scanf("%d",&x[i]);
            sum+=search_tree(x[i],n-1,1);
            update_tree(x[i],1);
        }
        int ret=sum;
        for(int i=0; i<n; i++)
        {
            sum+=n-x[i]-x[i]-1;
            ret=min(ret,sum);
        }
        printf("%d\n",ret);
    }
    return 0;
}