算法训练营day40

一、整数拆分

动态规划 -> 如何找状态转移方程，推算几个简单的例子进行数学归纳来书写代码

class Solution {
    int[] memo;

    public int integerBreak(int n) {
        memo = new int[n+1];
        return dp(n);
    }

    //定义：拆分 n 获得的最大乘积
    int dp(int n){
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }
        if(memo[n] > 0){
            return memo[n];
        }
        
        //状态转移方程
        int res = Integer.MIN_VALUE;
        for(int i = 1; i<=n; i++){
            res = Math.max(res, i * Math.max(dp(n-i), n - i));
        }
        memo[n] = res;
        return res;
    }
}

二、不同的搜索二叉树

二叉搜索树：根节点的左子树都比根节点小，右子树都比根节点大

class Solution {
    int[][] memo;
    public int numTrees(int n) {
        // 备忘录的值初始化为0
        memo = new int[n + 1][n + 1];
        return count(1, n);
    }

    int count(int lo, int hi){
        if(lo > hi) return 1;
        //查备忘录
        if(memo[lo][hi] != 0){
            return memo[lo][hi];
        }

        int res = 0;
        for(int mid = lo; mid <= hi; mid++){
            int left = count(lo, mid-1);
            int right = count(mid+1, hi);
            res += left * right;
        }
        //将结果存入备忘录
        memo[lo][hi] = res;

        return res;
    }
}

三、不同的搜索二叉树2

构建出所有有效的BST

class Solution {
    /* 主函数 */
    public List<TreeNode> generateTrees(int n) {
        if (n == 0) return new LinkedList<>();
        // 构造闭区间 [1, n] 组成的 BST 
        return build(1, n);
    }

    /* 构造闭区间 [lo, hi] 组成的 BST */
    List<TreeNode> build(int lo, int hi) {
        List<TreeNode> res = new LinkedList<>();
        // base case
        if (lo > hi) {
            // 这里需要装一个 null 元素，这样才能让下面的两个内层 for 循环都能进入，正确地创建出叶子节点
            // 举例来说吧，什么时候会进到这个 if 语句？当你创建叶子节点的时候，对吧。
            // 那么如果你这里不加 null，直接返回空列表，那么下面的内层两个 for 循环都无法进入
            // 你的那个叶子节点就没有创建出来，看到了吗？所以这里要加一个 null，确保下面能把叶子节点做出来
            res.add(null);
            return res;
        }

        // 1、穷举 root 节点的所有可能。
        for (int i = lo; i <= hi; i++) {
            // 2、递归构造出左右子树的所有有效 BST。
//最后一次for循环到 lo == hi, 但是最后的循环是build(lo, i-1)/(i+1, hi)
//所以最后的build(lo,hi) 一定是 lo > hi ，如果不执行res.add(null)那么返回的leftTree && rightTree就是空列表
//无法进入两层for循环，那么叶子节点对应的左右子树的null就无法做出来
            List<TreeNode> leftTree = build(lo, i - 1);
            List<TreeNode> rightTree = build(i + 1, hi);
            // 3、给 root 节点穷举所有左右子树的组合。/两个for循环相当于乘法
            for (TreeNode left : leftTree) {
                for (TreeNode right : rightTree) {
                    // i 作为根节点 root 的值
                    TreeNode root = new TreeNode(i);
                    root.left = left;
                    root.right = right;
                    res.add(root);
                }
            }
        }
        
        return res;
    }
}