POJ 2299-Ultra-QuickSort（树状数组求逆序数）_pku2299 求逆序数的题 java-CSDN博客

本文链接：https://blog.csdn.net/MIKASA3/article/details/51336402

Ultra-QuickSort

Time Limit: 7000MS		Memory Limit: 65536K
Total Submissions: 52967		Accepted: 19434

Description

In this problem, you have to analyze a particular sorting algorithm. The algorithm processes a sequence of n distinct integers by swapping two adjacent sequence elements until the sequence is sorted in ascending order. For the input sequence
9 1 0 5 4 ,
Ultra-QuickSort produces the output
0 1 4 5 9 .
Your task is to determine how many swap operations Ultra-QuickSort needs to perform in order to sort a given input sequence.

Input

The input contains several test cases. Every test case begins with a line that contains a single integer n < 500,000 -- the length of the input sequence. Each of the the following n lines contains a single integer 0 ≤ a[i] ≤ 999,999,999, the i-th input sequence element. Input is terminated by a sequence of length n = 0. This sequence must not be processed.

Output

For every input sequence, your program prints a single line containing an integer number op, the minimum number of swap operations necessary to sort the given input sequence.

Sample Input

Sample Output

6
0

Source

Waterloo local 2005.02.05

题目意思：

有一组数，求升序排列需要交换多少次，即对给定的每组数逆序数。
可以用选择排序、归并排序和树状数组的思想来考虑，但是选择排序会超时。

解题思路：

这里我们考虑用树状数组来解决。
分两步，离散化和求逆序数。
①离散化
因为题目中给出的n < 500,000而0 ≤ a[i] ≤ 999,999,999，所以我们可以把输入的N个数a[i]，按大小顺序分别映射到1~N。
例如 9 1 0 5 4 可以离散化映射为 5 2 1 4 3.
②求逆序数
“逆序数就是数中各位在它前面有多少个数比它大，求出这些元素个数之和。”
每输入一个数就更新一次c数组再判断一次当前比这个数大的数的个数。
说明：
i是当前已经插入的数字的个数；
num[i]是原序列中的数离散化后的各个数；
getsum(num[i])表示比num[i]小的数的个数，getsum(num[i])等于num[num[i]–lowbit(num[i])+1]+...+num[num[i]]；
i-getsum(num[i])表示比num[i]大的数的个数，这就是逆序数。

Note：困扰了我好几个小时的就是为什么“getsum(num[i])表示比num[i]小的数的个数”？
想了很久，我的理解是这样的：
因为是依次插入，每次都做查询，所以肯定是与当前的数有关。c数组是对数组的一种求和统计，每次输入后需要更新，更新时把该数被包含在c数组里的数据全部加一，所以c[i]表示当前比i小的数的个数。

代码一：先更新再求和

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 500005
int c[MAXN],n,num[MAXN];
struct Node
{
    int val,no;
} data[MAXN];
bool cmp(Node a,Node b)
{
    return a.val<b.val;
}
int lowbit(int x)
{
    return x&(-x);
}
void update(int x,int v)
{
    while(x<=n)
    {
        c[x]+=v;
        x+=lowbit(x);
    }
}
int getsum(int x)
{
    int sum=0;
    while(x)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    int i;
    long long ans;
    while(scanf("%d",&n),n)
    {
        memset(c,0,sizeof(c));
        for(i=1; i<=n; i++)
        {
            scanf("%d",&data[i].val);
            data[i].no=i;//保存每个数输入时的下标
        }
        sort(data+1,data+n+1,cmp);//对输入的序列排序
        for(i=1; i<=n; i++)
        {
            //离散化，把n个点按大小映射到1~n
            //data[i].no是数在原序列中的下标
            num[data[i].no]=i;//离散下标表示
        }
        ans=0;
        for(i=1; i<=n; i++)
        {
            //n是总数，num[i]是原序列中的数离散化后的各个数
            //getsum(num[i])表示比num[i]小的数的个数
            //getsum(num[i])等于num[num[i]–lowbit(num[i])+1]+...+num[num[i]]
            update(num[i],1);
            ans+=i-getsum(num[i]);
        }
        cout<<ans<<endl;
    }
}

代码二：先求和再更新

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define MAXN 500005
int c[MAXN],n,num[MAXN];
struct Node
{
    int val,no;
} data[MAXN];
bool cmp(Node a,Node b)
{
    return a.val<b.val;
}
int lowbit(int x)
{
    return x&(-x);
}
void update(int x,int v)
{
    while(x<=n)
    {
        c[x]+=v;
        x+=lowbit(x);
    }
}
int getsum(int x)
{
    int sum=0;
    while(x)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    int i;
    long long ans;
    while(scanf("%d",&n),n)
    {
        memset(c,0,sizeof(c));
        for(i=0; i<n; i++)
        {
            scanf("%d",&data[i].val);
            data[i].no=i;//保存每个数输入时的下标
        }
        sort(data,data+n,cmp);//对输入的序列排序
        for(i=0; i<n; i++)
        {
            //离散化，把n个点按大小映射到1~n
            //data[i].no是数在原序列中的下标
            num[data[i].no]=i+1;//离散下标表示
        }
        ans=0;
        for(i=0; i<n; i++)
        {
            //n是总数，num[i]是原序列中的数离散化后的各个数
            //getsum(n)是数在原序列中的下标
            //getsum(num[i])表示比num[i]小的数的个数
            //getsum(num[i])等于num[num[i]–lowbit(num[i])+1]+...+num[num[i]]
            ans+=(getsum(n)-getsum(num[i]));
            update(num[i],1);
        }
        cout<<ans<<endl;
    }
}

转载：

树状数组，具体的说是离散化+树状数组。这也是学习树状数组的第一题.

算法的大体流程就是：

1.先对输入的数组离散化，使得各个元素比较接近，而不是离散的，

2.接着，运用树状数组的标准操作来累计数组的逆序数。

算法详细解释：

1.解释为什么要有离散的这么一个过程？

刚开始以为999.999.999这么一个数字，对于int存储类型来说是足够了。

还有只有500000个数字，何必要离散化呢？

刚开始一直想不通，后来明白了，后面在运用树状数组操作的时候，

用到的树状数组C[i]是建立在一个有点像位存储的数组的基础之上的，

不是单纯的建立在输入数组之上。