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