LeetCode 剑指 Offer II 前缀树(上) 专题总结

已于 2022-01-19 15:57:15 修改
阅读量830 收藏 3
点赞数 15
分类专栏： LeetCode 文章标签： leetcode 算法 树结构
于 2022-01-19 07:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45911678/article/details/122568696
版权
  • 📚 博客主页：⭐️这是一只小逸白的博客鸭~⭐️
  • 👉 欢迎 关注❤️点赞👍收藏⭐️评论📝
  • 😜 小逸白正在备战实习，经常更新面试题和LeetCode题解，欢迎志同道合的朋友互相交流~
  • 💙 若有问题请指正，记得关注哦，感谢~

往期文章 ：

第一题了解前缀树比较简单，后面两题应用就稍微难一点，代码量都挺高的，但思路很简单，希望别劝退新手

目录

062. 实现前缀树

题目：

Trie（发音类似 “try”）或者说 前缀树 是一种树形数据结构，用于高效地存储和检索字符串数据集中的键。这一数据结构有相当多的应用情景，例如自动补完和拼写检查。
请你实现 Trie 类：

  • Trie() 初始化前缀树对象。
  • void insert(String word) 向前缀树中插入字符串 word 。
  • boolean search(String word) 如果字符串 word 在前缀树中，返回 true（即，在检索之前已经插入）；否则，返回 false 。
  • boolean startsWith(String prefix) 如果之前已经插入的字符串 word 的前缀之一为 prefix ，返回 true ；否则，返回 false 。

示例：

输入
inputs = [“Trie”, “insert”, “search”, “search”, “startsWith”, “insert”, “search”]
inputs = [[], [“apple”], [“apple”], [“app”], [“app”], [“app”], [“app”]]
输出
[null, null, true, false, true, null, true]
解释
Trie trie = new Trie();
trie.insert(“apple”);
trie.search(“apple”); // 返回 True
trie.search(“app”); // 返回 False
trie.startsWith(“app”); // 返回 True
trie.insert(“app”);
trie.search(“app”); // 返回 True

提示：

  • 1 <= word.length, prefix.length <= 2000
  • word 和 prefix 仅由小写英文字母组成
  • insert、search 和 startsWith 调用次数 总计 不超过 3 * 104 次

思路：

Trie，又称前缀树或字典树，是一棵有根树，其每个节点包含以下字段：

  • 指向子节点的指针数组 children。对于本题而言，数组长度为 26，即小写英文字母的数量。此时 children[0] 对应小写字母 a，children[1] 对应小写字母 b，…，children[25] 对应小写字母 z。
  • 布尔字段 isEnd，表示该节点是否为字符串的结尾。

我习惯用next替代children，因为比较好写吧，这题相当于介绍前缀树，所以代码也很简单，不懂的可以先百度前缀树，了解了再来看，无非就是把二叉树替换成26叉树，然后一个bool判断是否到达结尾，然后掌握插入和查询方法。

class Trie {
private:
    // 前缀树， 相当于26叉树
    vector<Trie*> next;
    // 判断是否为单词终点
    bool isWrod;

    // 因为search，startsWith方法都需要查询，所以提取出查询方法
    // 直接返回查询最后的点
    Trie* searchPrefix(string prefix) {
        Trie* node = this;
        for(char ch : prefix) {
            int index = ch - 'a';
            if(node->next[index] != nullptr) {
                node = node->next[index];
            }else {
                return nullptr;
            }
        }
        return node;
    }
public:
    
    Trie():next(26),isWrod(false) {}
    
    void insert(string word) {
    int count = 0;
        // 指向当前类，每个类都有26个分支
        Trie* node = this;
        for(char ch : word) {
            int index = ch - 'a';
            if(node->next[index] == nullptr) {
                // 创建父类节点的index节点，此时index也有26个分支
                node->next[index] = new Trie();
            }
            // 将父类指向index节点
            node = node->next[index];
        }
        // 创建完当前node指向最后一个单词，设为单词终点
        node->isWrod = true;
    }
    
    // 不为空 and 最后一个点的isWrod为true 代表word存在
    bool search(string word) {
        Trie* node = this->searchPrefix(word);
        return node != nullptr && node->isWrod;
    }
    // 不为空即查到了前缀
    bool startsWith(string prefix) {
        Trie* node = this->searchPrefix(prefix);
        return node != nullptr;
    }
};

