代码随想录算法训练营第四十天 | 整数拆分、不同的二叉搜索树

整数拆分

dp[i]：分拆数字i，可以得到的最大乘积为dp[i]。
dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j)); j是从1开始遍历
j * (i - j) 是单纯的把整数拆分为两个数相乘，而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。
dp[2] = 1
从前向后遍历

拆分一个数 n 使之乘积最大，那么一定是拆分成 m 个近似相同的子数相乘才是最大的。

例如 6 拆成 3 * 3， 10 拆成 3 * 3 * 4。

m 一定大于等于 2 ，最差也应该是拆成两个相同的才可能是最大值。

j 遍历只需要遍历到 n / 2 即可，后面没有必要遍历，一定不是最大值。

class Solution {

    // 动规五部曲：
    // dp[i] 分拆数字i 可以得到的最大乘积 为 dp[i]

    // dp[i] = max(dp[i], max((i - j) * j, dp[i - j] * j));  j是从1开始遍历
    // j * (i - j) 是单纯的把整数拆分为两个数相乘，而j * dp[i - j]是拆分成两个以及两个以上的个数相乘。
    // 在递推公式推导的过程中，每次计算dp[i]，取最大的而已。
    // 初始化：dp[2] = 1
    // 遍历顺序： 从前往后
    // 举例：
    public int integerBreak(int n) {
        int[] dp = new int[n + 1];
        dp[2] = 1;
        for (int i = 3; i <= n; i++) {
            for (int j = 1; j <= i - j; j++) {
                // 这里的 j 其实最大值为 i-j,再大只不过是重复而已，
                // 并且，在本题中，我们分析 dp[0], dp[1]都是无意义的，
                // j 最大到 i-j,就不会用到 dp[0]与dp[1]
                dp[i] = Math.max(dp[i], Math.max(j*(i-j), j*dp[i - j]));
            }
        }
        return dp[n];
    }
}

不同的二叉搜索树

给定一个整数 n，求以 1 … n 为节点组成的二叉搜索树有多少种？

举几个例子：

在这里插入图片描述

n = 1 有一棵树，n为2有两棵树。
n = 3 时，情况如下：

1为头节点：右子树两个节点的布局和 n = 2 时两棵树的布局一致
3为头节点：左子树两个节点的布局和 n = 2 时两棵树的布局一致
2为头节点：左右子树只有一个节点，布局和n为1时一致

重叠子问题

元素1为头结点搜索树的数量 = 右子树有2个元素的搜索树数量 * 左子树有0个元素的搜索树数量

元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量 * 左子树有1个元素的搜索树数量

元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量 * 左子树有2个元素的搜索树数量

dp[3] = 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量

dp[3] = dp[2] * dp[0] + dp[1] * dp[1] + dp[0] * dp[2]

class Solution {

    // 举例子： n=1  1
    // n=2 2
    // n=3 5 dp[3]，就是 元素1为头结点搜索树的数量 + 元素2为头结点搜索树的数量 + 元素3为头结点搜索树的数量
    // n=4 

    // 动规五部曲
    // dp[i]  1到i节点组成的二叉搜索树的个数
    // dp[i] += dp[j - 1] * dp[i - j];  j-1 为j为头结点左子树节点数量，i-j 为以j为头结点右子树节点数量
    // dp[1] = 1 
    // 遍历顺序 遍历i里面每一个数作为头结点的状态，用j来遍历。

    public int numTrees(int n) {
        int[] dp = new int[n+1];
        dp[0] = 1;
        // dp[1] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                // 对于第i个节点，需要考虑1作为根节点直到i作为根节点的情况，所以需要累加
                dp[i] += dp[j-1]*dp[i-j];
            }
        }
        return dp[n];
    }
}