图的搜索_机器人运动范围

机器人运动范围问题

问题描述：

地上有一个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。请问该机器人能够到达多少个格子？

分析

经典棋盘问题，借助dfs 和 bfs 两种思路解决

深度优先搜索：借助栈结构，走到一个不能走的点，回退。

//dfs 深度优先搜索用栈结构
    public int movingCount_dfs(int m,int n,int k){
        Stack<int[]> stack = new Stack<>();
        int[][] grid = new int[m][n];
        int[] dot = new int[2];
        stack.add(dot);
        int count=0;
        while(!stack.isEmpty()){
            int[] newdot = stack.pop();
            int x = newdot[0];
            int y = newdot[1];
            if(grid[x][y] == 0){
                int sum_x = x/10 + x%10;
                int sum_y = y/10 + y%10;
                int sum = sum_x + sum_y;
                if(sum <= k){
                    count++;
                    grid[x][y]=1;
                    if(x+1<m && grid[x+1][y]==0) stack.add(new int[]{x+1,y});
                    if(x-1>=0 && grid[x-1][y]==0) stack.add(new int[]{x-1,y});
                    if(y+1<n && grid[x][y+1]==0) stack.add(new int[]{x,y+1});
                    if(y-1>=0 && grid[x][y-1]==0) stack.add(new int[]{x,y-1});
                }
            }
        }
        return count;
    }

广度优先搜索：借助队列结构，查看每一个格子附近的格子，走一遍。

//bfs 广度优先搜索用队列
    public int movingCount_bfs(int m, int n, int k) {
        Queue<int[]> queue = new LinkedList<>();
        int[][] grid = new int[m][n];
        int[] dot = new int[2];

        queue.offer(dot);
        int count =0;
        while(!queue.isEmpty()){
            int[] newdot = queue.remove();
            int x = newdot[0];
            int y = newdot[1];
            if(grid[x][y] == 0){
                int sum_x = x/10 + x%10;
                int sum_y = y/10 + y%10;
                int sum = sum_x + sum_y;
                if(sum <= k){
                    count++;
                    grid[x][y]=1;
                    if(x+1<m && grid[x+1][y]==0) queue.offer(new int[]{x+1,y});
                    if(x-1>=0 && grid[x-1][y]==0) queue.offer(new int[]{x-1,y});
                    if(y+1<n && grid[x][y+1]==0) queue.offer(new int[]{x,y+1});
                    if(y-1>=0 && grid[x][y-1]==0) queue.offer(new int[]{x,y-1});
                }
            }
        }
        return count;
    }