可持久化Trie模板

最新推荐文章于 2024-10-31 16:45:22 发布
最新推荐文章于 2024-10-31 16:45:22 发布
阅读量116 收藏
点赞数
文章标签： 数据结构与算法
原文链接：http://www.cnblogs.com/LiHior/p/9141345.html
版权

如果你了解过 01 Trie 和 可持久化线段树（例如 :  主席树 ）、那么就比较好去可持久化 Trie

可持久化 Trie 当 01 Trie 用的时候能很方便解决一些原本 01 Trie 不能解决的一些问题

01 Trie 的经典贪心算法可以在一个数集里面找出某个数和 X 异或的最值

但若数集不固定、变成了每次问询一段区间或者树上路径此时 01 Trie 便无法快速解决

这个时候需要使用可持久化的 Trie 来维护和进行查询操作、例如用前缀和建 Trie 就能方便查询某一区间的状况

可持久化 Trie 和主席树很类似，都是通过为每个前缀or路径等存储一颗 Trie

然后再通过减法的方式来达到某一区间或者某一历史版本的状态

这里只给出模板、关于这个算法的学习、推荐 ==> Click here

 

模板 :

#include<bits/stdc++.h>
using namespace std;
const int maxNode = 1e6 + 10;
const int maxn = 1e5 + 10;
int root[maxn];///每颗Trie的根节点编号
int sz[maxNode];///每个节点被添加or访问了多少次
int ch[maxNode][2];///静态指针、指向每个节点的01边指向的节点
int totNode = 0;///用于新开节点编号、多测问题别忘初始化

///静态开辟节点
int newNode()
{
    memset(ch[totNode], 0, sizeof(ch[totNode]));
    sz[totNode] = 0;
    return totNode++;
}

///F是将要被继承的树、C是当前新增的树、val就是即将被添加到C这棵树上的值
inline void Insert(int F, int C, int val)
{
    F = root[F], C = root[C];
    for(int i=15; i>=0; i--){
        int bit = (val>>i) & 1;
        if(!ch[C][bit]){
            ch[C][bit] = newNode();
            ch[C][!bit] = ch[F][!bit];
            sz[ ch[C][bit] ] = sz[ ch[F][bit] ];
        }
        C = ch[C][bit], F = ch[F][bit];
        sz[C]++;
    }
}

///查询函数可以说是很多变了
///可持久化Trie的查询并不是很模板的一个东西
///所以请务必理解可持久化Trie的原理再来运用这个模板
///以下的查询函数是 HDU 4757 的查询函数
int Query(int A, int B, int val)
{
    int lca = LCA(A, B);
    int lcaAns = arr[lca]^val;
    A = root[A], B = root[B], lca = root[lca];
    int ret = 0;
    for(int i=15; i>=0; i--){
        int bit = (val>>i) & 1;
        if(sz[ch[A][!bit]] + sz[ch[B][!bit]] - 2 * sz[ch[lca][!bit]] > 0){
            ret += 1<<i;
            A = ch[A][!bit];
            B = ch[B][!bit];
            lca = ch[lca][!bit];
        }else A = ch[A][bit], B = ch[B][bit], lca = ch[lca][bit];
    }

    return max(ret, lcaAns);
}

///这个查询函数则对应 BZOJ 3261
int query(int x, int y, int val)
{
    int ret = 0;
    for(int i=Bit; i>=0; i--){
        int c = (val>>i) & 1;
        if(sum[ch[y][!c]] - sum[ch[x][!c]] > 0)
            ret += (1<<i),
            y = ch[y][!c],
            x = ch[x][!c];
        else x = ch[x][c], y = ch[y][c];
    }
    return ret;
}
View Code

 

 

一些题目 :

BZOJ 3261 最大异或和

分析 : 每次更新都是从最后加一个数、而每次问询都是查询某一后缀的异或和

