HDU 5775 树状数组

Bubble Sort

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

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.

 

Author

FZU

 

Source

2016 Multi-University Training Contest 4

 

题意：冒泡排序中  求每一个位置的上的数 移动的最左端与最右端的距离差值

题解：因为在冒泡排序中，每次都将序列中最小的数向前移动，所以位置i上的数只会与在它之后的并小于它的数交换

树状数组倒序遍历求求小于i位置数的个数x  所有最右端为r=i+x;对于左边界l=min(原位置,升序排列之后的位置);

但是注意 此题中的n个数都是不同的

可以这么想,在一次冒泡过程中,只有当前未排序的最大元素才有可能向右移动,其余元素均会向左移动;

那么一个元素ai 的最左端位置为l= i-num(左端比ai大的数的个数) r=max(原位置,升序排列之后的位置）

两种思路都是可以的 代码是按照第二种写的的

 

另外,刚开始有一个错误的思路 

两次使用树状数组,记录ai左边大于ai的个数xl，ai右边小于的ai的个数xr

l=i-xl;  r=i+xr

hack 数据

5

5 4 2 3 1

 /******************************
 code by drizzle
 blog: www.cnblogs.com/hsd-/
 ^ ^    ^ ^
  O      O
 ******************************/
 //#include<bits/stdc++.h>
 #include<iostream>
 #include<cstring>
 #include<cstdio>
 #include<map>
 #include<algorithm>
 #include<queue>
 #include<cmath>
 #define ll __int64
 #define PI acos(-1.0)
 #define mod 1000000007
 using namespace std;
 #define NN 100000
 int tree[];
 int t;
 int n;
 int a[];
 struct node
 {
     int l;
     int r;
 } N[],MM[];
 struct pan{
  int v;
  int pos;
 }M[];
 bool cmp(struct pan aa,struct pan bb)
 {
     return aa.v<bb.v;
 }
 int lowbit(int t)
 {
     return t&(-t);
 }
 void add(int i,int v)
 {
     for(; i<=NN; i+=lowbit(i))
         tree[i]+=v;
 }
 int sum(int i)
 {
     int ans=;
     for(; i>; i-=lowbit(i))
         ans+=tree[i];
     return ans;
 }
 int main()
 {
     while(~scanf("%d",&t))
     {
         for(int i=; i<=t; i++)
         {
             scanf("%d",&n);
             for(int j=; j<=n; j++)
             {
                 scanf("%d",&a[j]);
                 M[j].pos=j;
                 M[j].v=a[j];
                 N[j].l=j;
                 N[j].r=j;
             }
             for(int j=; j<=n; j++)
                 tree[j]=;
             for(int j=; j<=n; j++)
             {
                 add(a[j],);
                 N[j].l=N[j].l-(j-sum(a[j]));
             }
             sort(M+,M++n,cmp);
             for(int j=;j<=n;j++)
                 N[M[j].pos].r=max(j,N[M[j].pos].r);
             for(int j=;j<=n;j++)
             {
                 MM[a[j]].l=N[j].l;
                 MM[a[j]].r=N[j].r;
             }
             for(int j=; j<=n; j++)
             {
                 if(j==)
                     printf("Case #%d: %d",i,MM[j].r-MM[j].l);
                 else
                     printf(" %d",MM[j].r-MM[j].l);
             }
             printf("\n");
         }
     }
     return ;
 }