题目描述

给定一个 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 仅由大小写英文字母组成

代码及注释

func exist(board [][]byte, word string) bool {
    // 获取二维字符网格的行数和列数
    m, n := len(board), len(board[0])
    
    // 初始化访问标记数组
    visited := make([][]bool, m)
    for i := range visited {
        visited[i] = make([]bool, n)
    }
    
    // 定义DFS函数
    var dfs func(i, j, k int) bool 
    dfs = func(i, j, k int) bool {
        // 如果已经找到单词的所有字符，则返回true
        if k == len(word) {
            return true
        }
        
        // 如果当前位置超出边界，或者已经访问过，或者当前字符不匹配，则返回false
        if i < 0 || j < 0 || i >= m || j >= n || visited[i][j] || board[i][j] != word[k] {
            return false
        }

        // 标记当前位置已访问
        visited[i][j] = true
        
        // 搜索上下左右四个方向
        if dfs(i + 1, j, k + 1) || dfs(i - 1, j, k + 1) || dfs(i, j + 1, k + 1) || dfs(i, j - 1, k + 1) {
            return true
        }
        
        // 回溯，撤销当前位置的访问标记
        visited[i][j] = false

        return false
    }

    // 遍历二维字符网格，从每个位置开始搜索
    for i := 0; i < m; i++ {
        for j := 0; j < n; j++ {
            if dfs(i, j, 0) {
                return true
            }
        }
    }
    
    // 如果没有找到匹配的单词，则返回false
    return false
}

代码解释：

1. 获取二维字符网格的行数和列数

   m, n := len(board), len(board[0])
   

   获取二维字符网格 board 的行数 m 和列数 n。

2. 初始化访问标记数组

   visited := make([][]bool, m)
   for i := range visited {
       visited[i] = make([]bool, n)
   }
   

   使用 make 函数初始化一个二维布尔数组 visited，用于标记每个位置是否已经访问过。

3. 定义DFS函数

   var dfs func(i, j, k int) bool 
   

   定义一个DFS函数 dfs，该函数将用于在二维字符网格 board 中搜索是否存在单词 word。

4. DFS函数的实现

   dfs = func(i, j, k int) bool {
       // 如果已经找到单词的所有字符，则返回true
       if k == len(word) {
           return true
       }
       
       // 如果当前位置超出边界，或者已经访问过，或者当前字符不匹配，则返回false
       if i < 0 || j < 0 || i >= m || j >= n || visited[i][j] || board[i][j] != word[k] {
           return false
       }
   
       // 标记当前位置已访问
       visited[i][j] = true
       
       // 搜索上下左右四个方向
       if dfs(i + 1, j, k + 1) || dfs(i - 1, j, k + 1) || dfs(i, j + 1, k + 1) || dfs(i, j - 1, k + 1) {
           return true
       }
       
       // 回溯，撤销当前位置的访问标记
       visited[i][j] = false
   
       return false
   }
   

   • 终止条件：如果已经找到单词的所有字符（即 k == len(word)），则返回 true。
   • 边界条件：如果当前位置超出边界，或者已经访问过，或者当前字符不匹配，则返回 false。
   • 标记和搜索：标记当前位置已访问，然后搜索上下左右四个方向。
   • 回溯：在回溯时，撤销当前位置的访问标记。

5. 遍历二维字符网格，从每个位置开始搜索

   for i := 0; i < m; i++ {
       for j := 0; j < n; j++ {
           if dfs(i, j, 0) {
               return true
           }
       }
   }
   

   使用双重循环遍历二维字符网格 board，从每个位置开始搜索是否存在单词 word。

6. 返回结果

   return false
   

   如果没有找到匹配的单词，则返回 false。

通过这样的DFS递归实现，可以在 O(m*n*3^k) 的时间复杂度内搜索二维字符网格中是否存在单词 word，其中 m 和 n 分别是二维字符网格的行数和列数，k 是单词 word 的长度。