单词搜索I II/前缀树

最新推荐文章于 2025-02-18 21:43:37 发布
原创 最新推荐文章于 2025-02-18 21:43:37 发布 · 806 阅读 · 0 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
标签
#word #深度优先 #算法
文章介绍了如何使用Python实现基于字典树的搜索算法，包括在二维矩阵中搜索单词和构建前缀树。主要涉及了深度优先搜索（DFS）策略，以及在字典树中插入、查找和前缀匹配的功能。

79单词搜索

在这里插入图片描述

思路：
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

注意：
我自己在写

for i in range(m):
    for j in range(n):
        # 对每一个格子都从头开始搜索
        if self.__search_word(board, word, 0, i, j, marked, m, n):
            return True

这一段的时候，就写成了：

这一段代码是错误的，不要模仿

for i in range(m):
    for j in range(n):
        # 对每一个格子都从头开始搜索
        return self.__search_word(board, word, 0, i, j, marked, m, n)

这样其实就变成只从坐标 (0,0) 开始搜索，搜索不到返回 False，但题目的意思是：只要你的搜索返回 True 才返回，如果全部的格子都搜索完了以后，都返回 False ，才返回 False。

class Solution:
    directs = [(0,1),(0,-1),(1,0),(-1,0)]
   
    def exist(self, board: List[List[str]], word: str) -> bool:
        m = len(board)
        if m == 0:
            return False
        
        n = len(board[0])
        visited = [[0] * n for _ in range(m)]

        for i in range (0,m):
            for j in range (0,n):
                if self.dfs(i, j, 0, board, word, visited):
                    return True
        return False
    
    def dfs(self, x, y, begin, board, word, visited):
        # 递归出口，如果遍历的index在word的最后，判断盘上是否和单词最后一个是否一样
        if begin == len(word) - 1:
            return board[x][y] == word[begin]

        if board[x][y] == word[begin]:
            # 访问过标记
            visited[x][y] = 1

            for dire in self.directs:
                new_x = x + dire[0]
                new_y = y + dire[1]
                # 遍历四个方向，且保证不越界且没访问过,接着遍历单词的下一个位置
                if 0 <= new_x < len(board) and 0<= new_y < len(board[0]) and visited[new_x][new_y]==0:
                    if self.dfs(new_x, new_y, begin+1, board, word, visited):
                        return True
            # 回溯
            visited[x][y] = 0
        return False

class Solution:
    directs = [(0,1),(0,-1),(1,0),(-1,0)]
   
    def exist(self, board: List[List[str]], word: str) -> bool:
        m = len(board)
        if m == 0:
            return False
        
        n = len(board[0])
        visited = [[0] * n for _ in range(m)]
        def dfs(x, y, begin):
            # 递归出口，如果遍历的index在word的最后，判断盘上是否和单词最后一个是否一样
            if begin == len(word) - 1:
                return board[x][y] == word[begin]
            
    
            if board[x][y] == word[begin]:
                # 访问过标记
                visited[x][y] = 1

                for dire in self.directs:
                    new_x = x + dire[0]
                    new_y = y + dire[1]
                    # 遍历四个方向，且保证不越界且没访问过,接着遍历单词的下一个位置
                    if 0 <= new_x < len(board) and 0<= new_y < len(board[0]) and visited[new_x][new_y]==0:
                        if dfs(new_x, new_y, begin+1):
                            return True
                # 回溯
                visited[x][y] = 0
            return False

        for i in range (0,m):
            for j in range (0,n):
                if dfs(i, j, 0):
                    return True
        return False

208 前缀树

在这里插入图片描述

包含三个单词 “sea”,“sells”,“she” 的 Trie 会长啥样呢？
在这里插入图片描述
简化后：
在这里插入图片描述
定义类 Trie

class Trie {
private:
    bool isEnd;
    Trie* next[26];
public:
    //方法将在下文实现...
};

插入
描述：向 Trie 中插入一个单词 word

实现：这个操作和构建链表很像。首先从根结点的子结点开始与 word 第一个字符进行匹配，一直匹配到前缀链上没有对应的字符，这时开始不断开辟新的结点，直到插入完 word 的最后一个字符，同时还要将最后一个结点isEnd = true;，表示它是一个单词的末尾。

void insert(string word) {
    Trie* node = this;
    for (char c : word) {
        if (node->next[c-'a'] == NULL) {
            node->next[c-'a'] = new Trie();
        }
        node = node->next[c-'a'];
    }
    node->isEnd = true;
}

查找
描述：查找 Trie 中是否存在单词 word

实现：从根结点的子结点开始，一直向下匹配即可，如果出现结点值为空就返回 false，如果匹配到了最后一个字符，那我们只需判断 node->isEnd即可。

