字典树模板

原创 已于 2024-11-08 22:48:14 修改 · 815 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#leetcode #算法 #职场和发展
于 2021-08-07 21:00:22 首次发布
本文介绍了ACWing和LeetCode中的字典树模板，展示了如何使用字典树结构实现字符串插入和查询操作，以及在LeetCode 720题中应用字典树解决最长单词问题。

目录

介绍

字典树，也叫trie树，是用来高效存储字符串和查询字符串的数据结构！

在这里插入图片描述

1 acwing字典树模板

C++代码如下，

const int N = 100010;

int son[N][26], cnt[N], idx;
char str[N];


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] = ++idx;
        p = son[p][u];
    }
    cnt[p]++;//以p结尾的单词数目，p表示结点编号
    return;
}


int query(char str[]){
    int p = 0;
    for(int i = 0; str[i]; i++){
        int u = str[i] - 'a';
        if(!son[p][u]) return 0;
        p = son[p][u];
    }
    return cnt[p];
}

2 leetcode字典树模板

题目1：720. 词典中最长的单词

解题思路：字典树

C++代码如下，

class Trie {
public:
    Trie() {
        this->children = vector<Trie *>(26, nullptr);
        this->isEnd = false;
    }

    bool insert(const string &word) {
        Trie* node = this;
        for (const auto &ch : word) {
            int index = ch - 'a';
            if (node->children[index] == nullptr) {
                node->children[index] = new Trie();
            }
            node = node->children[index];
        }
        node->isEnd = true;
        return true;
    }

    bool search(const string& word) {
        Trie* node = this;
        for (const auto& ch : word) {
            int index = ch - 'a';
            if (node->children[index] == nullptr || !node->children[index]->isEnd) {
                return false;
            }
            node = node->children[index];
        }
        return node != nullptr && node->isEnd;
    }

private:
    vector<Trie*> children;
    bool isEnd;
};

class Solution {
public:
    string longestWord(vector<string>& words) {
        Trie trie;
        for (const auto& word : words) {
            trie.insert(word);
        }
        string longest = "";
        for (const auto& word : words) {
            if (trie.search(word)) {
                if (word.size() > longest.size() || (word.size() == longest.size() && word < longest)) {
                    longest = word;
                }
            }
        }
        return longest;
    }
};

python3代码如下，

class Trie:
    def __init__(self):
        self.children = [None] * 26
        self.isEnd = False

    def insert(self, word: str) -> None:
        node = self
        for ch in word:
            ch = ord(ch) - ord('a')
            if not node.children[ch]:
                node.children[ch] = Trie()
            node = node.children[ch]
        node.isEnd = True
    
    def search(self, word: str) -> bool:
        node = self
        for ch in word:
            ch = ord(ch) - ord('a')
            if node.children[ch] is None or not node.children[ch].isEnd:
                return False
            node = node.children[ch]
        return True

class Solution:
    def longestWord(self, words: List[str]) -> str:
        t = Trie()
        for word in words:
            t.insert(word)
        longest = ""
        for word in words:
            if t.search(word) and (len(word) > len(longest) or len(word) == len(longest) and word < longest):
                longest = word
        return longest

题目2：1803. 统计异或值在范围内的数对有多少

解题思路：前缀字典树。

C++代码如下，

class TrieNode {
public:
    TrieNode* children[2] = {nullptr, nullptr};
    int sum = 0;
    TrieNode() : sum(0) {}
};

class Trie {
private:
    TrieNode* root = new TrieNode();
    static constexpr int HIGH_BIT = 14;
public:
    void add(int x) {
        //将数x插入到前缀字典树中
        TrieNode* cur = root;
        for (int i = HIGH_BIT; i >= 0; --i) {
            int bit = (x >> i) & 1;
            if (cur->children[bit] == nullptr) {
                cur->children[bit] = new TrieNode();
            }
            cur = cur->children[bit];
            cur->sum += 1;
        }
        return;
    }

