HDU 5775 Bubble Sort

Bubble Sort

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

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.

   
   
   
    
  
  

先考虑 i 能移动到的最右边的距离：假设这个位置之后有 x 个数比 i 小,那么 x 能移动到的最右边的距离就是i原来的位置 +x（因为在 i 右边的且比 i 小的值都要移动到 i 的前面）；求X时用类似于用树状数组求逆序数的方法来求。  

再考虑i能移动到的最左边的距离,因为每次冒泡排序都是把最小的值移动到最前面,所以如果i的后面有数比 i 小,那么轮不到 i 向左移动,如果i后面的数都比 i 大,那么 i 也肯定不能向左移动，因为 i 前面的数一定都比 i 小,所以最左边的答案为 min（i 原来的位置，i 所应该在的位置）。

AC代码：

 

#include <set>
#include <map>
#include <stack>
#include <cmath>
#include <queue>
#include <cstdio>
#include <bitset>
#include <string>
#include <vector>
#include <iomanip>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <functional>
#define maxn 100010
using namespace std;
int a[maxn];
int n,m;
int c[maxn]; //树状数组
//q[]记录初始位置 ; p[]记录某个数后面比它小的的数的个数
int p[maxn],q[maxn];
int lowbit(int x)
{
        return x & (-x);
}
void  update(int i,  int x)
{
        while (i <= n)
        {
                c[i] = c[i] + x;
                i += lowbit(i);
        }
}
int sum(int i)
{
        int  ans = 0;
        while (i > 0)
        {
                ans += c[i];
                i -= lowbit(i);
        }
        return ans;
}
int main()
{
        int t;
        scanf("%d", &t);
        for (int tt = 1; tt <= t; tt++)
        {
                scanf("%d",&n);
                memset(c,0,sizeof(c));
                memset(p,0,sizeof(p));
                memset(q,0,sizeof(q));
                for(int i=1;i<=n;i++)
                {
                        scanf("%d",&a[i]);
                        q[a[i]]=i;  //记录初始位置
                }
                for(int i=n;i>=1;i--) //记录在a[i]后面比a[i]小的数的个数
                {
                        update(a[i],1);
                        p[a[i]]=(sum(a[i]-1));
                }
                printf("Case #%d:",tt);
                for(int i=1;i<=n;i++)
                {
                        printf(" %d",abs(p[i]+q[i]-min(q[i],i)));
                }
                printf("\n");
        }
        return 0;
}