可信大闯关

可信大闯关

客观题

1、单选

1-4 CCCD 5.BCD
6 BBCDC
11 ABBC
15 B
16 D
17 A
18 B
19B
20B

2. 多选

1、ADF
2、BC
3、ACD
4、ABCD
5、ABC
6、BCD
7、ABCD
8、ABCD
9、BC
10、AC

编程题

1、二叉树中和为某一值的路径

class Solution {
    public List<List<Integer>> pathSum(TreeNode root, int sum) {
        List<List<Integer>> result = new ArrayList<>();
        dfs(root, sum, new ArrayList<>(), result);
        return result;
    }
    
    private void dfs(TreeNode node, int target, List<Integer> tmp, List<List<Integer>> result) {
        if (node == null) {
            return;
        }
        tmp.add(node.val);
        target -= node.val;
        if (target == 0 && node.left == null && node.right == null) {
            result.add(new ArrayList<>(tmp));
        } else {
            dfs(node.left, target, tmp, result);
            dfs(node.right, target, tmp, result);
        }
        tmp.remove(tmp.size() - 1);
    }
}

黄金矿工

 public int getMaximumGold(int[][] grid) {
        int res = 0;
        for (int i = 0; i < grid.length; i++) {
            for (int j = 0; j < grid[0].length; j++) {
                res = Math.max(res, dfs(grid, i, j));
            }
        }
        return res;
    }

    private int dfs(int[][] grid, int i, int j) {
        //递归的终止条件
        if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0) {
            return 0;
        }

        //保存当前点的值 并将grid[i][j]置为0 避免在下一次递归的时候计算回来
        int value = grid[i][j];
        grid[i][j] = 0;

        //分上下左右四个方向搜索
        int up = dfs(grid, i + 1, j);
        int down = dfs(grid, i - 1, j);
        int left = dfs(grid, i, j - 1);
        int right = dfs(grid, i, j + 1);

        //将grid[i][j]的值复原
        grid[i][j] = value;

        //最大值为上下左右的最大值在加value
        return Math.max(Math.max(up, down), Math.max(left, right)) + value;
    }

打家劫舍2

class Solution {
    public int rob(int[] nums) {
        int len = nums.length;
        if (len == 0) {
            return 0;
        }
        if (len == 1) {
            return nums[0];
        }
        if (len == 2) {
            return Math.max(nums[0], nums[1]);
        }
        int[] memory1 = new int[len];
        int[] memory2 = new int[len];
        memory1[len - 1] = nums[len - 1];
        memory1[len - 2] = Math.max(nums[len-2], memory1[len - 1]);
        for (int i = len - 3; i >= 0; i--) {
            memory1[i] = Math.max(nums[i] + memory1[i + 2], memory1[i + 1]);
        }
        memory2[0] = nums[0];
        memory2[1] = Math.max(nums[1], memory2[0]);
        for (int j = 2; j < len; j++) {
            memory2[j] = Math.max(nums[j] + memory2[j - 2], memory2[j - 1]);
        }
        return Math.max(memory1[1], memory2[len - 2]);
    }
}

打家劫舍3

class Solution {
    public int rob(TreeNode root) {
        int[] res = helper(root);
        return Math.max(res[0],res[1]);
    }
    public int[] helper(TreeNode r){
        if(r == null) {
            return new int[2];
        }
        int[] left = helper(r.left);
        int[] right = helper(r.right);
        int[] res = new int[2];
        res[0] = Math.max(left[0], left[1]) + Math.max(right[0],right[1]);
        res[1] = r.val + left[0] + right[0];
        return res;
    }
}