hdu 1394 Minimum Inversion Number 求逆序数(树状数组/归并排序/暴力)

hdu 1394

题意：

给一个数列，数列的顺序可以更改，即原数列为 a1, a2, ..., an-1, an 

可以变成以下这些都ok

a2, a3, ..., an, a1
a3, a4, ..., an, a1, a2 
...
an, a1, a2, ..., an-1 

然后问 这n种数列中 包含的逆序数对的最小总数是多少？

如：2 3 1 4 这个数列 2 1 是一个逆序数对 3 1 是一个逆序数对 逆序数的总数为2个 

求逆序数的方式有两种 一是确定一个数 往前看比它大的有几个 另一种是 往后看 比它小的有几个

从做题的角度 貌似从前看比较科学 以下代码中 暴力做法是往后看 当然改成往前看也是可以大 树状数组、归并排序做法是往前看

算出一种 即原给定的数列顺序的逆序对总数后 其他n-1种方式的逆序对总是可通过下列方法算出：

//左移序列之后得到新的序列的逆序数的个数，就等与当前逆序对总的个数减最左边的数的逆序数a[i]，然后加上新增的逆序数n-1-a[i]~

//暴力求逆序数
#include <stdio.h>
#include <stdlib.h>
#include <algorithm>
#include <string.h>
#include <math.h>
using namespace std;

int num[10010];
int a[5010];

int main()
{
	int n;
	while(scanf("%d",&n)!=EOF){
		memset(a,0,sizeof(a));
		for(int i=0;i<n;i++){
			scanf("%d",&num[i]);
			num[i+n]=num[i];//再加一个等长的数组 形成循环状
		}
		int minn=0;
		//计算初始逆序对数量 并统计每个数的逆序数（为防止给出的数列不是从0到n-1的，尽管此题貌似是0到n-1）
		for(int i=0;i<n;i++){
			for(int j=i+1;j<n+i;j++){
				if(num[j]<num[i]){
					a[i]++;//a[i]表示下标为i的数在整个数列中存在的比其小的数个数
						//为方便当a[i]为首位时 计算将其换到最后到逆序对总数的影响
					if(j<n)
						minn++;//minn为统计当前初始顺序时的逆序对的数量
				}
			}
		}
		int temp=minn;
		for(int i=0;i<n-1;i++){
			temp=temp-a[i]+n-1-a[i];
			minn=min(minn,temp);
		}
		printf("%d\n",minn);
	}
	return 0;
}

//树状数组求逆序数：
//每插入一个数字，查询之前插入的数字中，比它大的数字的个数，及此位造成的逆序个数
#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
const int MAXN=5050;
int c[MAXN];
int n;
int lowbit(int x)
{
    return x&(-x);
}
void add(int i,int val)
{
    while(i<=n)
    {
        c[i]+=val;
        i+=lowbit(i);
    }
}
int sum(int i)
{
    int s=0;
    while(i>0)
    {
        s+=c[i];
        i-=lowbit(i);
    }
    return s;
}
int a[MAXN];
int main()
{
    while(scanf("%d",&n)!=EOF)
    {
        int ans=0;
        memset(c,0,sizeof(c));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
            a[i]++;//输入的数字中包含0，令所有数字都++，正好符合树状数组从1开始的情况~
            ans+=sum(n)-sum(a[i]);//查询到的之前已经插入的从1到n的数字个数 减去 从1到a[i]的数字个数
                                //就是之前插入的比a[i]大的数字个数 即这位上的数造成的逆序数
            add(a[i],1);//将这个数字添加到树状数组中 个数加1
        }
        int Min=ans;
        for(int i=1;i<=n;i++)
        {
            ans+=n-a[i]-(a[i]-1);
            if(ans<Min)Min=ans;
        }
        printf("%d\n",Min);
    }
    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;//sum用于记录逆序数 当后半部分最小的比前半部分最小的小的时候 
             			//说明前半部分的所有值全比后半部分大 将个数加到统计逆序对的数sum中	
             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=sum-num2[i]+n-1-num2[i];
             ans=min(ans,sum);
         }
         printf("%d\n",ans);
     }
     return 0;
 }