（HDU - 5775）Bubble Sort

最新推荐文章于 2019-08-11 21:43:01 发布

原创最新推荐文章于 2019-08-11 21:43:01 发布 · 533 阅读

1 ·

CC 4.0 BY-SA版权

文章标签：

#hdu

树状数组专栏收录该内容

6 篇文章

订阅专栏

本文探讨了在冒泡排序过程中，每个元素从初始位置到最终排序完成时所达到的最左与最右位置，并计算两者之间的差距。通过构建特定的数据结构，实现了高效的计算方法。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

（HDU - 5775）Bubble Sort

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)

Total Submission(s): 1574 Accepted Submission(s): 833

Problem Description

P is a permutation of the integers from 1 to N(index starting from 1).
Here is the code of Bubble Sort in C++.

for(int i=1;i<=N;++i)
for(int j=N,t;j>i;—j)
if(P[j-1] > P[j])
t=P[j],P[j]=P[j-1],P[j-1]=t;

After the sort, the array is in increasing order. ?? wants to know the absolute values of difference of rightmost place and leftmost place for every number it reached.

Input

The first line of the input gives the number of test cases T; T test cases follow.
Each consists of one line with one integer N, followed by another line with a permutation of the integers from 1 to N, inclusive.

limits
T <= 20
1 <= N <= 100000
N is larger than 10000 in only one case.

Output

For each test case output “Case #x: y1 y2 … yN” (without quotes), where x is the test case number (starting from 1), and yi is the difference of rightmost place and leftmost place of number i.

Sample Input

2
3
3 1 2
3
1 2 3

Sample Output

Case #1: 1 1 2
Case #2: 0 0 0

Hint

In first case, (3, 1, 2) -> (3, 1, 2) -> (1, 3, 2) -> (1, 2, 3)
the leftmost place and rightmost place of 1 is 1 and 2, 2 is 2 and 3, 3 is 1 and 3
In second case, the array has already in increasing order. So the answer of every number is 0.

题目大意：问一个数字序列中，每一个数再进行冒泡排序的过程中，出现的最右边位置和最左边位置的差是多少。

思路：用a[i]记录这一序列，因为数字和下标都是1到n，所以a[i]中i表示没有排序前的位置，a[i]表示排序后的位置，显然最左边的位置l=min(i,a[i])，而最右边的位置是看右边有多少个数小于a[i]，那么这个数就可以往右移几位。如果根据普通逆序数的模板来求，那么i-getsum(a[i])表示逆序数，那么n-a[i]-(i-getsum(a[i]))表示a[i]后面有多少大于a[i]的数，那么n-i-(n-a[i]-(i-getsum(a[i])))就是后面小于a[i]的数化简可得为a[i]-getsum(a[i])，最后到达的位置便是i+a[i]-getsum(a[i])。其实也可以不用这么推，直接在进行计算时就算出后面有多少个比a[i]小的数，然后计算即可。

根据逆序数模板：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int maxn=100005;
int a[maxn],c[maxn],ans[maxn];
int n;

int lowbit(int x)
{
    return x&-x;
}

void update(int x,int d)
{
    for(;x<=n;x+=lowbit(x)) c[x]+=d;
}

int getsum(int x)
{
    int sum=0;
    for(;x>0;x-=lowbit(x)) sum+=c[x];
    return sum;
}

int main()
{
    int T,kase=0;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        memset(c,0,sizeof(c));
        for(int i=1;i<=n;i++) scanf("%d",a+i);
        for(int i=1;i<=n;i++)
        {
            update(a[i],1);
            int l=min(i,a[i]);
            int r=max(i,i+a[i]-getsum(a[i]));
            ans[a[i]]=abs(r-l);
        }
        printf("Case #%d:",++kase);
        for(int i=1;i<=n;i++) printf(" %d",ans[i]);
        printf("\n");
    }
    return 0;
}

直接推：

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;

const int maxn=100005;
int a[maxn],c[maxn],xiao[maxn],ans[maxn];
int n;

int lowbit(int x)
{
    return x&-x;
}

void update(int x,int d)
{
    for(;x<=n;x+=lowbit(x)) c[x]+=d;
}

int getsum(int x)
{
    int sum=0;
    for(;x>0;x-=lowbit(x)) sum+=c[x];
    return sum;
}

int main()
{
    int T,kase=0;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d",&n);
        memset(c,0,sizeof(c));
        for(int i=1;i<=n;i++) scanf("%d",a+i);
        for(int i=n;i>=1;i--) 
        {
            update(a[i],1);
            xiao[a[i]]=getsum(a[i]-1);
        }
        for(int i=1;i<=n;i++)
        {
            int l=min(i,a[i]);
            int r=i+xiao[a[i]];
            ans[a[i]]=abs(r-l);
        }
        printf("Case #%d:",++kase);
        for(int i=1;i<=n;i++) printf(" %d",ans[i]);
        printf("\n");
    }
    return 0;
}