LeetCode动态规划专题：第十一天

最新推荐文章于 2025-11-24 01:23:29 发布

原创最新推荐文章于 2025-11-24 01:23:29 发布 · 161 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#leetcode #动态规划 #算法

动态规划专栏收录该内容

23 篇文章

订阅专栏

这篇博客探讨了两种算法问题的解决方案：一是使用多路归并算法生成丑数数组；二是通过递归方式构建不同形态的二叉搜索树。文章详细介绍了每种思路，并提供了C++实现代码，展示了如何从根节点出发，通过组合左右子树生成所有可能的二叉搜索树结构。

丑数二

思路：多路归并算法

丑数数组本身乘以因子得到新的三个序列，这三个序列合并就是丑数数组本身，使用三个指针，用当前丑数数组元素扩展新的丑数数组，每扩展一次指针后移丑数数组长度为n为止

class Solution {
public:
    int nthUglyNumber(int n) {
        vector<int> f(1, 1);
        for (int i = 0, j = 0, k = 0; f.size() < n; ) {
            int t = min(f[i] * 2, min(f[j] * 3, f[k] * 5));
            f.push_back(t);
            if (f[i] * 2 == t) i ++ ;
            if (f[j] * 3 == t) j ++ ;
            if (f[k] * 5 == t) k ++ ;
        }
        return f.back();
    }
};

不同二叉搜索树二

思路：搜索

中序遍历有序，枚举根结点，递归建树，每一次返回左右子树可能的序列，依次递归合并，返回序列

/**
 * Definition for a binary tree node.
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode() : val(0), left(nullptr), right(nullptr) {}
 *     TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
 *     TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
 * };
 */
class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        return dfs(1, n);
    }

    vector<TreeNode*> dfs(int l, int r) {
        if (l > r) return {NULL};
        vector<TreeNode*> res;
        for (int i = l; i <= r; i ++ ) {
            auto left = dfs(l, i - 1), right = dfs(i + 1, r);
            for (auto L : left)
                for (auto R : right) {
                    auto root = new TreeNode(i);
                    root->left = L;
                    root->right = R;
                    res.push_back(root);
                }
        }
        return res;
    }
};

不同的二叉搜索树

思路

枚举根结点，每个根结点得到的二叉搜索树个数为：
左子树个数*右子树个数

class Solution {
public:
    int numTrees(int n) {
        // 递归
        vector<int> f(n + 1);
        f[0] = 1;
        for (int i = 1; i <= n; i ++ ) {
            for (int j = 1; j <= i; j ++ ) {
                f[i] += f[j - 1] * f[i - j];
            }
        }
        return f[n];
    }
};