【剑指offer】【C++】13. 机器人的运动范围

地上有一个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

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/ji-qi-ren-de-yun-dong-fan-wei-lcof
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

一、考点：深度优先或者广度优先遍历

二、主要思路：

1. 题目获取信息。

• m行n列方格，表示是一个矩阵；
• 每次可以向左右上下移动一格，表示每次只有一个方向的索引会发生变化，因此计算两个下标位数之和 的公式： 新点下标位数和=上个点一个方向位数和 + （上一个点另一个方向位数和 + 变化量）。不论是向右还是向下移动；
• 不能移到方格外以及不能进入行坐标和列坐标的数位之和大于k的格子、移动过的方格就不能再计算 表示 终止条件。
• **重点：**重点是计算前一个点到下一个点两下标数位和，以便于深度优先遍历时的递归推导，或者广度优先遍历时存储下一层的点的数位和的计算。
• 访问的数组标记。vector<vector>使用二维数组来标记。

2. 下标位数和递推

解答过程见此解析：剑指 Offer 13. 机器人的运动范围（ 回溯算法，DFS / BFS ，清晰图解）

3.深度优先遍历

• 同一结点处走向不同方向的函数。在一个结点上可能很多方向都满足条件，深度优先遍历是先沿着一个方向走到底，而再回溯时再沿着其他方向走。其使用递归实现。

1）如统计同一结点处不同方向的数值，return 处的处理不同方向的函数可以是相加减的形式联接的。
return 1 + dfs(left) + (right);
上式是将总问题进行了分解，分解为当前节点以及站在当前节点走向不同的方向各自的贡献。1表示当前节点的贡献，dfs(left)表示第一个方向的贡献，dfs(right)表示第二个方向的贡献。

2）如确定有没有、是不是等返回布尔类型的问题，return处的处理不同方向的函数可以是 并&&或||的形式联接。如果是只要找到一个满足的即可，使用||（一个true，则全为true），如果是只要找到一个不满足的即可，使用&&（一个false，则全为false）。

3）回溯的过程也可以不同的方向之间并没有联系。可以并列写。
int x = dfs(left);
int y = def(right);

• 停止条件。梳理递归问题的停止条件后，一般写在递归函数体的开头，如果不满足条件，就如何如何。比如二叉树中如果为空，return nullptr。
• 可行性剪枝。放在函数体中，经过判断后，是否跳过后续的递归调用，如果跳过就是进行了剪枝操作。一般使用if（） continue。

4.广度优先遍历

• 广度优先遍历按照平推的方式向前搜索。与二叉树中的广度优先遍历相同，二叉树在访问当前结点的同时要将其左右子节点存入队列中，并且是循环的方式将结点弹出队列，并保存其子节点。
• 使用广度优先遍历时，需要准备：
  1）考虑每个节点含有的信息。如果不像二叉树的结点信息均是在对象内部保存的话，就需要自行包装结点信息。如queue<vector>等，每个节点对应一个vector。
  2）创建队列保存节点信息。
  3）当队列为空时，停止循环访问。
  4）循环体中，弹出节点，是否满足条件，满足就继续入队，否则就不入队。

//模板

queue<T> queue1;
queue1.push(data1);
while(queue1.size()>0){
	T data =queue1.front();
	queue1.pop();
	//其他处理
	if(condition){//满足条件，就入队
	queue1.push(data2);
	queue1.push(data3);
	...
	} 
}

三、代码

深度优先：

class Solution {
public:
    int movingCount(int m, int n, int k) {
        this->m = m;this->n = n;this->k = k;
        vector<vector<bool>> visited(m, vector<bool>(n, false));
        return dfs(0, 0, 0, 0, visited);
    }
private:
    int m, n, k;
    int dfs(int i, int j, int si, int sj, vector<vector<bool>>& visited){
        if(i>=this->m || j>=this->n || si+sj > this->k || visited[i][j]) return false;
        visited[i][j] = true;
        return 1 + dfs(i+1, j, (i+1)%10? si+1 : si-8, sj, visited) + 
        dfs(i, j+1, si, (j+1)%10? sj+1:sj-8, visited);
    }
};

广度优先：

class Solution {
public:
    int movingCount(int m, int n, int k) {
        queue<vector<int>> que;
        vector<vector<bool>>  visited(m, vector<bool>(n, false));
        que.push({0, 0, 0, 0});
        int res = 0, i, j, si, sj;
        while(que.size()>0){
            vector<int> tmp = que.front();
            que.pop();
            i = tmp[0]; j=tmp[1]; si = tmp[2]; sj = tmp[3];
            if(i>=m || j>=n || si+sj>k || visited[i][j]) continue;//可行性剪枝
            visited[i][j] = true;
            ++res;
            que.push({i+1, j, (i+1)%10? si+1 : si-8, sj});
            que.push({i, j+1, si, (j+1)%10? sj+1 : sj-8});
            //按照这样的压入方法，是存在重叠的，尤其是第一个点的右方和下一个点的下方可能相同
        }
        return res;
    }
};