剑指offer 2021/7/28

13. 机器人的运动范围

代码：

回溯法。

class Solution {
    int m, n;
    int res = 0;
    int[][] visited;
    public int movingCount(int m, int n, int k) {
        this.m = m;
        this.n = n;
        visited = new int[m][n];
        dfs(0, 0, k);
        return res;
    }
    void dfs(int i, int j, int k){
        if(i >= m || j >= n || !valid(i, j, k) || visited[i][j] != 0){
            return;
        }else{
            res += 1;
            visited[i][j] = 1;
        }
        if(j+1 < n && visited[i][j+1] == 0){
            dfs(i, j + 1, k);
        }
        if(i+1 < m && visited[i+1][j] == 0){
            dfs(i+1, j, k);
        }
    }
    boolean valid(int i, int j, int k){
        int count = 0;
        while(i != 0 || j != 0){
            if(i != 0){
                count += i%10;
                i /= 10;
            }
            if(j != 0){
                count += j%10;
                j /= 10;
            }
        }
        if(count > k){
            return false;
        }
        return true;
    }
}

改进1：

直接在返回值+1，不需要单独设置count计数。

class Solution {
    int m, n;
    int[][] visited;
    public int movingCount(int m, int n, int k) {
        this.m = m;
        this.n = n;
        visited = new int[m][n];
        return dfs(0, 0, k);
    }
    int dfs(int i, int j, int k){
        if(i >= m || j >= n || !valid(i, j, k) || visited[i][j] != 0){
            return 0;
        }
        visited[i][j] = 1;
        return 1 + dfs(i+1, j, k) + dfs(i, j+1, k);
    }
    boolean valid(int i, int j, int k){
        int count = 0;
        while(i != 0 || j != 0){
            if(i != 0){
                count += i%10;
                i /= 10;
            }
            if(j != 0){
                count += j%10;
                j /= 10;
            }
        }
        if(count > k){
            return false;
        }
        return true;
    }
}

改进2：

BFS

class Solution {
    public int movingCount(int m, int n, int k) {
        int res = 0;
        boolean[][] visited = new boolean[m][n];
        LinkedList<int[]> queue = new LinkedList<>();
        queue.add(new int[]{0, 0});
        while(!queue.isEmpty()){
            int x[] = queue.poll();
            int i = x [0], j = x[1];
            if(i >= m || j >= n || !valid(i, j, k) || visited[i][j])
            {
                continue;
            }
            visited[i][j] =true;
            res ++;
            queue.add(new int[]{i+1, j});
            queue.add(new int[]{i, j+1});
        }
        return res;
    }
    boolean valid(int i, int j, int k){
        int count = 0;
        while(i != 0 || j != 0){
            if(i != 0){
                count += i%10;
                i /= 10;
            }
            if(j != 0){
                count += j%10;
                j /= 10;
            }
        }
        if(count > k){
            return false;
        }
        return true;
    }
}

12. 矩阵中的路径

代码：

回溯法。

class Solution {
    public boolean exist(char[][] board, String word) {
        char[] words = word.toCharArray();
        for(int i = 0; i < board.length; ++i){
            for(int j = 0; j < board[0].length; ++j){
                if(dfs(i, j, 0, board, words))  return true;
            }
        }
        return false;
    }
    boolean dfs(int i, int j, int k, char[][] board, char[] words){
        if(i < 0 || i >= board.length || j < 0 || j >= board[0].length
        || board[i][j] != words[k]){
            return false;
        }
        if(k == words.length - 1){
            return true;
        }
        board[i][j] = '\0';
        boolean res = dfs(i+1, j, k+1, board, words) || dfs(i, j+1, k+1, board, words) || 
        dfs(i-1, j, k+1, board, words) || dfs(i, j-1, k+1, board, words);
        board[i][j] = words[k];
        return res;
    }   
}

注意：

数组在函数中作为引用参数传递，原值会改变。