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

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

法1：DFS

必须掌握方法！

Python

## 写法2
class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        m, n = len(board), len(board[0])
        word_arr = list(word)
        for i in range(m):
            for j in range(n):
                if board[i][j] == word_arr[0]:
                    visited = [[0] * n for _ in range(m)]
                    if 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


## 写法1
class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        m = len(board)
        n = len(board[0])
        for i in range(m):
            for j in range(n):
                visited = [[False]*n for _ in range(m)]
                res = self.dfs(i, j, 0, board, word, visited)
                if res:
                    return res

        return False

    def dfs(self, i, j, layer, board, word, visited):
        if layer == len(word):
            return True
        if (i < 0 or i >= len(board) 
            or j < 0 or j >= len(board[0])
            or board[i][j] != word[layer]
            or visited[i][j]):
            return False
        visited[i][j] = True
        tmp_res = (self.dfs(i-1, j, layer+1, board, word, visited) 
                    or self.dfs(i+1, j, layer+1, board, word, visited) 
                    or self.dfs(i, j-1, layer+1, board, word, visited)
                    or self.dfs(i, j+1, layer+1, board, word, visited))
        if tmp_res:
            return tmp_res
        else:
            visited[i][j] = False
            return False

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;
        }
    }
}