可持久化 01 Trie 能够很方便知道某一区间的状况、但关键是往区间里面装什么才能方便查询

注意到异或的自反性质、可以每次给每一个前缀以可持久化的方式建立一颗 Trie 

然后对于区间 (L, R) 在可持久化 01 Trie 内查询其两个区间与 (PreSum[N] xor x) 的异或最大值便是答案

因为如果某个下标假设为 idx ( L ≤ idx ≤ R ) 且 PreSum[idx] xor (PreSum[N] xor x) 有最大值

那么就说明了 idx 便是这个 p 、因为上面的异或表达式实际上 (1 ~ idx) 这段的异或和都被自反掉了

所以剩下的肯定就是后缀异或和了、所以利用前缀异或和建可持久化 Trie 即可。

#include<bits/stdc++.h>
#define LL long long
#define ULL unsigned long long
 
#define scs(i) scanf("%s", i)
#define sci(i) scanf("%d", &i)
#define scd(i) scanf("%lf", &i)
#define scl(i) scanf("%lld", &i)
#define scIl(i) scanf("%I64d", &i);
#define scii(i, j) scanf("%d %d", &i, &j)
#define scdd(i, j) scanf("%lf %lf", &i, &j)
#define scll(i, j) scanf("%lld %lld", &i, &j)
#define scIll(i, j) scanf("%I64d %I64d", &i, &j)
#define sciii(i, j, k) scanf("%d %d %d", &i, &j, &k)
#define scddd(i, j, k) scanf("%lf %lf %lf", &i, &j, &k)
#define sclll(i, j, k) scanf("%lld %lld %lld", &i, &j, &k)
#define scIlll(i, j, k) scanf("%I64d %I64d %I64d", &i, &j, &k)
 
#define lson l, m, rt<<1
#define rons m+1, r, rt<<1|1
#define lowbit(i) (i & (-i))
#define mem(i, j) memset(i, j, sizeof(i))
 
#define fir first
#define sec second
#define ins(i) insert(i)
#define pb(i) push_back(i)
#define pii pair<int, int>
#define mk(i, j) make_pair(i, j)
#define pll pair<long long, long long>
using namespace std;
const int maxn = (300000<<1) + 30;
const int Bit = 23;
int ch[maxn*24][2], sum[maxn*24], sz = 1;
int root[maxn];
 
int newNode()
{
    memset(ch[sz], 0, sizeof(ch[sz]));
    sum[sz] = 0;
    return sz++;
}
 
void Insert(int y, int x, int val)
{
    for(int i=Bit; i>=0; i--){
        int c = (val>>i) & 1;
        if(!ch[x][c]){
            ch[x][c] = newNode();
            ch[x][!c] = ch[y][!c];
            sum[ch[x][c]] = sum[ch[y][c]];
        }
        x = ch[x][c], y = ch[y][c];
        ++sum[x];
    }
}
 
int query(int x, int y, int val)
{
    int ret = 0;
    for(int i=Bit; i>=0; i--){
        int c = (val>>i) & 1;
        if(sum[ch[y][!c]] - sum[ch[x][!c]] > 0)
            ret += (1<<i),
            y = ch[y][!c],
            x = ch[x][!c];
        else x = ch[x][c], y = ch[y][c];
    }
    return ret;
}
 
int N, M, arr[maxn], PreSum[maxn];
int main(void)
{
    scii(N, M);
    arr[1] = 0, N++;
    for(int i=2; i<=N; i++) sci(arr[i]);
    for(int i=1; i<=N; i++) PreSum[i] = PreSum[i-1]^arr[i];
    for(int i=1; i<=N; i++){
        root[i] = newNode();
        Insert(root[i-1], root[i], PreSum[i]);
    }
 
    char ch[3];
    int l, r, x;
    while(M--){
        scs(ch);
        if(ch[0] == 'A'){
            N++;
            sci(arr[N]);
            PreSum[N] = PreSum[N-1]^arr[N];
            root[N] = newNode();
            Insert(root[N-1], root[N], PreSum[N]);
        }else{
            sciii(l, r, x);
            int ans = query(root[l-1], root[r], PreSum[N]^x);
            printf("%d\n", ans);
        }
    }
    return 0;
}
View Code

 

 

 

