codeforces-675D Tree Construction

大致题意：输入n个不相同的数，依次插入bst中，输出最后每个数对应节点的父亲

思路一：

bst的中序遍历是有序的，所以每一棵子树对应有序序列的一个区间。
先将原序列排序，按插入顺序取没有处理的节点，找到它在有序序列里的位置p，假定它的父亲所表示子树的范围是[l,r]，那么[l,p-1]和[p+1,r]分别成为p的左右子树，[l,p-1]和[p+1,r]的父亲由p的父亲更改为p。
所以需要一个支持区间修改的数据结构来维护节点的父亲，线段树就可以解决。同时这样做还需要离散化，需要记录每个节点表示的子树的范围区间。

#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 7;
struct Range {
    int l, r;
    void setrg(int l, int r) {
        this->l = l;
        this->r = r;
    }
};
struct SegTree {
    int fa[N << 2];
    void pushdown(int rt) {
        if (fa[rt]) {
            fa[rt << 1] = fa[rt << 1 | 1] = fa[rt];
            fa[rt] = 0;
        }
    }
    void update(int L, int R, int x, int l, int r, int rt) {
        if (L > R) {
            return;
        }
        if (L <= l && r <= R) {
            fa[rt] = x;
            return;
        }
        int m = l + r >> 1;
        pushdown(rt);
        if (L <= m) update(L, R, x, l, m, rt << 1);
        if (R > m) update(L, R, x, m + 1, r, rt << 1 | 1);
    }
    int query(int p, int l, int r, int rt) {
        if (l == r) {
            return fa[rt];
        }
        int m = l + r >> 1;
        pushdown(rt);
        if (p <= m) return query(p, l, m, rt << 1);
        return query(p, m + 1, r, rt << 1 | 1);
    }
};
SegTree st;
Range rg[N][2];
int ans[N], fa, n, a[N], b[N], p;
int main() {
    cin >> n;
    for (int i = 1; i <= n; i++) {
        scanf("%d", a + i);
        b[i] = a[i];
    }
    sort(b + 1, b + 1 + n);
    for (int i = 1; i <= n; i++) {
        a[i] = lower_bound(b + 1, b + 1 + n, a[i]) - b;
    }
    rg[a[1]][0].setrg(1, a[1] - 1);
    rg[a[1]][1].setrg(a[1] + 1, n);
    st.update(1, a[1] - 1, a[1], 1, n, 1);
    st.update(a[1] + 1, n, a[1], 1, n, 1);
    for (int i = 2; i <= n; i++) {
        ans[i] = fa = st.query(a[i], 1, n, 1);
        rg[a[i]][0].setrg(rg[fa][a[i] > fa].l, a[i] - 1);
        rg[a[i]][1].setrg(a[i] + 1, rg[fa][a[i] > fa].r);
        st.update(rg[fa][a[i] > fa].l, a[i] - 1, a[i], 1, n, 1);
        st.update(a[i] + 1, rg[fa][a[i] > fa].r, a[i], 1, n, 1);
    }
    for (int i = 2; i <= n; i++) {
        printf("%d%c", b[ans[i]], " \n"[i == n]);
    }
    return 0;
}

思路二：

在bst中插入一个数x，假设bst中比x小的是a，比x大的是b，如果b比a先插入，那么x成为a的右孩子，如果a比b先插入，那么x成为b的左孩子。因为连续的三个数只能是如下情况：

(1)  a      (2)  b
      \         /
       b       a
      /         \
     x           x

需要注意下边界

#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int n, x, ans;
int main() {
    cin >> n >> x;
    mp[-1] = 0;
    mp[x] = 1;
    for (int i = 2; i <= n; i++) {
        scanf("%d", &x);
        auto it = mp.lower_bound(x), _it = it;
        _it--;
        if (it != mp.end() && it->second > _it->second) {
            ans = it->first;
        }
        else {
            ans = _it->first;
        }
        printf("%d%c", ans, " \n"[i == n]);
        mp[x] = i;
    }
    return 0;
}

思路三：

维护bst中每个节点x的右子树的“最左节点”b。在需要插入y时，找到比它小的最大的数x，那么就可以直接把它插入到b下面。可以使用一个map来维护。

     x                   x
      \                   \
       a                   a
      / \                 / \
    ... ...             ... ...
    /                   /
   b                   b
                      /
                     y

#include <bits/stdc++.h>
using namespace std;
map<int, int> mp;
int n, x;
int main() {
    cin >> n >> x;
    mp[-1] = mp[x] = x;
    for (int i = 1; i < n; i++) {
        scanf("%d", &x);
        auto it = mp.lower_bound(x);
        it--;
        printf("%d%c", it->second, " \n"[i == n - 1]);
        mp[it->first] = mp[x] = x;
    }
    return 0;
}