01trie树

最新推荐文章于 2023-11-09 21:10:26 发布
最新推荐文章于 2023-11-09 21:10:26 发布
阅读量585 收藏 6
点赞数 1
文章标签： 01trie树 字典树
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_51216553/article/details/120228774
版权

01trie树顾名思义，是trie的一种特殊形式，树上只有0和1两种值，主要用于解决点与点甚至是区间的异或和最大、最小问题。

建树插入数字的时候和普通的trie树一模一样，而求一个数x与树上所有数的异或最大值时主要是用到贪心与二进制的思想：要使得异或和最大，肯定是每一位都最好是1

  • 当x的第i位为1
    • 如果树上此时可以选0，那就选0，此时该位异或后是1
    • 如果树上此时只能选1，那就选1，此时该位异或后是0
  • 当x的第i位为0
    • 如果树上此时可以选1，那就选1，此时该位异或后是1
    • 如果树上此时只能选0，那就选0，此时该位异或后是0

总结来说，看当前树上当前这一位^1的值存不存在，如果有，那就说明二进制下这一位是1，如果不存在，那二进制下这一位就是0

具体请看代码

int getans(int x){
    int ans = 0;
    int root = 0;
    for(int i = 31; i >= 0; --i){
        int id = (x >> i) & 1;//获取x的第i位
        if(tr[root][id ^ 1]){
            ans = ans << 1 | 1;
            root = tr[root][id ^ 1];
        }
        else{
            ans = ans << 1;
            root = tr[root][id];
        }
    }
    return ans;
}

看一个板子题：

The XOR Largest Pair

题目描述：

在给定的N个整数A1,A2…AN中选出两个进行xor运算，得到的结果最大是多少？

思路：

建树的时候将所有数都放到树上，然后再从头跑一遍，对每个数都查一次，比较出最大值输出即可

取数字x的第i位时，有三种方法：提前转换成字符串来做、用二进制、使用bitset

这三种都可以，不过后两种写起来容易一些。这三种方法中二进制的最快，其次是bitset，最后是字符串（亲测

#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<bitset>
#include<cstdio>
#include<string>
#include<vector>
#include<sstream>
#include<cstring>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
using namespace std;

#pragma GCC optimize("Ofast")
#pragma GCC target("fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")

#define eps 1e-8
#define endl '\n'
#define inf 0x3f3f3f3f
#define MAX  3300000 + 50
#define mod 1000000007
#define lowbit(x) (x & (-x))
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d %d",&n,&m)
#define pd(n) printf("%d\n", (n))
#define pdd(n,m) printf("%d %d\n",n, m)
#define sddd(n,m,z) scanf("%d %d %d",&n,&m,&z)
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
//#define max(a,b) (((a)>(b)) ? (a):(b))
//#define min(a,b) (((a)>(b)) ? (b):(a))

typedef  long long ll ;
typedef unsigned long long ull;
//不开longlong见祖宗!不看范围见祖宗!
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}

int n, tot;
int tr[MAX][2];
int ar[100005];

void insert(int x){
    bitset<32>b(x);
    int root = 0;
    for(int i = 31; i >= 0; --i){
        int id = b[i];
        if(!tr[root][id])tr[root][id] = ++tot;
        root = tr[root][id];
    }
}

int getans(int x){
    int ans = 0;
    bitset<32>b(x);
    int root = 0;
    for(int i = 31; i >= 0; --i){
        int id = b[i];
        if(tr[root][id ^ 1]){
            ans = ans << 1 | 1;
            root = tr[root][id ^ 1];
        }
        else{
            ans <<= 1;
            root = tr[root][id];
        }
    }
    return ans;
}

int main(){
    sd(n);
    for(int i = 1; i <= n; ++i){
        sd(ar[i]);
        insert(ar[i]);
    }
    int ans = -1;
    for(int i = 1; i <= n; ++i){
        ans = max(ans, getans(ar[i]));
    }
    cout<<ans<<endl;
    return 0;   
}

Xor Sum

题目描述：

给n个数，然后m次查询，每次查询都给一个数x，问哪个数k与n异或后的值最大

思路：

这和上个题就有点区别了，上次是输出最大值，这次是要输出谁与x异或后最大