063. 替换单词

题目：

在英语中，有一个叫做 词根(root) 的概念，它可以跟着其他一些词组成另一个较长的单词——我们称这个词为 继承词(successor)。例如，词根an，跟随着单词 other(其他)，可以形成新的单词 another(另一个)。
现在，给定一个由许多词根组成的词典和一个句子，需要将句子中的所有继承词用词根替换掉。如果继承词有许多可以形成它的词根，则用最短的词根替换它。
需要输出替换之后的句子。

示例：

输入：dictionary = [“cat”,“bat”,“rat”], sentence = “the cattle was rattled by the battery”
输出：“the cat was rat by the bat”

提示：

  • 1 <= dictionary.length <= 1000
  • 1 <= dictionary[i].length <= 100
  • dictionary[i] 仅由小写字母组成。
  • 1 <= sentence.length <= 10^6
  • sentence 仅由小写字母和空格组成。
  • sentence 中单词的总量在范围 [1, 1000] 内。
  • sentence 中每个单词的长度在范围 [1, 1000] 内。
  • sentence 中单词之间由一个空格隔开。
  • sentence 没有前导或尾随空格。

思路：

  1. 将词根加入到前缀树中，insert方法跟上一题一样
  2. 分割字符串，将单词保存到数组中
  3. 处理字符串，就是找到词根就截取单词的词根部分，否则直接添加单词
    prefixLen方法跟上题查询方法很像，本来查到结尾返回true，现在返回词根长度，查不到结尾就返回0，方便判断是否查到词根
class Trie {
private:
    bool isWord;
    vector<Trie*> next;
public:
    Trie():next(26,nullptr),isWord(false){};
    // 跟上一题一样
    void insert(const string& word) {
        Trie* node = this;
        for(char ch : word) {
            int index = ch - 'a';
            if(node->next[index] == nullptr) {
                node->next[index] = new Trie();
            }
            node = node->next[index];
        }
        node->isWord = true;
    }
    // 相对于上一题的search稍作修改
    int prefixLen(const string& word) {
        Trie* node = this;
        // 返回前缀的长度
        int len = 0;
        for(char ch : word) {
            int index = ch - 'a';
            // 没有这个前缀
            if(node->next[index] == nullptr) {
                return 0;
            }
            node = node->next[index];
            len++;
            // 找到这个前缀并返回这个前缀的长度
            if(node->isWord) 
                return len;
        }
        return 0;
    }
};

class Solution {
public:
    string replaceWords(vector<string>& dictionary, string sentence) {
        Trie* root = new Trie();
        // 将词根加入前缀树
        for(auto& word : dictionary) {
            root->insert(word);
        }

        // 分割字符串
        vector<string> words{""};
        for(char ch : sentence) {
            if(ch == ' ') {
                words.push_back("");
            }else {
                words.back().push_back(ch);
            }
        }
        // 处理字符串
        string res;
        for(auto& word : words) {
            int len = root->prefixLen(word);
            // 没找到直接添加
            if(len == 0){
                res += word + " ";
            }else {
                // 找到前缀只添加前缀部分
                res += word.substr(0, len) + " ";
            }
        }
        res.pop_back();
        return res;
    }
};

064. 神奇的字典

题目：

设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。
实现 MagicDictionary 类：
MagicDictionary() 初始化对象
void buildDict(String[] dictionary) 使用字符串数组 dictionary 设定该数据结构，dictionary 中的字符串互不相同
bool search(String searchWord) 给定一个字符串 searchWord ，判定能否只将字符串中 一个 字母换成另一个字母，使得所形成

示例：

输入
inputs = [“MagicDictionary”, “buildDict”, “search”, “search”, “search”, “search”]
inputs = [[], [[“hello”, “leetcode”]], [“hello”], [“hhllo”], [“hell”], [“leetcoded”]]
输出
[null, null, false, true, false, false]
解释
MagicDictionary magicDictionary = new MagicDictionary();
magicDictionary.buildDict([“hello”, “leetcode”]);
magicDictionary.search(“hello”); // 返回 False
magicDictionary.search(“hhllo”); // 将第二个 ‘h’ 替换为 ‘e’ 可以匹配 “hello” ，所以返回 True
magicDictionary.search(“hell”); // 返回 False
magicDictionary.search(“leetcoded”); // 返回 False