HDU 4757 Tree

题意 : 给出一颗树、树上的节点都有权值、接下来给出若干个询问 (u、v、x)

问从 u 到 v 最短路径上哪个节点和 x 异或结果最大、输出这个结果

分析 : 和上一题有点类似、只不过这里的区间变成了 u 到 v 间的最短路径即树上路径

嘚想办法建出和上题一样类似 "前缀和" 的东西方便使用减法来查询历史版本

针对树上路径的自然联想到 LCA 如果先随意指定一个根节点、先变成一颗有根树

那么 u 到 v 的最短路径可以用 LCA 表示为 dist(u) + dist(v) - 2 * dist(LCA(u, v))

根据上面这条式子、可以得到一个启发、可持久化 Trie 也可以通过这种方法来得到

我们需要的树上路径 Trie 即可以理解为从 u 到 v 最短路径中所有节点的组成 Trie

那做法就是先指定一个根、然后从根开始DFS、每次遍历到一个新节点

便以可持久化的方式新建一颗 Trie 且是继承自其父亲节点的 Trie

那么在查询的时候、给出两个节点 u、v 就对于每一位就可以通过

sz(u) + sz(v) - 2 * sz(LCA(u, v)) 来判断某一位是否包含 0/1 从而进行贪心选择

最后得到异或最值、当然注意这样做会漏掉 LCA、最后只要和 LCA ^ x 取最大便是答案

#include<bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
struct EDGE{ int v, nxt, w; }Edge[maxn<<1];
int Head[maxn], cnt;
int dep[maxn], maxDep;
int Fa[maxn][16];
int arr[maxn];
int n, m;

const int maxNode = 2e6 + 10;
int root[maxn], sz[maxNode], ch[maxNode][2];
int tot = 0;

inline void init_Graph()
{
    memset(Head, -1, sizeof(Head));
    memset(Fa, 0, sizeof(Fa));
    cnt = 0; maxDep = 0;
}

inline void AddEdge(int from, int to)
{
    Edge[cnt].v = to;
    Edge[cnt].nxt = Head[from];
    Head[from] = cnt++;
}

int newNode()
{
    memset(ch[tot], 0, sizeof(ch[tot]));
    sz[tot] = 0;
    return tot++;
}

inline void Insert(int F, int C, int val)
{
    F = root[F], C = root[C];
    for(int i=15; i>=0; i--){
        int bit = (val>>i) & 1;
        if(!ch[C][bit]){
            ch[C][bit] = newNode();
            ch[C][!bit] = ch[F][!bit];
            sz[ ch[C][bit] ] = sz[ ch[F][bit] ];
        }
        C = ch[C][bit], F = ch[F][bit];
        sz[C]++;
    }
}

void dfs(int v, int fa)
{
    root[v] = newNode();
    Insert(fa, v, arr[v]);
    if(Fa[v][0] != 0) maxDep = max(maxDep, dep[v] = dep[Fa[v][0]]+1);
    for(int i=Head[v]; i!=-1; i=Edge[i].nxt){
        int Eiv = Edge[i].v;
        if(Eiv == Fa[v][0]) continue;
        Fa[Eiv][0] = v;
        dfs(Eiv, v);
    }
}

inline void Doubling()
{
    int UP = (int)(log(maxDep)/log(2));
    for(int j=1; j<=UP; j++){
        for(int i=1; i<=n; i++){
            if(Fa[i][j-1] != 0)
                Fa[i][j] = Fa[Fa[i][j-1]][j-1];
        }
    }
}