这里只需要对上面那个题进行小小的修改即可，也就是求max的时候进行判断，判断当前是0还是1，根据这个来确定k的每一位

  • 如果此时tr[root] [id ^ 1]不等于0
    • 如果此时id = 1，那k的这一位是0
    • 如果此时id = 0，那k的这一位是1
  • 如果此时tr[root] [id ^ 1]等于0
    • 如果此时id = 1，那k的这一位是1
    • 如果此时id = 1，那k的这一位是0

（id指的是x的第i位，k指的是每次查询需要输出的答案，root就是字典树用的那个东西

#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<bitset>
#include<cstdio>
#include<string>
#include<vector>
#include<sstream>
#include<cstring>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
using namespace std;

#pragma GCC optimize("Ofast")
#pragma GCC target("fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")

#define eps 1e-8
#define endl '\n'
#define inf 0x3f3f3f3f
#define MAX  3000000 + 50
#define mod 998244353
#define lowbit(x) (x & (-x))
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d %d",&n,&m)
#define pd(n) printf("%d\n", (n))
#define pdd(n,m) printf("%d %d\n",n, m)
#define sddd(n,m,z) scanf("%d %d %d",&n,&m,&z)
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
//#define max(a,b) (((a)>(b)) ? (a):(b))
//#define min(a,b) (((a)>(b)) ? (b):(a))

typedef  long long ll ;
typedef unsigned long long ull;
//不开longlong见祖宗!不看范围见祖宗!
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}

int T;
int n, m, x;
int tot;
int tr[MAX][2];
int ans[MAX];
int flag, pos;

void insert(int x){
    int root = 0;
    for(int i = 31; i >= 0; --i){
        int id = (x >> i) & 1;
        if(!tr[root][id])tr[root][id] = ++tot;
        root = tr[root][id];
    }
    ans[root] = x;
}

int getans(int x){
    int cnt = 0;
    int root = 0;
    for(int i = 31; i >= 0; --i){
        int id = (x >> i) & 1;
        if(tr[root][id ^ 1]){
            if(id == 1)cnt = cnt << 1;
            else cnt = cnt << 1 | 1;
            root = tr[root][id ^ 1];

        }
        else{
            if(id == 1)cnt = cnt << 1 | 1;
            else cnt = cnt << 1;
            root = tr[root][id];
        }
    }
    return cnt;
}

void work(){
    flag = -1;tot = 0;
    mem(ans, 0);
    mem(tr, 0);
    sdd(n, m);
    for(int i = 1; i <= n; ++i){
        sd(x);
        insert(x);
    }
    for(int i = 1; i <= m; ++i){
        sd(x);
        cout<<getans(x)<<endl;
    }
}

int main(){
    sd(T);
    for(int t = 1; t <= T; ++t){
        cout<<"Case #"<<t<<":\n";
        work();
    }
    
    return 0;
}

Chip Factory

题目描述：

n个数，找到三个数ai、aj、ak，在i与j与k三者互不相同的条件下，输出(ai+aj)⊕ak的最大值，⊕指的是异或

思路：

n<=1000，说明可以直接暴力计算个ai+aj，将他作为一个数p，来查ak且与p异或后的最大值

但是这里的难点是怎么忽略ai与aj？建树的时候他们俩很大可能和别的数有公共的前缀，那就没法直接删掉了，不然会影响其他的数，但是我们可以通过一个num数组来标记，插入的时候给每个有值的位置的num都++，删除的时候就对要删的数x对应到树上的每一位的num都–，查询的时候就在if那里面加一个num的判断条件即可

#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<bitset>
#include<cstdio>
#include<string>
#include<vector>
#include<sstream>
#include<cstring>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
using namespace std;

#pragma GCC optimize("Ofast")
#pragma GCC target("fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")

#define eps 1e-8
#define endl '\n'
#define inf 0x3f3f3f3f
#define MAX  300000 + 50
#define mod 998244353
#define lowbit(x) (x & (-x))
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d %d",&n,&m)
#define pd(n) printf("%d\n", (n))
#define pdd(n,m) printf("%d %d\n",n, m)
#define sddd(n,m,z) scanf("%d %d %d",&n,&m,&z)
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
//#define max(a,b) (((a)>(b)) ? (a):(b))
//#define min(a,b) (((a)>(b)) ? (b):(a))

