hrbust 2028 小猴和冒泡2 （逆序数）

最新推荐文章于 2020-01-14 14:49:16 发布

古宇hhhh

最新推荐文章于 2020-01-14 14:49:16 发布

阅读量351

点赞数

分类专栏：树状数组 hrbust

本文链接：https://blog.csdn.net/qq_30591245/article/details/71105072

版权

hrbust 同时被 2 个专栏收录

44 篇文章 0 订阅

订阅专栏

树状数组

4 篇文章 0 订阅

订阅专栏

Time Limit: 1000 MS

Memory Limit: 32768 K

Total Submit: 217(57 users)

Total Accepted: 43(35 users)

Rating:

Special Judge: No

Description

小猴和冒泡问题已经成了一个历史问题，因为很多年没有人做这个题了。但是这个问题又是一个多种解法，

并且很经典的问题。今天这个问题同样又出现了。

仍然是一个长度为n(n <= 500000)的数组，将其变成递增序列。

冒泡的思想大家都会，每次比较相邻两个数的大小。如果想要得到递增序列，那么前一个数字大于后一个

数字就要把他们交换一下位置，经过很多趟就能得到想要的递增序列。

这次我们的要求有些改变，不再判断是不是会超时，而是计算出需要交换多少次才能将这个数组变成一个有序的数组（递增）。

Input

本题测试数据多组测试数据，对于每组测试数据第一行一个整数n，表示这个序列有n个数，接下来n行，每行一个整数ai（0<=ai<=999999999）。
当n等于0时，输入结束，这组数据不做处理。

Output

对于每组数据，输出一个整数，表示交换的次数。

Sample Input

5
9
1
0
5
4
3
1
2
3
0

Sample Output

Source

2014 Winter Holiday Contest 4

冒泡排排序就是一位位的往后交换

那么这题不就符合逆序数的问题了？

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
struct data
{
    long long n;
    long long pos;
} x[1000003];
long long a[1000033];
long long c[1000003];
long long  n;
bool cmp(data a,data b)
{
    if(a.n==b.n)
        return a.pos<b.pos;
        return a.n<b.n;
}
long long lowbit(long long x)
{
    return x&(-x);
}
void update(long long x)
{
    while(x<=n)
    {
        c[x]+=1;
        x+=lowbit(x);
    }
}
long long getsum(long long x)
{
    long long sum=0;
    while(x>0)
    {
        sum+=c[x];
        x-=lowbit(x);
    }
    return sum;
}
int main()
{
    while(scanf("%d",&n)==1&&n)
    {

        memset(c,0,sizeof(c));
        for(long long i=1; i<=n; i++)
        {
            scanf("%lld",&x[i].n);
            x[i].pos=i;
        }
        sort(x+1,x+1+n,cmp);
        long long res=0;
        for(long long i=1; i<=n; i++)
        {
            a[x[i].pos]=i;
        }
        for(int i=1; i<=n; i++)
        {
            update(a[i]);
            res+=(i-getsum(a[i]));
        }
        printf("%lld\n",res);
    }
}