单词搜索

题目

给定一个二维网格和一个单词，找出该单词是否存在于网格中。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

示例:

board =
[
[‘A’,‘B’,‘C’,‘E’],
[‘S’,‘F’,‘C’,‘S’],
[‘A’,‘D’,‘E’,‘E’]
]

给定 word = “ABCCED”, 返回 true
给定 word = “SEE”, 返回 true
给定 word = “ABCB”, 返回 false

提示：

board 和 word 中只包含大写和小写英文字母。
1 <= board.length <= 200
1 <= board[i].length <= 200
1 <= word.length <= 10^3

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/word-search
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

解题思路

1、循环遍历

测试及修正过程

1.1 while 循环

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        i = 0
        j = 0
        k = 0
        while i < len(word):
            while j < len(board):
                while k < len(board[j]):
                    if word[i] == board[j][k]:
                        i += 1
                        if j - 1 >= 0:
                            if word[i] == board[j - 1][k]:
                                j -= 1
                        if j + 1 < len(board):
                            if word[i] == board[j + 1][k]:
                                j += 1
                        if k - 1 >= 0:
                            if word[i] == board[j][k - 1]:
                                k -= 1
                        if k + 1 < len(board[j]):
                            if word[i] == board[j][k + 1]:
                                k += 1
                    else:k += 1
                j += 1
        if i == len(word) - 1:return True
        else:return False
                            

超出时间限制

在测试例子的时候就没有通过，于是改为 for 循环，直接控制变量递增。

1.2 for 循环

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        i = 0
        j = 0
        k = 0
        for i in range(len(word)):
            for j in range(len(board)):
                for k in range(len(board[j])):
                    if word[i] == board[j][k]:
                    # 在原来基础上增设判断，测试时出现超出范围的错误
                        if i + 1 < len(word):
                            i += 1
                            if j - 1 >= 0:
                                if word[i] == board[j - 1][k]:
                                    j -= 1
                            if j + 1 < len(board):
                                if word[i] == board[j + 1][k]:
                                    j += 1
                            if k - 1 >= 0:
                                if word[i] == board[j][k - 1]:
                                    k -= 1
                            if k + 1 < len(board[j]):
                                if word[i] == board[j][k + 1]:
                                    k += 1
        if i == len(word) - 1:return True
        else:return False
                            

解答错误

分析：

• 最开始想到最边上一圈网格元素每个情况都不同，分情况考虑较为繁琐，于是“一视同仁”：当遍历网格出现对应字母时，判断下一个可能出现的位置，对 4 个方向全部确认一遍；
• 结果造成同一个位置重复出现的情况，对测试示例中 word = “SEE” 的情况适用，但包含了“ABCB”，不符合题意，还需进一步对可能出现的位置作修正。

回溯算法

官方情况

对每一个位置 (i,j) 都调用函数 check(i,j,0) 进行检查：只要有一处返回 true，就说明网格中能够找到相应的单词，否则说明不能找到。

为了防止重复遍历相同的位置，需要额外维护一个与 board 等大的 visited 数组，用于标识每个位置是否被访问过。每次遍历相邻位置时，需要跳过已经被访问的位置。

提交代码

回溯算法

from typing import List


class Solution:
    #         (x-1,y)
    # (x,y-1) (x,y) (x,y+1)
    #         (x+1,y)

    directions = [(0, -1), (-1, 0), (0, 1), (1, 0)]

    def exist(self, board: List[List[str]], word: str) -> bool:
        m = len(board)
        if m == 0:
            return False
        n = len(board[0])

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

    def __search_word(self, board, word, index,
                      start_x, start_y, marked, m, n):
        # 先写递归终止条件
        if index == len(word) - 1:
            return board[start_x][start_y] == word[index]

        # 中间匹配了，再继续搜索
        if board[start_x][start_y] == word[index]:
            # 先占住这个位置，搜索不成功的话，要释放掉
            marked[start_x][start_y] = True
            for direction in self.directions:
                new_x = start_x + direction[0]
                new_y = start_y + direction[1]
                # 注意：如果这一次 search word 成功的话，就返回
                if 0 <= new_x < m and 0 <= new_y < n and \
                        not marked[new_x][new_y] and \
                        self.__search_word(board, word,
                                           index + 1,
                                           new_x, new_y,
                                           marked, m, n):
                    return True
            marked[start_x][start_y] = False
        return False

#https://leetcode-cn.com/problems/word-search/solution/zai-er-wei-ping-mian-shang-shi-yong-hui-su-fa-pyth/

官方解

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        directions = [(0, 1), (0, -1), (1, 0), (-1, 0)]

        def check(i: int, j: int, k: int) -> bool:
            if board[i][j] != word[k]:
                return False
            if k == len(word) - 1:
                return True
            
            visited.add((i, j))
            result = False
            for di, dj in directions:
                newi, newj = i + di, j + dj
                if 0 <= newi < len(board) and 0 <= newj < len(board[0]):
                    if (newi, newj) not in visited:
                        if check(newi, newj, k + 1):
                            result = True
                            break
            
            visited.remove((i, j))
            return result

        h, w = len(board), len(board[0])
        visited = set()
        for i in range(h):
            for j in range(w):
                if check(i, j, 0):
                    return True
        
        return False

#https://leetcode-cn.com/problems/word-search/solution/dan-ci-sou-suo-by-leetcode-solution/

学习总结

1. 偏移量数组
   从该题中了解到偏移量数组，它在二维平面内是经常使用的，这里可以把它的设置当做一个技巧，并且在这个问题中，偏移量数组内的 4 个偏移的顺序无关紧要；
2. 回溯算法的又一练习
   原理上对回溯算法有了更清楚的认识，在实际代码上手时还是需要重复思考细节。