排序机械臂(splay)

题目链接: 排序机械臂

大致题意

给定一个长度为n的序列, 需要进行n次交换操作. 第i次操作需要将区间[i, pi]进行翻转, 其中pi表示序列第i小的数字的下标.

特别的, 如果序列中有重复的元素, 则认为在初始序列中下标小的数字更小.

解题思路

题目中由于涉及到了区间翻转, 我们应当联想到是否可以采用==平衡树==解决该问题.

首先有个疑问, 我们应当如何维护序列? 怎么来维护序列? (下面描述先不考虑有重复元素的情况)

因为每次我们需要找到序列中第k小的数字, 然后进行区间翻转. 于是我们考虑两种维护序列的方式

①如果我们在平衡树中维护题目中给定的序列, 那么我们如何找到区间中第k小的数字?
②如果我们在平衡树中从小到大维护序列值, 那么又如何实现区间翻转操作?

我们发现好像 找区间第k小的数字 和 区间翻转 并不能同时得到处理. (可能刚学平衡树太菜了, 我看网上别的大佬并没有纠结如何去维护这个序列)(注: 由于本题的特殊性, 是可以一起实现这两个操作的, 见2021.3更新)

其实冷静下来分析, 我们必须依靠平衡树来实现区间翻转, 因此我们只能采用①的方法来维护这个序列, 而找到区间第k小, 我们需要进行一步思路转化.

如果单纯依靠平衡树, 来处理这样的一个==动态区间第k小数问题, 好像是不可能的. 但是这个题有一个特点: 第i次操作后, [1, i]区间一定是从小到大排列好的, 而第i + 1次操作时, 我们不妨看成在[i + 1, n]区间找到最小的数字, 这样一个上述问题就转换成了动态区间找最小值==的问题.

那么对于这样的一个问题, 我们可以通过在树内部维护一个fmin, 表示当前区间的最小值是多少. 通过递归左右子树的方式, 我们可以在logn的复杂度内找到那个节点.

这样整个题的思路就十分清晰了. 唯一我们还没有解决的问题就是, 题目中可能会有重复元素的情况.

其实这个问题解决起来很简单, 给原来的序列排个序即可, 但是要求采用稳定排序的方式, 最后给原序列每个位置分配一个新的值即可.

2021.3更新:

本次进行代码优化, 我们可以通过开一个额外数组的方式, 来记录第i小的值在平衡树中的节点编号.

这样 每次操作前, 我们可以把第i小的数字转到根结点, 然后其左子树的大小+1便是其所处的位置.

更新代码: https://pasteme.cn/111743

AC代码

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E5 + 10, INF = 0x3f3f3f3f;
pair<int, int> a[N]; //原序列数组, 为了保证稳定排序, 所以采用pair

int w[N]; //用于建树, 记录每个位置的初值
struct node {
    int s[2], p, v;
    int size, fmin;
    bool flag; //是否翻转区间
    
    void init(int _p, int _v) {
        s[0] = s[1] = 0; p = _p, v = _v;
        size = 1, fmin = INF;
        flag = 0;
    }
}t[N]; int root, ind;
void pushdown(node& op, bool flag) { //表示翻转当前区间(flag可以不传)
    swap(op.s[0], op.s[1]);
    op.flag ^= 1;
}
void pushdown(int x) {
    if (!t[x].flag) return;
    pushdown(t[t[x].s[0]], 1), pushdown(t[t[x].s[1]], 1);
    t[x].flag = 0;
}

void pushup(int x) {
    node& p = t[x], &l = t[t[x].s[0]], &r = t[t[x].s[1]];
    p.size = l.size + r.size + 1;
    p.fmin = min(min(l.fmin, r.fmin), p.v);
}

void rotate(int x) {
    int y = t[x].p, z = t[y].p;
    pushdown(y), pushdown(x);
    int k = t[y].s[1] == x;
    t[y].s[k] = t[x].s[k ^ 1], t[t[x].s[k ^ 1]].p = y;
    t[x].s[k ^ 1] = y, t[y].p = x;
    t[z].s[t[z].s[1] == y] = x, t[x].p = z;
    pushup(y), pushup(x);
}

void splay(int x, int k) {
    while (t[x].p != k) {
        int y = t[x].p, z = t[y].p;
        if (z != k) (t[y].s[1] == x) == (t[z].s[1] == y) ? rotate(y) : rotate(x);
        rotate(x);
    }
    if (!k) root = x;
}

int getk(int k) {
    int x = root;
    while (x) {
        pushdown(x); int cou = t[t[x].s[0]].size;
        if (cou >= k) x = t[x].s[0];
        else if (cou + 1 == k) return x;
        else k -= cou + 1, x = t[x].s[1];
    }
    assert(0);
}

int build(int l, int r, int p = root) {
    int mid = l + r >> 1;
    int x = ++ind; t[x].init(p, w[mid]);
    if (l < mid) t[x].s[0] = build(l, mid - 1, x);
    if (r > mid) t[x].s[1] = build(mid + 1, r, x);
    pushup(x);
    return x;
}

int findmin(int x) { //找到当前子树的最小值
    while (x) {
        pushdown(x);
        if (t[x].v == t[x].fmin) return x;
        if (t[t[x].s[0]].fmin == t[x].fmin) x = t[x].s[0];
        else x = t[x].s[1];
    }
    assert(0);
}

int getnext(int x) { //找到根节点的后继
    x = t[x].s[1];
    while (t[x].s[0]) pushdown(x), x = t[x].s[0];
    return x;
}
int main()
{
    int n; cin >> n;
    rep(i, n) scanf("%d", &a[i].first), a[i].second = i;
    sort(a + 1, a + 1 + n);
    
    t[0].fmin = t[0].v = INF; //特别的要将空节点的值赋为INF, 以免影响fmin的正确性
    rep(i, n) w[a[i].second] = i;
    w[0] = w[n + 1] = INF;
    
    root = build(0, n + 1);
    
    rep(i, n) { //翻转[i, pi]区间
        int l = getk(i); //找到i位置的前一个位置
        splay(l, 0); 
        int index = findmin(t[l].s[1]); //相当于找[i, n]区间的最小值
        splay(index, 0);
        int r = getnext(index); //找到最小值点的后继
        int res = t[t[index].s[0]].size + 1; //记录所处位置
        
        splay(l, 0), splay(r, l); //翻转[l + 1, r - 1]区间
        pushdown(t[t[r].s[0]], 1);
        pushup(r), pushup(l);
        
        printf("%d%c", res - 1, " \n"[i == n]);
    }
    return 0;
}

END