【重点】【回溯】79.单词搜索

原创已于 2025-08-16 02:08:12 修改 · 440 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#深度优先 #回溯

于 2023-12-19 01:04:46 首次发布

力扣Top100 专栏收录该内容

100 篇文章

订阅专栏

文章讲述了如何通过深度优先搜索(DFS)算法在给定的字符矩阵中查找是否存在特定单词，强调了在处理岛屿题时无需回溯过程。解决方案包含了一个递归的DFS函数，检查每个位置是否符合单词路径条件。

题目
注意：此题跟岛屿的数量对比来看，增加了回溯的过程，岛屿题并无回溯。

法1：DFS

必须掌握方法！

Python

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        m, n = len(board), len(board[0])
        word_arr = list(word)
        visited = [[0] * n for _ in range(m)]
        for i in range(m):
            for j in range(n):
                if board[i][j] == word_arr[0] and self.dfs(i, j, 0, board, word_arr, visited, m, n):
                    return True

        return False

    def dfs(self, i, j, start, board, word_arr, visited, m, n):
        if start == len(word_arr):
            return True

        if (i < 0 or i >= m or j < 0 or j >= n 
            or board[i][j] != word_arr[start]
            or visited[i][j]):
            return False

        visited[i][j] = 1 # 访问board[i][j]
        res = (self.dfs(i-1, j, start+1, board, word_arr, visited, m, n) 
                or self.dfs(i+1, j, start+1, board, word_arr, visited, m, n)
                or self.dfs(i, j-1, start+1, board, word_arr, visited, m, n)
                or self.dfs(i, j+1, start+1, board, word_arr, visited, m, n))
        visited[i][j] = 0 # 恢复现场
        
        return res

Java

class Solution {
    public boolean exist(char[][] board, String word) {
        int m = board.length, n = board[0].length;
        for (int i = 0; i < m; ++i) {
            for (int j = 0; j < n; ++j) {
                int[][] used = new int[m][n];
                if (dfs(board, word, used, i, j, 0)) {
                    return true;
                }
            }
        }

        return false;
    }

    public boolean dfs(char[][] board, String word, int[][] used, int i, int j, int curInx) {
        if (i < 0 || i >= board.length 
                || j < 0 || j >= board[0].length 
                || curInx >= word.length() 
                || used[i][j] == 1 
                || board[i][j] != word.charAt(curInx)) {
            return false;
        }
        used[i][j] = 1;
        if (curInx == word.length() - 1) {
            return true;
        }
        boolean res = dfs(board, word, used, i - 1, j, curInx + 1) 
                        || dfs(board, word, used, i + 1, j, curInx + 1) 
                        || dfs(board, word, used, i, j - 1, curInx + 1) 
                        || dfs(board, word, used, i, j + 1, curInx + 1);
        if (res) {
            return true;
        } else {
            used[i][j] = 0;
            return false;
        }
    }
}