fhq-Treap 学习笔记

本文介绍了fhq-Treap及非旋Treap,其每个点有val和rank,期望树高为log。核心操作包括Build(O(n))、Split(O(log))和Merge(O(log)),还说明了各操作的具体实现方式,如Build用栈维护最右链,Split划分子树,Merge合并子树,其他操作基于这两者。

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

fhq-Treap 及非旋Treap, 类似普通的Treap, 每个点有一个val(值), 和rank(随记出来的), 期望树高log

核心操作有如下 Build -> O(n), Split -> O(log), Merge -> O(log)

当然, Build 也可以一个一个插入, 也不是很慢


Build

先将树按值排序, 然后一个一个加, 用栈维护最右链, 每次直接加在最右链的右儿子下

如果当前的rank小于父亲, 就在栈中将父亲退掉, 直到合法(满足堆的性质),然后把退掉的子树接到左儿子

int Build(int *a, int n){
    int top = 0, pre = 0, u = 0;
    for(int i=1; i<=n; i++){
        u = new_node(a[i]); pre = 0;
        while(top && t[sta[top]].rank > t[u].rank)
            pre = sta[top], Pushup(sta[top]), sta[top--] = 0;
        if(top) t[sta[top]].rc = u;
        t[u].lc = pre; sta[++top] = u;
    } while(top) Pushup(sta[top--]);
    return sta[1];
}

Split

Split(x, k) 指将x为根的子树的前k个与后n-k+1个划开

我们类似找第k大, 边找边割, 然后在合并, 用一个pair存划开后的左右子树

#define pa pair<int,int>
pa split(int x, int k){
    if(!x) return  mp(0, 0);
    pa T; Pushdown(x);
    if(t[ls].siz >= k) T = split(ls, k), ls = T.second, T.second = x;
    else T = split(rs, k - t[ls].siz - 1), rs = T.first, T.first = x;
    Pushup(x); return T;
}

Merge

Merge(u, v) 指将以u, v为根的两个子树合并成一棵, 其中u的值全部小于v的值(有顺序), 合并时注意堆的性质

如果u -> rank < v->rank, 那么只有u为根, 然后合并u的左儿子和v(因为v全部大于u, 所以一定在u的左儿子), 反之亦然

int merge(int u, int v){
    if(!u || !v) return u+v;
    if(t[u].rank < t[v].rank){
        Pushdown(u); t[u].rc = merge(t[u].rc, v);
        Pushup(u); return u;
    } else{
        Pushdown(v); t[v].lc = merge(u, t[v].lc);
        Pushup(v); return v;
    }
}

其它操作都是基于Merge, Split上的

