多校4 5775 Bubble Sort

最新推荐文章于 2025-03-07 11:48:34 发布

原创最新推荐文章于 2025-03-07 11:48:34 发布 · 371 阅读

0 ·

CC 4.0 BY-SA版权

树状数组专栏收录该内容

1 篇文章

订阅专栏

本文探讨了冒泡排序过程中每个元素从初始位置到最终排序位置的变化情况，通过使用树状数组记录并计算每个元素到达最左端和最右端位置的差值。

Bubble Sort

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

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

Sample Output

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

HintIn 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.

题意：问排序过程中，每个元素到达最左端和最右端位置的差。

思路：查询树状数组。每次加进去一个元素，就差一下他前面有几个，这样就知道之前比他小的有几个，减一下就是后面比他小的，也就是他需要右偏的次数即最右端，最左端可能是他最初的位置也可能是他应该在的位置。

代码：

#include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <set>
 
using namespace std;

int P[100000 + 10],ans[100000 + 10];
long long sum[100000 + 10];
long long pm[100000 + 10];

int lowbit(int x)
{
    return x&-x;
}
long long premin(int x)
{
     long long s = 0;
     while(x)
     {
             s += sum[x];
             x -= lowbit(x);
     }
     return s;
} 
int main()
{
    int t;
    scanf("%d",&t);
    int cas = t;
    while(t--)
    {
         int n;
         scanf("%d",&n);
         memset(sum,0,sizeof sum);
         for(int i = 1; i <= n; i++)
         {
                 scanf("%d",&P[i]);
                 ans[P[i]] = i;          //记录每个元素最初的位置
                 int temp = P[i];
                 while(temp <= n)
                 {
                       sum[temp] += 1;
                       temp += lowbit(temp);        //向后更新
                 }
                 pm[P[i]] = premin(P[i]);             //算他之前的和即原位置前面比他小的元素的个数
         }
         printf("Case #%d:",cas-t);
         for(int i = 1; i <= n; i++)
              printf(" %d",ans[i]+(i-pm[i])-min(ans[i],i)); 
         printf("\n");
    }
    return 0;
}