60. 普通平衡树

题目链接

点此跳转

代码1（无旋Treap）

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

#define LL long long
#define mem(a, b) memset(a, b, sizeof a)
#define lowbit(x) (-x&x)
#define IOS ios::sync_with_stdio(false),cin.tie(0)
#define endl '\n'

using namespace std;

const int N = 1e5 + 10;

struct Node {
    int l, r;
    int val, key, size;
}tr[N];

int n, root, idx;

void newnode(int &x, int v) {
    x = ++ idx;
    tr[x].val = v;
    tr[x].key = rand();
    tr[x].size = 1;
}

void pushup(int u) {
    tr[u].size = tr[tr[u].l].size + tr[tr[u].r].size + 1;
}

void split(int u, int v, int &x, int &y) {
    if (!u) {
        x = y = 0;
        return;
    }

    if (tr[u].val <= v) {
        x = u;
        split(tr[u].r, v, tr[u].r, y);
        pushup(x);
    } else {
        y = u;
        split(tr[u].l, v, x, tr[u].l);
        pushup(y);
    }
}

int merge(int x, int y) {
    if (!x || !y) return x + y;
    if (tr[x].key < tr[y].key) {
        tr[x].r = merge(tr[x].r, y);
        pushup(x);
        return x;
    } else {
        tr[y].l = merge(x, tr[y].l);
        pushup(y);
        return y;
    }
}

void insert(int v) {
    int x, y, z;
    split(root, v, x, y);
    newnode(z, v);
    root = merge(merge(x, z), y);
}

void del(int v) {
    int x, y, z;
    split(root, v, x, z);
    split(x, v - 1, x, y);
    y = merge(tr[y].l, tr[y].r);
    root = merge(merge(x, y), z);
}

int getrank(int v) {
    int x, y, res;
    split(root, v - 1, x, y);
    res = tr[x].size + 1;
    root = merge(x, y);
    return res;
}

int getval(int u, int k) {
    if (tr[tr[u].l].size + 1 == k) return tr[u].val;
    else if (k <= tr[tr[u].l].size) return getval(tr[u].l, k);
    else return getval(tr[u].r, k - tr[tr[u].l].size - 1);
}

int getpre(int v) {
    int x, y, res;
    split(root, v - 1, x, y);
    res = getval(x, tr[x].size);
    root = merge(x, y);
    return res;
}

int getne(int v) {
    int x, y, res;
    split(root, v, x, y);
    res = getval(y, 1);
    root = merge(x, y);
    return res;
}

int main() {
    IOS;

    cin >> n;

    int op, x;
    for (int i = 0; i < n; i ++ ) {
        cin >> op >> x;
        if (op == 1) insert(x);
        else if (op == 2) del(x);
        else if (op == 3) cout << getrank(x) << endl;
        else if (op == 4) cout << getval(root, x) << endl;
        else if (op == 5) cout << getpre(x) << endl;
        else cout << getne(x) << endl;
    }

    return 0;
}

代码1（有旋Treap）

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <iostream>
#include <sstream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <stack>
#include <queue>
#include <deque>
#include <bitset>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>

#define LL long long
#define mem(a, b) memset(a, b, sizeof a)
#define lowbit(x) (-x&x)
#define IOS ios::sync_with_stdio(false),cin.tie(0)
#define endl '\n'
#define rev(x) reverse(x.begin(), x.end())

using namespace std;

const int N = 100010;

struct Node {
	int l, r;
	int key, val;
	int num, size;
}tr[N];

int rt, idx, n;

int newnode(int val) {
	int x = ++ idx;
	tr[x].l = tr[x].r = 0;
	tr[x].key = rand();
	tr[x].val = val;
	tr[x].num = tr[x].size = 1;
	return x;
}

void pushup(int p) {
	tr[p].size = tr[tr[p].l].size + tr[tr[p].r].size + tr[p].num;
}

void zig(int &p) {
	int q = tr[p].l;
	tr[p].l = tr[q].r;
	tr[q].r = p;
	tr[q].size = tr[p].size;
	pushup(p);
	p = q;
}

void zag(int &p) {
	int q = tr[p].r;
	tr[p].r = tr[q].l;
	tr[q].l = p;
	tr[q].size = tr[p].size;
	pushup(p);
	p = q;
}

void insert(int &p, int val) {
	if (!p) {
		p = newnode(val);
		return;
	}
	
	tr[p].size ++ ;
	if (val == tr[p].val) {
		tr[p].num ++ ;
		return;
	} else if (val < tr[p].val) {
		insert(tr[p].l, val);
		if (tr[tr[p].l].key > tr[p].key) zig(p);
	} else {
		insert(tr[p].r, val);
		if (tr[tr[p].r].key > tr[p].key) zag(p);
	}
}

void del(int &p, int val) {
	if (!p) return;
	
	tr[p].size -- ;
	if (val == tr[p].val) {
		if (tr[p].num > 1) {
			tr[p].num -- ;
			return;
		}
		if (!tr[p].l || !tr[p].r) {
			p = tr[p].l + tr[p].r;
			return;
		} else if (tr[tr[p].l].key > tr[p].key) {
			zig(p);
			del(tr[p].r, val);
		} else {
			zag(p);
			del(tr[p].l, val);
		}
	} else if (val < tr[p].val) {
		del(tr[p].l, val);
	} else {
		del(tr[p].r, val);
	}
}

int getpre(int val) {
	int p = rt;
	int res = 0;
	while (p) {
		if (tr[p].val < val) {
			res = tr[p].val;
			p = tr[p].r;
		} else p = tr[p].l;
	}
	return res;
}

int getne(int val) {
	int p = rt;
	int res = 0;
	while (p) {
		if (tr[p].val > val) {
			res = tr[p].val;
			p = tr[p].l;
		} else p = tr[p].r;
	}
	return res;
}

int getrank(int p, int val) {
	if (!p) return 0;
	else if (tr[p].val == val) return tr[tr[p].l].size + 1;
	else if (tr[p].val > val) return getrank(tr[p].l, val);
	else return getrank(tr[p].r, val) + tr[tr[p].l].size + tr[p].num;
}

int getval(int p, int k) {
	if (!p) return 0;
	else if (k <= tr[tr[p].l].size) return getval(tr[p].l, k);
	else if (k <= tr[tr[p].l].size + tr[p].num) return tr[p].val;
	else return getval(tr[p].r, k - tr[tr[p].l].size - tr[p].num);
}

void solve() {
	int op, x;
	cin >> n;
	while (n -- ) {
		cin >> op >> x;
		switch(op) {
			case 1:
				insert(rt, x);
				break;
			case 2:
				del(rt, x);
				break;
			case 3:
				cout << getrank(rt, x) << endl;
				break;
			case 4:
				cout << getval(rt, x) << endl;
				break;
			case 5:
				cout << getpre(x) << endl;
				break;
			case 6:
				cout << getne(x) << endl;
				break;
		}
	}
}

int main() {
	IOS;
	
	solve();
	
	return 0;
}