例如区间翻转[l, r], 那么只需Split(rt, l-1), 将后面那棵树 Split(rt', r-l+1), 然后打上标记即可

Split 完记得 Merge 回去

void Reverse(int l, int r){
	pa t1 = Split(rt, l-1), t2 = Split(t1.second, r - l + 1);
	Pushrev(t2.first); Merge(t1.first, Merge(t2.first, t2.second));
}

例如 在pos后 Insert 长度为cnt 的一串数, 只需Build那些树, 令根为u, 然后Split(rt, pos), 在Merge(first, Merge(u, second))

void Insert(int pos, int cnt){
    for(int i=1; i<=cnt; i++) tmp[i] = read();
    int u = Build(tmp, cnt);
    pa t = split(rt, pos);
    rt = merge(t.first, merge(u, t.second));
}

总之就是通过Split 将区间取出来操作, 再Merge回去


模板 P2042 [NOI2005]维护数列

#include<bits/stdc++.h>
#define N 800050
using namespace std;
const int inf = 0x3fffffff;
#define pa pair<int, int>
#define mp make_pair
int read(){
    int cnt = 0, f = 1; char ch = 0;
    while(!isdigit(ch)){ ch = getchar(); if(ch == '-') f = -1;}
    while(isdigit(ch)) cnt = cnt*10 + (ch-'0'), ch = getchar();
    return cnt * f;
}
int Random(){
    static int seed = 233;
    return seed = int(seed*47281LL%2147483647);
}
struct Node{
    int lc, rc, val, rank, siz;
    int mx, lx, rx, sum, cover, rev;
}t[N];
stack<int> S;
int n, m, a[N], rt, tot, tmp[N];
int sta[N];
int new_node(int val){
    int u = 0; if(S.size()) u = S.top(), S.pop(); else u = ++tot;
    t[u] = (Node){0, 0, val, Random(), 1, val, max(val, 0), max(val, 0), val, 223223, 0};
    return u;
}
void recycle(int u){
    if(!u) return; S.push(u); recycle(t[u].lc); recycle(t[u].rc);
}
#define ls t[x].lc
#define rs t[x].rc
#define w t[x].cover
void Pushup(int x){
    if(!x) return;
    t[x].siz = t[ls].siz + t[rs].siz + 1;
    t[x].sum = t[ls].sum + t[rs].sum + t[x].val;
    t[x].mx = max(t[ls].rx + t[x].val + t[rs].lx, max(t[ls].mx, t[rs].mx));
    t[x].lx = max(t[ls].lx, t[ls].sum + t[x].val + t[rs].lx);
    t[x].rx = max(t[rs].rx, t[rs].sum + t[x].val + t[ls].rx);
}
void Pushrev(int x){ if(!x) return; swap(ls, rs); swap(t[x].lx, t[x].rx); t[x].rev ^= 1;}
void Pushcover(int x, int v){ 
    if(!x) return;
    t[x].val = v; t[x].sum = v * t[x].siz; w = v;
    if(v > 0) t[x].mx = t[x].lx = t[x].rx = t[x].sum;
    else t[x].mx = v, t[x].lx = t[x].rx = 0;
}
void Pushdown(int x){
    if(t[x].rev) Pushrev(ls), Pushrev(rs), t[x].rev = 0;
    if(w != 223223) Pushcover(ls, w), Pushcover(rs, w), w = 223223; 
}
int Build(int *a, int n){
    int top = 0, pre = 0, u = 0;
    for(int i=1; i<=n; i++){
        u = new_node(a[i]); pre = 0;
        while(top && t[sta[top]].rank > t[u].rank)
            pre = sta[top], Pushup(sta[top]), sta[top--] = 0;
        if(top) t[sta[top]].rc = u;
        t[u].lc = pre; sta[++top] = u;
    } while(top) Pushup(sta[top--]);
    return sta[1];
}
int merge(int u, int v){
    if(!u || !v) return u+v;
    if(t[u].rank < t[v].rank){
        Pushdown(u); t[u].rc = merge(t[u].rc, v);
        Pushup(u); return u;
    } else{
        Pushdown(v); t[v].lc = merge(u, t[v].lc);
        Pushup(v); return v;
    }
}
pa split(int x, int k){
    if(!x) return  mp(0, 0);
    pa T; Pushdown(x);
    if(t[ls].siz >= k) T = split(ls, k), ls = T.second, T.second = x;
    else T = split(rs, k - t[ls].siz - 1), rs = T.first, T.first = x;
    Pushup(x); return T;
}
void Insert(int pos, int cnt){
    for(int i=1; i<=cnt; i++) tmp[i] = read();
    int u = Build(tmp, cnt);
    pa t = split(rt, pos);
    rt = merge(t.first, merge(u, t.second));
}
void Delete(int pos, int cnt){
    pa t1 = split(rt, pos-1), t2 = split(t1.second, cnt);
    recycle(t2.first); rt = merge(t1.first, t2.second);
}
void Cover(int pos, int cnt, int v){
    pa t1 = split(rt, pos-1), t2 = split(t1.second, cnt);
    Pushcover(t2.first, v); rt = merge(t1.first, merge(t2.first, t2.second));
}
void Reverse(int pos, int cnt){
    pa t1 = split(rt, pos-1), t2 = split(t1.second, cnt);
    Pushrev(t2.first); rt = merge(t1.first, merge(t2.first, t2.second));
}
int Getsum(int pos, int cnt){
    pa t1 = split(rt, pos-1), t2 = split(t1.second, cnt);
    printf("%d\n", t[t2.first].sum);
    rt = merge(t1.first, merge(t2.first, t2.second));
}
int Maxsum(){ printf("%d\n", t[rt].mx);} 
int main(){
	t[0].mx = -1e9; 
    n = read(), m = read(); 
    for(int i=1; i<=n; i++) a[i] = read();
    rt = Build(a, n);
    while(m--){
        char s[15]; scanf("%s", s);
        if(s[0] == 'I'){ int pos = read(), cnt = read(); Insert(pos, cnt);}
        if(s[0] == 'D'){ int pos = read(), cnt = read(); Delete(pos, cnt);}
        if(s[0] == 'M' && s[2] == 'K'){ int pos = read(), cnt = read(), v = read(); Cover(pos, cnt, v);}
        if(s[0] == 'R'){ int pos = read(), cnt = read(); Reverse(pos, cnt);}
        if(s[0] == 'G'){ int pos = read(), cnt = read(); Getsum(pos, cnt);}
        if(s[0] == 'M' && s[2] == 'X') Maxsum();
    } return 0;
}

 

<think>嗯,用户想了解FHQ-Treap的空间优化方法。首先,我得回忆一下FHQ-Treap的基本结构。FHQ-Treap也就是非旋转Treap,它通过分裂和合并操作来维护平衡,不需要旋转,所以代码相对简单,还能支持可持久化。那空间优化方面,用户可能遇到节点过多导致内存占用大的问题,需要找优化方法。 根据引用[2],FHQ-Treap相比Splay虽然常数大,但实现容易,还能可持久化。可持久化通常会占用更多空间,但用户问的是空间优化,所以可能需要减少节点数量或重用节点。 首先想到的是节点复用。比如删除节点时,不是立即释放内存,而是加入一个缓存池,需要时再取出。这样可以避免频繁申请内存的开销,尤其在多次插入删除的情况下。这种方法在很多数据结构中都有应用,比如内存池技术。 然后是动态分配策略。比如根据操作频率调整节点预分配的数量,高频使用时多分配,低频时减少。不过具体如何实现可能需要进一步思考,比如初始分配一定数量的节点,当不够时再批量申请,而不是每次插入都申请新节点。 还有延迟回收技术。删除节点后不立即回收,而是标记为无效,后续操作中复用。这需要维护一个无效节点列表,并在需要时进行清理或复用。不过要注意避免内存泄漏,可能需要定期清理。 另外,引用[5]提到使用虚节点来优化合并操作,虽然主要是针对并查集,但或许可以借鉴。比如在FHQ-Treap中,是否有类似虚节点的设计,减少结构中的辅助节点数量?或者通过某些方式共享部分结构,比如持久化时的路径复用,但用户可能指的是常规优化而非可持久化场景。 还有,合并操作的优化可能减少临时节点的使用。比如在合并过程中尽量复用现有节点,而不是创建中间节点。不过这可能需要调整合并算法的实现细节。 还需要考虑Treap本身的特性,比如优先级。如果优先级生成策略可以优化,比如使用哈希或更紧凑的存储方式,减少存储开销。例如,使用较小的数据类型存储优先级,或者用伪随机数生成器避免存储全部优先级。 另外,内存对齐和紧凑的节点结构设计也很重要。比如将节点的键、优先级、左右子指针紧凑排列,减少内存碎片,或者使用更小的数据类型。例如,如果键的范围允许,使用int而非long来存储。 可能还需要分析FHQ-Treap的具体实现,比如每个节点通常包含哪些字段。通常有key, priority, left, right,可能还有size。如果size可以动态计算而不存储,但这样会影响性能,需要权衡。 总结可能的优化点: 1. 节点复用与缓存池 2. 延迟回收和批量分配 3. 紧凑的节点结构设计 4. 动态调整预分配策略 5. 优化优先级存储 6. 合并/分裂时的临时节点复用 需要将这些方法具体化,给出实际的技巧,比如如何实现缓存池,如何设计节点结构等。同时要确保这些方法适用于FHQ-Treap的特性,比如非旋转和分裂合并操作。 比如,节点池的实现:预先分配一个节点数组,用栈或队列管理空闲节点。插入时从池中取节点,删除时将节点放回池中。这样减少内存分配次数,提高效率,同时控制内存占用。 紧凑结构方面,可以用union或者位域来压缩字段,但可能增加访问复杂度。或者根据具体情况选择合适的数据类型,比如用32位整数代替64位。 优先级生成方面,如果使用随机数,可以存储种子而不是每个节点的优先级,但Treap需要每个节点有唯一的优先级,所以可能不可行。或者使用哈希函数生成优先级,减少存储空间,比如用较低的位数。 延迟回收的话,维护一个删除列表,当需要新节点时先检查列表,有则复用,无则新建。但要注意节点信息的正确重置。 可能还需要注意可持久化时的优化,但用户的问题可能是一般情况下的空间优化,所以重点放在常规方法上。 最后,给出具体的优化技巧,结合实现示例,比如代码中的节点池管理,或者结构体设计。同时引用相关参考资料,比如引用[2]提到FHQ可用于可持久化,可能涉及节点复用;引用[5]的虚节点思路是否有借鉴意义。</think>### FHQ-Treap 空间优化技巧详解 FHQ-Treap(非旋转 Treap)通过分裂与合并操作实现平衡树功能,其非旋特性使得可持久化成为可能[^2]。以下是针对空间优化的具体技巧及实现方法: --- #### 1. **节点复用与缓存池** **核心思路**:避免频繁的内存分配/释放,通过预分配和复用节点减少系统调用开销。 - **实现方法**: - **预分配节点池**:初始化时批量申请内存(如数组或链表),维护空闲节点列表。 - **删除节点缓存**:删除操作时将节点标记为“无效”并加入缓存池,插入时优先使用缓存节点。 ```python class NodePool: def __init__(self, chunk_size=1024): self.free_list = [] self.allocate_chunk(chunk_size) def allocate_chunk(self, size): new_nodes = [Node() for _ in range(size)] self.free_list.extend(new_nodes) def get_node(self): if not self.free_list: self.allocate_chunk() # 按需扩容 return self.free_list.pop() def recycle_node(self, node): node.left = node.right = None self.free_list.append(node) ``` --- #### 2. **延迟回收与批量清理** **应用场景**:高频插入/删除操作中,减少即时回收的开销。 - **优化策略**: - 标记节点为“逻辑删除”(如设置 `deleted` 标志),定期批量清理。 - 合并操作时跳过无效节点,减少物理删除次数[^3]。 --- #### 3. **紧凑型节点结构设计** 通过压缩字段节省内存: - **数据类型优化**:根据数据范围选择最小类型(如 `int32` 代替 `int64`)。 - **合并字段**:使用联合体(Union)存储互斥数据(如可持久化版本号与子指针)。 ```c++ struct CompactNode { int32_t key; uint16_t priority; // 使用更小的随机数范围 union { struct { CompactNode *left, *right; }; int32_t version; // 可持久化场景下的版本号 }; }; ``` --- #### 4. **动态优先级生成** **避免存储显式优先级**:通过哈希函数生成优先级,减少存储开销。 - **公式**:`priority = hash(key) % MAX_PRIORITY` - **优点**:无需额外字段存储优先级,但需保证优先级分布近似随机性。 --- #### 5. **可持久化场景优化** **虚节点技术**:参考并查集虚点思想[^5],将频繁修改的子树映射到独立内存区域。 - **实现**:为每个节点绑定虚节点,合并/分裂操作仅修改虚节点,减少真实节点的变更次数。 --- #### 6. **合并/分裂操作优化** 减少临时节点生成: - **原地修改**:合并时直接调整指针而非创建新节点。 - **栈式分裂**:分裂过程中复用中间节点(需严格保证线程安全)。 --- ### 关键权衡与注意事项 | 优化方法 | 优点 | 缺点 | |------------------|--------------------------|-------------------------------| | 节点池 | 减少内存碎片 | 预分配可能浪费内存 | | 延迟回收 | 降低高频操作开销 | 内存占用短期增加 | | 紧凑结构 | 节省单节点空间 | 代码复杂度增加 | | 动态优先级 | 无需存储优先级字段 | 哈希冲突可能影响平衡性 | --- ### 相关问题 1. **如何验证节点池优化后的内存使用效率?** 2. **FHQ-Treap 在可持久化场景中如何避免内存泄漏?** 3. **紧凑节点结构对分裂/合并操作性能有何影响?** : FHQ-Treap 的非旋特性使其适合可持久化优化。 : 延迟回收技术可借鉴滑动窗口的复用思想。 [^5]: 虚节点技术常用于减少真实数据结构的修改频率。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

FSYo

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值