CS Academy Sorting Step

题目链接：https://csacademy.com/contest/archive/task/sorting-steps

题目大意：求冒泡排序的总趟数。一趟冒泡排序能够将最大的数字交换到序列尾部。详见题目描述。

解题思路：这个题最主要的一方面就是要能够观察到，每一趟之后对于位置i的数字a[i]会与其左边最大的那个值交换。那么只需要求出来每个数左边比他大的数的个数然后取其最大值再+1即可。那么如何计算左边比他大的数字的个数呢？如果写过逆序数的可能知道其实是可以使用树状数组的。由于本题数据大小为1e9，因此先离散化，之后用树状数组记录每个数字出现的次数的前缀和，这样便可以在log(N)时间内查询得到。核心代码：

for(int i = 1; i <= n; i++){
        int u = mmp[a[i]];//离散化后的值
        int tmp = sum(m) - sum(u);//比u大的数字出现了几个
        ans = max(ans, tmp);
        add(u, 1);//记录u出现了一次
    }

另外，假如我们将数组排序，那么，排序后的下标即是该数字前小于等于它的数字的个数，那么原数组的一个数的下标减去排序后这个数字的下标就是它之前大于它的数的个数，然后取最大值即可得到相同的结果。

树状数组 代码：

const int maxn = 1e6 + 5;
int n, a[maxn], sa[maxn];
int bit[maxn];
map<int, int> mmp;
int m;

void add(int x, int v){
    while(x <= m){
        bit[x] += v;
        x += x & (-x);
    }
}
int sum(int x){
    int ans = 0;
    while(x > 0){
        ans += bit[x];
        x -= x & (-x);
    }
    return ans;
}
void solve(){
    memset(bit, 0, sizeof(bit));
    for(int i = 1; i <= n; i++) sa[i] = a[i];
    sort(sa + 1, sa + n + 1);
    m = 1;
    for(int i = 1; i <= n; i++) 
        if(mmp[sa[i]] == 0) 
            mmp[sa[i]] = m++;
    int ans = 0;
    for(int i = 1; i <= n; i++){
        int u = mmp[a[i]];
        int tmp = sum(m) - sum(u);
        ans = max(ans, tmp);
        add(u, 1);
    }
    printf("%d
", ans + 1);
}
int main(){
    scanf("%d", &n);
    for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
    solve();
}

排序代码 ：

const int maxn = 1e6 + 5;
int n;
int a[maxn], sa[maxn];

void solve(){
    for(int i = 0; i < n; i++) sa[i] = a[i];
    sort(sa, sa + n);
    int ans = 0;
    for(int i = 0; i < n; i++){
        int u = upper_bound(sa, sa + n, a[i]) - sa - 1;
        ans = max(i - u, ans);
    }
    printf("%d
", ans + 1);
}
int main(){
    scanf("%d", &n);
    for(int i = 0; i < n; i++) scanf("%d", &a[i]);
    solve();
}

题目：

Sorting Steps

Time limit: 1000 ms
Memory limit: 128 MB

 

One of the most famous sorting algorithms is the bubble sort. Consider the following C++ code:

1

2

3

4

5

6

7

8

9

10

11

12

 

 

 

int steps = 0;

while (true) {

++steps;

bool isSorted = true;

for (int i = 1; i < N; ++i)

if (A[i] > A[i + 1]) {

swap(A[i], A[i + 1]);

isSorted = false;

}

if (isSorted) break;

}

 

 

 

 

Here, we are sorting array AA of size NN, where AA is 1-indexed. You should find the value of steps at the end of the algorithm.

Standard input

The first line contains a single integer NN.

The second line contains NN integers representing the elements of AA.

Standard output

Print the answer on the first line.

Constraints and notes

• 1 leq N leq 10^51≤N≤10​5​​ 
• 1 leq A_i leq 10^91≤A​i​​≤10​9​​ 

Input	Output	Explanation
4 1 3 4 2	3	The array at each step: 1 2 3 4       1 3 4 2 1 3 2 4 1 2 3 4
4 1 2 3 4	1	1 2       1 2 3 4
4 4 3 2 1	4	1 2 3 4 5       4 3 2 1 3 2 1 4 2 1 3 4 1 2 3 4
4 3 7 4 3	3	1 2 3 4       3 7 4 3 3 4 3 7 3 3 4 7