typedef  long long ll ;
typedef unsigned long long ull;
//不开longlong见祖宗!不看范围见祖宗!
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}

int n;
int x, tot;
int tr[MAX][2];
int num[MAX];
int ar[MAX];

void insert(int x){
    int root = 0;
    ++num[root];
    for(int i = 31; i >= 0; --i){
        int id = (x >> i) & 1;
        if(!tr[root][id])tr[root][id] = ++tot;
        root = tr[root][id];
        ++num[root];
    }
}

void update(int x, int op){
    int root = 0;
    num[root] += op;
    for(int i = 31; i >= 0; --i){
        int id = (x >> i) & 1;
        root = tr[root][id];
        num[root] += op;
    }
}

int getans(int x){
    int ans = 0;
    int root = 0;
    for(int i = 31; i >= 0; --i){
        int id = (x >> i) & 1;
        if(tr[root][id ^ 1] && num[tr[root][id ^ 1]] > 0){
            ans = ans << 1 | 1;
            root = tr[root][id ^ 1];
        }
        else{
            ans = ans << 1;
            root = tr[root][id];
        }
    }
    return ans;
}



void work(){
    tot = 0;
    mem(tr, 0);
    mem(num, 0);
    sd(n);
    for(int i = 1; i <= n; ++i){
        sd(ar[i]);
        insert(ar[i]);
    }
    int maxn = 0;
    for(int i = 1; i <= n; ++i){
        update(ar[i], -1);
        for(int j = i + 1; j <= n; ++j){
            update(ar[j], -1);
            maxn = max(maxn, getans(ar[i] + ar[j]));
            update(ar[j], 1);
        }
        update(ar[i], 1);
    }
    cout<<maxn<<endl;
}

int main(){
    int T;
    sd(T);
    for(int t = 1; t <= T; ++t){
        work();
    }
    
    return 0;
}

Nikitosh 和异或

题目描述：

给一个数组，找两个任意长度且没有重叠的区间[l1, r1], [l2, r2],设这两个区间异或的值分别为a,b，输出最大的a+b

思路：

这个题需要一些思维

求两个没有重叠的区间的异或后的和最大，没有重叠不好搞

我们可以求两个数组ar、br，ar代表从1开始到i中连续区间的异或和的最大值，br代表从i到n中连续区间的异或和的最大值

那ans就只需要从1循环到最后，取max(ar[i] + br[i + 1])即可

这样我们需要做的就是求前缀区间的异或最大值、后缀区间的异或最大值、就想普通的那样做就行

#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<bitset>
#include<cstdio>
#include<string>
#include<vector>
#include<sstream>
#include<cstring>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
using namespace std;

#pragma GCC optimize("Ofast")
#pragma GCC target("fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")

#define eps 1e-8
#define endl '\n'
#define inf 0x3f3f3f3f
#define MAX  13000000 + 50
#define mod 1000000007
#define lowbit(x) (x & (-x))
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d %d",&n,&m)
#define pd(n) printf("%d\n", (n))
#define pdd(n,m) printf("%d %d\n",n, m)
#define sddd(n,m,z) scanf("%d %d %d",&n,&m,&z)
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
//#define max(a,b) (((a)>(b)) ? (a):(b))
//#define min(a,b) (((a)>(b)) ? (b):(a))

typedef  long long ll ;
typedef unsigned long long ull;
//不开longlong见祖宗!不看范围见祖宗!
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}

int n, x, num;
int tr[MAX][2];
int ar[400005], br[400005];
int tot;

void insert(int x){
    int root = 0;
    bitset<32>b(x);
    for(int i = 31; i >= 0; --i){
        int id = b[i];
        if(!tr[root][id])tr[root][id] = ++tot;
        root = tr[root][id];
    }
}

int getans(int x){
    bitset<32>b(x);
    int ans = 0, root = 0;
    for(int i = 31; i >= 0; --i){
        int id = b[i];
        if(tr[root][id ^ 1]){
            ans <<= 1;ans |= 1;
            root = tr[root][id ^ 1];
        }
        else{
            ans <<= 1;
            root = tr[root][id];
        }
    }
    return ans;
}


