[USACO18OPEN] Out of Sorts G

题解>USACO
2.9k 词

题目描述

DESCRIPTION

Keeping an eye on long term career possibilities beyond the farm, Bessie the cow has started learning algorithms from various on-line coding websites.

Her favorite algorithm thus far is “bubble sort”. Here is Bessie’s initial implementation, in cow-code, for sorting an array AA of length NN.

1
2
3
4
5
6
7
8
sorted = false
while (not sorted):
  sorted = true
  moo
  for i = 0 to N-2:
    if A[i+1] < A[i]:
      swap A[i], A[i+1]
      sorted = false

Apparently, the “moo” command in cow-code does nothing more than print out “moo”. Strangely, Bessie seems to insist on including it at various points in her code.

After testing her code on several arrays, Bessie learns an interesting observation: while large elements can be pulled to the end of the array very quickly, it can take small elements a very long time to “bubble” to the front of the array (she suspects this is how the algorithm gets its name). In order to try and alleviate this problem, Bessie tries to modify her code so that it scans forward and then backward in each iteration of the main loop, so that both large and small elements have a chance to be pulled long distances in each iteration of the main loop. Her code now looks like this:

1
2
3
4
5
6
7
8
9
10
11
12
13
sorted = false
while (not sorted):
  sorted = true
  moo
  for i = 0 to N-2:
    if A[i+1] < A[i]:
      swap A[i], A[i+1]
  for i = N-2 downto 0:
    if A[i+1] < A[i]:
      swap A[i], A[i+1]
  for i = 0 to N-2:
    if A[i+1] < A[i]:
      sorted = false

Given an input array, please predict how many times “moo” will be printed by Bessie’s modified code.

INPUT FORMAT

The first line of input contains NN ( 1≤N≤100,0001 \leq N \leq 100,000 ). The next NN lines describe A[0]…A[N−1]A[0] \dots A[N−1], each being an integer in the range 0…1090 \dots10^9. Input elements are not guaranteed to be distinct.

OUTPUT FORMAT

Print the number of times “moo” is printed.

SAMPLE INPUT

1
2
3
4
5
6
5
1
8
5
3
2

SAMPLE OUTPUT

1
2

Problem credits: Brian Dean

题目大意

求对序列 ana_n 双向冒泡排序的 循环 次数 ( 1≤N≤1051 \leq N \leq 10^5 ).

题解

通过模拟题目所给的程序，我们可以注意到每次循环其实就是将未排序的部分中最小值和最大值分别移到左右端.

对于任意位置的xx，就是将在其前面大于xx的数与在其后面小于xx的数交换，故答案为 maxi=1n{∑j=1i[aj>ai]}max_{i=1}^{n}\{\sum_{j=1}^{i}[a_j>a_i]\} .

我们将序列ana_n进行离散化，可以得到答案是 maxi=1n{∑j=1i[aj>i]}max_{i=1}^{n}\{\sum_{j=1}^{i}[a_j>i]\} ，但是这样的时间复杂度是 O(n2)O(n^2) 并不能通过此题，考虑使用树状数组优化查询第二维，可将时间复杂度降为 O(nlogn)O(nlogn) .

注意: 原本有序的序列也会进行一次循环，答案为 11 .

代码实现

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
#include <bits/stdc++.h>

using namespace std;

const int N = 100000 + 5;

#define val first
#define pos second

int n, a;
pair<int, int> p[N];

struct Tree
{
    int c[N];
    inline int lowbit(int x)
    {
        return x & -x;
    }
    inline void modify(int u)
    {
        for (int i = u; i <= n; i += lowbit(i))
        {
            c[i]++;
        }
    }
    inline int query(int u)
    {
        int res = 0;
        for (int i = u; i; i -= lowbit(i))
        {
            res += c[i];
        }
        return res;
    }
} T;

int main()
{
    scanf("%d", &n);
    for (int i = 1; i <= n; i++)
    {
        scanf("%d", &a);
        p[i] = make_pair(a, i);
    }
    sort(p + 1, p + n + 1);
    // 原数列有序也会moo一次
    int ans = 1;
    for (int i = 1; i <= n; i++)
    {
        T.modify(p[i].pos);
        ans = max(ans, i - T.query(i));
    }
    printf("%d\n", ans);
    return 0;
}