[动态规划] leetcode 95 Unique Binary Search Trees II

problem:https://leetcode.com/problems/unique-binary-search-trees-ii/

         用递归传最小值和最大值写起来代码应该会更简练，此处用的是递推写的。

class Solution {
public:
    TreeNode* clone(TreeNode* p, int val)
    {
        if(!p) return nullptr;
        TreeNode* node = new TreeNode(p->val + val);
        node->left = clone(p->left, val);
        node->right = clone(p->right, val);
        return node;
    }
    vector<TreeNode*> generateTrees(int n) {
        vector<vector<TreeNode*>> dp(n + 1);
        for(int k = 1; k <= n; k++)
        {
            for(int c = 1; c <= k; c++)
            {
                int l = c - 1;
                int r = k - c;
                vector<TreeNode*>& left = dp[l];
                vector<TreeNode*>& right = dp[r];
                if(left.size() == 0 && right.size() == 0)
                {
                    TreeNode* p = new TreeNode(c);
                    dp[k].push_back(p);                    
                }
                else if(left.size() == 0)
                {
                    for(int i = 0;i < right.size();i++)
                    {
                        TreeNode* p = new TreeNode(c);
                        p->right = clone(right[i], c);
                        dp[k].push_back(p);
                    }
                }
                else if(right.size() == 0)
                {
                    for(int i = 0;i < left.size();i++)
                    {
                        TreeNode* p = new TreeNode(c);
                        p->left = left[i];
                        dp[k].push_back(p);
                    }
                }
                else
                {
                    for(int i = 0;i < left.size(); i++)
                    {
                        for(int j = 0;j < right.size(); j++)
                        {
                            TreeNode* p = new TreeNode(c);
                            p->left = left[i];
                            p->right = clone(right[j], c);
                            dp[k].push_back(p);                           
                        }
                    }
                }
            }
        }
        return dp[n];
    }
};