平衡树巩固——part1.简单

最新推荐文章于 2025-08-15 16:44:13 发布

weixin_30474613

最新推荐文章于 2025-08-15 16:44:13 发布

阅读量56

点赞数

CC 4.0 BY-SA版权

文章标签：数据结构与算法

原文链接：http://www.cnblogs.com/Neroysq/archive/2011/10/29/2228443.html

本文详细介绍了使用Treap和Splay树解决平衡树相关问题的方法，并通过三道经典水题实例展示了其应用。同时，作者表达了对进阶数据结构Splay树的兴趣，计划深入学习并优化其实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

最近预计做一下各种平衡树的题，这是第一部分，就是一类简单的各种操作，由于实在是太简单了，各种数据结构都可以胜任，我就用treap和sbt分别做了一遍平衡树的三大水题，于是这两种数据结构就比较熟练了。

treap就是普通的二叉排序树多满足了一个堆的性质，相当好写，贴一贴三道题的代码：

1.hnoi2002 turnover（无敌大水题）

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int nmax = 32767;

int ans, n, tot, root;
struct typetreapnode
{
    int chi[2], val, fix;
}tap[nmax + 18];

int min(int a, int b)
{
    return a > b ? b : a;
}

void rotate_treap(int m, int &p)//0 left 1 right
{
    int b = tap[p].chi[m ^ 1];
    tap[p].chi[m ^ 1] = tap[b].chi[m];
    tap[b].chi[m] = p;
    if (p == root) root = b;
    p = b;
}

void insert_treap(int x, int &p)
{
    if (!p)
    {
	p = ++tot;
	tap[tot].val = x;
	tap[tot].fix = rand();
    }
    else
    {
	int m = (tap[p].val <= x);
	insert_treap(x, tap[p].chi[m]);
	if (tap[tap[p].chi[m]].fix < tap[p].fix)
	    rotate_treap(m ^ 1, p);
    }
}

void find_treap(int m, int val, int p, int &opt)
{
    if (!p)
	return;
    bool k = (tap[p].val >= val);
    if (!(k ^ m))
	find_treap(m, val, tap[p].chi[m ^ 1], opt = p);
    else
	find_treap(m, val, tap[p].chi[m], opt);
}

int main()
{
    srand((unsigned) time(NULL));
    scanf("%d%d", &n, &ans);
    insert_treap(ans, root);
    root = 1;
    for (int i = 2, tmp, pre, suc; i <= n; ++i)
    {
	scanf("%d", &tmp);
	pre = suc = 0;
	if (i == n)
	    i = i + i - i;
	find_treap(0, tmp, root, pre);
	find_treap(1, tmp, root, suc);
	ans += min(pre ? tmp - tap[pre].val : 99999999, suc ? tap[suc].val - tmp : 99999999);
	insert_treap(tmp, root);
    }
    printf("%d", ans);
    return 0;
}

2.hnoi 2004 pet

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int nmax = 80000, mo = 1000000;

struct typetreapnode
{
    int chi[2], fix, val;
}tap[nmax + 18];

int n, now, rnt, ans, root, tot;

void rotate(int &p, int m)
{
    int b = tap[p].chi[m ^ 1];
    tap[p].chi[m ^ 1] = tap[b].chi[m];
    tap[b].chi[m] = p;
    p = b;
}

void insert_treap(int &p, int x)
{
    if (!p)
    {
	tap[p = ++tot].val = x;
	tap[p].fix = rand();
    }
    else
    {
	int m = (tap[p].val < x);
	insert_treap(tap[p].chi[m], x);
	if (tap[p].fix > tap[tap[p].chi[m]].fix)
	    rotate(p, m ^ 1);
    }
}

void findround_treap(int p, int x, int m, int &opt)
{
    if (!p) return;
    int k = (tap[p].val >= x);
    if (!(k ^ m))
	findround_treap(tap[p].chi[m ^ 1], x, m, opt = p);
    else
	findround_treap(tap[p].chi[m], x, m, opt);
}

void delete_treap(int &p, int x)
{
    if (x == tap[p].val)
    {
	if (!tap[p].chi[0] || !tap[p].chi[1])
	    p = tap[p].chi[!tap[p].chi[0]];
	else
	{
	    int m = tap[tap[p].chi[0]].fix < tap[tap[p].chi[1]].fix;
	    rotate(p, m ^ 1);
	    delete_treap(tap[p].chi[m ^ 1], x);
	}
    }
    else
	delete_treap(tap[p].chi[tap[p].val < x], x);
}

int better(int a, int b, int x)
{
    if (!a) return b;
    if (!b) return a;
    return abs(tap[a].val - x) > abs(tap[b].val - x) ? b : a;
}

int main()
{
    scanf("%d", &n);
    srand((unsigned)time(NULL));
    for (int i = 1, a, b, pre, suc; i <= n; ++i)
    {
	scanf("%d%d", &a, &b);
	if (!rnt || a == now) insert_treap(root, b), now = a, ++rnt;
	else
	{
	    pre = suc = 0;
	    findround_treap(root, b, 0, pre);
	    findround_treap(root, b, 1, suc);
	    pre = better(pre, suc, b);
	    ans = (ans + abs(b - tap[pre].val)) % mo;
	    delete_treap(root, tap[pre].val);
	    --rnt;
	}
    }
    printf("%d", ans);
    return 0;
}

3.noi2004 cashier

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
const int nmax = 100000;

struct typetreapnode
{
    int chi[2], val, fix, sze;
}tap[nmax + 18];
int n, min, ans, del, root, tot, tmp;
char c;

void rotate_treap(int &p, int m) //0 left 1 right
{
    int b = tap[p].chi[m ^ 1];
    tap[p].chi[m ^ 1] = tap[b].chi[m];
    tap[b].chi[m] = p;
    tap[b].sze = tap[p].sze;
    tap[p].sze = tap[tap[p].chi[0]].sze + tap[tap[p].chi[1]].sze + 1;
    p = b;
}

void insert_treap(int &p, int x)
{
    if (!p)
    {
	tap[p = ++tot].val = x;
	tap[tot].sze = 1;
	tap[tot].fix = rand();
    }
    else
    {
	int m = (tap[p].val < x);
	++tap[p].sze;
	insert_treap(tap[p].chi[m], x);
	if (tap[tap[p].chi[m]].fix < tap[p].fix)
	    rotate_treap(p, m ^ 1);
    }
}

void deletegroup_treap(int &p, int x)
{
    if (!p) return;
    if (tap[p].val < x)
    {
	tap[p].sze = 0;
	deletegroup_treap(p = tap[p].chi[1], x);
    }
    else
    {
	deletegroup_treap(tap[p].chi[0], x);
	tap[p].sze = tap[tap[p].chi[0]].sze + tap[tap[p].chi[1]].sze + 1;
    }
}

void findbyrank_treap(int p, int rank, int &pos)
{
    if ((tmp = tap[tap[p].chi[0]].sze + 1) == rank) return (void) (pos = p);
    if (tmp < rank)
	findbyrank_treap(tap[p].chi[1], rank - tmp, pos);
    else
	findbyrank_treap(tap[p].chi[0], rank, pos);
}

int main()
{
    srand((unsigned) time(NULL));
    scanf("%d%d\n", &n, &min);
    for (int i = 1, k; i <= n; ++i)
    {
	scanf("%c %d\n", &c, &k);
	if (c == 'I')
	    if (k >= min)
		insert_treap(root, k - del), ++ans;
	    else
		ans = ans;
	else
	    if (c == 'A')
		del += k;//lowbound = min + del
	    else
		if (c == 'S')
		{
		    del -= k;
		    deletegroup_treap(root, min - del);
		}
		else
		    if (k <= tap[root].sze)
		    {
			int pos;
			findbyrank_treap(root, tap[root].sze - k + 1, pos);
			printf("%d\n", tap[pos].val + del);
		    }
		    else
			printf("-1\n");
    }
    printf("%d", ans - tap[root].sze);
    return 0;
}

sbt和treap相当像，只不过把维护堆性质的操作换成了maintain，这个过程其实不是很好懂，每次都要推好久，不过代码只有8行，果断背啊！

1.turnover

#include <stdio.h>
#include <stdlib.h>
const int nmax = 32767;

int n, ans, root, tot, pre, suc;
struct typesbt
{
    int sze, val, chi[2];
}sbt[nmax + 18];

void rotate(int &p, int m) //l 0 r 1
{
    int b = sbt[p].chi[m ^ 1];
    sbt[p].chi[m ^ 1] = sbt[b].chi[m];
    sbt[b].chi[m] = p;
    sbt[b].sze = sbt[p].sze;
    sbt[p].sze = sbt[sbt[p].chi[0]].sze + sbt[sbt[p].chi[1]].sze + 1;
    p = b;
}

