剑指 Offer 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：广度优先遍历
看下面的代码结构很像二叉树的按层遍历（只是这里“节点”被放进queue的判断条件不再是“左右孩子不为空”，而是 满足此处题意的条件——不超出整个面板的范围 && 横纵坐标数字和<=k && 还没有进过queue， 这个判断条件在下面的代码中被反着表述了出来）。
class Solution {
public int movingCount(int m, int n, int k) {
int[] dx = {0,1};
int[] dy = {1,0};
boolean[][] visited = new boolean[m][n];
Queue<int[]> queue = new LinkedList<>();
int[] cur = new int[]{0,0};
queue.offer(cur);
visited[0][0]=true;
int ans=1;
while(!queue.isEmpty()){
cur = queue.poll();
for(int i=0;i<2;i++){
int x = cur[0]+dx[i];
int y = cur[1]+dy[i];
if(x<0||x>=m||y<0||y>=n||(get(x)+get(y))>k||visited[x][y]){
continue;
}
queue.offer(new int[]{x,y});
visited[x][y]=true;
ans++;
}
}
return ans;
}
public int get(int x){
int res=0;
while(x!=0){
res+=x%10;
x/=10;
}
return res;
}
}
思路2：深度优先遍历
根据上面的广度优先搜索，可以写出深度优先搜索的代码如下。
注意：因为事先想好了，每次决策都是“向下”或“向右”，所以dsf递归函数的base case 只需照顾x,y的上限即可，而不用操心下限的情况。
有意思的是，这里的深度优先搜索并不用恢复现场，因为本题希望求有多少格子是机器人能走的。文章来源：https://www.toymoban.com/news/detail-664948.html
int count=0;
public int movingCount(int m, int n, int k) {
count++;
boolean[][] visited = new boolean[m][n];
visited[0][0]=true;
dsf(m,n,0,0,k,visited);
return count;
}
public void dsf(int m, int n, int x, int y, int k,boolean[][] visited){
if(x==m&&y==n){
return;
}
if(x+1<m && (get(x+1)+get(y))<=k && !visited[x+1][y]){
count++;
visited[x+1][y]=true;
dsf(m,n,x+1,y,k,visited);
}
if(y+1<n && (get(x)+get(y+1))<=k && !visited[x][y+1]){
count++;
visited[x][y+1]=true;
dsf(m,n,x,y+1,k,visited);
}
}
public int get(int x){
int res=0;
while(x!=0){
res+=x%10;
x/=10;
}
return res;
}
书上的写法
我觉得书上这版是思路最清晰的……具体地，“怎么数”，根据代码猜测大概是“只要从(0,0)出发能够登录成功的格子都算（不管是否能够达到(m-1,n-1)）”。注意，每个格子只能登陆一次，所以需要使用二维布尔型数组标记那些已经被登录成功、被计数的格子，从而保证不被重复计数。文章来源地址https://www.toymoban.com/news/detail-664948.html
public int movingCount(int m, int n, int k) {
boolean[][] visited=new boolean[m][n];
return func(0,0,m,n,k,visited);
}
public int func(int x, int y, int m, int n, int k,boolean[][] visited){
int count=0;
if(check(x,y,m,n,k,visited)){
visited[x][y]=true;
count=1+
func(x-1,y,m,n,k,visited)+
func(x,y-1,m,n,k,visited)+
func(x,y+1,m,n,k,visited)+
func(x+1,y,m,n,k,visited);
}
return count;
}
public boolean check(int x, int y, int m, int n, int k, boolean[][] visited){
return x>=0&&x<m&&y>=0&&y<n&&(bitSum(x)+bitSum(y)<=k)&&!visited[x][y];
}
public int bitSum(int x){
// if()
int sum=0;
while(x>0){
sum+=x%10;
x/=10;
}
return sum;
}
- 我自己瞎写了一下，因为没有考虑到“重复访问”的问题，发生了栈溢出。然后，我看着书上的答案，修正了一下，有了下面的代码。
其实思路不如上面的代码清晰，尤其是条件判断的组织。
int res;
boolean[][] visited;
public int movingCount(int m, int n, int k) {
res=0;
visited=new boolean[m][n];
bfs(0,0,m,n,k);
return res;
}
public void bfs(int x, int y, int m, int n, int k){
if(bitSum(x)+bitSum(y)<=k && !visited[x][y]){
visited[x][y]=true;
res++;
if(x-1>=0){// up
bfs(x-1,y,m,n,k);
}
if(x+1<m)//down
{
bfs(x+1,y,m,n,k);
}
if(y-1>=0){
bfs(x,y-1,m,n,k);
}
if(y+1<n){
bfs(x,y+1,m,n,k);
}
}
}
到了这里，关于剑指 Offer ！！13. 机器人的运动范围(回溯算法)的文章就介绍完了。如果您还想了解更多内容，请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章，希望大家以后多多支持TOY模板网！
