leetcode-机器人的运动范围

 题目来自LeetCode，链接：面试题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 <= n,m <= 100
• 0 <= k <= 20

 示例1:

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

 示例2:

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

 首先一眼望去，这种题目就是一种BFS/DFS的题目嘛，只需要从[0, 0]出发，然后往右和往下搜索，递归这个过程即可。这里为啥只用往右和往下呢，这是因为从[0, 0]开始的时候就是往右和往下，足够遍历所有可能的坐标（因为不会存在只有通过向上或向左才能到达的点，假设存在这样的点Z可以通过Y向左得到，那么Y可以假设是从X向下得到，因为在X左边一定会存在数位和比X小的比如是W，那么Z一定可以通过W向下再向右得到）。

 时间复杂度为 $O(mn)$，空间复杂度为 $O(mn)$。

 DFS的JAVA版代码如下：

class Solution {
    private int count;
    private boolean[][] visited;
    private int row;
    private int col;
    private int limit;

    private void visit(int i, int j) {
        if (i < 0 || j < 0 || i >= row || j >= col || visited[i][j]) {
            return;
        }
        visited[i][j] = true;
        int sum = i % 10 + i / 10 + j % 10 + j / 10;
        if (sum <= limit) {
            ++count;
            visit(i + 1, j);
            visit(i, j + 1);
        }

    }
    public int movingCount(int m, int n, int k) {
        count = 0;
        visited = new boolean[m][n];
        row = m;
        col = n;
        limit = k;
        visit(0, 0);
        return count;
    }
}

 提交结果如下:

 BFS的JAVA版代码如下：

class Solution {
    private int digitSum(int n) {
        return n / 10 + n % 10;
    }

    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        visited[0][0] = true;
        int[] dx = {1, 0};
        int[] dy = {0, 1};
        int count = 1;
        Queue<int[]> queue = new LinkedList<>();
        queue.offer(new int[] {0, 0});
        while(!queue.isEmpty()) {
            int[] cord = queue.poll();
            for (int i = 0; i < 2; ++i) {
                int x = cord[0] + dx[i];
                int y = cord[1] + dy[i];
                if (x < m && y < n && !visited[x][y] && digitSum(x) + digitSum(y) <= k) {
                    ++count;
                    visited[x][y] = true;
                    queue.offer(new int[] {x, y});
                }
            }
        }
        return count;
    }
}

 提交结果如下:

 接着考虑到每次都是向下或向右，所以可以将递归改为递推实现。时间复杂度还是 $O(mn)$，空间复杂度也还是 $O(mn)$。

 JAVA版代码如下：

class Solution {
    private int digitSum(int n) {
        return n / 10 + n % 10;
    }

    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        visited[0][0] = true;
        int count = 1;
        for (int i = 1; i < m; ++i) {
            if (digitSum(i) <= k) {
                visited[i][0] = true;
                ++count;
            }
            else {
                break;
            }
        }
        for (int j = 1; j < n; ++j) {
            if (digitSum(j) <= k) {
                visited[0][j] = true;
                ++count;
            }
            else {
                break;
            }
        }
        for (int i = 1; i < m; ++i) {
            for (int j = 1; j < n; ++j) {
                if ((visited[i - 1][j] || visited[i][j - 1]) && digitSum(i) + digitSum(j) <= k) {
                    visited[i][j] = true;
                    ++count;
                }
            }
        }
        return count;
    }
}

 提交结果如下:

 Python版代码如下：

class Solution:
    def digitSum(self, n):
        return n // 10 + n % 10

    def movingCount(self, m: int, n: int, k: int) -> int:
        visited = [[False for _ in range(n)] for _ in range(m)]

        def dfs(i, j):
            if i < 0 or j < 0 or i >= m or j >= n or visited[i][j]:
                return 0
            visited[i][j] = True
            if self.digitSum(i) + self.digitSum(j) <= k:
                return 1 + dfs(i + 1, j) + dfs(i, j + 1)
            return 0

        return dfs(0, 0)

 提交结果如下: