LeetCode 面试题13. 机器人的运动范围

我的LeetCode：https://leetcode-cn.com/u/ituring/

我的LeetCode刷题源码[GitHub]：https://github.com/izhoujie/Algorithmcii

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：

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

示例 1：

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

解题思路

题目等价于：从点[0][0]开始向上下左右扩散，求有多少个点满足条件：行坐标和列坐标的数位之和不大于k；
所以，这类问题用bfs或者dfs来解决最适合了；
另外，还可以用递推验证的方式求解：对于非起点位置，所在位置是否可达必须满足：所在位置可达且所在位置的左方位置和上方位置至少有一个可达；
因为机器人必须得有“路”能走到那个位置，否则即使该位置满足行坐标和列坐标的数位之和不大于k，但是其左上位置都是不可达的，机器人又不能“跳”到该位置，所以这样的位置也是不可达的；

思路1-BFS

算法复杂度:

• 时间复杂度：O(m*n)
• 空间复杂度：O(m*n)

思路2-DFS

算法复杂度:

• 时间复杂度：O(m*n)
• 空间复杂度：O(m*n)

思路3-递推验证

算法复杂度:

• 时间复杂度：O(m*n)
• 空间复杂度：O(m*n)

上面三个算法的时间复杂度都一样：

• 对于时间复杂度，因为三个算法中每个方格的位置都至多计算两次，即2mn次，O(2mn)=O(m*n);
• 对于空间复杂度，每个算法都需要一个额外的[m][n]大小的boolean数组来记录数据，即O(m*n)

算法源码示例

package leetcode;

import java.util.ArrayDeque;

/**
 * @author ZhouJie
 * @date 2020年4月8日 下午7:38:21 
 * @Description: 面试题13. 机器人的运动范围
 *
 */
public class LeetCode_Offer_13 {
	/**
	 * @author: ZhouJie
	 * @date: 2020年4月8日 下午7:38:58 
	 * @param: @param m
	 * @param: @param n
	 * @param: @param k
	 * @param: @return
	 * @return: int
	 * @Description: 1-本题等价于从[0,0]点扩散，共有多少个点满足条件：行坐标和列坐标的数位之和不大于k；故可用BFS解决
	 *
	 */
	public int movingCount_1(int m, int n, int k) {
		// 是否到达过
		boolean[][] f = new boolean[m][n];
		// 方向数组，因为是从[0，0]开始，所以只需要向右和向下扩散搜索即可；
		int[] dx = new int[] { 0, 1 };
		int[] dy = new int[] { 1, 0 };
		// bfs队列
		ArrayDeque<int[]> deque = new ArrayDeque<int[]>();
		deque.offer(new int[] { 0, 0 });
		int count = 0;
		while (!deque.isEmpty()) {
			int[] poll = deque.poll();
			int x = poll[0];
			int y = poll[1];
			if (f[x][y]) {
				continue;
			}
			count++;
			f[x][y] = true;
			for (int i = 0; i < 2; i++) {
				int x0 = x + dx[i];
				int y0 = y + dy[i];
				if (x0 < m && y0 < n && (x0 % 10 + x0 / 10 + y0 % 10 + y0 / 10) <= k) {
					deque.offer(new int[] { x0, y0 });
				}
			}
		}
		return count;
	}

	/**
	 * @author: ZhouJie
	 * @date: 2020年4月8日 下午8:16:57 
	 * @param: @param m
	 * @param: @param n
	 * @param: @param k
	 * @param: @return
	 * @return: int
	 * @Description: 2-方法1是bfs，现在用dfs；
	 *
	 */
	public int movingCount_2(int m, int n, int k) {
		boolean[][] f = new boolean[m][n];
		return dfs(m, n, 0, 0, k, f);
	}

	private int dfs(int m, int n, int x, int y, int k, boolean[][] f) {
		if (x < m && y < n && !f[x][y] && (x % 10 + x / 10 + y % 10 + y / 10) <= k) {
			// 符合条件的在右和下两个方向上继续搜索
			f[x][y] = true;
			return 1 + dfs(m, n, x + 1, y, k, f) + dfs(m, n, x, y + 1, k, f);
		} else {
			return 0;
		}
	}

	/**
	 * @author: ZhouJie
	 * @date: 2020年4月8日 下午8:45:57 
	 * @param: @param m
	 * @param: @param n
	 * @param: @param k
	 * @param: @return
	 * @return: int
	 * @Description: 3-递推验证，某一个位置是否可达，取决于其本身是否可达且其左方和上方至少有一个可达；
	 *
	 */
	public int movingCount_3(int m, int n, int k) {
		boolean[][] f = new boolean[m][n];
		int count = 0;
		for (int i = 0; i < m; i++) {
			for (int j = 0; j < n; j++) {
				// 起点位置不需要前置验证
				if (i == 0 && j == 0) {
					f[i][j] = true;
					count++;
					continue;
				}
				// 非起点位置，必须验证当前起点可达且其左位置和上位置至少有一个可达
				if ((i % 10 + i / 10 + j % 10 + j / 10) <= k && (i > 0 && f[i - 1][j] || j > 0 && f[i][j - 1])) {
					f[i][j] = true;
					count++;
				}
			}
		}
		return count;
	}
}