bool search(string word) {
    Trie* node = this;
    for (char c : word) {
        node = node->next[c - 'a'];
        if (node == NULL) {
            return false;
        }
    }
    return node->isEnd;
}

前缀匹配
描述：判断 Trie 中是或有以 prefix 为前缀的单词

实现：和 search 操作类似，只是不需要判断最后一个字符结点的isEnd，因为既然能匹配到最后一个字符，那后面一定有单词是以它为前缀的。

bool startsWith(string prefix) {
    Trie* node = this;
    for (char c : prefix) {
        node = node->next[c-'a'];
        if (node == NULL) {
            return false;
        }
    }
    return true;
}

链接：https://leetcode.cn/problems/implement-trie-prefix-tree/solution/trie-tree-de-shi-xian-gua-he-chu-xue-zhe-by-huwt/


class Trie:
    # 根节点不存字母
    # next 存了26个字母

    def __init__(self):
        self.next = [None] * 26
        self.isEnd = False


    def insert(self, word: str) -> None:
        node = self
        # 先查找有没有这个字母，没有就新建一个节点，新建后就有该字母的节点，就将树遍历下去
        for ch in word:
            # 如果ch在树中不存在，就新建一个单词的
            if node.next[ord(ch) - ord('a')] == None:
                node.next[ord(ch) - ord('a')] = Trie()
            node = node.next[ord(ch) - ord('a')]
        node.isEnd = True
            


    def search(self, word: str) -> bool:
        node = self
        for ch in word:
             if node.next[ord(ch) - ord('a')] == None:
                 return False
             node = node.next[ord(ch) - ord('a')]
        # 遍历到最后 判断是不是单词的结束
        return node.isEnd


    def startsWith(self, prefix: str) -> bool:
        node = self
        for ch in prefix:
             if node.next[ord(ch) - ord('a')] == None:
                 return False
             node = node.next[ord(ch) - ord('a')]
        # 遍历到最后 不需要判断是不是单词的结束 说明存在prefix 
        return True



# Your Trie object will be instantiated and called as such:
# obj = Trie()
# obj.insert(word)
# param_2 = obj.search(word)
# param_3 = obj.startsWith(prefix)

211. 添加与搜索单词 - 数据结构设计

在这里插入图片描述

思路：和208构建字典树类似
只是查询的时候需要对通配符.特殊处理，
在这里插入图片描述

class WordDictionary:

    def __init__(self):
        self.next = [None] * 26
        self.isEnd = False


    def addWord(self, word: str) -> None:
        node = self
        for ch in word:
            if node.next[ord(ch) - ord("a")] == None:
                node.next[ord(ch) - ord("a")] =  WordDictionary()
            node = node.next[ord(ch) - ord("a")]
        node.isEnd = True


    def search(self, word: str) -> bool:
        root =  self
        def dfs(index,node):
            if index == len(word):
                return node.isEnd
            ch = word[index]
            # 如果ch不是. 看是否存在该字符的节点 如果存在该字符节点 且往后搜索后面的字符 dfs(word下一个字符，树上的下一个节点)
            if ch != '.':
                child = node.next[ord(ch) - ord("a")]
                if child != None and dfs(index+1,child):
                    return True
            # ch 是. ,遍历整个next数组，26个元素，对每个元素都进行dfs
            else:
                for child in node.next:
                    if child != None and dfs(index+1,child):
                        return True
            return False
        return dfs(0,root)
            
            



# Your WordDictionary object will be instantiated and called as such:
# obj = WordDictionary()
# obj.addWord(word)
# param_2 = obj.search(word)

212单词搜索 II

在这里插入图片描述

思路：
对棋盘上的每个位置进行dfs，对输入的单词集合构建成字典树，对于棋盘上的任意位置（i，j）只有在字典树存在从字符a到字符b的边的时候，我们才能在棋盘上找到a-b的路径，

注意：
回溯过程，每次只需要判断新增单元格的字母是否是上一个单元格对应前缀树结点的子结点即可。
在这里插入图片描述

from collections import defaultdict
class TrieNode:
    def __init__(self):
        self.children = defaultdict(TrieNode) 
        #这里要把原来的指针换成map映射 因为要存具体字母的值  如果key不存在也会自动创建再插入不会报错
        self.word = ""# 这里把原来的isEnd换成单词串，如果是结尾存的是单词本身
    
    def insert(self, word):
        node = self
        for ch in word:
            node = node.children[ch] 
        node.word = word