void maintain(int &p, int m)
{
    if (sbt[sbt[sbt[p].chi[m]].chi[m]].sze > sbt[sbt[p].chi[!m]].sze)
	rotate(p, !m);
    else if (sbt[sbt[sbt[p].chi[m]].chi[!m]].sze > sbt[sbt[p].chi[!m]].sze)
	rotate(sbt[p].chi[m], m), rotate(p, !m);
    else
	return;
    maintain(sbt[p].chi[0], 0);
    maintain(sbt[p].chi[1], 1);
    maintain(p, 0);
    maintain(p, 1);
}

void insert_sbt(int &p, int x)
{
    if (!p)
    {
	sbt[p = ++tot].sze = 1;
	sbt[p].val = x;
    }
    else
    {
	++sbt[p].sze;
	insert_sbt(sbt[p].chi[sbt[p].val <= x], x);
	maintain(p, x >= sbt[p].val);
    }
}

void searchround_sbt(int p, int x, int m, int &opt)
{
    if (!p) return ;
    int k = (sbt[p].val >= x);
    if (!(m ^ k))
	searchround_sbt(sbt[p].chi[m ^ 1], x, m, opt = p);
    else
	searchround_sbt(sbt[p].chi[m], x, m, opt);
}

int getmin(int a, int b, int p)
{
    if (!a) return abs(p - sbt[b].val);
    if (!b) return abs(p - sbt[a].val);
    return ((a = abs(p - sbt[a].val)) > (b = abs(p - sbt[b].val))) ? b : a;
}

int main()
{
    scanf("%d", &n);
    scanf("%d", &ans);
    insert_sbt(root, ans);
    for (int i = 2, tmp; i <= n; ++i)
    {
	scanf("%d", &tmp);
	pre = suc = 0;
	searchround_sbt(root, tmp, 0, pre);
	searchround_sbt(root, tmp, 1, suc);
	ans += getmin(pre, suc, tmp);
	insert_sbt(root, tmp);
    }
    printf("%d", ans);
    return 0;
}

2.pet

#include <stdio.h>
#include <stdlib.h>
const int nmax = 80000, mo = 1000000;

struct typesbt
{
    int sze, val, chi[2];
}sbt[nmax + 18];
int n, now, rnt, tot, ans;
int root, pre, suc;

void rotate(int &p, int m)
{
    int b = sbt[p].chi[!m];
    sbt[p].chi[!m] = sbt[b].chi[m];
    sbt[b].chi[m] = p;
    sbt[b].sze = sbt[p].sze;
    sbt[p].sze = sbt[sbt[p].chi[0]].sze + sbt[sbt[p].chi[1]].sze + 1;
    p = b;
}
    
void maintain(int &p, int m)
{
    if (sbt[sbt[sbt[p].chi[m]].chi[m]].sze > sbt[sbt[p].chi[!m]].sze)
	rotate(p, !m);
    else
	if (sbt[sbt[sbt[p].chi[m]].chi[!m]].sze > sbt[sbt[p].chi[!m]].sze)
	    rotate(sbt[p].chi[m], m), rotate(p, !m);
	else
	    return;
    maintain(sbt[p].chi[0], 0);
    maintain(sbt[p].chi[1], 1);
    maintain(p, 0);
    maintain(p, 1);
}

void insert_sbt(int &p, int x)
{
    if (!p)
    {
	sbt[p = ++tot].sze = 1;
	sbt[tot].val = x;
    }
    else
    {
	++sbt[p].sze;
	insert_sbt(sbt[p].chi[sbt[p].val <= x], x);
	maintain(p, sbt[p].val <= x);
    }
}

void searchround_sbt(int p, int m, int x, int &opt)
{
    if (!p) return;
    int k = (sbt[p].val >= x);
    if (!(m ^ k))
	searchround_sbt(sbt[p].chi[!m], m, x, opt = p);
    else
	searchround_sbt(sbt[p].chi[m], m, x, opt);
}

int deletenode_sbt(int &p, int x)
{
    --sbt[p].sze;
    if (x == sbt[p].val || !sbt[p].chi[x > sbt[p].val])
    {
	int rnt = sbt[p].val;
	if (!sbt[p].chi[0] || !sbt[p].chi[1])
	    p = sbt[p].chi[!sbt[p].chi[0]];
	else
	    sbt[p].val = deletenode_sbt(sbt[p].chi[0], x + 1);
	return rnt;
    }
    else
	return deletenode_sbt(sbt[p].chi[x > sbt[p].val], x);
}

