medium 剑指 Offer 矩阵中的路径 回溯（递归）

---

回溯（递归）：

路径要求：可上下左右，但是不可以重复使用进入过的位置

* 类似于找迷宫的问题，使用回溯法
* 回溯也是递归

回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。

c++

class Solution {
public:
    bool exist(vector<vector<char>>& board, string word) {
        if(board.size() == 0){
            return false;
        }

        int rows = board.size();
        int cols = board[0].size();
        for(int i=0; i<rows; i++){
            for(int j=0; j<cols; j++){
                if (search(board, i, j, word, 0)){  // 从word的第0个字母开始搜索
                    return true;  // 匹配成功
                }                
            }
        }

        return false;  // 匹配失败
    }

private:
    bool search(vector<vector<char>>& board, int i, int j, string word, int idx){
        // 匹配 word[idx]
        if(idx >= word.size()){
            return true;
        }
        // board索引 上下出界: i<0 || i>=board.size() 左右出界: j<0 || j>=board[0].size()
        // 当前board网格点 不等于 当前匹配word字母 board[i][j] != word[idx]
        if(i<0 || i>=board.size() || j<0 || j>=board[0].size() || board[i][j] != word[idx]){
            return false;
        }

        // 匹配 word[idx]成功，继续匹配 word[idx+1] (必须连着匹配成功)
        board[i][j] = '\0';  // 将已经搜索过的board[i][j]标记一下，防止循环。只要变成另外一个字符，就不会再有循环了
        // 匹配word[idx+1]顺序, board[i][j]上下左右
        bool res =  search(board, i - 1, j, word, idx + 1) ||  // dfs深度优先搜索,递归search
                    search(board, i + 1, j, word, idx + 1) ||
                    search(board, i, j - 1, word, idx + 1) ||
                    search(board, i, j + 1, word, idx + 1);
        board[i][j] = word[idx];  // 恢复board[i][j]

        return res;
    }

};

python

class Solution:
    def exist(self, board: List[List[str]], word: str) -> bool:
        def search(i, j, idx):
            # 递归出口
            if idx >= len(word):
                return True
            if i<0 or i>=len(board) or j<0 or j>=len(board[0]) or board[i][j] != word[idx]:
                return False
            
            # 继续递归
            # 匹配board[i][j] == word[idx]成功，继续匹配board[i][j]上下左右 与 word[idx+1]
            board[i][j] = ''
            res = search(i - 1, j, idx + 1) or  search(i + 1, j, idx + 1) or search(i, j - 1, idx + 1) or search(i, j + 1, idx + 1)  # dfs深度优先搜索,递归search

            board[i][j] = word[idx]   # 恢复board[i][j]

            return res
            

                     
        if len(board) == 0:
            return False
        
        rows = len(board)
        cols = len(board[0])
        for i in range(rows):
            for j in range(cols):
                if search(i, j, 0):  # 从word[0]开始匹配
                    return True

        return False

---