1. 题目链接：79. 单词搜索

2. 题目描述：

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

3. 解法：

3.1 算法思路：

我们需要假设每个位置的元素作为第一个字母，然后相邻的四个方向进行递归，并且不能出现重复使用同一个位置的元素。通过深度优先遍历搜索的方式，不断地枚举相邻元素作为下一个字母出现的可能性，并在递归结束时，直到枚举完所有的可能性，得到正确的结果。

3.2 递归函数流程：

1. 遍历每个位置，标记当前位置并将当前位置的字母作为首字母进行递归，并且在回溯时撤回标记。
2. 在每次递归的状态中，我们维护一个步数step，表达当前已经处理了几个字母
   1. 若当前位置的字母与字符中的第step个字母不相等，则返回false
   2. 若当前step的值与字符串长度相等，表示存在一种路径使得word成立，返回true
3. 对当前位置的上下左右四个相邻位置进行递归，若递归结果为true，则返回true
4. 相邻的四个位置的递归结果为false，则返回false

特别地，如果使用将当前遍历的字符赋值为空格，并在回溯时恢复为原来的字母的方法，则在递归时不会重复遍历当前元素，可达到不使用标记数组的目的

3.3 C++算法代码：

class Solution {
    bool vis[7][7]; // 用于标记已经访问过的单元格
    int m, n; // 矩阵的行数和列数

public:
    bool exist(vector<vector<char>>& board, string word) {
        m = board.size(); // 获取矩阵的行数
        n = board[0].size(); // 获取矩阵的列数

        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (board[i][j] == word[0]) { // 如果当前单元格的字符与单词的第一个字符相同
                    vis[i][j] = true; // 标记该单元格为已访问
                    if (dfs(board, i, j, word, 1)) return true; // 从当前单元格开始进行深度优先搜索
                    vis[i][j] = false; // 回溯时取消标记
                }
            }
        }

        return false; // 如果遍历完所有单元格都没有找到匹配的单词，则返回false
    }

    int dx[4] = {0, 0, -1, 1}; // 定义四个方向的偏移量，分别表示向上、向下、向左、向右移动
    int dy[4] = {1, -1, 0, 0};

    bool dfs(vector<vector<char>>& board, int i, int j, string& word, int pos) {
        if (pos == word.size()) return true; // 如果已经找到了整个单词，则返回true

        for (int k = 0; k < 4; k++) {
            int x = i + dx[k], y = j + dy[k]; // 计算下一个单元格的坐标
            if (x >= 0 && x < m && y >= 0 && y < n && !vis[x][y] && board[x][y] == word[pos]) {
                vis[x][y] = true; // 标记下一个单元格为已访问
                if (dfs(board, x, y, word, pos + 1)) return true; // 继续在下一个单元格进行深度优先搜索
                vis[x][y] = false; // 回溯时取消标记
            }
        }

        return false; // 如果四个方向都没有找到匹配的字符，则返回false
    }
};