int main(){
    sd(n);
    for(int i = 1; i <= n; ++i){
        sd(ar[i]);
    }
    insert(0);
    int maxn = -1;
    int pre = 0;
    for(int i = 1; i <= n; ++i){
        pre ^= ar[i];
        maxn = max(maxn, getans(pre));
        ar[i] = maxn;
        insert(pre);
    }
    tot = 0;maxn = -1;
    mem(tr, 0);
    pre = 0;
    for(int i = n; i >= 1; --i){
        pre ^= ar[i];
        maxn = max(maxn, getans(pre));
        br[i] = maxn;
        insert(pre);
    }
    int ans = -1;
    for(int i = 1; i < n; ++i){
        ans = max(ans, ar[i] + br[i + 1]);
    }
    cout<<ans<<endl;
    return 0;
}

奶牛异或

题目描述：

农民约翰在喂奶牛的时候被另一个问题卡住了。他的所有N(1 <= N <= 100,000)个奶牛在他面前排成一行(按序号1…N的顺序)，按照它们的社会等级排序。奶牛#1有最高的社会等级，奶牛#N最低。每个奶牛同时被指定了一个不唯一的附加值，这个数在 [0, 221 - 1] 的范围内。

帮助农民约翰找出应该从哪一头奶牛开始喂，使得从这头奶牛开始的一个连续的子序列上，奶牛的附加值的异或最大。

如果有多个这样的子序列，选择结尾的奶牛社会等级最高的。如果还不唯一，选择最短的。

思路：

求一个连续区间的异或最大值，还要结尾是社会等级最高的

我们边输入边查询答案，再插入前缀异或值

这样就有利于确定结尾是谁而不会混乱

要注意一些边界的细节问题

还有就是ans的初始值必须要小于0，不然如果最终ans是0就会出大问题，你的l和r是不会更新的！

#include<map>
#include<set>
#include<stack>
#include<queue>
#include<cmath>
#include<bitset>
#include<cstdio>
#include<string>
#include<vector>
#include<sstream>
#include<cstring>
#include<stdlib.h>
#include<iostream>
#include<algorithm>
using namespace std;

#pragma GCC optimize("Ofast")
#pragma GCC target("fma,sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,avx2,tune=native")
#pragma GCC optimize("unroll-loops")

#define eps 1e-8
#define endl '\n'
#define inf 0x3f3f3f3f
#define MAX  2300000 + 50
#define mod 1000000007
#define lowbit(x) (x & (-x))
#define sd(n) scanf("%d",&n)
#define sdd(n,m) scanf("%d %d",&n,&m)
#define pd(n) printf("%d\n", (n))
#define pdd(n,m) printf("%d %d\n",n, m)
#define sddd(n,m,z) scanf("%d %d %d",&n,&m,&z)
#define io ios::sync_with_stdio(false); cin.tie(0); cout.tie(0)
#define mem(a,b) memset((a),(b),sizeof(a))
//#define max(a,b) (((a)>(b)) ? (a):(b))
//#define min(a,b) (((a)>(b)) ? (b):(a))

typedef  long long ll ;
typedef unsigned long long ull;
//不开longlong见祖宗!不看范围见祖宗!
inline int IntRead(){char ch = getchar();int s = 0, w = 1;while(ch < '0' || ch > '9'){if(ch == '-') w = -1;ch = getchar();}while(ch >= '0' && ch <= '9'){s = s * 10 + ch - '0';ch = getchar();}return s * w;}

int n;
int tot, x, num;
int l, r, ans;
int tr[MAX][2];
int now[MAX];

void insert(int x, int pos){
    int root = 0;
    for(int i = 21; i >= 0; --i){
        int id = (x>>i) & 1;
//        cout<<id;
        if(!tr[root][id])tr[root][id] = ++tot;
        root = tr[root][id];
    }
//    cout<<endl;
    now[root] = pos;
}

void getans(int x, int rr){
    int root = 0;
    int cnt = 0;
    for(int i = 21; i >= 0; --i){
        int id = (x>>i) & 1;
        if(tr[root][id ^ 1]){
            cnt <<= 1;cnt |= 1;
            root = tr[root][id ^ 1];
        }
        else {
            cnt <<= 1;
            root = tr[root][id];
        }
    }
    if(ans < cnt){
        ans = cnt;
        r = rr;
        l = now[root] + 1;
    }
}

