技術標籤：# 平衡樹資料結構平衡樹splayacm競賽演算法

題目連結: 排序機械臂

大致題意

給定一個長度為n的序列, 需要進行n次交換操作. 第i次操作需要將區間[i, pi]進行翻轉, 其中pi表示序列第i小的數字的下標.

特別的, 如果序列中有重複的元素, 則認為在初始序列中下標小的數字更小.

解題思路

題目中由於涉及到了區間翻轉, 我們應當聯想到是否可以採用==平衡樹==解決該問題.

首先有個疑問, 我們應當如何維護序列? 怎麼來維護序列? (下面描述先不考慮有重複元素的情況)

因為每次我們需要找到序列中第k小的數字, 然後進行區間翻轉. 於是我們考慮兩種維護序列的方式

①如果我們在平衡樹中維護題目中給定的序列, 那麼我們如何找到區間中第k小的數字?

我們發現好像 找區間第k小的數字 和 區間翻轉 並不能同時得到處理. (可能剛學平衡樹太菜了, 我看網上別的大佬並沒有糾結如何去維護這個序列)

其實冷靜下來分析, 我們必須依靠平衡樹來實現區間翻轉, 因此我們只能採用①的方法來維護這個序列, 而找到區間第k小, 我們需要進行一步思路轉化.

如果單純依靠平衡樹, 來處理這樣的一個==動態區間第k小數問題, 好像是不可能的. 但是這個題有一個特點: 第i次操作後, [1, i]區間一定是從小到大排列好的, 而第i + 1次操作時, 我們不妨看成在[i + 1, n]區間找到最小的數字

那麼對於這樣的一個問題, 我們可以通過在樹內部維護一個fmin, 表示當前區間的最小值是多少. 通過遞迴左右子樹的方式, 我們可以在logn的複雜度內找到那個節點.

這樣整個題的思路就十分清晰了. 唯一我們還沒有解決的問題就是, 題目中可能會有重複元素的情況.

其實這個問題解決起來很簡單, 給原來的序列排個序即可, 但是要求採用穩定排序的方式, 最後給原序列每個位置分配一個新的值即可.

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