代码随想录 11.01 || 动态规划 LeetCode 343.整数拆分、96.不同的二叉搜索树

343.整数拆分

        给定一个正整数 n，将其拆分为 k 个 正整数 的和（k >= 2），并使这些整数的乘积最大化。返回 你可以获得的最大乘积。

        按照动态规划五部曲：

        1）：确定 dp 数组的含义，拆分整数 i 能够获得的最大乘积 dp[i]；

        2）：确定递推公式，给定某一个正整数 n，其能够拆分成 i + (n - i)，乘积为 i * (n - i)，其中 (n - i) 项可能允许进一步拆分，如何表示进一步拆分的 (n - i)，即 dp[n - i]。考虑到最大乘积可能出现在任意拆分阶段，因此通过 max 函数，选取最大的乘积保存。递推公式，dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]))。上述递推公式，允许将正整数 n，拆分成若干项，并累计此前的项的状态；

        3）：初始化 dp 数组，整数 0 和 1 无法拆分，不符合我们对于 dp 数组的定义，直接不初始化就好，dp[2] 初始化为 1；

        4）确定遍历方向，从前向后；

        5）打印 dp 数组 debug。

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1);
        dp[2] = 1;

        for (int i = 3; i <= n; ++i) {
            for (int j = 1; j < i; ++j) {
                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]));
            }
        }

        return dp[n];
    }
};

        本题还可以通过回溯方法解决，但是会超时，拆分整数也可以划分为组合问题。

class Solution {
private:
    void backtracking(int n, int count, int &path, int &max) {
        if (n <= 0) return ;

        for(int i = 1; i <= n; ++i) {
            path *= i; 
            ++count;

            if (path >= max && count >= 2) max = path;
            backtracking(n - i, count, path, max);

            path /= i; 
            --count;
        }
    }
    
public:
    int integerBreak(int n) {
        int count = 0, path = 1, max = 1;
        backtracking(n, count, path, max);
        return max;
    }
};

96.不同的二叉搜索树（难）

        详细的分析过程可以参考代码随想录对应章节，这里仅给出我的分析。求给定整数 n 能够组成的二产搜索树的种类。就是求以 1 ~ n 这些个数，为根节点的二叉搜索树的可能组合，当选定的根节点为 i 时，此时该树的左子树有 i - 1 个节点（二叉搜索树要求左子树都小于根节点），右子树有 n - i 个节点，总共可能的组合有 (i - 1) * (n - i)。因此，整数 n 累积了此前所有的状态，也就适用于动态规划算法。

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1);
        dp[0] = 1;

        for (int i = 1; i <= n; ++i) {
            for (int j = 1; j <= i; ++j) {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        
        return dp[n];
    }
};