剑指offer的一道经典题目。
描述
地上有一个 rows 行和 cols 列的方格。坐标从 [0,0] 到 [rows-1,cols-1] 。一个机器人从坐标 [0,0] 的格子开始移动,每一次只能向左,右,上,下四个方向移动一格,但是不能进入行坐标和列坐标的数位之和大于 threshold 的格子。 例如,当 threshold 为 18 时,机器人能够进入方格 [35,37] ,因为 3+5+3+7 = 18。但是,它不能进入方格 [35,38] ,因为 3+5+3+8 = 19 。请问该机器人能够达到多少个格子?
数据范围: 0≤threshold≤15 ,1≤rows,cols≤100
进阶:空间复杂度 O(nm) ,时间复杂度 O(nm)
知识点:深度优先搜索(dfs)
深度优先搜索一般用于树或者图的遍历,其他有分支的(如二维矩阵)也适用。它的原理是从初始点开始,一直沿着同一个分支遍历,直到该分支结束,然后回溯到上一级继续沿着一个分支走到底,如此往复,直到所有的节点都有被访问到。
思路:
我们从[0,0]开始,每次选择一个方向开始检查能否访问,如果能访问进入该节点,该节点作为子问题,继续按照这个思路访问,一条路走到黑,然后再回溯,回溯的过程中每个子问题再选择其他方向,正是深度优先搜索。注意我们可以用二叉树来类比这次深度优先搜索,而数据的大小越大则深度越深。所以我们向下向右遍历可以看作向左子树遍历和向右子树遍历(只是这么理解)
具体做法:
- 第一步:检查若是threshold小于等于0,只能访问起点这个格子。
- 第二步:从起点开始深度优先搜索,每次访问一个格子的下标时,检查其有没有超过边界,是否被访问过了。同时用连除法分别计算每个下标的位数和,检查位数和是否大于threshold。
- 第三步:若是都符合访问条件,则进行访问,增加访问的格子数,同时数组中标记为访问过了。
- 第四步:然后遍历两个方向,依次进入两个分支继续访问。
代码:
public class Solution {
//记录遍历的两个方向
int[][] dir = {{1, 0}, {0, 1}};
//记录答案
int res = 0;
//计算一个数字的每个数之和
int cal(int n){
int sum = 0;
//连除法算出每一位
while(n != 0){
sum += (n % 10);
n /= 10;
}
return sum;
}
//深度优先搜索dfs
void dfs(int i, int j, int rows, int cols, int threshold, boolean[][] vis){
//越界或者已经访问过
if(i < 0 || i >= rows || j < 0 || j >= cols || vis[i][j] == true)
return;
//行列和数字相加大于threshold,不可取
if(cal(i) + cal(j) > threshold)
return;
res += 1;
//标记经过的位置
vis[i][j] = true;
//下右四个方向搜索
for(int k = 0; k < 2; k++)
dfs(i + dir[k][0], j + dir[k][1], rows, cols, threshold, vis);
}
public int movingCount(int threshold, int rows, int cols) {
//判断特殊情况
if(threshold <= 0)
return 1;
//标记某个格子没有被访问过
boolean[][] vis = new boolean[rows][cols];
dfs(0, 0, rows, cols, threshold, vis);
return res;
}
}
复杂度分析:
- 时间复杂度:O(mn)O(mn),其中mm与nn分别为格子的边长,深度优先搜索最坏情况下遍历格子每个位置一次
- 空间复杂度:O(mn)O(mn),递归栈的最大空间为格子的大小,同时记录是否访问过的数组vis空间为O(mn)O(mn)
用广度优先遍历也可以实现,思考一下?
代码参考:
import java.util.*;
public class Solution {
//记录遍历的两个方向
int[][] dir = {{1, 0}, {0, 1}};
//记录答案
int res = 0;
//计算一个数字的每个数之和
int cal(int n) {
int sum = 0;
//连除法算出每一位
while (n != 0) {
sum += (n % 10);
n /= 10;
}
return sum;
}
public int movingCount(int threshold, int rows, int cols) {
//判断特殊情况
if (threshold <= 0)
return 1;
//标记某个格子没有被访问过
boolean[][] vis = new boolean[rows][cols];
//记录答案
int res = 0;
Queue<ArrayList<Integer> > q = new LinkedList<ArrayList<Integer>>();
//起点先入队列
q.offer(new ArrayList<Integer>(Arrays.asList(0, 0)));
vis[0][0] = true;
while (!q.isEmpty()) {
//获取符合条件的一步格子
ArrayList<Integer> node = q.poll();
res += 1;
//遍历两个方向
for (int i = 0; i < 2; i++) {
int x = node.get(0) + dir[i][0];
int y = node.get(1) + dir[i][1];
//符合条件的下一步才进入队列
if (x >= 0 && x < rows && y >= 0 && y < cols && vis[x][y] != true) {
if (cal(x) + cal(y) <= threshold) {
q.offer(new ArrayList<Integer>(Arrays.asList(x, y)));
vis[x][y] = true;
}
}
}
}
return res;
}
}