可持久化字典树

普通模板:
//给出一个长度为N的正整数数组A,再给出Q个查询,每个查询包括3个数,L, R, X (L <= R)。求A[L] 至 A[R] 这R - L + 1个数中,与X 进行异或运算(Xor),得到的最大值是多少? 
const int N = 50000 + 10;
int son[N*35][2], sum[N*35];
int root[N];
int tot;
int len = 31;
bool bs[35];
//空树的话,所有值都是0,可以直接看作一个点,免去了建空树的过程,要建的话,参考主席树即可
void trie_insert(int p, int pre, int &x)
{
    x = ++tot;
    son[x][0] = son[pre][0], son[x][1] = son[pre][1];
    //memcpy(son[x], son[pre], sizeof(int) * 2);
    sum[x] = sum[pre] + 1;
    if(! p) return;
    trie_insert(p-1, son[pre][bs[p-1]], son[x][bs[p-1]]);
}
int trie_query(int p, int st, int en)
{//此时bs储存的是跟查询值完全相反的二进制位,即查询值要取得异或最大值所需要的二进制位
    if(! p) return 0;
    //此区间内在p-1位置上有需要的二进制位,就加上相应的值,并进入下一层
    if(sum[son[en][bs[p-1]]] > sum[son[st][bs[p-1]]]) return trie_query(p-1, son[st][bs[p-1]], son[en][bs[p-1]]) + (1<<(p-1));
    //p-1位置上没有需要的二进制位,说明这种类型的数字不存在,只能进入另一种类型的数字中去递归查询
    return trie_query(p-1, son[st][1-bs[p-1]], son[en][1-bs[p-1]]);
}
//以下被注释的是非递归版
//int trie_insert(int val, int pre)
//{
//    int x = ++tot, t = x;
//    for(int i = len-1; i >= 0; i--)
//    {
//        son[x][0] = son[pre][0], son[x][1] = son[pre][1];
//        sum[x] = sum[pre] + 1;
//        int j = 1 & (val >> i);
//        son[x][j] = ++tot;
//        x = son[x][j], pre = son[pre][j];
//    }
//    sum[x] = sum[pre] + 1;
//    return t;
//}
//int trie_query(int val, int y, int x)
//{
//    int ans = 0;
//    for(int i = len-1; i >= 0; i--)
//    {
//        int j = !(1 & (val >> i));
//        if(sum[son[x][j]] - sum[son[y][j]]> 0)
//        {
//            ans |= (1 << i);
//            x = son[x][j], y = son[y][j];
//        }
//        else x = son[x][!j], y = son[y][!j];
//    }
//    return ans;
//}
//int main()
//{
//    int n, m, x;
//    scanf("%d%d", &n, &m);
//    tot = 0;
//    for(int i = 1; i <= n; i++)
//    {
//        scanf("%d", &x);
//        root[i] = trie_insert(x, root[i-1]);
//    }
//    int l, r;
//    for(int i = 1; i <= m; i++)
//    {
//        scanf("%d%d%d", &x, &l, &r);
//        l++, r++;
//        int ans = trie_query(x, root[l-1], root[r]);
//        printf("%d\n", ans);
//    }
//    return 0;
//}
int main()
{
    int n, m, x;
    scanf("%d%d", &n, &m);
    tot = 0;
    for(int i = 1; i <= n; i++)
    {
        scanf("%d", &x);
        for(int j = len-1; j >= 0; j--) bs[j] = 1 & (x >> j);
        trie_insert(len, root[i-1], root[i]);
    }
    int l, r;
    for(int i = 1; i <= m; i++)
    {
        scanf("%d%d%d", &x, &l, &r);
        for(int j = len-1; j >= 0; j--) bs[j] = !(1 & (x >> j));
        l++, r++;
        int ans = trie_query(len, root[l-1], root[r]);
        printf("%d\n", ans);
    }
    return 0;
}

树上的模板:

//给出一棵树,树上的点都有权值,每次给出一组询问x y z,求从xy路径上的点权值和z异或得到的最大值
const int N = 100000 + 10, INF = 0x3f3f3f3f;
int tot, root[N];
int son[N*35][2], sum[N*35];
int cnt, head[N];
int dep[N], p[N][25];
int a[N];
bool bs[35];
int len = 31;
struct edge
{
    int to, next;
}g[N*2];
void init()
{
    cnt = 0;
    memset(head, -1, sizeof head);
    tot = 0;
}
void add_edge(int v, int u)
{
    g[cnt].to = u, g[cnt].next = head[v], head[v] = cnt++;
}
void trie_insert(int p, int pre, int &x)
{
    x = ++tot;
    son[x][0] = son[pre][0], son[x][1] = son[pre][1];
    //memcpy(son[x], son[pre], sizeof(int) * 2);
    sum[x] = sum[pre] + 1;
    if(! p) return;
    trie_insert(p-1, son[pre][bs[p-1]], son[x][bs[p-1]]);
}
int trie_query(int p, int st, int en)
{
    if(! p) return 0;
    if(sum[son[en][bs[p-1]]] > sum[son[st][bs[p-1]]]) return trie_query(p-1, son[st][bs[p-1]], son[en][bs[p-1]]) + (1<<(p-1));
    return trie_query(p-1, son[st][1-bs[p-1]], son[en][1-bs[p-1]]);
}
void dfs(int v, int fa, int d)
{
    dep[v] = d, p[v][0] = fa;
    for(int i = len-1; i >= 0; i--) bs[i] = 1 & (a[v] >> i);
    trie_insert(len, root[fa], root[v]);
    for(int i = head[v]; i != -1; i = g[i].next)
    {
        int u = g[i].to;
        if(u == fa) continue;
        dfs(u, v, dep[v] + 1);
    }
}
void lca_init(int n)
{
    for(int j = 1; (1<<j) <= n; j++)
        for(int i = 1; i <= n; i++)
            p[i][j] = p[p[i][j-1]][j-1];
}
int LCA(int v, int u)
{
    if(dep[v] < dep[u]) swap(v, u);
    int d = dep[v] - dep[u];
    for(int i = 0; (d>>i) != 0; i++)
        if((d>>i) & 1) v = p[v][i];
    if(v == u) return v;
    for(int i = 20; i >= 0; i--)
        if(p[v][i] != p[u][i]) v = p[v][i], u = p[u][i];
    return p[v][0];
}
int main()
{
    int n, m;
    while(~ scanf("%d%d", &n, &m))
    {
        init();
        for(int i = 1; i <= n; i++) scanf("%d", &a[i]);
        for(int i = 1; i <= n-1; i++)
        {
            int v, u;
            scanf("%d%d", &v, &u);
            add_edge(v, u); add_edge(u, v);
        }
        dfs(1, 0, 1);
        lca_init(n);
        for(int i = 1; i <= m; i++)
        {
            int x, y, val;
            scanf("%d%d%d", &x, &y, &val);
            for(int j = len-1; j >= 0; j--) bs[j] = ! (1 & (val >> j));
            int lca = LCA(x, y);
            int ans = trie_query(len, root[p[lca][0]], root[x]);
            ans = max(ans, trie_query(len, root[p[lca][0]], root[y]));
            printf("%d\n", ans);
        }
    }
    return 0;
}
### 可持久化数据结构的概念及其实现 #### 什么是可持久化数据结构? 可持久化数据结构是一种允许访问其任何历史版本的数据结构。这种特性使得它在某些场景下非常有用,比如需要频繁回溯或者比较不同状态的应用程序中。为了支持这一功能,可持久化数据结构通常会通过共享未修改部分的方式来减少内存消耗[^1]。 #### 如何实现可持久化数据结构? ##### 不可变性原则 实现可持久化的基础在于保持数据结构的不可变性。每次更新操作实际上并不改变原有数据结构,而是创建一个新的版本,其中新旧版本之间尽可能多地共享相同的部分以节省空间。 ##### 版本管理机制 对于每一次的操作(如插入、删除),都需要记录该次变化形成的新版本号,并且能够依据此版本号恢复对应的状态。这可以通过路径复制技术完成,在不破坏原结构的前提下构建新的节点链路[^2]。 #### 应用实例分析——可持久化 Trie 树 作为一种典型的例子,可持久化Trie被广泛应用于字符串匹配等领域。当向一棵已存在的Trie树添加一个单词时,仅需沿着可能影响到的分支新建若干个节点即可,其余不变区域依旧指向原来的节点地址,从而实现了高效的空间利用率提升以及快速查询能力增强的效果。 以下是基于 Python 的简单模拟代码展示如何构造基本形式上的可持久化字典树: ```python class PersistentTrieNode: def __init__(self, value=None): self.children = {} self.value = value def insert(root_versions, word, version_id=0): root = root_versions[version_id].copy() node_stack = [] current_node = root for char in word: if char not in current_node['children']: new_child = {'value': None, 'children': {}} current_node['children'][char] = len(node_stack) node_stack.append(new_child) index = current_node['children'].get(char) next_node = node_stack[index] if isinstance(index, int) else {} node_stack.append(next_node.copy()) current_node = next_node current_node['value'] = True root_versions.append({k:v.copy() for k,v in zip(['root'], [node_stack[-1]])}) ``` 上述代码片段展示了如何维护多个版本的根节点列表 `root_versions` ,并通过深拷贝确保每一步骤都独立存在而不互相干扰。 #### 数据校验中的作用 除了作为纯粹的数据存储工具外,可持久化数据结构还可以与其他技术相结合用于更复杂的场合。例如,在分布式文件系统的元数据管理过程中引入数据校验方法,则可以进一步加强整个体系面对硬件故障等情况下的稳定性表现[^3]。 ---
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值