提示：

  • 1 <= dictionary.length <= 100
  • 1 <= dictionary[i].length <= 100
  • dictionary[i] 仅由小写英文字母组成
  • dictionary 中的所有字符串 互不相同
  • 1 <= searchWord.length <= 100
  • searchWord 仅由小写英文字母组成
  • buildDict 仅在 search 之前调用一次
  • 最多调用 100 次 search

思路：

前缀树 + dfs
初始化跟插入方法跟前两题一样
查询方法：

  • 如果 达到字典单词的末尾 and 查询单词的末尾 and 修改次数 ==1 代表查询成功
  • 遍历26个可能的字母，如果有一个true 直接返回true

以后函数传参记得将字符串这种类型的能加上引用&就加上
效率差了十倍，内存差了6倍，恐怖如斯
因为不加引用，dfs调用函数时会再创建一个形参string，费时间空间，加引用的话直接取传递的string参数，就不用再创建

在这里插入图片描述
在这里插入图片描述

class Trie {
public:
    vector<Trie*> next;
    bool isWord;
    Trie():next(26,nullptr),isWord(false){}
    void insert(const string& word) {
        Trie* node = this;
        for(auto& ch : word) {
            int index = ch - 'a';
            if(node->next[index] == nullptr) {
                node->next[index] = new Trie();
            }
            node = node->next[index];
        }
        node->isWord = true;
    }
};

class MagicDictionary {
private:
    Trie* root;
    bool dfs(Trie* root, string& word, int index, int edit) {
        if(root == nullptr || edit > 1) return false;
        //如果root正好在字典字符串结尾，且index刚好到达字符串末尾，且只被修改过一个字符
        if(root->isWord && index == word.size() && edit == 1) {
            return true;
        }
        if(index >= word.size())
            return false;

        //必须都遍历，否则如果 hello, hallo  查询hello直接查询完，就不会返回true
        for(int i = 0; i < 26; i++) {
            //如果子节点存在，edit不变；否则，edit加1；
            int nextEdit = i == word[index] - 'a'? edit : edit + 1;
            // 遍历26种，直到返回true
            if(dfs(root->next[i], word, index + 1, nextEdit))
                return true;
        }
        return false;
    }

public:
    /** Initialize your data structure here. */
    MagicDictionary() {
        root = new Trie();
    }
    
    void buildDict(vector<string> dictionary) {
        for(auto& word : dictionary) {
            root->insert(word);
        }
    }
    
    bool search(string searchWord) {
        return dfs(root, searchWord, 0, 0);
    }
};
一只小逸白
关注
  • 15
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 13
    评论
