剑指Offer-面试题13：机器人的运动范围

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。

• 例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。但是，它不能进入方格（35,38），因为3+5+3+8 = 19。
  请问该机器人能够达到多少个格子？

思路

仍旧是递归，上下左右四个格子。
一些问题：
（1）int类型数组初始化，元素均为0。
（2）整个解题过程需要把递归单独分出来，作为一个独立的函数。
（3）位数之和的方法中使用到了do{ }while( );循环，因为起始点是从(0,0)点开始的；直到型循环的应用；以及使用了ArrayList函数时在OJ中需要引入包。
（4） 递归函数中的终止条件容易漏写以及我的写法中的4个if条件的递归当前与下一次情况的混杂。
（5） 一直忽略了最后的return moving(threshold,rows,cols,i-1,j,count,arr)+ ... +1;最后的 +1 的巧妙之处；同时想着用arr[i][j]==1当成是可行的点，最后返回的则是整个矩阵个数之和，因为其实是所有的元素都遍历了，属于深度优先搜索的情况。
（6） 还有矩阵右对角线位数之和的性质，但是发现当0<=k<=4和 10<=k<=13之间还隔着其他的元素，不能直接得出结论,而且实际中不一定给出的是方阵。
（7） 本道题与面试题12：矩阵中的路径的区别：
（8） 关键的还是对递归的思想把握以及对程序的分类情况。

解法1

不能全部AC

/**
 * 面试题13：机器人的运动范围
 *
 * @author Heroin X
 * @date 2019/12/24 16:05
 */
public class RobotMoveRange {

    public static void main(String[] args) {
        int i = new RobotMoveRange().movingCount(2, 5, 5);
        System.out.println(i);
    }
    
    public int movingCount(int threshold, int rows, int cols) {
        // 需要记录当前点的坐标
        int i=0;int j=0;
        int[][] arr = new int[rows][cols];
        return moving(threshold,rows,cols,i,j,0,arr);

//        int c2=0;
//        for (int k=0;k<rows;k++){
//            for (int l=0;l<cols;l++){
//                if (arr[i][j]==1){
//                    c2++;
//                }
//            }
//        }
//
//        System.out.println("统计的次数："+c2);
    }

	//递归函数
    int moving(int threshold, int rows, int cols, int i, int j,int count,int[][] arr) {
    
        //递归终止条件
        if (sum2(i,j)>threshold || i>=rows || j>=cols || i<0 || j<0 || arr[i][j]==1){
            return 0;
        }

        arr[i][j]=1;

        return moving(threshold,rows,cols,i-1,j,count,arr)+moving(threshold,rows,cols,i+1,j,count,arr)
                + moving(threshold,rows,cols,i,j+1,count,arr)+moving(threshold,rows,cols,i,j-1,count,arr)+1;

		//我的写法：
//        if (i>0 && countTotal(i,j)<threshold && arr[i][j]==0){
//            arr[i][j]=1;
//            i++;
//            return moving(threshold,rows,cols,i,j,count++,arr);
//        }
//
//        if (i<rows && countTotal(i,j)<threshold && arr[i][j]==0){
//            arr[i][j]=1;
//            i--;
//            return moving(threshold,rows,cols,i,j,count++,arr);
//        }
//
//        if (j>0 && countTotal(i,j)<threshold && arr[i][j]==0){
//            arr[i][j]=1;
//            j++;
//            return moving(threshold,rows,cols,i,j,count++,arr);
//        }
//
//        if (j<cols && countTotal(i,j)<threshold && arr[i][j]==0){
//            arr[i][j]=1;
//            j--;
//            return moving(threshold,rows,cols,i,j,count++,arr);
//        }
//
//        return count;

    }
	
	// 改进后的位数上求和
    static int sum2(int rows, int cols){

        int sum=0;
        do {
            sum=sum+ rows % 10;
            rows=rows/10;
        }while (rows/10>0);

        do {
            sum=sum+ cols % 10;
            cols=cols/10;
        }while (cols/10>0);
        
        return sum;
    }

	//最初的求和，用到了ArrayList，在newcoder 需要导包
    static int sum(int rows, int cols){
        int i=0;int j=0;
        ArrayList<Integer> arr1 = new ArrayList<>();
        do {
            i=rows%10;
            arr1.add(i);
            rows=rows/10;
        }while (rows>0);

        do {
            j=cols%10;
            arr1.add(j);
            cols=cols/10;
        }while (cols>0);

        int count =0;
        for (int k=0;k<arr1.size();k++){
            count=count+arr1.get(k);
        }
        return count;
    }


}


//        if (符合要求？ 有没有走过？)
//        count=1;
//        else return 0；

解法2-递归

nowcoder的AC
提交时间：2019-12-30 ，语言：Java ，运行时间： 18 ms，占用内存：9248K ，状态：答案正确
之前的解法1不能全部AC的主要问题就是再求和的时候while (cols/10>0)多除了一次。

public class Solution {
  
    public int movingCount(int threshold, int rows, int cols)
    {
        int i=0;int j=0;
        int[][] flag = new int[rows][cols];
        return moving(threshold,rows,cols,i,j,flag);
    }
      
    public int moving(int threshold, int rows, int cols, int i, int j,int[][] flag) {
  
        //递归终止条件
        if (sum(i,j)>threshold || i>=rows || j>=cols || i<0 || j<0 || flag[i][j]==1){
            return 0;
        }
          
        flag[i][j]=1;
         
        return moving(threshold,rows,cols,i+1,j,flag)
            +moving(threshold,rows,cols,i-1,j,flag)
            +moving(threshold,rows,cols,i,j+1,flag)
            +moving(threshold,rows,cols,i,j-1,flag)+1;
    }
  
    int sum(int rows, int cols){
        int sum=0;
        do{
            sum = sum+ rows % 10;
            rows = rows/10;
        }while(rows>0);
          
        do{
            sum = sum+ cols % 10;
            cols = cols/10;
        }while(cols>0);
        
        return sum;
    }    
}

解法2-2

2020/4/8

class Solution {

    int row = 0;
    int col = 0;
    public int movingCount(int m, int n, int k) {
        row = m;
        col = n;
        int[][] flag = new int[m][n];
        int i = 0;
        int j = 0;
        return dfs(i, j, flag, k);
    }

    private int dfs(int i, int j,int[][] flag, int k){
        if(i < 0 || i >= row || j < 0 || j >= col || sum(i, j) > k || flag[i][j] == 1 ){
            return 0;
        }

        flag[i][j] = 1;
        return dfs(i+1, j, flag, k) + dfs(i-1, j, flag, k) + dfs(i, j+1, flag, k) + dfs(i, j-1, flag, k) + 1;
    }

    private int sum(int a, int b){
        int res = 0;
        while(a > 0){
            res += a % 10;
            a /= 10;
        }

        while(b > 0){
            res += b % 10;
            b /= 10;
        }
        return res;
    }
}