LeetCode ：95/96 不同的二叉搜索树 (二叉搜索树组合的个数)

96：比较简单，直接DP

参考力扣上官方的题解，采用动态规划法，关键点在于：

1、状态转移公式的推导；

2、边界的处理：dp[0]也初始化为1，因为转移方程要用到dp[0]-->即 j=1 时，此时BST的左子树为空，对应的dp[0]需要有1来占位

3、初始化：因为+=的存在，dp除0,1之外，后面的都要初始化为0 

class Solution {
public:
    int numTrees(int n) {
        if(n <= 1) return n;

        vector<int> dp(n + 1, 0); //dp[1]代表n为1时的情况,需要初始化为1
        dp[0] = 1; dp[1] = 1;

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

95：相比96题复杂很多，类似于22题括号生成的DP解法

class Solution {
public:
    //拷贝树
    TreeNode* copyTree(TreeNode* root, int delta = 0) { //delta为偏置量
        TreeNode* nroot = new TreeNode(root->val + delta);
        if(root->left) nroot->left = copyTree(root->left, delta); //拷贝树写错了!!写错了2处
        if(root->right) nroot->right = copyTree(root->right, delta);
        return nroot;
    }
    vector<TreeNode*> generateTrees(int n) {
        // 使用static变量，节省不同用例执行时的重复求解开销
        static vector<vector<TreeNode*>> dp(1, vector<TreeNode*>(1, NULL)); //dp的下标i元素代表了1-i节点组成的所有二叉搜索树集合
        //dp[0] = {};
        int c_size = n+1;
        int o_size = dp.size();
        if(c_size > dp.size()) dp.resize(c_size); //这三行搭配之前的静态数组,为了避免多样例重复求解dp的前缀部分

        for(int i = o_size; i <= n; i++) { //第一个用例从1开始，之后就不需要从头开始了
            for(int j = 1; j <= i; j++) {
                //j表示根节点取为j,i表示j的范围
                const auto &left = dp[j-1];
                const auto &right = dp[i-j];
                auto &cc = dp[i];

                for(const auto left_ptr : left)  //左子树遍历
                    for(const auto right_ptr : right) { //右子树遍历
                        auto root = new TreeNode(j);
                        if(j > 1) {
                            root->left = copyTree(left_ptr);
                        }
                        if(i > j) {
                            root->right = copyTree(right_ptr, j);
                        }
                        cc.push_back(root);
                    }        
            }
        }
        if(n == 0) return {};
        return dp[n];
    }
};

递归的解法，写起来最简单、最直观！

class Solution {
public:
    vector<TreeNode*> generateTrees(int n) {
        if(n == 0) {
            return {};
        }
        return generateTrees(1, n);
    }

    vector<TreeNode*> generateTrees(int start, int end) {
        vector<TreeNode*> all_trees;
        if(start > end) {
            all_trees.push_back(NULL);
            return all_trees;
        }

        for(int i = start; i <= end; i++) {
           
            vector<TreeNode*> left_trees = generateTrees(start, i-1);
            vector<TreeNode*> right_trees = generateTrees(i+1, end);

            for(auto left : left_trees) {
                for(auto right : right_trees) {
                    //针对i为根节点，左子树、右子树分别遍历左右子树集合中的所有选项
                    auto root = new TreeNode(i);
                    root->left = left;
                    root->right = right;
                    all_trees.push_back(root);
                }
            }
        }
        return all_trees;
    }
};