    int get(int x, int limit) {
        //从前缀字典树中找到y，使得y^x <= limit，求有多少个这样的y
        int res = 0;
        TrieNode* cur = root;
        for (int i = HIGH_BIT; i >= 0; --i) {
            int bit = (x >> i) & 1;
            if ((limit >> i) & 1) {
                //limit的第i为1，从高位14开始数
                if (cur->children[bit] != nullptr) {
                    res += cur->children[bit]->sum;
                }
                if (cur->children[bit^1] == nullptr) {
                    return res;
                }
                cur = cur->children[bit^1];
            } else {
                //limit的第i位为0，从高位14开始数
                if (cur->children[bit] == nullptr) {
                    return res;
                }
                cur = cur->children[bit];
            }
        }
        res += cur->sum;
        return res;
    }
};

class Solution {
public:
    int countPairs(vector<int>& nums, int low, int high) {
        function<int(int)> f =[&] (int limit) -> int {
            int res = 0;
            int n = nums.size();
            Trie trie = Trie();
            for (int i = 0; i < n-1; ++i) {
                trie.add(nums[i]);
                res += trie.get(nums[i+1], limit);
            }
            return res;
        };   
        return f(high) - f(low-1);
    }
};

python3代码如下，

HIGH_BIT = 14

class TrieNode:
    def __init__(self):
        self.children = [None, None]
        self.sum = 0

class Trie:
    def __init__(self):
        self.root = TrieNode()
    
    def add(self, x: int) -> None:
        #往前缀trie树中插入数x
        cur = self.root
        for i in range(HIGH_BIT, -1, -1):
            bit = (x >> i) & 1
            if not cur.children[bit]:
                cur.children[bit] = TrieNode()
            cur = cur.children[bit]
            cur.sum += 1
        return 
    
    def get(self, x: int, limit: int) -> int:
        #从前缀trie树中找到y，使得y^x <= limit，返回这样的y的个数
        res = 0
        cur = self.root 
        for i in range(HIGH_BIT, -1, -1):
            bit = (x >> i) & 1
            if (limit >> i) & 1:
                if cur.children[bit]:
                    #字典树中y^x的值，与limit进行比较
                    #记HIGH_BIT-i为k
                    #前k-1位相同，但第k位不同，y^x的第k为0，而limit的第k位为1
                    res += cur.children[bit].sum 
                if not cur.children[bit^1]:
                    #字典树中y^x的值，与limit进行比较
                    #记HIGH_BIT-i为k
                    #前k位都相同的数，它不存在
                    return res 
                cur = cur.children[bit^1]
            else:
                #记HIGH_BIT-i为k
                #limit的第k位为0
                #y^X的第k位的数只能为0
                if not cur.children[bit]:
                    #字典树中y^x的值，与limit进行比较
                    #记HIGH_BIT-i为k
                    #前k位都相同的数，它不存在
                    return res 
                cur = cur.children[bit]
        res += cur.sum #加上末尾结点的值 
        return res 
    
class Solution:
    def countPairs(self, nums: List[int], low: int, high: int) -> int:
        def f(limit: int) -> int:
            #nums中nums[i]^nums[j]<=limit，且i<j的(i,j)的个数
            res = 0
            trie = Trie()
            n = len(nums)
            for i in range(n-1):
                trie.add(nums[i])
                res += trie.get(nums[i+1], limit)
            return res 
        return f(high) - f(low-1)

题目3：421. 数组中两个数的最大异或值

C++字典树模板，只需要定义一个TrieNode结构体即可。

struct TrieNode {
    TrieNode* children[2] = {nullptr, nullptr};
    TrieNode() {
        children[0] = nullptr;
        children[1] = nullptr;
    }
};