专栏目录
考研数据结构和leetcode-Coding:coding能力需要每天加强练习~剑指offer~leetcode~
06-30
剑指offer~ leetcode~ 数据结构与算法 数据结构研究的是数据如何在计算机中组织和存储，使得我们可以高效地获取数据和修改数据。 我们需要根据应用场景的不同，灵活选择最合适的数据结构。 线性结构 数组 链表 栈 ...
字典树实现_【每日算法Day 84】面试必考题：Trie（字典树/前缀树）的实现
weixin_32821251的博客
01-15 131
题目链接LeetCode 208. 实现 Trie (前缀树)[1]题目描述实现一个 Trie （前缀树），包含 insert, search, 和 startsWith 这三个操作。示例1Trie trie = new Trie(); trie.insert("apple"); trie.search("apple"); // 返回 true trie.search("app"); ...
【剑指 Offer II】 064. 神奇的字典
漆黑梦工厂
11-04 159
题目： 设计一个使用单词列表进行初始化的数据结构，单词列表中的单词 互不相同 。 如果给出一个单词，请判定能否只将这个单词中一个字母换成另一个字母，使得所形成的新单词存在于已构建的神奇字典中。 实现 MagicDictionary 类： MagicDictionary() 初始化对象 void buildDict(String[] dictionary) 使用字符串数组 dictionary 设定该数据结构，dictionary 中的字符串互不相同 bool search(String searchWord
剑指 Offer II 064. 神奇的字典
zy的博客
03-13 468
字典树 广义邻居
leetcode周赛有原题吗-leetcode:leetcodepractice(Java)，包含《剑指offer》和少量《leetbook》
06-30
leetcode周赛有原题吗 leetcode 题号 题目 难度 tag 两数之和 简单 两数相加 中等 无重复字符的最长子串 中等 : 最长回文子串 中等 字符串转换整数 (atoi) 中等 盛最多水的容器 中等 罗马数字转整数 简单 0014 最长...
leetcode题库-leetcode530:个人用来刷Leetcode的
06-29
剑指offer24 反转链表 双指针 :glowing_star: 69求平方根 二分法查找 :glowing_star: 剑指offer03 hashset :glowing_star: 20有效括号 栈 :glowing_star: 155最小栈 栈 :glowing_star: 160多数元素 hashmap :glowing...
leetcode计算机刷墙-learnNote:各种学习笔记
06-30
七、剑指offer系列 八、LeetCode 0、解题方法总结 1、BFS 2、DFS 3、DP 4、二分 5、位运算 6、双指针 7、哈希表 8、回溯 9、字符串 10、数学 11、数组 12、滑动窗口 13、链表 14、字典树 15、堆 16、前缀和 17、背包...
leetcode题库-work:C++后端开发面经整理
06-29
leetcode题库 后端开发 操作系统 计算机网络 C++基础知识 数据库 笔试常考类型 模拟 ★★★★★ 可难可易 大部分题都是模拟中使用某个算法优化 ...剑指offer先刷 + leetcode以下各类型至少10道+leetc
力扣Hot100-994腐烂的橘子
qq_52241267的博客
08-10 359
由于在找到腐烂水果后直接将它周围的水果置为腐烂水果，但是可能当前轮次腐烂的水果，又在当前轮次中影响周围水果，导致错误，所以可以标记：在不同轮次中被传染腐烂的水果标记为不同的数字，由于一开始time=0时，腐烂水果标记为2，所以在time=0到1这段时间被传染的水果标记为2+time+1,这样就可以使得本轮time=0时不会让标记为3的水果传染它周围的水果。左下角的橘子（第 2 行， 第 0 列）永远不会腐烂，因为腐烂只会发生在 4 个方向上。因为 0 分钟时已经没有新鲜橘子了，所以答案就是 0。
【LeetCode每日一题】——623.在二叉树中增加一行
IronmanJay的博客
08-14 787
给定一个二叉树的根 root 和两个整数 val 和 depth ，在给定的深度 depth 处添加一个值为 val 的节点行。 注意，根节点 root 位于深度 1 。 加法规则如下: 给定整数 depth，对于深度为 depth - 1 的每个非空树节点 cur ，创建两个值为 val 的树节点作为 cur 的左子树根和右子树根。 cur 原来的左子树应该是新的左子树根的左子树。 cur 原来的右子树应该是新的右子树根的右子树。 如果 depth == 1 意味着 depth - 1 根本没有深度
leetcode 103.二叉树的锯齿形层序遍历
m0_54244065的博客
08-09 892
2.做题思路:由题我们可以判断，树中每到偶数层时，就会逆置，所以我们可以采用层序遍历和逆置函数的方法来解此题。
【Hot100】LeetCode—76. 最小覆盖子串
最新发布
weixin_44382896的博客
08-14 292
【代码】【Hot100】LeetCode—76. 最小覆盖子串。
leetcode:1822. 数组元素积的符号(python3解法)
qq_41905051的博客
08-09 430
leetcode:1822. 数组元素积的符号(python3解法)
Java | Leetcode Java题解之第332题重新安排行程
m0_57195758的博客
08-13 378
Java | Leetcode Java题解之第332题重新安排行程
Leetcode JAVA刷刷站（10）正则表达式匹配
m0_73399576的博客
08-10 821
Leetcode JAVA刷刷站——字符串转换整数篇
Python | Leetcode Python题解之第332题重新安排行程
Mopes__的博客
08-13 317
Python | Leetcode Python题解之第332题重新安排行程
(回溯) LeetCode 39. 组合总和
zth12212003的博客
08-10 868
本题也十分建议练习，巩固回溯的基础同时可以应对相关的变题时间复杂度：O(S)，S 为所有可行解的长度之和；空间复杂度：O(target)。
LeetCode Hot100 排序链表
m0_67582670的博客
08-09 252
给你链表的头结点head，请将其按排列并返回。
评论 13
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

一只小逸白

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

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

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

打赏作者

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

抵扣说明：

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

余额充值