题目解释
地上有一个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
解题思路
此类问题通常可使用 深度优先搜索(DFS) 或 广度优先搜索(BFS) 解决。在介绍 DFS / BFS 算法之前,为提升计算效率,首先讲述两项前置工作: 数位之和计算、 搜索方向简化。
数位之和计算:
- 设一数字 xx ,向下取整除法符号 //,求余符号⊙ ,则有:
x⊙10 :得到 xx 的个位数字;
x//10 : 令 xx 的十进制数向右移动一位,即删除个位数字。 - 因此,可通过循环求得数位和 ss ,数位和计算的封装函数如下所示:
def sums(x):
s = 0
while x:
s += x % 10
x = x // 10
return s
- 由于机器人每次只能移动一格(即只能从 x 运动至 x±1),因此每次只需计算 x 到 x±1 的数位和增量。本题说明 1 ≤ n , m ≤ 1001 ≤ n , m ≤ 100 1 \leq n,m \leq 1001≤n,m≤100 1≤n,m≤1001≤n,m≤100 ,以下公式仅在此范围适用。
- 数位和增量公式: 设 xx 的数位和为
s
x
s_x
sx, x+1的数位和为
s
x
+
1
s_{x+1}
sx+1
1. 当(x+1)⊙ 10 = 0时: s x + 1 = s x − 8 s_{x+1} = s_x - 8 sx+1=sx−8,例如19,20的数位和分别为10,2
2. 当(x+1)⊙ 10 ≠ 0时: s x + 1 = s x + 1 s_{x+1} = s_x + 1 sx+1=sx+1,例如1,2的数位和分别为1,2
以下代码为增量公式的三元表达式写法,将整合入最终代码中。
python | java |
---|---|
s x s_x sx + 1 if (x + 1) % 10 else s x − 8 s_x - 8 sx−8 | (x + 1) % 10 == 1 ? s x + 1 : s x − 8 s_x + 1 : s_x - 8 sx+1:sx−8 |
搜索方向简化:
- 数位和特点:根据数位和增量公式得知,数位和每逢进位突变一次。
- 解的三角形结构:
1. 根据数位和特点,矩阵中满足数位和的解构成的几何形状如多个等腰直角三角形,每个三角形的直角顶点位于0,10,20,…等数位和突变的矩阵索引处。
2. 三角形内的解虽然都满足数位和要求,但由于机器人每步只能走一个单元格,而三角形间不一定是连通的,因此机器人不一定能到达,称之为 不可达解;同理,可到达的解称为可达解 - 结论:根据可达解的结构,易推出机器人可仅通过向右和向下移动,访问所有可达解。
1. 三角形内部:全部连通,易证;
2. 两三角形连通处:若某三角形内的解为可达解,则比其左边或上边的三角形连通(即相交),即机器人必可从左边或上边走进此三角形。
图例展示了 n , m = 20 , k ∈ [ 6 , 19 ] 的 可 达 解 、 不 可 达 解 、 非 解 , 以 及 连 通 性 的 变 化 n,m = 20,k \in [6,19]的可达解、不可达解、非解,以及连通性的变化 n,m=20,k∈[6,19]的可达解、不可达解、非解,以及连通性的变化
方法一:深度优先遍历 DFS
- 深度优先搜索:可以理解为暴力模拟机器人在矩阵中所有的路径。DFS通过递归,先朝一个方向搜到底,再回溯至上个节点,沿另一个方向搜索,以此类推。
- 剪枝:在搜索中,遇到数位和超出目标值、此元素已访问,即应立即返回,称之为
可行性剪枝
。
算法解析:
- 递归参数:当前元素在矩阵中行列索引
i
和j
,两者的数位和si
和sj
。 - 终止条件:当 ① 行列索引越界或 ② 数位和超出目标值
k
或 ③ 当前元素已访问过 时,返回 00 ,代表不计入可达解。 - 递推工作:
- 标记当前单元格:将索引
(i,j)
存入Setvisited
中,代表此单元格已被访问过。 - 搜索下一单元格:计算当前元素的下、右两个方向元素的数位和,并开启下层递归。
- 标记当前单元格:将索引
- 回溯返回值:返回
1 + 右方搜索的可达解总数 + 下方搜索的可达解总数
,代表从本单元格递归搜索的可达解总数。
复杂度分析:
M,N 分别为矩阵行列大小。
- 时间复杂度 O(MN): 最差情况下,机器人遍历矩阵所有单元格,此时时间复杂度为 O(MN)。
- 空间复杂度 O(MN): 最差情况下,Set
visited
内存储矩阵所有单元格的索引,此时时间复杂度为 O(MN)。
代码:
Java代码中
visited
为辅助矩阵,Python中为Set。
# Python DFS实现方式
class Solution:
def movingCount(self, m: int, n: int, k: int) -> int:
def dfs(i, j, si, sj):
if not 0 <= i < m or not 0 <= j < n or k < si + sj or (i, j) in visited: return 0
visited.add((i,j))
return 1 + dfs(i + 1, j, si + 1 if (i + 1) % 10 else si - 8, sj) + dfs(i, j + 1, si, sj + 1 if (j + 1) % 10 else sj - 8)
visited = set()
return dfs(0, 0, 0, 0)
// java DFS实现方式
class Solution {
int m, n, k;
boolean[][] visited;
public int movingCount(int m, int n, int k) {
this.m = m; this.n = n; this.k = k;
this.visited = new boolean[m][n];
return dfs(0, 0, 0, 0);
}
public int dfs(int i, int j, int si, int sj) {
if(i < 0 || i >= m || j < 0 || j >= n || k < si + sj || visited[i][j]) return 0;
visited[i][j] = true;
return 1 + dfs(i + 1, j, (i + 1) % 10 != 0 ? si + 1 : si - 8, sj) + dfs(i, j + 1, si, (j + 1) % 10 != 0 ? sj + 1 : sj - 8);
}
}
方法二:广度优先遍历 BFS
- BFS/DFS:两者目标都是遍历整个矩阵,不同点在于搜索顺序不同。DFS 是朝一个方向走到底,再回退,以此类推;BFS 则是按照“平推”的方式向前搜索。
- BFS 实现:通常利用队列实现广度优先遍历。
算法解析:
- 初始化:将机器人初始点(0,0)加入队列
queue
; - 迭代终止条件:
queue
为空。代表已遍历完所有可达解。 - 迭代工作:
- 单元格出队:将队首单元格的索引、数位和弹出,作为当前搜索单元格。
- 判断是否跳过: 若 ① 行列索引越界 或 ② 数位和超出目标值 k 或 ③ 当前元素已访问过 时,执行
continue
。 - 标记当前单元格:将单元格索引
(i,j)
存入 Setvisited
中,代表此单元格已被访问过。 - 单元格入队:将当前元素的下方、右方单元格的索引、数位和加入
queue
。
- 返回值:Set
visited
的长度len(visited)
,即可达解的数量。
Java使用了辅助变量
res
统计可达解数量;Python直接返回Set的元素数即可。
复杂度分析:
M,N 分别为矩阵行列大小。
- 时间复杂度 O(MN): 最差情况下,机器人遍历矩阵所有单元格,此时时间复杂度为 O(MN)。
- 空间复杂度 O(MN): 最差情况下,Set
visited
内存储矩阵所有单元格的索引,此时时间复杂度为 O(MN)。
Java代码中
visited
为辅助矩阵,Python中为Set。
# Python BFS实现方式
class Solution:
def movingCount(self, m: int, n: int, k: int) -> int:
queue, visited, = [(0, 0, 0, 0)], set()
while queue:
i, j, si, sj = queue.pop(0)
if not 0 <= i < m or not 0 <= j < n or k < si + sj or (i, j) in visited: continue
visited.add((i,j))
queue.append((i + 1, j, si + 1 if (i + 1) % 10 else si - 8, sj))
queue.append((i, j + 1, si, sj + 1 if (j + 1) % 10 else sj - 8))
return len(visited)
// java BFS实现方式
class Solution {
public int movingCount(int m, int n, int k) {
boolean[][] visited = new boolean[m][n];
int res = 0;
Queue<int[]> queue= new LinkedList<int[]>();
queue.add(new int[] { 0, 0, 0, 0 });
while(queue.size() > 0) {
int[] x = queue.poll();
int i = x[0], j = x[1], si = x[2], sj = x[3];
if(i < 0 || i >= m || j < 0 || j >= n || k < si + sj || visited[i][j]) continue;
visited[i][j] = true;
res ++;
queue.add(new int[] { i + 1, j, (i + 1) % 10 != 0 ? si + 1 : si - 8, sj });
queue.add(new int[] { i, j + 1, si, (j + 1) % 10 != 0 ? sj + 1 : sj - 8 });
}
return res;
}
}