【力扣】每日三题 -- Day4（数组）

39. 组合总和 – 回溯算法

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> res = new ArrayList<>();
        List<Integer> path = new ArrayList<>();
        Arrays.sort(candidates);
        backtrack(candidates, target, path, res, 0);
        return res;
    }

    public void backtrack(int[] candidates, int target, List<Integer> path, List<List<Integer>> res, int start) {
        if (target < 0) 
            return;
        if (target == 0) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = start; i < candidates.length; i ++)  {
            if(candidates[i] > target)
                return;
            if(i > 0 && candidates[i] == candidates[i-1])
                continue;

            path.add(candidates[i]);
            backtrack(candidates, target - candidates[i], path, res, i);
            path.remove(path.size() - 1);

        }
    }
}

64. 最小路径和

class Solution {
    public int minPathSum(int[][] grid) {
        if(grid == null || grid.length == 0 || grid[0].length == 0)
            return 0;
        int m = grid.length;
        int n = grid[0].length;
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (i == 0 && j == 0)
                    dp[i][j] = grid[i][j];
                else if (i == 0)
                    dp[i][j] = grid[i][j] + dp[i][j-1];
                else if (j == 0)
                    dp[i][j] = grid[i][j] + dp[i-1][j];
                else 
                    dp[i][j] = grid[i][j] + Math.min(dp[i-1][j], dp[i][j-1]);
            }
        }
        return dp[m-1][n-1];
    }
}

105. 从前序与中序遍历序列构造二叉树

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode() {}
 *     TreeNode(int val) { this.val = val; }
 *     TreeNode(int val, TreeNode left, TreeNode right) {
 *         this.val = val;
 *         this.left = left;
 *         this.right = right;
 *     }
 * }
 */
class Solution {
    public TreeNode buildTree(int[] preorder, int[] inorder) {
        if(preorder.length == 0 || inorder.length == 0) {
            return null;
        }
        TreeNode root = new TreeNode(preorder[0]);
        for(int i = 0; i < preorder.length; i++) {
            if (inorder[i] == preorder[0]) {
                int[] pre_left = Arrays.copyOfRange(preorder, 1, i+1);
                int[] pre_right = Arrays.copyOfRange(preorder, i+1, preorder.length);
                int[] in_left = Arrays.copyOfRange(inorder, 0, i);
                int[] in_right = Arrays.copyOfRange(inorder, i+1, inorder.length);
                root.left = buildTree(pre_left, in_left);
                root.right = buildTree(pre_right, in_right);
                break;
            }
        }
        return root;
    }
}

162. 寻找峰值

class Solution {
    public int findPeakElement(int[] nums) {
        int left = 0, right = nums.length - 1;
        while(left < right) {
            int m = left + (right - left)/2;
            if( nums[m + 1] < nums[m])
                right = m;//m有可能是峰值
            else
                left = m + 1;
        }
        return left;
    }
}

山脉、峰值问题：
#852 山脉数组的峰顶索引 （数组长度>=3）
#剑指 Offer II 069 山峰数组的顶部 （和852一模一样）
#162 寻找峰值 （数组长度>=1 解法和852就不一样了）
#1095 山脉数组中查找目标值 （考察最为全面，同时考察峰顶索引、二分法-左区间、二分法-右区间三种）
#941 有效的山脉数组 (双指针)
#845 数组中的最长山脉 （双指针）