第10题。

DFS
下面方法针对的是，起始位置任意的情况（但没有把位置输入拉出来）

package exercise10;


//地上有一个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。请问该机器人能够到达多少个格子？
public class Solution {
    int sum = 0;
    public static void main(String[] args) {
        Solution solution = new Solution();
        int i = solution.movingCount(38, 15, 9);
        System.out.println(i);
    }
    //思路：给每次经过的格子都设置标记，每设置一次就总量加一
    //路径采取右-下-左-上
    public int movingCount(int m, int n, int k) {
        boolean[][] visited = new boolean[m][n];
        walk(0,0,m,n,visited,k);
        return sum;
    }
    
    public void walk(int x,int y,int m,int n,boolean[][] visited,int k){
        if (visited[x][y] == true){
            return;
        }
        int nums = nums(x, y);
        if (nums > k){
            return;
        }
        sum++;
        visited[x][y] = true;
        int selection = 0;
        while (selection < 4){
            int x0 = x;
            int y0 = y;
            switch (selection){
                case 0:
                    y0++;
                    break;
                case 1:
                    x0++;
                    break;
                case 2:
                    y0--;
                    break;
                case 3:
                    x0--;
                    break;
            }
            if (x0 < m && x0 >= 0 && y0 < n && y0 >= 0){
                walk(x0,y0,m,n,visited,k);
            }
            selection++;
        }
    }
    public int nums(int x,int y){
        //取出各位数字
        int x1 = x / 10;
        int x0 = x % 10;
        int y1 = y / 10;
        int y0 = y % 10;
        //数位和
        int num = x0 + x1 + y0 + y1;
        return num;
    }
}

再根据题意写一个：这里只有右和下情况，起始位置如果不是（0,0）就出错了

public void walk(int x,int y,int m,int n,boolean[][] visited,int k){
        if (x >= m || y >= n || visited[x][y] == true || nums(x,y) > k){
            return;
        }
        sum++;
        visited[x][y] = true;
        walk(x,y+1,m,n,visited,k);
        walk(x+1,y,m,n,visited,k);
    }

BFS

package exercise10;


import java.util.LinkedList;
import java.util.Queue;

//地上有一个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。请问该机器人能够到达多少个格子？
public class Solution1 {
    public static void main(String[] args) {
        Solution1 solution = new Solution1();
        int i = solution.movingCount(38, 15, 9);
        System.out.println(i);
    }
    //思路：给每次经过的格子都设置标记，每设置一次就总量加一
    //路径采取右-下-左-上
    public int movingCount(int m, int n, int k) {
        int sum = 0;
        boolean[][] visited = new boolean[m][n];
        //存放遍历过的位置
        LinkedList<int[]> list = new LinkedList<>();
        list.add(new int[]{0,0});
        while (list.size() > 0){
            int[] poll = list.poll();//poll是队列 数据结构 实现类的方法，从队首获取元素，同时获取的这个元素将从原队列删除
            int i = poll[0];
            int j = poll[1];
            if (i >= m || j >= n || visited[i][j] == true || nums(i,j) > k){
                continue;
            }
            sum++;
            visited[i][j] = true;
            list.add(new int[]{i,j + 1});
            list.add(new int[]{i + 1,j});
        }
        return sum;
    }

    public int nums(int x,int y){
        //取出各位数字
        int x1 = x / 10;
        int x0 = x % 10;
        int y1 = y / 10;
        int y0 = y % 10;
        //数位和
        int num = x0 + x1 + y0 + y1;
        return num;
    }
}

这里提交的时候，DFS用时，内存消耗较BFS少
分析两者时空间复杂度都是o(mn)