class Solution:
    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
        # 给每个单词建立字典树
        trie = TrieNode()
        for word in words:
            trie.insert(word)
        print(trie.children)
        print( "b" in trie.children['o'].children) 
            #         defaultdict(<class '__main__.TrieNode'>, {'o': <__main__.TrieNode object at 0x7f518eeae7d0>, 'p': <__main__.TrieNode object at 0x7f518eef51b0>, 'e': <__main__.TrieNode object at 0x7f518eef52d0>, 'r': <__main__.TrieNode object at 0x7f518eef53f0>})
            # False
      
        m,n = len(board),len(board[0])
        directions = [(0,1),(0,-1),(1,0),(-1,0)]

    
        def dfs(x, y, node):
            # 加上也没错 但是运行时间会变长，因为多判断了一次 进入dfs永远不会经过这个 因为最后回溯都会复原 进入的xy也在范维内
            # if  not( 0<= x < m and 0 <= y < n) or board[x][y]=="#":
            #     return
            # 如果当前位置字符不在字典树当前节点的孩子中，直接返回
            ch = board[x][y]
            if ch not in node.children:
                return
            
            # 获取当前字符对应的子节点 
            child = node.children[ch]

            # 说明是单词结尾，加入结果集
            if child.word!="":
                res.add(child.word)
            
            # 如果不是单词结尾，标记已访问，探索该点的四个方向,说明应该有孩子节点
            if child.children: #!!关键语句 可以使运行时间减半
                board[x][y] = '#'
                for dire in directions:
                    new_x = x + dire[0]
                    new_y = y + dire[1]
                    # 边界符合且未访问过 dfs(board的新位置，字典树的下一个节点即孩子节)
                    if 0<= new_x < m and 0 <= new_y < n and board[new_x][new_y]!="#":
                        dfs(new_x, new_y, child)
                # 回溯
                board[x][y] = ch




        
        #存储搜索到的单词
        res  = set()
        # 对棋盘上的每个位置都dfs
        for i in range(m):
            for j in range(n):
                dfs(i,j,trie)
        return list(res)
