【hot100】刷题记录(27)-单词搜索

捞鱼哲学家

已于 2025-02-24 10:29:37 修改

阅读量221

点赞数 4

文章标签： leetcode python 算法数据结构

于 2025-02-24 10:29:08 首次发布

本文链接：https://blog.youkuaiyun.com/Aerochacha/article/details/145822103

版权

题目描述：

给定一个 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

示例 2：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "SEE"
输出：true

示例 3：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCB"
输出：false

提示：

m == board.length
n = board[i].length
1 <= m, n <= 6
1 <= word.length <= 15
board 和 word 仅由大小写英文字母组成

我的作答：

类似于岛屿问题+回溯，难点在于什么时候return和return什么；

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        m = len(board)
        n = len(board[0])
        def backtracking(x, y, path, index, visited):
            if index==len(word):
                if ''.join(path)==word: return True #刚好搜索到return T
                else: return False #搜索完但是不正确return F
            direction = [[1,0], [-1,0], [0,1], [0,-1]]
            for i, j in direction:
                next_x = x+i
                next_y = y+j
                if next_x<0 or next_y<0 or next_x>m-1 or next_y>n-1:
                    continue
                if index<len(word) and board[next_x][next_y]==word[index] and not visited[next_x][next_y]:
                    path.append(board[next_x][next_y])
                    visited[next_x][next_y] = 1
                    if backtracking(next_x, next_y, path, index+1, visited):
                        return True #层层返回True，期间只要有一层不对就不会返回TRUE
                    visited[next_x][next_y] = 0
                    path.pop()
            return False #只要不返回t就会返回f（此时四个方向都搜过了）
        visited = [[0]*n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if not visited[i][j] and board[i][j]==word[0]:
                    visited[i][j] = 1
                    if len(word)>1:
                        result = backtracking(i, j, [word[0]], 1, visited)
                    if len(word)==1 or result: return True #如果长度大于1且返回True
                    else:
                        visited[i][j] = 0 #重设为0
        return False

参考：

牛！

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        def dfs(i, j, k):
            if not 0 <= i < len(board) or not 0 <= j < len(board[0]) or board[i][j] != word[k]: return False
            if k == len(word) - 1: return True
            board[i][j] = '' #随便改成什么避免下一层被搜到（避免重复）
            res = dfs(i + 1, j, k + 1) or dfs(i - 1, j, k + 1) or dfs(i, j + 1, k + 1) or dfs(i, j - 1, k + 1)
            board[i][j] = word[k] #复原
            return res

        for i in range(len(board)):
            for j in range(len(board[0])):
                if dfs(i, j, 0): return True
        return False