LeetCode学习笔记——机器人的运动范围

个人博客：The Blog Of WaiterXiaoYY 欢迎来互相交流学习。

机械人运动这类问题在做题的过程中遇到过好几次，

大概类型就是给定一个初始位置，可以往多个方向走（一般是2个，即右下），

有时候是4个方向（上下左右），

然后求到右下角的最小路径，这类问题一般是采用动态规划来做，

有时候可能会出现阻碍物，

但机器人这道题就简化了很多，直接看题吧。

机器人的运动范围

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

解题思路

题目和我们一开始分析的那样，

机器人的位置在m行n列方格的左上角开始，

但目标不是右下角了，而是移动当坐标的数位之和大于k后就不能继续移动了，

这道题有个隐藏的条件，

题目说可以上下左右移动，我觉得有一定的误导，这道题只要两个方向就可以了，

因为机器人的初始位置在左上角，只要向右或者向下两个方向就行了，

对于每个点，只要满足三个条件，就可以继续进行两个方向的选择，

• 该点还没被访问过
• 该点的数位之和小于等于k
• 该点不在边界

对于该点是否被访问，我们可以用一个boolean型的数组记录该点的访问状态，被访问后就变为true，

对于该点的数位之和，我们可以写一个函数专门计算数位的和，

//传入坐标信息
public int sums(int x, int y) {
    //记录结果
    int ans = 0;
    //一直取x的个位数加到结果里面，直到x为0
    while(x != 0) {
        ans += x % 10;
        x /= 10;
    }
    //一直取y的个位数加到结果里面，直到y为0
    while(y != 0) {
        ans += y % 10;
        y /= 10;
    }
    return ans;
}

对该点是否在边界，如果在右边界，就只能向下运动，如果在下边界，就只能向右运动，其他边界无需考虑，

本题可以使用深度优先搜索和广度优先搜索来做，

深度优先搜索就是对每一个方向都递归前进，

广度优先搜索要采用队列来记录合格的点信息，还需要对方格进行抽象坐标化，

具体我们看代码。

代码

• 深度优先搜索

class Solution {
    int m, n, k;
    public int movingCount(int m, int n, int k) {
        this.m = m;
        this.n = n;
        this.k = k;
        //每个方格的访问状态初始为false
        boolean [][]visited = new boolean[m][n];
        //从坐标（0,0）开始
        return dfs(0, 0, 0, visited);
    }
    //深度优先搜索
    public int dfs(int i, int j, int sum, boolean [][]visited) {
        //如果此时i和j已经超过边界，或数位之和大于k，或者该方格已经被访问，递推回归
        if(i == m || j == n || sum > k || visited[i][j])
            return 0;
        //将该方格（坐标）的访问状态改为已访问
        visited[i][j] = true;
        //从两个方向进行递推，i+1表示向下，j+1表示向右
        return 1 + dfs(i + 1, j, sums(i + 1, j), visited) + dfs(i, j + 1, sums(i, j + 1), visited);
    }
    
    //进行计算坐标的数位之和
    public int sums(int x, int y) {
        //记录结果
        int ans = 0;
        //一直取x的个位数加到结果里面，直到x为0
        while(x != 0) {
            ans += x % 10;
            x /= 10;
        }
        //一直取y的个位数加到结果里面，直到y为0
        while(y != 0) {
            ans += y % 10;
            y /= 10;
        }
        return ans;
	}
}

• 广度优先搜索

class Solution {
    public int movingCount(int m, int n, int k) {
        //用于储存坐标信息的队列，储存的都是符合要求的坐标
        Queue<Point> queue = new ArrayDeque<>();
        //每个方格的访问状态初始为false
        boolean[][] visited = new boolean[m][n];
        //队列先加入起点位置
        queue.add(new Point(0, 0));
        visited[0][0] = true;
        //统计能访问点的数量
        int count = 0;
        while(!queue.isEmpty()) {
            //取出队首的坐标
            Point curPoint = queue.poll();
            count++;
            //如果下一个点不超过边界，且数位和不超过k，且该点未被访问过
            if(curPoint.x + 1 < m && sums(curPoint.x + 1, curPoint.y) <= k && !visited[curPoint.x + 1][curPoint.y]) {
                //将该点加入到队列中
                queue.add(new Point(curPoint.x + 1, curPoint.y));
                //访问状态改为已访问
                visited[curPoint.x + 1][curPoint.y] = true;
            }
            if(curPoint.y + 1 < n && sums(curPoint.x, curPoint.y + 1) <= k && !visited[curPoint.x][curPoint.y + 1]) {
                queue.add(new Point(curPoint.x, curPoint.y + 1));
                visited[curPoint.x][curPoint.y + 1] = true;
            }
        }
        return count;
    }
    
    //进行计算坐标的数位之和
    public int sums(int x, int y) {
        //记录结果
        int ans = 0;
        //一直取x的个位数加到结果里面，直到x为0
        while(x != 0) {
            ans += x % 10;
            x /= 10;
        }
        //一直取y的个位数加到结果里面，直到y为0
        while(y != 0) {
            ans += y % 10;
            y /= 10;
        }
        return ans;
	}
}

//抽象坐标类
class Point {
    int x;
    int y;
    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }
}

---

整理于2020.4.9