int LCA(int u, int v)
{
    int UP = (int)(log(maxDep)/log(2));
    if(dep[u] < dep[v]) swap(u, v);
    for(int j=UP; j>=0; j--)
        if(Fa[u][j] != 0 && dep[Fa[u][j]] >= dep[v])
            u = Fa[u][j];

    if(u == v) return v;

    for(int j=UP; j>=0; j--){
        if(Fa[u][j] != Fa[v][j]){
            u = Fa[u][j];
            v = Fa[v][j];
        }
    }

    return Fa[u][0];
}

int Query(int A, int B, int val)
{
    int lca = LCA(A, B);
    int lcaAns = arr[lca]^val;
    A = root[A], B = root[B], lca = root[lca];
    int ret = 0;
    for(int i=15; i>=0; i--){
        int bit = (val>>i) & 1;
        if(sz[ch[A][!bit]] + sz[ch[B][!bit]] - 2 * sz[ch[lca][!bit]] > 0){
            ret += 1<<i;
            A = ch[A][!bit];
            B = ch[B][!bit];
            lca = ch[lca][!bit];
        }else A = ch[A][bit], B = ch[B][bit], lca = ch[lca][bit];
    }

    return max(ret, lcaAns);
}

int main(void)
{
    while(~scanf("%d %d", &n, &m)){
        for(int i=1; i<=n; i++) scanf("%d", &arr[i]);

        init_Graph();
        for(int i=1; i<n; i++){
            int u, v;
            scanf("%d %d", &u, &v);
            AddEdge(u, v);
            AddEdge(v, u);
        }

        tot = 0;
        dfs(1, 0);
        Doubling();

        while(m--){
            int u, v, x;
            scanf("%d %d %d", &u, &v, &x);
            printf("%d\n", Query(u, v, x));
        }
    }
    return 0;
}
View Code

 

 

 

转载于:https://www.cnblogs.com/LiHior/p/9141345.html