class Solution {
public:
    int findMaximumXOR(vector<int>& nums) {
        TrieNode* trie = new TrieNode();
        int res = 0;
        for (auto num : nums) {
            //在trie中查找num
            TrieNode* cur = trie;
            int ans = 0;
            for (int i = 31; i >= 0; --i) {
                if (cur == nullptr) break;
                int x = (num >> i) & 1;
                if (cur->children[1-x] != nullptr) {
                    ans += 1 << i;
                    cur = cur->children[1-x];
                } else {
                    cur = cur->children[x];
                }
            }
            res = max(res, ans);

            //把num写入到trie中
            cur = trie; //重新将cur置为起始结点
            for (int i = 31; i >= 0; --i) {
                int x = (num >> i) & 1;
                if (cur->children[x] == nullptr) {
                    cur->children[x] = new TrieNode();
                }
                cur = cur->children[x];
            }
        }
        return res;
    }
};

python3简洁版字典树（纯字典实现），

class Solution:
    def findMaximumXOR(self, nums: List[int]) -> int:
        trie = {}
        res = 0
        for num in nums:
            #从trie树中查找元素
            ans = 0
            cur = trie 
            for i in range(31,-1,-1):
                x = (num >> i) & 1
                if (1-x) in cur:
                    ans += (1 << i)
                    cur = cur[1-x]
                else:
                    if x in cur:
                        cur = cur[x]
                    else:
                        break 
            res = max(res, ans) #更新res
            #将num插入trie树中
            cur = trie
            for i in range(31,-1,-1):
                x = (num >> i) & 1
                if x in cur:
                    pass 
                else:
                    cur[x] = {}
                cur = cur[x]
        return res

参考

acwing算法基础之数据结构–trie算法或字典树算法

oi-wiki字典树

字典树的模版（模版）
07-18
字典树的模版，想学习的自己亲自把代码打一下就可以了。
【图解算法】模板+变式——带你彻底搞懂字典树(Trie树)
热门推荐
丧心病狂Loli控的博客
07-12 2万+
  啥是字典树？ 【字典树】(Trie Tree) 是一种树形结构，是一种哈希树的变种。典型应用是用于统计，排序和保存大量的字符串（但不仅限于字符串）。 它的优点是：利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较，查询效率比哈希树高。                                                     ——百度 · 百科 so？所以到底什么是字典树？   还好，它还有其他的名字，更能表述出它的实质： 前缀树、单词查找树 &nbs
