2016 Multi-University Training Contest 4 hdu 5775 Bubble Sort【树状数组+思维】-优快云博客

本文探讨了一种特殊的冒泡排序过程，分析了每个数字在排序过程中所能达到的最左或最右位置与其初始位置的差值，并提供了一种使用树状数组进行优化的有效算法。

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

Bubble Sort

Time Limit: 2000/1000 MS (Java/Others) Memory Limit: 65536/65536 K (Java/Others)
Total Submission(s): 24 Accepted Submission(s): 18

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

3 1 2

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.

Author

FZU

题目大意：

给你一个长度为n的序列，求该序列在以上冒泡排序代码中，每一个数字能够到达的最左边或最右边与当前所在的位子差值。

思路：

1、其当前数字所在位子能够向右走的步数就是其数字所在位子右边一共有多少个数比他小。

2、那么同理，其当前数字所在位子能够向左走的步数就是其数字所在位子左边一共有多少个数比他大。

3、那么不难理解：ans=max（当前位子能够向左走的步数，当前位子能够向右走的步数）

4、如果n^2求这个步数显然不行，用树状数组优化之即可。

Ac代码：

#include<stdio.h>
#include<string.h>
#include<iostream>
using namespace std;
int a[100005];
int tree[100005];//树
int zuo[100005];
int you[100005];
int ans[100005];
int n;
int lowbit(int x)//lowbit
{
    return x&(-x);
}
int sum(int x)//求和求的是比当前数小的数字之和，至于这里如何实现，很简单：int sum=sum(a[i])；
{
    int sum=0;
    while(x>0)
    {
        sum+=tree[x];
        x-=lowbit(x);
    }
    return sum;
}
void add(int x,int c)//加数据。
{
    while(x<=n)
    {
        tree[x]+=c;
        x+=lowbit(x);
    }
}
int main()
{
    int t;
    int kase=0;
    scanf("%d",&t);
    while(t--)
    {
        scanf("%d",&n);
        memset(tree,0,sizeof(tree));
        for(int i=1;i<=n;i++)
        {
            scanf("%d",&a[i]);
        }
        for(int i=n;i>=1;i--)
        {
            you[a[i]]=sum(a[i]);
            add(a[i],1);
        }
        memset(tree,0,sizeof(tree));
        for(int i=1;i<=n;i++)
        {
            zuo[a[i]]=sum(n)-sum(a[i]);
            add(a[i],1);
            ans[a[i]]=max(zuo[a[i]],you[a[i]]);
        }
        printf("Case #%d:",++kase);
        for(int i=1;i<=n;i++)
        {
            printf(" %d",ans[i]);
        }
        printf("\n");
    }
}