【剑指offer系列】-13机器人的运动范围（岛屿的数量）

题目

地上有一个m行和n列的方格。一个机器人从坐标0,0的格子开始移动，每一次只能向左，右，上，下四个方向移动一格，但是不能进入行坐标和列坐标的数位之和大于k的格子。
例如，当k为18时，机器人能够进入方格（35,37），因为3+5+3+7=18。但是，它不能进入方格（35,38），因为3+5+3+8=19。请问该机器人能够达到多少个格子？

方式一：BFS

public class RobotMoveRange {
    public static void main(String[] args) {
        int m = 9;
        int n = 8;
        int[][] matrix = new int[m][n];
        int k = 5;
        List<List<Pair<Integer, Integer>>> res = func(matrix, k);
        for (List<Pair<Integer, Integer>> list : res) {
            for (Pair<Integer, Integer> pair : list) {
                System.out.println(pair);
            }
        }
    }

    private static List<List<Pair<Integer, Integer>>> func(int[][] matrix, int k) {
        List<List<Pair<Integer, Integer>>> res = new ArrayList<>();
        boolean[][] occupied = new boolean[matrix.length][matrix[0].length];
        for (int i = 0; i < matrix.length; i++) {
            for (int j = 0; j < matrix[0].length; j++) {
                if (valid(i, j, k, matrix, occupied)) {
                    List<Pair<Integer, Integer>> path = fromHerePioneerAndMarkMainlandOccupied(i, j, matrix, occupied, k);
                    res.add(path);
                }
            }
        }
        return res;
    }

    private static List<Pair<Integer, Integer>> fromHerePioneerAndMarkMainlandOccupied(int i, int j, int[][] matrix, boolean[][] occupied, int k) {
        List<Pair<Integer, Integer>> path = new ArrayList<>();
        Queue<Pair<Integer, Integer>> queue = new LinkedBlockingQueue<>();

        Pair<Integer, Integer> pair = new Pair<>(i, j);
        path.add(pair);
        queue.add(pair);
        occupied[i][j] = true;

        int[] xOffset = {-1, 1 ,0 ,0};
        int[] yOffset = {0, 0, -1, 1};
        while (queue.size() > 0) {
            Pair<Integer, Integer> position = queue.poll();
            for (int l = 0; l < 4; l++) {
                int nextX = position.getKey() + xOffset[l];
                int nextY = position.getValue() + yOffset[l];
                if (valid(nextX, nextY, k, matrix, occupied)) {
                    Pair<Integer, Integer> next = new Pair<>(nextX, nextY);
                    path.add(next);
                    queue.add(next);
                    occupied[nextX][nextY] = true;
                }
            }
        }

        return path;
    }

    private static boolean valid(int i, int j, int k, int[][] matrix, boolean[][] occupied) {
        // 越界
        if (i < 0 || j < 0 || i >= matrix.length || j >= matrix[0].length) {
            return false;
        }
        // 被占领
        if (occupied[i][j]) {
            return false;
        }
        // 小于k
        int sum = 0;
        String m = String.valueOf(i);
        for (int l = 0; l < m.length(); l++) {
            sum += m.charAt(l) - '0';
        }
        String n = String.valueOf(j);
        for (int l = 0; l < n.length(); l++) {
            sum += n.charAt(l) - '0';

        }
        return sum <= k;
    }
}

方式二：DFS

    /**
     * 比如 k=1
     *  (0,0) (0,1) (0,2)
     *  (1,0) (1,1) (1,2)
     * 开始(0,0)可以行得通(标记为已走过)
     * 一.走(0,0)的左边
     *                  (0,-1)行不通
     * 二.走(0,0)的右边
     *                 (0,1)行的通，标记为已走过true
     *                                          走(0,1)的左边
     *                                              其左边  (0,0)走不通，已走过
     *                                              其右边  (0,2)走不通，大于k
     *                                              其上面  (-1,1)走不通，边界不符合
     *                                              其下面  (1,1)走不通，大于k
     *三.走(0,0)的上
     *              (-1,0),不通
     *四.走(0,0)的下
     *              (1,0)行得通，标记为true
     *                                      走(1,0)的左边
     *                                              其左边  (1,-1)走不通，边界不符合
     *                                              其右边  (1,1)走不通，大于k
     *                                              其上面  (0,1)走不通，已走过
     *                                              其下面  (2,0)走不通，边界不符合
     *
     * 至此结束
     *                                              
     */

2.各个位上的和

/**
* 求x位数+y位数的和
* 123(1+2+3=6) + 43(4+3=7) = 13
* 123:
* 个位: 3= 123 / 10^0 % 10
* 十位: 2= 123 / 10^1 % 10
* 百位：1= 123 / 10^2 % 10
*/

import java.util.Scanner;
class Main12 {
    private static int count = 0;//统计次数
    
    private static void findPath(int x, int y, int row, int col, int key,boolean[][] visited) {
        //当向右左上下其中一个方向走后，出现越界、已来过、大于key的情况  =>都行不通
        if (x < 0 || y < 0 || x >= row || y >= col || visited[x][y] || calculate(x,y) > key)
            return ;
        //行得通，标记为已来过
        visited[x][y] = true;
        count++;
        findPath(x,y-1 ,row ,col ,key , visited);//上下左右dfs
        findPath(x,y+1 ,row ,col ,key , visited);
        findPath(x-1,y-1 ,row ,col ,key , visited);
        findPath(x+1,y-1 ,row ,col ,key , visited);
    }

    
     //求x位数+y位数的和
    private static int calculate(int x, int y) {
        int sum = 0;
        int xlen = (x+"").length();
        int ylen = (y+"").length();
        for (int i = 0; i < xlen; i++) {
            sum += x / Math.pow(10,i) % 10;
        }
        for (int i = 0; i < ylen; i++) {
            sum += y / Math.pow(10,i ) % 10;
        }
        return sum;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int m = sc.nextInt();
        int n = sc.nextInt();
        int key = sc.nextInt();
        boolean[][] visited = new boolean[m][n];
        findPath(0,0,m,n,key,visited);
        System.out.println(count);
    }
}