Minimum Inversion Number HDU 1394

 

题意：给出n个数的一个排列，要求求出这列数按如下变换得到的n个排列中最小的逆序数。（逆序数：a given number sequence a1, a2, ..., an is the number of pairs (ai, aj) that satisfy i < j and ai > aj）

例如原数列为：a1,a2,a3......an。

第一个数列：原数列：a1,a2,a3......an。

第二个数列：将原数列的第一个元素移到末尾得到的数列：a2,a3......an,a1。

第三个数列：将上述得到的数列的第一个元素移到末尾得到的数列：a3,a4......an,a1,a2。

以此类推......

 

题解：线段树（树状数组和归并排序亦可解之，下附代码）。

这里详细讲解如何利用线段树求解逆序数的：

 先建一个空树； 逐个插入值（即输入的一个值）； 在每插入一个值后就更新包含该区间的所有的数的个数（加一）。 为什么可以这样呢，下面引用一个人的说明：

 

线段树求逆序数  

3 2 5 4 6 1

插入 3 时  询问 3-6 之间元素的个数  v1=0

插入 2 时  询问 2-6 之间元素的个数  v2=1

......

......                                                         v6=6

累加v1……v6  =sum。

再详细点，举个例子，插入2的时候，你要的找的数肯定是比2大的数的个数（当然是已经插进来了的，就是序列里排在2前面的），这时候发现只有3比2先被插入到树中（且只有3而已），那么2由2产生的逆序数就是1了，累加到sum中；之后更新，update(2,1),把包含2的所有区间的数的个数都+1，便于之后的1，0，去查找。

 

AC代码：

线段树解法：

 

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int maxn=5005;
int sum[maxn<<2],num[maxn];
int Query(int l,int r,int left,int right,int pos){
    if(l<=left&&right<=r)return sum[pos];
    int mid=(left+right)>>1;
    if(r<=mid)return Query(l,r,left,mid,pos*2);
    if(l>mid)return Query(l,r,mid+1,right,pos*2+1);
    int lsum=Query(l,r,left,mid,pos*2);
    int rsum=Query(l,r,mid+1,right,pos*2+1);
    return lsum+rsum;
}
void Updata(int p,int l,int r,int pos){
    if(l==r){
        sum[pos]++;
        return;
    }
    int mid=(l+r)>>1;
    if(p<=mid)Updata(p,l,mid,pos*2);
    else      Updata(p,mid+1,r,pos*2+1);
    sum[pos]=sum[pos*2]+sum[pos*2+1];
}
int main()
{
    int n;
    while(~scanf("%d",&n)){
        memset(sum,0,sizeof(sum));
        int sum=0;
        for(int i=0;i<n;i++){
            scanf("%d",&num[i]);
            sum+=Query(num[i],n-1,0,n-1,1);
            Updata(num[i],0,n-1,1);
        }
        int ans=sum;
        for(int i=0;i<n-1;i++){
            sum+=n-num[i]-num[i]-1;
            ans=ans<sum?ans:sum;
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

 

 

树状数组解法（详见代码及注释）：

此题用树状数组要比线段树快。

 

#include<cstdio>
#include<cstring>
#include<iostream>
using namespace std;
const int maxn=5005;
int num[maxn],c[maxn];
int n;
int lowbit(int x){
    return x&(-x);
}
int SuM(int p){//统计1--p的和，即1--p中有多少个数已经出现了，也就是计算比p小的数的个数
    int sum=0;
    while(p>0){
        sum+=c[p];
        p-=lowbit(p);
    }
    return sum;
}
void Updata(int p,int val){
    while(p<=n){
        c[p]+=val;
        p+=lowbit(p);
    }
}
int main()
{
    while(~scanf("%d",&n)){
        int sum=0;
        memset(c,0,sizeof(c));
        for(int i=0;i<n;i++){
            scanf("%d",&num[i]);
            sum+=SuM(n)-SuM(++num[i]);//这里num[i]全部都要加一！否则遇到0时在Updata()时会死循环。
            //每输入一个数首先逆序数
            Updata(num[i],1);
            //更新c[]数组，使所有相应的c[]的加一，表示num[i]在第i次已经出现
        }
        int ans=sum;
        for(int i=0;i<n-1;i++){
            sum+=n-num[i]-num[i]+1;
            ans=ans<sum?ans:sum;
        }
        printf("%d\n",ans);
    }
    return 0;
}

 

 归并排序解法：

 

#include<cstdio>
#include<iostream>
using namespace std;
const int maxn=5005;
int num1[maxn],num2[maxn],temp[maxn];
int sum;
void Merge(int l,int mid,int r){
    int p=0;
    int i=l,j=mid+1;
    while(i<=mid&&j<=r){
        if(num1[i]>num1[j]){
            sum+=mid-i+1;
            temp[p++]=num1[j++];
        }
        else temp[p++]=num1[i++];
    }
    while(i<=mid)temp[p++]=num1[i++];
    while(j<=r)temp[p++]=num1[j++];
    for(i=0;i<p;i++)
        num1[l+i]=temp[i];
}
void MergeSort(int l,int r){
    if(l<r){
        int mid=(l+r)>>1;
        MergeSort(l,mid);
        MergeSort(mid+1,r);
        Merge(l,mid,r);
    }
}
int main()
{
    int n;
    while(~scanf("%d",&n)){
        for(int i=0;i<n;i++){
            scanf("%d",&num1[i]);
            num2[i]=num1[i];
        }
        sum=0;
        MergeSort(0,n-1);
        int ans=sum;
        for(int i=0;i<n-1;i++){
            sum+=n-num2[i]-num2[i]-1;
            ans=ans<sum?ans:sum;
        }
        printf("%d\n",ans);
    }
    return 0;
}