int chkmin(int &a, int b, int c)
{
    if (!a || abs(sbt[a].val - c) > abs(sbt[b].val - c)) a = b;
    return abs(sbt[a].val - c);
}

int main()
{
    scanf("%d", &n);
    for (int i = 1, a, b; i <= n; ++i)
    {
	scanf("%d%d", &a, &b);
	if (!rnt || now == a) insert_sbt(root, b), now = a, ++rnt;
	else
	{
	    suc = pre = 0;
	    searchround_sbt(root, 0, b, pre);
	    searchround_sbt(root, 1, b, suc);
	    ans = (ans + chkmin(pre, suc, b)) % mo;
	    --rnt;
	    deletenode_sbt(root, sbt[pre].val);
	}
    }
    printf("%d", ans);
    return 0;
}

3.cashier

#include <stdio.h>
const int nmax = 100000;

struct typesbt
{
    int sze, chi[2], val;
}sbt[nmax + 18];
int n, ans, del, min, tot, num, root;
char c;

void rotate(int &p, int m)
{
    int b = sbt[p].chi[!m];
    sbt[p].chi[!m] = sbt[b].chi[m];
    sbt[b].chi[m] = p;
    sbt[b].sze = sbt[p].sze;
    sbt[p].sze = sbt[sbt[p].chi[0]].sze + sbt[sbt[p].chi[1]].sze + 1;
    p = b;
}

void maintain(int &p, int m)
{
    if (sbt[sbt[sbt[p].chi[m]].chi[m]].sze > sbt[sbt[p].chi[!m]].sze)
	rotate(p, !m);
    else
	if (sbt[sbt[sbt[p].chi[m]].chi[!m]].sze > sbt[sbt[p].chi[!m]].sze)
	    rotate(sbt[p].chi[m], m), rotate(p, !m);
	else
	    return;
    maintain(sbt[p].chi[0], 0);
    maintain(sbt[p].chi[1], 1);
    maintain(p, 0);
    maintain(p, 1);
}

void insert_sbt(int &p, int x)
{
    if (!p)
    {
	sbt[p = ++tot].sze = 1;
	sbt[p].val = x;
    }
    else
    {
	++sbt[p].sze;
	insert_sbt(sbt[p].chi[sbt[p].val <= x], x);
	maintain(p, sbt[p].val <= x);
    }
}

void deletegroup_sbt(int &p, int x)
{
    if (!p) return;
    if (sbt[p].val < x)
    {
	sbt[p].sze = 0;
	deletegroup_sbt(p = sbt[p].chi[1], x);
    }
    else
    {
	deletegroup_sbt(sbt[p].chi[0], x);
	sbt[p].sze = sbt[sbt[p].chi[0]].sze + sbt[sbt[p].chi[1]].sze + 1;
    }
}

int getbyrank_sbt(int p, int k)
{
    int tmp = sbt[sbt[p].chi[0]].sze + 1;
    if (tmp == k) return p;
    if (tmp < k)
	return getbyrank_sbt(sbt[p].chi[1], k - tmp);
    else
	return getbyrank_sbt(sbt[p].chi[0], k);
}

int main()
{
    scanf("%d%d", &n, &min);
    for (int i = 1, tmp; i <= n; ++i)
    {
	scanf("\n%c %d", &c, &tmp);
	if (c == 'I')
	    if (tmp >= min)
		insert_sbt(root, tmp - del), ++num;
	    else
		;
	else
	    if (c == 'A')
		del += tmp;
	    else
		if (c == 'S')
		{
		    del -= tmp;
		    deletegroup_sbt(root, min - del);
		}
		else
		    printf("%d\n", tmp <= sbt[root].sze ? sbt[getbyrank_sbt(root, sbt[root].sze - tmp + 1)].val + del : -1);
    }
    printf("%d", num - sbt[root].sze);
    return 0;
}

总之，上面这些水题多多少少耗了我两个晚自习，下面就要向序列之神，维护之神——splay进发了，去年的时候搞了一下，现在看来发现丑得无可比拟，一定要重写一个比较漂亮的单旋版本！

转载于:https://www.cnblogs.com/Neroysq/archive/2011/10/29/2228443.html