單詞搜尋

weixin_44619759發表於2021-01-03

單詞搜尋

題目

給定一個二維網格和一個單詞，找出該單詞是否存在於網格中。

單詞必須按照字母順序，通過相鄰的單元格內的字母構成，其中“相鄰”單元格是那些水平相鄰或垂直相鄰的單元格。同一個單元格內的字母不允許被重複使用。

示例:

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. 回溯演算法的又一練習
    原理上對回溯演算法有了更清楚的認識，在實際程式碼上手時還是需要重複思考細節。

相關文章