【剑指offer】13.机器人运动范围

此题我用的深度搜索方法求解，而题解不管从时间复杂度还是空间复杂度上都要简单许多，还开启了新的运算符|&，故用博客记录此题。

题意分析

这题的最开始我用的是暴力求解法，遍历数组判断符合条件的点。这种做法错误原因在于，本题要求机器人能到达的点，那些不能到达点看作是障碍，机器人只能上下左右四个方向依次通过，不能越过障碍。

所以我后来选择了深度遍历的方法。

深度遍历解决

public class offer_12 {
    boolean[][] visited;
    public boolean exist(char[][] board, String word) {
        //肯定要有一个visited[][]数组来存放有没有被访问过
        //可以用深度优先的感jiao做
        //深度优先有顺序
        //界限：越界、未找到、不可重复访问
        visited = new boolean[board.length][board[0].length];
        for (int i = 0; i < board.length; i++){
            for (int j = 0; j < board[0].length; j++){
                visited[i][j] = false;
            }
        }
        for (int i = 0; i < board.length; i++){
            for (int j = 0; j < board[0].length; j++){
                if (board[i][j] == word.charAt(0)){
                    visited[i][j] = true;
                    if(dfsexist(board, word, i, j, 1)){
                        return true;
                    }
                }
            }
        }
        return  false;
    }

    public boolean dfsexist(char[][] board, String word, int width, int height, int count){
        if (count > word.length()-1){
            return true;
        }
        int[] pos_x = {-1, 0, 1, 0};
        int[] pos_y = {0, 1, 0, -1};
        for (int i = 0; i < 4; i++){
            if (width + pos_x[i] < 0 || width + pos_x[i] >board.length - 1 || height + pos_y[i] < 0 || height + pos_y[i] > board[0].length - 1){
                continue;
            }
            if(!visited[width + pos_x[i]][height + pos_y[i]]){
                if (board[width + pos_x[i]][height + pos_y[i]] == word.charAt(count)){
                    visited[width + pos_x[i]][height + pos_y[i]] = true;
                    if(dfsexist(board, word, width + pos_x[i], height + pos_y[i], count+1)){

                        return true;
                    }
                }
            }
        }
        visited[width][height] = false;
        return false;
    }
}

leecode大佬解答

public class Solution {
        public int movingCount(int m, int n, int k) {
            if (k == 0) {
                return 1;
            }
            boolean[][] vis = new boolean[m][n];
            int ans = 1;
            vis[0][0] = true;
            for (int i = 0; i < m; ++i) {
                for (int j = 0; j < n; ++j) {
                    if ((i == 0 && j == 0) || get(i) + get(j) > k) {
                        continue;
                    }
                    // 边界判断
                    if (i - 1 >= 0) {
                        vis[i][j] |= vis[i - 1][j];
                    }
                    if (j - 1 >= 0) {
                        vis[i][j] |= vis[i][j - 1];
                    }
                    ans += vis[i][j] ? 1 : 0;
                }
            }
            return ans;
        }

        private int get(int x) {
            int res = 0;
            while (x != 0) {
                res += x % 10;
                x /= 10;
            }
            return res;
        }
}

其中：

关于 |= 运算符：|= 运算符和 += 这一类的运算符一样，拆解开就是 a = a | b；| 的运算是二进制运算，为或运算 ，即0和0做|为0，1和任意（0/1）做|为1。

代码的关键在于：不用深度遍历找可达点，抓住如果这个点可达，那么横向前一个或纵向前一个一定可达。通过这样判断是否可达能大大降低时间复杂