ajumn60282
关注
洛谷P4735 最大异化和 / 可持久化Trie树模板 题解
一只蒟蒻的博客
02-06 240
分析： 因为异或满足可减性，可以考虑像前缀和一样维护前缀异或和，即 令 sn=a1⊕a2⊕⋯⊕ans_n = a_1 \oplus a_2 \oplus \cdots \oplus a_nsn​=a1​⊕a2​⊕⋯⊕an​ 则有 al⊕al+1⊕⋯⊕ar=sr⊕sl−1a_l \oplus a_{l + 1} \oplus \cdots \oplus a_r = s_r \oplus s_{l -...
01Trie/可持久化01Trie学习笔记
Lolierl的博客
08-15 1795
01Trie是什么？它是一种较为特殊的权值线段树，可以解决一类与按位运算有关的问题。
模板 - 可持久化Trie
aoying6521的博客
09-05 124
https://www.acwing.com/problem/content/258/ #include<bits/stdc++.h> using namespace std; typedef long long ll; const int N = 600010; int trie[N * 24][2], latest[N * 24]; int s[N], root[N],...
可持久化 01Trie
cheng__yu_的博客
09-27 455
01TrieP4551 最长异或路径 （01trie） P4551 最长异或路径 （01trie） 链接：https://www.luogu.com.cn/problem/P4551 题意：给定一棵 nnn 个点的带权树，结点下标从 1 开始到 n 。寻找树中找两个结点，求最长的异或路径。异或路径指的是指两个结点之间唯一路径上的所有边权的异或。 思路： 01trie 模板题 从高位开始贪心，每次枚举一个数字时，需要关心与它异或相反的位置。 #include <bits/stdc++.h> #
可持久化trie树
qq_52048593的博客
03-02 617
https://blog.csdn.net/weixin_43959739/article/details/84922554 详情可以看这一篇，或者李煜东老师的书p253. 下面来介绍一下本人理解的 建立可持久化trie树的过程。 1.创建新版本的时候什么时候和之前版本的节点发生关系? 私以为，不妨以下图为例，具体来说，就是将当前版本与之前版本都从根节点出发，将当前版本该节点出发没有，之前版本有的一些信息进行连接，很好理解，因为最新版本相当于目前所有版本的总和 因此之前的信息就通过这种方式维护
Trie树的可持久化
Cauchy的博客
05-13 1059
文章目录
【数据结构】可持久化线段树&Trie总结
氧化钠的博客
11-22 1311
可持久化：可以访问历史版本的“升级版”的数据结构，利用访问历史版本的性质，可以做到许多在区间上的操作。可持久化线段树：例题： cqoi2111：区间第k大 给定一个长度为n的序列，m个询问，每个询问的形式为：l，r，k表示在[l,r]间中的第k大元素. (n<=100000, m<=100000,1<=l<=r<=n, 1<=k<=r-l+1) 如果用线段树来储存某个区间的第i大，显然是
【洛谷4735】 最大异或和（可持久化01Trie）
Michael_GLF的博客
11-15 307
传送门 【题目分析】 emmmm，似乎是个最大异或和的模板？ 先将第二个操作里的式子转一下，求a[p]^a[p+1]^....a[n]^x等价于前缀异或和sum[p-1]^sum[n]^x，后面两个的异或值是一个定值，所以我们只用在[l,r]中找到使sum[p]^(sum[n]^x)最大的即可。 【代码~】 #include<bits/stdc++.h> using nam...
Trie树
繁凡さん的博客
07-24 1099
Trie树 int son[N][26], cnt[N], idx; // 0号点既是根节点，又是空节点 // son[][]存储树中每个节点的子节点 // cnt[]存储以每个节点结尾的单词数量 // 插入一个字符串 void insert(char *str) { int p = 0; for (int i = 0; str[i]; i ++ ) { int u = str[i] - 'a'; if (!son[p][u]) son[p][u]
可持久化字典树模板
冰柠橙的博客
08-21 356
一般字典树： void update(char *s){ int len=strlen(s); int rt=0; for(int i=0;i<len;i++){ int xb=s[i]-'a'; if(!tree[rt][xb])tree[rt][xb]=++tot; //tsize[tree[rt][xb]]++; ...
可持久化01trie字典树
fanshui682的博客
04-01 293
可持久化01trie字典树是个比较复杂的数据结构，和主席树的构成原理很相似。区别就在主席树构造时候左右子树都是显示的，而可持久化01的左右（0或1）其中的一个是隐藏的，一开始看会有些抽象。题目意思：给一棵树，树上每个节点有权值，给q个询问，每次询问u，v。我们建造1~1的线段树，1~2状态的线段树，1~3状态的线段树，1~4状态的线段树。我们可以用dfn序把树上问题转化成区间问题，然后就可以直接套可持久化的板子了。但这样建造，复杂度太高了，所以我们需要优化空间。同理，可持续化01trie也是这样。
可持久化01字典树解析和模板
卖炫迈的小男孩的博客
03-04 775
一、可持久数据结构 主要指的是我们可以查询历史版本**的情况并支持插入，利用使用之前历史版本的数据结构来减少对空间的消耗**（能够对历史进行修改的是函数式）。引用于https://www.cnblogs.com/BLADEVIL/p/3681291.html 其实就是我们的数据结构的内容会不断发生变化，而我们还要查询以前的历史版本，比如某个区间的情况。 **三、思路：** 我们**要维护的是的异或和s[]并在==任意区间内找到s[p]使之与（s[n]^x）取得最大异或值==**，——异或+区间 求异或最
可持久化数据结构（一）：可持久化Trie
jwg2732的专栏
07-27 2996
近日学习了可持久化数据结构，因此特来总结一下，那就先从最简单的可持久化Trie开始吧！（虽然我理解这个的时间比主席树还久） 一：可持久化Trie的用途 正常的Trie树可以解决字符串的一些问题，特殊的Trie树（比如0/1Trie）可以解决最大异或和的相关问题，但是如果每次的询问是针对区间的，Trie树就不好解决，因为你不能对每个区间都建一棵Trie树，那样空间就会爆炸，于是，我们的可持久化Trie就登场了 二：可持久化Trie的构造 设trie[x][ch]，表示从x号节点连向的字符为ch的点的编号（与普
trie 树及其可持久化
洋溢
12-09 5741
trie 树及其可持久化 前言 本文主要介绍字符串组的存储方法，trie 字典树，首先我们讨论 trie 树的几个问题： trie 树的提出 trie 树的实现 trie 树的应用 在 trie 树的应用之中，我们介绍的它的特殊形式：01 字典树，并介绍区间异或最值问题。掌握 trie 树的相关算法后，讨论 trie 树的可持久化，解决更多的问题。 trie 字典树 trie 树的提出 存储大...
HJ51输出单向链表中倒数第k个结点
晴山の博客
10-29 270
HJ51输出单向链表中倒数第k个结点。
从零开始的LeetCode刷题日记：35. 分发糖果
chenjialehhh的博客
10-26 153
这道题的核心思想是分而治之！如果一开始就想着同时考虑一个小朋友的两边，那么很容易顾此失彼。我们可以先从前往后来确保这个方向的糖果数是符合题意的，然后再从后往前比较一次来确保另一个方向也符合题意，最后二者取最大值就同时满足了两边的需求。这里要注意的是，从前往后遍历的时候，比较的是i+1是否大于i，因为这有这样才能用到前面遍历得到的结果，逐步累加。同理，从后往前遍历比较的是i-1是否大于i。
C++算法第五天
2302_80418176的博客
10-31 803
1. 首这个解法叫滑动窗口，本质是同向双指针2. 使用这个解法的原因是利用了单调性3.滑动窗口的正确性：利用的单调性，规避了没必要的枚举行为4.枚举二字算是在博主的文章中第一次出现，那么我也解释枚举是什么意思，枚举就是将每一种情况都一一列举出来。
集成学习（2）
最新发布
weixin_74042627的博客
10-31 619
AdaBoostAdaBoost基本概念（Adaptive Boosting，自适应增强），其自适应在于：前一个基本分类器分错的样本会得到加强，加权后的全体样本再次被用来训练下一个基本分类器。同时，在每一轮中加入一个新的弱分类器，直到达到某个预定的足够小的错误率或达到预先指定的最大迭代次数。• 初始化训练样本的权值分布，每个样本具有相同权重；• 训练弱分类器，如果样本分类正确，则在构造下一个训练集中，它的权值就会被降低；反之提高。用更新过的样本集去训练下一个分类器；
【深搜算法】（第四篇）
weixin_73861555的博客
10-27 1277
然⽽，通过观察我们可以发现，如果我们先删除最底部的叶⼦节点，然后再处理删除后的节点，最终的结果并不会受到影响。因此，在处理完⼦节点后，我们仍然需要处理当前节点。3. 函数作⽤：整合⽗节点的信息与当前节点的信息计算当前节点数字，并向下传递，在回溯时返回当前⼦树（当前节点作为⼦树根节点）数字和。前序遍历按照根节点、左⼦树、右⼦树的顺序遍历⼆叉树的所有节点，通常⽤于⼦节点的状态依赖于⽗节点状态的题⽬。后序遍历按照左⼦树、右⼦树、根节点的顺序遍历⼆叉树的所有节点，通常⽤于⽗节点的状态依赖于⼦节点状态的题⽬。
trie树Python模板
04-09
当然，我可以为您介绍一下Trie树的Python模板。 Trie树，也称为字典树或前缀树，是一种用于高效存储和检索字符串的数据结构。下面是一个基本的Trie树的Python模板： ```python class TrieNode: def __init__(self...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值