HDU 1394 Minimum Inversion Number（最小逆序数/暴力 线段树 树状数组 归并排序）

题目链接: 传送门

Minimum Inversion Number

Time Limit: 1000MS     Memory Limit: 32768 K

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 Iutput

10
1 3 6 9 0 8 5 7 4 2

Sample Output

16

解题思路：

• 1、暴力
  注意到输入的n个数是从0~n-1并且每次都把第一个数移到最后一个数，所以原来比它小的数（和它构成逆序）在移动之后就不是逆序了，而原来比它大的数>（不和它构成逆序）在移动之后就是逆序了，因此很容易推得每次减少的逆序数为n-1-a[i]每次增加的逆序数为a[i]
• 2、线段树
  首先先来看一个序列 6 1 2 7 3 4 8 5，此序列的逆序数为5+3+1=9。冒泡法可以直接枚举出逆序数，但是时间复杂度太高O(n^2)。冒泡排序的原理是枚举每一个数组，然后找出这个数后面有多少个数是小于这个数的，小于它逆序数+1。仔细想一下，如果我们不用枚举这个数后面的所有数，而是直接得到小于这个数的个数，那么效率将会大大提高。
  总共有N个数，如何判断第i+1个数到最后一个数之间有多少个数小于第i个数呢？不妨假设有一个区间 [1,N]，只需要判断区间[i+1,N]之间有多少个数小于第i个数。如果我们把总区间初始化为0，然后把第i个数之前出现过的数都在相应的区间把它的值定为1，那么问题就转换成了[i+1,N]值的总和。再仔细想一下，区间[1,i]的值+区间[i+1,N]的值=区间[1,N]的值(i已经标记为1)，所以区间[i+1,N]值的总和等于N-[1,i]的值！因为总共有N个数，不是比它小就是比它(大或等于)。
  现在问题已经转化成了区间问题，枚举每个数，然后查询这个数前面的区间值的总和，N-[1,i]即为逆序数。

暴力求解

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef __int64 LL;

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

线段树

#include<cstdio>
#include<algorithm>
using namespace std;
#define lson l , m , rt << 1
#define rson m + 1, r , rt << 1 | 1
const int maxn = 5005;
int sum[maxn<<2];

void PushUp(int rt)
{
    sum[rt] = sum[rt<<1] + sum[rt<<1|1];
} 

void build(int l,int r,int rt)
{
    sum[rt] = 0;
    if (l == r) return;
    int m = (l + r) >> 1;
    build(lson);
    build(rson);
}

void upd(int p,int l,int r,int rt)
{
    if (l == r)
    {
        sum[rt]++;
        return;
    }
    int m = (l + r) >> 1;
    if (p <= m) upd(p,lson);
    else    upd(p,rson);
    PushUp(rt);
}

int qry(int L,int R,int l,int r,int rt)
{
    if (L <= l && r <= R)
    {
        return sum[rt];
    }
    int m = (l + r) >> 1;
    int ret = 0;
    if (L <= m) ret += qry(L,R,lson);
    if (R > m)  ret += qry(L,R,rson);
    return ret;
}

int main()
{
    int N;
    while (~scanf("%d",&N))
    {
        int ans[maxn];
        build(0,N - 1,1);
        int sum = 0;
        for (int i = 0; i < N;i++)
        {
            scanf("%d",&ans[i]);
            sum += qry(ans[i],N - 1,0,N - 1,1);
            upd(ans[i],0,N - 1,1);
        }
        int ret = sum;
        for (int i = 0;i < N;i++)
        {
            sum += N - ans[i] - ans[i] - 1;
            ret = min(ret,sum);
        }
        printf("%d\n",ret);
    }
    return 0;
}

树状数组

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
const int maxn = 5005;
int c[maxn],N;

void upd(int i,int v)
{
    while (i <= N)
    {
        c[i] += v;
        i += i & -i;
    }
}

int sum(int i)
{
    int ret = 0;
    while (i > 0)
    {
        ret += c[i];
        i -= i & -i;
    }
    return ret;
}

int main()
{
    while (~scanf("%d",&N))
    {
        int ans[maxn] = {0};
        int res = 0,tmp;
        memset(c,0,sizeof(c));
        for (int i = 0;i < N;i++)
        {
            scanf("%d",&ans[i]);
            res += sum(N) - sum(ans[i] + 1);
            upd(ans[i] + 1,1);
        }
        tmp = res;
        for (int i = 0;i < N;i++)
        {
            tmp -= ans[i];
            tmp += N - ans[i] - 1;
            res = min(tmp,res);
        }
        printf("%d\n",res);
    }
    return 0;
}

归并排序

#include<iostream>
#include<cstdio>
#include<cstring>
#include<cstdlib>
using namespace std;
const int maxn = 5005;
int sum;
void merge_array(int array[],int left,int mid,int right)
{
    if (left >= right)  return;
    int i = left,j = mid + 1,k = 0;
    int *p;
    p = (int *)malloc((right - left + 1)*sizeof(int));
    while (i <= mid && j <= right)
    {
        if (array[i] <= array[j])
        {
            p[k++] = array[i++];
        }
        else
        {
            p[k++] = array[j++];
            sum += mid - i + 1;            //[i-mid]序列就都能与a[j]构成逆序对，故：mid-i+1
        }
    }
    while (i <= mid)
    {
        p[k++] = array[i++];
    }
    while (j <= right)
    {
        p[k++] = array[j++];
    }
    for (int i = 0;i < k;i++)
    {
        array[i+left] = p[i];
    }
    free(p);
}

void merge_sort(int array[],int left,int right)
{
    if (left >= right)  return;
    int mid = (left + right)>>1;
    merge_sort(array,left,mid);
    merge_sort(array,mid + 1,right);
    merge_array(array,left,mid,right);
}

int main()
{
    int N;
    while (~scanf("%d",&N))
    {
        int a[maxn],b[maxn],res;
        sum = 0;
        for (int i = 0;i < N;i++)
        {
            scanf("%d",&a[i]);
            b[i] = a[i];
        }
        merge_sort(a,0,N - 1);
        res = sum;
        for (int i = 0;i < N;i++)
        {
            sum += N - b[i] - b[i] - 1;
            res = min(res,sum);
        }
        printf("%d\n",res);
    }
    return 0;
}