[SMOJ1700]数组排序

题目描述

某数组，包含$n$个整数，每个整数$X$都满足：$1 \leq X \leq N$，而且数组的每个整数都不会重复出现。 Frane 用以下的算法对数组排序 ：

算法共$n$个步骤：

• 第一步： 通过交换相邻的元素，把１移动到数组的第一个位置
• 第二步： 通过交换相邻的元素，把$n$移动到数组的最后一个位置.
• 第三步： 通过交换相邻的元素，把2移动到数组的第二个位置.
• 第四步： 通过交换相邻的元素,把$n-1$移动到数组的倒数第二个位置.
• 第五步： 通过交换相邻的元素，把3移动到数组的第三个位置.
• 第四步： 通过交换相邻的元素,把$n-2$移动到数组的倒数第三个位置.
……

你的任务：对于给定的数组，上述算法每个步骤需要交换元素的次数。

输入格式 1700.in

第一行：一个整数 $n$， ($1 \leq n \leq 100000$)，数组元素的个数。
接下来有$n$行，分别代表数组的第一个数、第二个数、……第$n$个数
数组不会有重复数据。

输出格式 1700.out

$n$行，第$i$行表示在上述算法的第$i$个步骤中，元素交换的次数。

数据范围

对于70%的测试数据，$n < 100$。

输入样例 1700.in

输入样例一：
3
2
1
3

输入样例二：
5
5
4
3
2
1

输入样例三：
7
5
4
3
7
1
2
6

输出样例 1700.out

输出样例一：
1
0
0

输出样例二：
4
3
2
1
0

输出样例三：
4
2
3
0
2
1
0

---

题目已经明确给出了步骤，因此朴素的$O(n^2)$模拟很容易写，期望得分是70分。

但是，正解却不是比较好想的，需要把思维稍微变化。在此之前，我曾经考虑过基于维护数字偏移量的做法，但是却是很麻烦的，不容易写。在lws靓仔的点拨下，另一种简单易懂的做法诞生了。后来想想，我觉得可以用快速排序的过程来帮助我们理解。

在快速排序算法中，我们不断对当前的待排序区间先进行初步的划分，然后对子区间进一步处理。对于已经确定了的部分，就不再进行改动了。而这种思想也可以移植到本题上。

先预处理出每个数字所在的位置$pos_i$。最初，所有元素都在它们的原始位置。第一步，我们把1移到第1位。移动所需的步数很容易算，就是$pos_1-1$。在模拟的做法中，算完这步之后，我们需要把原先位置在$[1, pos_1)$的数都向右移一位。这样显然会浪费大量时间。

我们不妨换个思路。其实把1移到第1位之后，要移动的那些数之间的相对位置关系并没有发生改变。而1在完成移动之后，就一直固定在这个位置，之后发生的所有都跟它无关了。

既然如此，我们为什么要移动数字的位置呢？为什么不干脆把已经完成移动的1直接变成0呢？这样一来，后面每次要统计数字j的移动步数的时候，就只需计算出$(min(j, pos_j), max(j, pos_j))$区间里非0的个数就可以了。对于之前完成移动的数，我们可以将其看作移到了数组外，与当前的移动之间不产生影响。

整理一下，大致是：

1. 先预处理出每个数字所在的位置；
2. 对于每个要移动的数字$j$，统计$(min(j, pos_j), max(j, pos_j))$区间里非0的个数（区间查询）；
3. 将当前数修改为0（单点修改）。

于是很显然又可以用树状数组或者线段树进行维护。

参考代码：

#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>

using namespace std;

const int maxn = 1e5 + 10;

struct SegT {
    int val;
    int lch, rch;
} tree[maxn << 2];

int n;
int a[maxn], p[maxn];

void build(int l, int r, int root) {
    if (l == r) { tree[root].val = 1; return; }
    int mid = l + r >> 1;
    build(l, mid, tree[root].lch = root << 1);
    build(mid + 1, r, tree[root].rch = tree[root].lch + 1);
    tree[root].val = tree[tree[root].lch].val + tree[tree[root].rch].val;
}

int query(int ql, int qr, int l, int r, int root) {
    if (ql > qr || ql < l || qr > r) return 0;
    if (ql <= l && r <= qr) return tree[root].val;
    int mid = l + r >> 1;
    if (qr <= mid) return query(ql, qr, l, mid, tree[root].lch);
    else if (mid < ql) return query(ql, qr, mid + 1, r, tree[root].rch);
    return query(ql, mid, l, mid, tree[root].lch) + query(mid + 1, qr, mid + 1, r, tree[root].rch);
}

void update(int upd, int l, int r, int root) {
    if (l == upd && upd == r) { tree[root].val = 0; return; }
    int mid = l + r >> 1;
    if (upd <= mid) update(upd, l, mid, tree[root].lch);
    else update(upd, mid + 1, r, tree[root].rch);
    tree[root].val = tree[tree[root].lch].val + tree[tree[root].rch].val;
}

int main(void) {
    freopen("1700.in", "r", stdin);
    freopen("1700.out", "w", stdout);
    scanf("%d", &n);
    for (int i = 1; i <= n; i++) {
        scanf("%d", &a[i]);
        p[a[i]] = i;
    }
    build(1, n, 1);
    for (int i = 0; i < n; i++) {
        int mov = i & 1 ? n - (i >> 1) : (i >> 1) + 1;
        printf("%d\n", i & 1 ? query(p[mov] + 1, n, 1, n, 1) : query(1, p[mov] - 1, 1, n, 1));
        update(p[mov], 1, n, 1);
    }
    return 0;
}