剑指 Offer 12. 矩阵中的路径_C++(回溯)

回溯都可以看成是树状问题，此题只要找到一个满足条件的路径即可，无需遍历整棵树，找到所有情况

回溯模板框架

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

此题需要做一些更改，循环的逻辑放到主函数里更容易理解；且递归需要返回值。

整体代码如下：

class Solution {
public:
    bool backtracking(vector<vector<char>>& board, string& word, int rowStart, int collumnStart, int wordStart){
        //终止条件
            //返回false：下标索引越界 || 字符不相等
        if(rowStart < 0 || rowStart >= board.size() || collumnStart < 0 || collumnStart >= board[0].size() || board[rowStart][collumnStart] != word[wordStart]){
            return false;
        }
        //终止条件
            //返回true：下标索引合法 && 字符相等
        if(wordStart == word.size() - 1){
            return true;
        }
        // 处理节点，相等将该处换位空格' ',防止死循环 
        board[rowStart][collumnStart] = '\0';
        //在一个位置有四个方向可以走：上下左右
        //有一个返回true，即可继续走，进入递归
        bool res = backtracking(board, word, rowStart - 1, collumnStart, wordStart + 1) 
                  || backtracking(board, word, rowStart + 1, collumnStart, wordStart + 1) 
                  || backtracking(board, word, rowStart, collumnStart - 1, wordStart + 1)
                  || backtracking(board, word, rowStart, collumnStart + 1, wordStart + 1);
        //回溯，撤销处理结果
        //将原本的字符换回来
        board[rowStart][collumnStart] = word[wordStart];
        return res;

    }


    bool exist(vector<vector<char>>& board, string word) {
        int row = board.size();
        int collumn = board[0].size();
        //不同的起点
        for(int i = 0; i < row; i++){
            for(int j = 0; j < collumn; j++){
                if(backtracking(board, word, i, j, 0)) return true;
            }
        }
        return false;
    }
};

复杂度分析

• 时间复杂度 O(3^KMN)： 最差情况下，需要遍历矩阵中长度为 KK 字符串的所有方案，时间复杂度为 O(3^K)
  • O(3^K)；矩阵中共有 MN个起点，时间复杂度为 O(MN)。
  • 方案数计算： 设字符串长度为 K ，搜索中每个字符有上、下、左、右四个方向可以选择，舍弃回头（上个字符）的方向，剩下 3种选择，因此方案数的复杂度为 O(3^KMN)

• 空间复杂度 O(K)： 搜索过程中的递归深度不超过 KK ，因此系统因函数调用累计使用的栈空间占用 O(K)因为函数返回后，系统调用的栈空间会释放）。

  • 最坏情况下 K = MN ，递归深度为 MN ，此时系统栈使用 O(MN)的额外空间。