sueong
关注
Python | 单词搜索(educoder)
鷾
03-11 5065
任务：编写一个能搜索单词的程序。
【算法】Trie数（前缀树/字典树）简介及Leetcode上关于前缀树的题
haolexiao的专栏
04-04 8426
前几天同学面今日头条被问到了Trie树，刚好我也对于Trie树这种数据结构不是很熟悉，所以研究了一下前缀树，然后把Leetcode上关于前缀树的题都给做了一遍。 Leetcode上关于前缀树的题有如下： 208. Implement Trie (Prefix Tree)这道题是实现一个前缀树，作为基础题啦 Add and Search Word - Data structure design这道题是
LeetCode Python - 79. 单词搜索
xuxu96
03-30 1237
输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCCED”输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “ABCB”输入：board = [[“A”,“B”,“C”,“E”],[“S”,“F”,“C”,“S”],[“A”,“D”,“E”,“E”]], word = “SEE”
LeetCode【0212】单词搜索 II
AnFany
11-25 785
题目难度：困难；数据结构：矩阵；应用算法：深度优先搜索、回溯算法
单词搜索 II（python）
weixin_38328708的博客
11-30 1469
leetcode算法题3
单词查词搜索并保存的方法-Python自制！
jxt_yes的博客
07-08 475
此代码是通过用户输入单词，调用到爬虫，去搜索单词的词意，和单词的音标，输入完之后，它会继续让你输入，如果你不想输入了，输入0，就是保存的意思，通过csv给你保存为office列表。
【DFS+Trie】力扣hard-单词搜索II（前缀树+DFS）
2202_75999061的博客
07-10 1499
这道题在Acwing题目的基础上添加了'.'这个“通配符”，也是是说在查找的过程中，如果遇到'.'他可以替换为任何字母，就好比打牌炸金花里面的王，可以替换任意牌。. - 备战技术面试？这个题目是让我们在一个字符矩阵中检索是否存在目标单词，存在就将目标单词枚举返回，对于单词的匹配可以使用前缀树来存储，然后我们枚举矩阵的所有可能的单词，判断这个单词是否是题目中所给的通过Trie树的search查询即可，枚举时需要通过dfs枚举每一个位置开头的单词，如果在dfs过程中发生他不是单词s的前缀，则进行剪枝。
leetocde212. 单词搜索 II/前缀树
yyf_blog
09-18 261
文章目录212. 单词搜索 II前缀树 212. 单词搜索 II 给定一个二维网格 board 和一个字典中的单词列表 words，找出所有同时在二维网格和字典中出现的单词。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母在一个单词中不允许被重复使用。 示例: 输入: words = ["oath","pea","eat","rain"] and board = [ ['o','a','a','n'], ['e','t'
数据结构与算法：前缀树（字典树、Trie树）
最新发布
2402_89326161的博客
02-18 1684
前缀树
python中重要的单词_Python中的单词搜索
weixin_42168750的博客
03-02 647
假设我们有一个2D板和一个单词，我们必须查找单词是否存在于网格中。单词可以由顺序相邻的单元格的字母组成，“相邻”单元格是水平或垂直相邻的单元格。我们不应多次使用同一个字母单元格。所以如果矩阵像-一种乙CË小号FC小号一种dËF给定单词“ ABCCED”，答案将是正确的，对于单词“ SEE”，它将是正确的，但是对于“ ABCB”，如果答案是错误的。让我们看看步骤-我们将使用递归方法解决此问题。因此，...
LeetCode-Python-79. 单词搜索
Keep Coding
05-14 2217
给定一个二维网格和一个单词，找出该单词是否存在于网格中。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 示例: board = [ ['A','B','C','E'], ['S','F','C','S'], ['A','D','E','E'] ] 给定 word = "ABCCE...
Leetcode做题日记：79. 单词搜索(PYTHON)
weixin_44033136的博客
03-09 734
给定一个二维网格和一个单词，找出该单词是否存在于网格中。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 示例: board = [ [‘A’,‘B’,‘C’,‘E’], [‘S’,‘F’,‘C’,‘S’], [‘A’,‘D’,‘E’,‘E’] ] 给定 word = “ABCCED”, 返回 true...
python 添加与搜索单词_Python实现单词搜索
weixin_42502448的博客
03-01 1414
题目要求：思路：先遍历数组，找到可能的起点定义一个helper函数，用来遍历当前起点的上下左右元素，看是否有符合给定单词的下一位的，如果又再递归调用helper函数当上下左右的下标越界或当前数组元素与当前的单词的字母不同时，返回False核心代码：#遍历二维数组for i in range(len(board)):for j in range(len(board[0])):#调用helper函数i...
单词搜索Python解法
皮_客的博客
11-30 644
给定一个m x n 二维字符网格board 和一个字符串单词word 。如果word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 来源：力扣（LeetCode） 链接：https://leetcode-cn.com/problems/word-search 例： 输入：board = [["A","B","C","E"]...
[Leetcode][python]Word Search/单词搜索
蛮三刀酱
10-23 1301
题目大意在一个二维矩阵中，每个元素都是一个字母，要判断目标字符串能否由该矩阵中的元素连接而成。所谓连接就是从矩阵中的某一个元素开始，向前后左右不断前进，但不允许再次经过走过的元素。解题思路回溯法DFS代码class Solution(object): def exist(self, board, word): """ :type board: List[Lis
Leetcode 079 搜索单词 Python C++ 史上最详细题解系列
weixin_41958153的博客
08-16 1851
题目： 给定一个二维网格和一个单词，找出该单词是否存在于网格中。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 示例: board = [ ['A','B','C','E'], ['S','F','C','S'], ['A','D','E','E'] ] 给定 word = "...
Leetcode 79. 单词搜索 (每日一题 20210720 同类型题)
BUPT-WT的博客
07-20 518
给定一个m x n 二维字符网格board 和一个字符串单词word 。如果word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。 示例 1： 输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED" 输出：true 示...
python自学做题记录之查找单词
qq_53029299的博客
01-22 484
今天做题做到一个题目，题目是英文就大概说一下题目意思 输入一个列表，里面都是由句子组成，例如 doc_list = [“The Learn Python Challenge Casino.”, “They bought a car”, “Casinoville”] 然后查找每个元素中是否含有某个单词，但是不区分大小写，并且这种情况：Casinoville中没有casino这个单词，编写一个函数，输出哪几个元素中含有这个单词，如果没有输出空列表 【样例输入】[“The Learn Python Challen
LeetCode第七十九题—单词搜索—Python实现
StriveZs'Blog
04-09 550
title: LeetCode No.79 categories: OJ LeetCode tags: Programing LeetCode OJ LeetCode第七十九题—单词搜索 自己代码的开源仓库:click here 欢迎Star和Fork ???? 题目描述 给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false 。 单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是
Python英文搜索引擎（模糊搜索）
徐奕的专栏
02-03 5041
假设在C:\Record下面有若干个.txt文件，均为纯英文文档。以这些文档为内容，实现一个本地搜索引擎，当用户给出某个输入时，列出相关的搜索结果。可以自行决定改搜索引擎的功能强弱，并给出有关的说明文档。（可考虑NLTK） 注意本程序能够对无空格输入、错误拼写输入、乱序输入、部分输入进行完整的模式匹配。并以相关性排序 更多python3内容访问omegaxyz.com 说明文档： 主要步骤
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值