【C++算法模板】字典树，超详细注释带例题讲解
qq_63586399的博客
03-14 1577
字典树是快速插入和查询字符串的多叉树结构，根节点编号为0，其余节点标识路径，还可以标记单词插入的次数，边表示字符。
手把手教你用Java代码离线激活FinalShell高级版（附完整源码）
最新发布
weixin_30527323的博客
04-29 363
本文详细解析了FinalShell高级版的离线激活技术原理，通过Java代码实现密钥生成器，帮助开发者理解硬件码转换算法与MD5哈希的应用。提供完整源码与实战指南，适用于需要离线激活FinalShell高级版的用户。
【字典树】模板+讲解
SY奇星的OI博客
07-11 582
字典树（Trie），也称为前缀树或字典树，是一种用于存储和检索字符串的数据结构。它是一种有序树，用于保存关联数组，其中键通常是字符串。字典树的特点是能够高效地进行字符串的插入、删除和查找操作。字典树的基本思想是利用字符串的公共前缀来节省存储空间和提高查询效率。树的根节点不包含任何字符，每个节点包含一个字符，从根节点到叶节点的路径上构成一个字符串。通过沿着树的路径遍历字符，可以找到相应的字符串。总的来说，字典树是一种非常有用的数据结构，特别适用于需要高效存储和检索字符串的场景。
Trie字典树——【模板】字典树
swk13306006908的博客
02-09 658
那第三个不同就要我们思考一下了：前面的cnt[i]储存的是有多少个字符串在编号为i的字符上结束，那这里问的是前缀，那我们是不是可以把cnt[i]转换成有多少个字符串经过了编号为i的字符。我们看到这道题，是不是头很晕，这题要求我们求一个字符串在一个字符串集合中有几个字符串可以满足这个字符串是它的前缀，对于还没学Trie字典树的我们是一大挑战，所以我们先从一题简单的开始。2.字典树我们需要高效的查询一个字符串，而链式前向星的查询速度为O(n+m)，很容易超时。输入的字符串只含大小写字母和数字，且不含空串。
字典树的指针模板与数组模板
qq_18661257的专栏
03-06 2709
第一个模板便是指针字典树的模板： #include #include #include const int MAX=26; struct Tire{ Tire *next[MAX]; int v; }; Tire *root; void createTrie(char *str) { int len = strlen(str); Trie *p = root, *q;
字典树模板详解附加例题
m0_73557680的博客
10-05 351
字典树模板详解附加例题,P3879 [TJOI2010] 阅读理解,P2580 于是他错误的点名开始了, P4551 最长异或路径
字典树（Trie树）模板以及简单的入门题总结
lajiyuan的博客
06-05 1万+
字典树模板 const int maxn =2e6+5;//如果是64MB可以开到2e6+5，尽量开大 int tree[maxn][30];//tree[i][j]表示节点i的第j个儿子的节点编号 bool flagg[maxn];//表示以该节点结尾是一个单词 int tot;//总节点数 void insert_(char *str) { int len=strlen(str)...
字典树or前缀树(Trie树)的Python模板及例题
liangshuangeryue的博客
12-06 1968
今天刷到了字典树的知识，看了一篇文章感觉总结的挺好，链接放在下方，只不过文中的代码用的java，因为平时自己刷题用的都是python，所以打算将文章中的代码同步为python语言，方便和我一样用python的小伙伴学习参考~
字典树/TrieTree
qq_42643660的博客
08-08 438
字典树/TrieTree
01字典树 详解（模板，应用，进阶）
w20221013的博客
07-27 1381
01字典树是一棵最多31层的二叉树，其每个节点的两条边分别代表二进制的某一位的值为0还是1.将某个路径上的值连起来就得到一个二进制串
P8306 【模板】字典树
STY_fish_2012的博客
07-09 603
sn​ 和 q 次询问，每次询问给定一个文本串 ti​，请回答 s1​∼sn​ 中有多少个字符串 sj​ 满足 ti​ 是 sj​ 的。查询的时候，就一步一步在树中找，如果找到叶子结点了，但查询的单词没找完，就说明它不是已出现字符串的前缀，如果找完了字符串，就说明是。在输入模式串的时候，就根据上图的思路，按字符串每一位查找，并且存储。第一行是两个整数，分别表示模式串的个数 n 和询问的个数 q。接下来 n 行，每行一个字符串，表示一个模式串。接下来 q 行，每行一个字符串，表示一次询问。
Trie树（字典树）
2301_80224556的博客
03-09 2590
Trie树，又叫字典树前缀树（Prefix Tree）单词查找树或键树，是一种多叉树结构。如下图：上图是一棵Trie树，表示了关键字集合{“a”, “to”, “tea”, “ted”, “ten”, “i”, “in”, “inn”}。根节点不包含字符，除根节点外的每一个子节点都包含一个字符。从根节点到某一个节点，路径上经过的字符连接起来，为该节点对应的字符串。每个节点的所有子节点包含的字符互不相同。通常在实现的时候，会在节点结构中设置一个标志，用来标记该结点处是否构成一个单词（关键字）。
01字典树模板详解
m0_73557680的博客
10-07 432
给定n个整数a1,...,an，任选两个数进行异或运算，得到的最大结果是多少？ 1构造tire树->在树上进行异或运算2.^不同为1，相同为0 ，尽量走相反位，异或值最大n个数,m个询问 ，将ans[i]加入01字典树 ，o(n*log(ans)) 三、简单介绍下>> 、
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

YMWM_

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

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

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

打赏作者

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

抵扣说明：

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

余额充值