剑指 Offer ！！13. 机器人的运动范围(回溯算法)

剑指 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的上限即可，而不用操心下限的情况。
有意思的是，这里的深度优先搜索并不用恢复现场，因为本题希望求有多少格子是机器人能走的。

  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)）”。注意，每个格子只能登陆一次，所以需要使用二维布尔型数组标记那些已经被登录成功、被计数的格子，从而保证不被重复计数。

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);
            }

        }
    }