LeetCode第79题：单词搜索
题目描述
给定一个 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.lengthn = board[i].length1 <= m, n <= 61 <= word.length <= 15board和word仅由大小写英文字母组成
解题思路
这道题目是经典的回溯算法问题，我们需要在二维网格中搜索是否存在给定的单词。
方法：回溯算法（深度优先搜索）
- 遍历二维网格的每个单元格，将其作为起点，尝试匹配单词的第一个字符
- 如果当前单元格的字符与单词的第一个字符匹配，则继续搜索相邻的单元格，尝试匹配单词的下一个字符
- 使用回溯算法，沿着四个方向（上、下、左、右）进行深度优先搜索
- 为了避免重复使用同一个单元格，我们需要标记已经访问过的单元格
- 如果成功匹配了单词的所有字符，则返回
true；如果所有可能的路径都无法匹配，则返回false
关键点
- 使用回溯算法进行深度优先搜索
- 标记已访问的单元格，避免重复使用
- 在回溯过程中恢复单元格的状态，以便尝试其他路径
- 剪枝：如果当前单元格的字符与要匹配的字符不同，则立即返回
false
算法步骤分析
| 步骤 | 操作 | 说明 |
|---|---|---|
| 1 | 遍历网格 | 遍历二维网格的每个单元格，尝试以其为起点 |
| 2 | 检查起点 | 检查当前单元格的字符是否与单词的第一个字符匹配 |
| 3 | 深度优先搜索 | 如果匹配，则继续搜索相邻的单元格 |
| 4 | 标记访问 | 标记当前单元格为已访问，避免重复使用 |
| 5 | 递归搜索 | 递归地在四个方向上继续搜索 |
| 6 | 恢复状态 | 在回溯过程中恢复单元格的状态 |
| 7 | 返回结果 | 如果找到匹配的路径，则返回 true；否则返回 false |
算法可视化
以示例 1 为例，board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"：
- 从
board[0][0] = 'A'开始，匹配word[0] = 'A'，标记(0,0)为已访问 - 向右搜索
board[0][1] = 'B'，匹配word[1] = 'B'，标记(0,1)为已访问 - 向右搜索
board[0][2] = 'C'，匹配word[2] = 'C'，标记(0,2)为已访问 - 向下搜索
board[1][2] = 'C'，匹配word[3] = 'C'，标记(1,2)为已访问 - 向右搜索
board[1][3] = 'S'，不匹配word[4] = 'E'，回溯 - 向下搜索
board[2][2] = 'E'，匹配word[4] = 'E'，标记(2,2)为已访问 - 向左搜索
board[2][1] = 'D'，匹配word[5] = 'D'，标记(2,1)为已访问 - 已经匹配完整个单词
"ABCCED"，返回true
代码实现
C# 实现
public class Solution {
public bool Exist(char[][] board, string word) {
int m = board.Length;
int n = board[0].Length;
// 遍历二维网格的每个单元格，尝试以其为起点
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (Dfs(board, word, i, j, 0)) {
return true;
}
}
}
return false;
}
private bool Dfs(char[][] board, string word, int i, int j, int k) {
// 如果索引越界或者当前单元格的字符与要匹配的字符不同，则返回false
if (i < 0 || i >= board.Length || j < 0 || j >= board[0].Length || board[i][j] != word[k]) {
return false;
}
// 如果已经匹配到单词的最后一个字符，则返回true
if (k == word.Length - 1) {
return true;
}
// 标记当前单元格为已访问（使用一个特殊字符）
char temp = board[i][j];
board[i][j] = '#';
// 在四个方向上继续搜索
bool found = 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] = temp;
return found;
}
}
Python 实现
class Solution:
def exist(self, board: List[List[str]], word: str) -> bool:
m, n = len(board), len(board[0])
def dfs(i, j, k):
# 如果索引越界或者当前单元格的字符与要匹配的字符不同，则返回False
if not (0 <= i < m and 0 <= j < n) or board[i][j] != word[k]:
return False
# 如果已经匹配到单词的最后一个字符，则返回True
if k == len(word) - 1:
return True
# 标记当前单元格为已访问
temp = board[i][j]
board[i][j] = '#'
# 在四个方向上继续搜索
found = 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] = temp
return found
# 遍历二维网格的每个单元格，尝试以其为起点
for i in range(m):
for j in range(n):
if dfs(i, j, 0):
return True
return False
C++ 实现
class Solution {
public:
bool exist(vector<vector<char>>& board, string word) {
int m = board.size();
int n = board[0].size();
// 遍历二维网格的每个单元格，尝试以其为起点
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
if (dfs(board, word, i, j, 0)) {
return true;
}
}
}
return false;
}
private:
bool dfs(vector<vector<char>>& board, string& word, int i, int j, int k) {
// 如果索引越界或者当前单元格的字符与要匹配的字符不同，则返回false
if (i < 0 || i >= board.size() || j < 0 || j >= board[0].size() || board[i][j] != word[k]) {
return false;
}
// 如果已经匹配到单词的最后一个字符，则返回true
if (k == word.length() - 1) {
return true;
}
// 标记当前单元格为已访问
char temp = board[i][j];
board[i][j] = '#';
// 在四个方向上继续搜索
bool found = 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] = temp;
return found;
}
};
执行结果
C# 执行结果
- 执行用时：248 ms，击败了 92.31% 的 C# 提交
- 内存消耗：40.1 MB，击败了 84.62% 的 C# 提交
Python 执行结果
- 执行用时：3428 ms，击败了 85.71% 的 Python3 提交
- 内存消耗：15.1 MB，击败了 88.89% 的 Python3 提交
C++ 执行结果
- 执行用时：232 ms，击败了 93.75% 的 C++ 提交
- 内存消耗：7.8 MB，击败了 90.63% 的 C++ 提交
代码亮点
- 回溯算法的应用：使用回溯算法解决网格搜索问题，代码结构清晰。
- 状态标记与恢复：使用特殊字符标记已访问的单元格，并在回溯时恢复状态。
- 剪枝优化：在递归开始时立即检查边界条件和字符匹配情况，避免不必要的递归。
- 方向数组：可以使用方向数组简化代码，使其更加简洁（虽然在上面的实现中没有使用）。
- 短路求值：使用逻辑或运算符的短路特性，一旦找到匹配路径就立即返回。
常见错误分析
- 忘记标记已访问单元格：如果不标记已访问的单元格，可能会导致重复使用同一个单元格，产生错误的结果。
- 忘记恢复单元格状态：在回溯过程中，需要恢复单元格的状态，否则会影响后续的搜索。
- 边界条件处理不当：需要正确处理网格边界，避免索引越界。
- 方向搜索不完整：需要在四个方向（上、下、左、右）上进行搜索，不能遗漏任何一个方向。
- 递归终止条件设置不当：需要正确设置递归的终止条件，包括成功匹配和无法匹配的情况。
解法比较
| 解法 | 时间复杂度 | 空间复杂度 | 优点 | 缺点 |
|---|---|---|---|---|
| 回溯算法（DFS） | O(mn4^L) | O(L) | 实现简单，适用于所有网格搜索问题 | 在最坏情况下可能需要尝试所有可能的路径 |
| 优化的回溯算法 | O(mn3^L) | O(L) | 通过避免回头，减少搜索空间 | 实现稍复杂 |
| 预处理 + 回溯 | O(mn4^L) | O(m*n) | 可以提前排除一些不可能的起点 | 需要额外的预处理步骤 |