int main(){
    sd(n);
    ans = -1;
    insert(0, 0);
    for(int i = 1; i <= n; ++i){
        sd(x);
        num ^= x;
        getans(num, i);
        insert(num, i);
    }
    cout<<ans<<' '<<l<<' '<<r<<endl;
    return 0;
}
Suryxin.
关注
  • 1
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Type-Ahead-Search:Quora挑战01
05-10
提前输入搜索 Michael Miller，Jeffrey Sham Quora编程挑战1-提前输入搜索 压缩哈希树 在这个trie数据结构的实现中。 我们采用的方法与普通链接或双数组trie结构略有不同。 这是由多种原因引起的，这将在本设计文档中进行解释。 在数组结构的trie实现中，每个节点都包含一个数组，该数组包含所有可能的字符，在这种情况下为126个ASCII字符。 这样做的好处是，当插入到trie中时，它需要O（L）时间，其中L是要插入的字符串的长度。 另外，字符串搜索也只需要O（L）时间。 删除也很容易，只需将字符串跟随到最后一个节点，然后递归删除其所有节点。 这又需要O（L）时间。 该实施方式的主要缺点是其空间效率非常大。 使用BIG-O表示法来显示此...在列表结构的trie实现中，trie的每个节点都链接到下一个节点和另一个节点。 这样可以节省空间，因为在Trie中仅使用
trie树（一）01trie
sophilex的博客
08-11 1494
trie树是个好东西，而它有一类专门的应用，是用来处理区间异或的问题的，考虑到异或操作中我们只关心0/1，因此01tire也就是一种每一个节点最多只有两个儿子的树，具体操作其实跟普通trie树差不多，具体看例题吧。我们发现，对于一个数的二进制表示，最高位对结果的贡献是大于之前所有位的贡献之和的，所以，如果我们从高到低遍历每一位时，只要当前这一位能满足异或后得到1，我们就一定取这个值。对于给定的s，我们考虑它的二进制表示，现在就是要尽可能使得它的每一个非1位都有一个0对应。......
可持久化01Trie
wsywsyyy的博客
11-09 144
假设max_id是3，限制条件是2，表示的是这个字数有一个数它的下标是3，所以就可以遍历这个节点，反之，就不可以遍历，因为每一个节点它的下标大于限制条件，都是l前面的数，所以就不能遍历。这里我们都是动态开点，也就是假设当前我们的数是1，所以我们要向下遍历找到一个0，由于我们是有限制条件的，所以对于每一个节点，加入他的0的这个儿子的max_id大于我们的限制条件，也就是这个子树里面存在一个s{i]，它的下标大于或等于我们的限制条件，所以我们就可以往0这个方向走。下面就用上面这个例题来介绍它的用处！
01Trie树
jiahonghao2002的博客
02-26 667
子集查找树 LeetCode 1178 猜字谜 前言 如果你看到了这篇题解，那么你应该对二进制状态压缩并枚举子集+哈希表和Tire树的做法有了一定的认识，那么我们能不能把这两种方法结合起来呢，答案是可以的，使用一种神奇的数据结构——子集查找树。另外，本题又要求加上必须包含首字母的这个条件，所以我们需要魔改一下。 子集查找树 子集查找树类似与Tire树，只不过Tire树处理的是字符串序列，而子集查找树处理的是二进制序列。类比与Tire树，子集查找树中每个节点有两个子节点，分别是0和1，代表了二进制序列中的下一
字典树（Trie）
cyyyyds857的博客
11-05 539
字典树，英文名 trie。顾名思义，就是一个像字典一样的树。
01 Trie （基本概念、经典例题）
SongyangJi
03-05 1065
The XOR Largest Pair 01Trie的典型例题 两数字异或运算求最值: 思路： 将数字理解为一个长度为32的01串，异或运算求最值，应该贪心地从最高位到最低位取不同的数字。 步骤： 将所有数字插入Trie，然后遍历n个数字，对于每个数字从高位到低位， 依次匹配与它不同的数字（没有就匹配相同的）。 注意这样贪心是合理的，因为高位的数字影响大于低位数字影响总和。 譬如: 0x1000...
01字典树的应用
wangkr ‘s blog
07-29 276
01字典树的应用 01Trie可以快速处理一堆数字 既然trie树比较与字符串亲近，我们就想方设法地把数字转成字符串 没错！就是二进制！ 01Trie的应用（1）： 给出一个集合，多次询问，每次给出一个数，求这个数和集合中的数的异或的最大值。 根据位运算的性质，高位越大越好。 按照数字的二进制建立 Trie，对于一个询问，从上往下走，贪心的选异或起来更大的方向走，直到走到叶子。 具体实现： #i...
01trie树学习笔记
J
01-01 878
01trie树学习笔记问题引入什么是01trie树问题解答两个扩展例题1.第kkk大异或和2.树上最大异或路径 问题引入 给一个长为nnn的数列，要求一个aia_iai​,aja_jaj​,使得aixoraja_i xor a_jai​xoraj​最大。 什么是01trie树 类似于字典树的做法，将每一个数化为二进制数，看作01串，插入到字典树中。 问题解答 首先建好01trie树，然后对于每一个数，在树上跑一遍贪心，即贪心选择与这个数当前位不同的那个节点。 也就是说，尽可能地保证越高的位的异或和为1，（因
Trie树和01Trie树
ComingLiu的博客
01-20 366
Trie树概要插入操作查找操作例题 概要 字典树又叫前缀树，一般用来存储一些单词或数字，在查找的时候比较方便，由于相同前缀只存储一次，所以也是比较省空间的 字典树是一棵树，一般用数组存储比较方便，从根节点出发，根节点不存储字母，每遇到一个字母，先判断树上是不是已经有了，如果有了，就顺着这条路；如果没有，新建立一条路径，直到最后一个字母，这时候将末尾字母所在位置染色，表示这是末尾字母。所以，字典树是一棵多叉树。 字典树思想相对比较容易 插入操作 使用p作为索引，贯穿于整条链，用k来记录节点次序，因为根
01Trie/可持久化01Trie学习笔记
Lolierl的博客
08-15 1676
01Trie是什么？它是一种较为特殊的权值线段树，可以解决一类与按位运算有关的问题。
leetcode76-Hihocode:Hihocode经典算法问题
06-30
Trie树 1015 KMP算法 1032 最长回文子串（manacher） 1039 字符消除 1323 回文字符串（dp增删字符） 1326 有序01字符串AC 1361 Playfair密码表 AC 1485 hiho字符串AC（滑动窗口） 恰好包含的最小长度 1485 LeetCode...
acwing和leetcode-Algorithm:acwinglabuladongleetcode
07-07
12、Trie树 Trie字符串统计(1) Trie字符串统计(2) Trie字符串统计(3) 13、并查集 合并集合 连通块中点的数量 labuladong专题 二叉树 二叉树的最近公共祖先 二叉树节点数 翻转二叉树 填充二叉树节点的右侧指针 将...
计算机算法与程序设计(python)-计算机PPT模板.pptx
05-28
第八章二叉搜索树 01 8.1二叉搜索树的定义与查找 02 8.2二叉搜索树的实现 03 8.3有序数组构造二叉搜索树 04 8.4二叉搜索树的区间查找 05 8.5二叉搜索树的插入 06 8.6trie树 计算机算法与程序设计(python)-计算机PPT...
C#，数值计算，解微分方程的龙格-库塔二阶方法与源代码
04-25
C#，数值计算，解微分方程的龙格-库塔二阶方法与源代码 微分方程 含有导数或微分的方程称为微分方程，未知函数为一元函数的微分方程称为常微分方程。 微分方程的阶数 微分方程中导数或微分的最高阶数称为微分方程的阶数。 微分方程的解 使得微分方程成立的函数称为微分方程的解。 微分方程的特解 微分方程的不含任意常数的解称为微分方程的特解。 微分方程的通解 所含相互独立的任意常数的个数与微分方程的阶数相等的微分方程的解称为微分方程的通解。
桌面聊天室
04-25
该毕业设计采用了c/s架构，通过javase中的知识编写完成，系统功能包括：用户注册，用户登录，聊天功能。 对于刚学完java基础的同学来说可以通过该毕业设计加深对所学知识的理解。该系统使用socket进行数据的发送，用户注册登录之后，可以进行多人聊天，功能类似qq群聊。
【前端素材】大数据-交通大屏.zip
最新发布
04-25
大数据技术指的是用于处理和分析大规模数据集的技术和工具。以下是一些常见的大数据技术和工具： Hadoop：Apache Hadoop是一个用于分布式存储和处理大规模数据的开源框架。它包括Hadoop Distributed File System（HDFS）用于数据存储和MapReduce用于数据处理。 Spark：Apache Spark是一个快速、通用的集群计算系统，提供了比MapReduce更快的数据处理能力。它支持内存计算和更多复杂的数据处理流程。 NoSQL数据库：NoSQL数据库（如MongoDB、Cassandra等）则更适用于处理这类数据。 数据仓库：数据仓库是一个用于集成和分析大规模数据的存储系统，一些知名的数据仓库包括Snowflake、Amazon Redshift等。 数据湖：数据湖是一个存储结构化和非结构化数据的存储池，用于支持数据分析和机器学习应用。 机器学习：大数据技术也广泛应用于机器学习领域，支持大规模数据的模型训练和预测分析。 流式处理：针对实时数据处理需求，流式处理技术（如Apache Kafka、Apache Flink）可以实时。
inspect：windows系统下的控件识别工具
04-25
windows系统下的控件识别工具，可用于桌面应用的UI自动化测试
038ssm-jsp-mysql高校毕业生就业满意度调查统计系统.zip（可运行源码+数据库文件+文档）
04-25
高校毕业生就业满意度调查统计系统是以实际运用为开发背景，运用软件工程开发方法，采用jsp技术构建的一个管理系统。整个开发过程首先对软件系统进行需求分析，得出系统的主要功能。接着对系统进行总体设计和详细设计。总体设计主要包括系统总体结构设计、系统数据结构设计、系统功能设计和系统安全设计等；详细设计主要包括模块实现的关键代码，系统数据库访问和主要功能模块的具体实现等。最后对系统进行功能测试，并对测试结果进行分析总结，及时改进系统中存在的不足，为以后的系统维护提供了方便，也为今后开发类似系统提供了借鉴和帮助。 本高校毕业生就业满意度调查统计系统采用的数据库是Mysql，使用JSP技术开发。在设计过程中，充分保证了系统代码的良好可读性、实用性、易扩展性、通用性、便于后期维护、操作方便以及页面简洁等特点。 关键词：高校毕业生就业满意度调查统计系统，JSP技术，Mysql数据库
小程序-58-童心党史小程序-源码.zip
04-25
提供的源码资源涵盖了小程序应用等多个领域，每个领域都包含了丰富的实例和项目。这些源码都是基于各自平台的最新技术和标准编写，确保了在对应环境下能够无缝运行。同时，源码中配备了详细的注释和文档，帮助用户快速理解代码结构和实现逻辑。 适用人群： 适合毕业设计、课程设计作业。这些源码资源特别适合大学生群体。无论你是计算机相关专业的学生，还是对其他领域编程感兴趣的学生，这些资源都能为你提供宝贵的学习和实践机会。通过学习和运行这些源码，你可以掌握各平台开发的基础知识，提升编程能力和项目实战经验。 使用场景及目标： 在学习阶段，你可以利用这些源码资源进行课程实践、课外项目或毕业设计。通过分析和运行源码，你将深入了解各平台开发的技术细节和最佳实践，逐步培养起自己的项目开发和问题解决能力。此外，在求职或创业过程中，具备跨平台开发能力的大学生将更具竞争力。 其他说明： 为了确保源码资源的可运行性和易用性，特别注意了以下几点：首先，每份源码都提供了详细的运行环境和依赖说明，确保用户能够轻松搭建起开发环境；其次，源码中的注释和文档都非常完善，方便用户快速上手和理解代码；最后，我会定期更新这些源码资源，以适应各平台技术的最新发展和市场需求。 所有源码均经过严格测试，可以直接运行，可以放心下载使用。有任何使用问题欢迎随时与博主沟通，第一时间进行解答！
trie树Python模板
04-09
当然，我可以为您介绍一下Trie树的Python模板。 Trie树，也称为字典树或前缀树，是一种用于高效存储和检索字符串的数据结构。下面是一个基本的Trie树的Python模板： ```python class TrieNode: def __init__(self...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值