好的！LeetCode 79题 “单词搜索” 是一个经典的回溯算法（DFS）问题。以下是中文详解及代码实现：

问题描述

给定一个 m x n 的二维字符网格 board 和一个字符串 word，判断 word 是否存在于网格中。

规则：

1. 单词必须按照字母顺序，通过相邻的单元格（上下左右）内的字母构成。
2. 同一个单元格内的字母不允许重复使用。

解题思路：回溯（DFS）

1. 遍历起点：遍历网格的每个单元格，作为搜索的起点。
2. DFS 递归搜索：从当前单元格出发，向四个方向递归搜索匹配下一个字符。
3. 回溯关键：
   • 标记已访问：避免重复使用同一单元格（临时修改为特殊字符如 \0）。
   • 恢复状态：递归返回后，将单元格恢复为原字符，允许其他路径使用。
4. 终止条件：
   • 越界或字符不匹配 → 失败。
   • 已匹配所有字符 → 成功。

复杂度分析

• 时间复杂度：O(M × N × 3^L)
  （M, N 为网格尺寸，L 为单词长度。每次递归有 3 个方向可选，起点有 M×N 个）
• 空间复杂度：O(L) （递归栈深度）

代码实现（Python）

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        def dfs(i, j, k):
            # 终止条件：越界或不匹配
            if not (0 <= i < len(board) and 0 <= j < len(board[0])) or board[i][j] != word[k]:
                return False
            # 全部字符匹配成功
            if k == len(word) - 1:
                return True

            # 标记已访问（临时修改为空字符）
            tmp, board[i][j] = board[i][j], ''
            # 向四个方向DFS搜索
            res = dfs(i+1, j, k+1) or dfs(i-1, j, k+1) or dfs(i, j+1, k+1) or dfs(i, j-1, k+1)
            # 回溯：恢复单元格状态
            board[i][j] = tmp
            return res

        # 遍历所有起点
        for i in range(len(board)):
            for j in range(len(board[0])):
                if dfs(i, j, 0):
                    return True
        return False

代码实现（Java）

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

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

        char tmp = board[i][j];
        board[i][j] = '\0'; // 标记已访问
        boolean res = dfs(board, word, i+1, j, k+1) || 
                      dfs(board, word, i-1, j, k+1) || 
                      dfs(board, word, i, j+1, k+1) || 
                      dfs(board, word, i, j-1, k+1);
        board[i][j] = tmp; // 回溯恢复
        return res;
    }
}

关键点说明

1. 方向处理：使用方向数组 dirs = [(1,0), (-1,0), (0,1), (0,-1)] 可简化代码（Python 示例中直接展开以提高可读性）。
2. 剪枝优化：在递归前检查下一个字符是否匹配，减少无效递归。
3. 避免重访问：通过修改原矩阵或使用额外 visited 数组实现（前者更节省空间）。

测试建议：尝试用例 board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"，预期结果为 True。

如有任何疑问，欢迎继续提问！