剑指offer13.机器人的运动范围C++

地上有一个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
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

深度优先搜索

class Solution {
public:
    /*
        机器人从[0,0]开始走动，每次可以向左右上下移动
        m行n列，机器人不能移动到方格外，也不能进入行坐标和列坐标的数位之和大于k的格子
    */
    int movingCount(int m, int n, int k) {
    	//创建二维数组
        bool **visited = new bool*[m];
        for(int i = 0; i < m; i++){
            visited[i] = new bool[n];
        }
        //将二维数组visited初始化为false
        for(int i = 0; i < m; i++){
            for(int j = 0; j < n; j++){
                visited[i][j] = false;
            }
        }
		//存放最后的结果
        int count = dfs(0, 0, visited, m, n, k);
		//释放刚刚申请的二维数组
        for(int i=0;i<m;i++)
            delete []visited[i];
        delete []visited;

        return count;
    }

	//深度优先搜索
    int dfs(int x, int y, bool** visited, int m, int n, int k){
    	//可进入方格数初始化为零
        int count = 0;
        //若当前格子下标未越界，并且没有被访问过，并且数位之和是小等于k的
        if(x >= 0 && x < m && y >= 0 && y < n && !visited[x][y] && check(x, y, k)){
            //走到当前格子，标记为true代表已经走过
            visited[x][y] = true;           
            //这里的 1 是代表当前格子 然后加上 当前格子 四个方向能过进入的格子数
            count = 1 + dfs(x - 1, y, visited, m, n, k)
                      + dfs(x, y - 1, visited, m, n, k)
                      + dfs(x + 1, y, visited, m, n, k)
                      + dfs(x, y + 1, visited, m, n, k);
        }
        //最后当dfs结束时，返回count即为机器人可以进入的格子数
        return count;
    }
	//检查下标数位之和是否小等于k
    bool check(int x, int y, int k){
        if(getDigitSum(x) + getDigitSum(y) <= k){
            return true;
        }
        return false;
    }
	//得到数位之和
    int getDigitSum(int number){
        int sum = 0;
        while(number){
            sum += number % 10;
            number /= 10;
        }
        return sum;
    }
};

广度优先搜索

class Solution {
    // 计算 x 的数位之和
    int get(int x) {
        int res=0;
        for (; x; x /= 10) {
            res += x % 10;
        }
        return res;
    }
public:
    int movingCount(int m, int n, int k) {
        if (!k) return 1;	//如果k==0返回1
        
        //pair是一个对组 可以返回两个数据
        queue<pair<int,int> > Q;	//创建一个 对组队列
        
        // 向右和向下的方向数组
        int dx[2] = {0, 1};
        int dy[2] = {1, 0};
      
        vector<vector<int> > vis(m, vector<int>(n, 0));	//二维vector容器的创建
        
        Q.push(make_pair(0, 0));	//利用make_pair插入初始点
        
        vis[0][0] = 1;	//插入初始点后，坐标(0,0)的位置就要赋值为1 ，代表已经走过
        int ans = 1; 	//ans初始为1
        
        while (!Q.empty()) {
            auto [x, y] = Q.front(); // auto front = Q.front()
            Q.pop();
            for (int i = 0; i < 2; ++i) {
                int tx = dx[i] + x; // int tx = dx[i] + front.first
                int ty = dy[i] + y; // int ty = dy[i] + front.second
                if (tx < 0 || tx >= m || ty < 0 || ty >= n || vis[tx][ty] || get(tx) + get(ty) > k) continue;
                Q.push(make_pair(tx, ty)); //如果当前格子能够进入，那么就把ta的下标放进队列
                vis[tx][ty] = 1; //放进队列 就去标记 为1
                ans++; //然后ans加一
            }
        }
        return ans;
    }
};