回溯法模板(矩阵中操作)

在矩阵中考察回溯算法，分为任意起点、左上角开始等情况。从而有不同的模板，其实区别就是直接开始还是每个坐标都去尝试。

目录

1.首先是从左上角开始这种情况

C++代码

2.从矩阵任意一点开始的情况

C++代码：

---

1.首先是从左上角开始这种情况

剑指 Offer 13. 机器人的运动范围

难度中等291收藏分享切换为英文接收动态反馈

地上有一个m行n列的方格，从坐标 [0,0] 到坐标 [m-1,n-1] 。一个机器人从坐标 [0, 0] 的格子开始移动，它每次可以向左、右、上、下移动一格（不能移动到方格外），也不能进入行坐标和列坐标的数位之和大于k的格子。例如，当k为18时，机器人能够进入方格 [35, 37] ，因为3+5+3+7=18。但它不能进入方格 [35, 38]，因为3+5+3+8=19。请问该机器人能够到达多少个格子？

 

示例 1：

输入：m = 2, n = 3, k = 1
输出：3

示例 2：

输入：m = 3, n = 1, k = 0
输出：1

提示：

• 1 <= n,m <= 100
• 0 <= k <= 20

C++代码：

class Solution {
    vector<vector<int>> visit;
public:
    int sum(int x,int y){
        int res=0;
        while(x){
            res+=x%10;
            x/=10;
        }
        while(y){
            res+=y%10;
            y/=10;
        }
        return res;
    }
    int dfs(int x, int y, int m, int n, int k){
        if(x < 0 || x >= m || y < 0 || y >= n || visit[x][y] || sum(x, y)>k) return 0;
        visit[x][y] = 1;
        return dfs(x-1,y,m,n,k)+dfs(x,y-1,m,n,k)+dfs(x+1,y,m,n,k)+dfs(x,y+1,m,n,k)+1;
    }
    int movingCount(int m, int n, int k) {
    if(k == 0) return 1;//k等于0应该输出1
    visit.resize(m, vector<int>(n, 0));
    return dfs(0, 0, m, n, k);
    }
};

 

2.从矩阵任意一点开始的情况

剑指 Offer 12. 矩阵中的路径

难度中等323收藏分享切换为英文接收动态反馈

给定一个 m x n 二维字符网格 board 和一个字符串单词 word 。如果 word 存在于网格中，返回 true ；否则，返回 false。

单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。

例如，在下面的 3×4 的矩阵中包含单词 "ABCCED"（单词中的字母已标出）。

 

示例 1：

输入：board = [["A","B","C","E"],["S","F","C","S"],["A","D","E","E"]], word = "ABCCED"
输出：true

示例 2：

输入：board = [["a","b"],["c","d"]], word = "abcd"
输出：false

提示：

• 1 <= board.length <= 200
• 1 <= board[i].length <= 200
• board 和 word 仅由大小写英文字母组成

C++代码：

class Solution {
    vector<vector<int>> visit;
    const  int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};//定义上下左右四个方向

public:
    bool check(vector<vector<char>>& board, string word, int i, int j, int k){
        if(i >= board.size() || i < 0 || j >= board[0].size() || j < 0 || visit[i][j] || board[i][j] != word[k])
            return false;
        if(k == word.size() - 1) return true;
        char tmp = board[i][j];
        visit[i][j] = 1;
        for(int d = 0; d < 4; d++){
            if(check(board, word, i + dx[d], j + dy[d], k+1)) return true;
        }
        visit[i][j] = 0;
        return false;
    }

    bool exist(vector<vector<char>>& board, string word) {
        int row = board.size(), col = board[0].size(), len = word.size();
        visit.resize(row, vector<int>(col, 0));
        if(len > row*col || word.empty()) return false;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(check(board, word, i, j, 0))
                    return true;
            }
        }
        return false;
    }
};

可以直接改变字符数组，节约访问记录数组空间。

class Solution {
    vector<vector<int>> visit;
    const  int dx[4] = {-1, 1, 0, 0}, dy[4] = {0, 0, -1, 1};//定义上下左右四个方向

public:
    bool check(vector<vector<char>>& board, string word, int i, int j, int k){
        if(i >= board.size() || i < 0 || j >= board[0].size() || j < 0 || visit[i][j] || board[i][j] != word[k])
            return false;
        if(k == word.size() - 1) return true;
        char tmp = board[i][j];
        board[i][j] = '/';      //占位符 访问过的就不再管
        //visit[i][j] = 1;
        for(int d = 0; d < 4; d++){
            if(check(board, word, i + dx[d], j + dy[d], k+1)) return true;
        }
        board[i][j] = tmp;  //回溯的时候需要复原
        //visit[i][j] = 0;
        return false;
    }

    bool exist(vector<vector<char>>& board, string word) {
        int row = board.size(), col = board[0].size(), len = word.size();
        visit.resize(row, vector<int>(col, 0));
        if(len > row*col || word.empty()) return false;
        for(int i = 0; i < row; i++){
            for(int j = 0; j < col; j++){
                if(check(board, word, i, j, 0))
                    return true;
            }
        }
        return false;
    }
};