动态规划 - 95. 不同的二叉搜索树 II

95. 不同的二叉搜索树 II

递归

/**
 * 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:
    // 官方题解：递归
    /*
    二叉搜索树关键的性质是根节点的值大于左子树所有节点的值，小于右子树所有节点的值，且左子树和右子树也同样为二叉搜索树。
    因此在生成所有可行的二叉搜索树的时候，
    假设当前序列长度为n，如果我们枚举根节点的值为i，那么根据二叉搜索树的性质我们可以知道左子树的节点值的集合为[1 ...i-1]，右子树的节点值的集合为[i＋1...n]。
    而左子树和右子树的生成相较于原问题是一个序列长度缩小的子问题

    定义generateTrees(start，end)函数表示当前值的集合为[start, end]，返回序列[start, end]生成的所有可行的二叉搜索树。
    考虑枚举[start, end]中的值i为当前二叉搜索树的根，那么序列划分为了[start,i―1]和[i＋1, end]两部分。
    递归调用这两部分，即generateTrees(start, i - 1)和generateTrees(i + 1,end)，获得所有可行的左子树和可行的右子树.
    那么最后一步只要从可行左子树集合中选一棵，再从可行右子树集合中选一棵拼接到根节点上，并将生成的二叉搜索树放入答案数组即可。

    递归的入口即为generateTrees(1，n)，出口为当start > end的时候，当前二叉搜索树为空，返回空节点即可。
    */
    vector<TreeNode*> generateTreesHelper(int start, int end){
        if(start > end){
            return {nullptr};
        }

        vector<TreeNode*> allTrees;
        // 枚举可行的根节点
        for(int i = start; i <= end; i++){
            // 获得所有可行的左子树集合
            vector<TreeNode*> leftTrees = generateTreesHelper(start, i - 1);
            // 获得所有可行的右子树集合
            vector<TreeNode*> rightTrees = generateTreesHelper(i + 1, end);

            // 从左子树集合中选出一棵左子树，从右子树集合中选出一棵右子树，拼接到根节点上
            for(auto& leftTree : leftTrees){
                for(auto& rightTree : rightTrees){
                    TreeNode* currTree = new TreeNode(i, leftTree, rightTree);
                    allTrees.emplace_back(currTree);
                }
            }
        }
        return allTrees;
    }
    vector<TreeNode*> generateTrees(int n) {
        if(!n){
            return {};
        }
        return generateTreesHelper(1, n);
    }
};

动态规划

/**
 * 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) {
        // 1.明确状态含义：dp[i]是vector<TreeNode*>，表示所有由n个节点组成且节点值从1到n互不相同的不同二叉搜索树
        vector<vector<TreeNode*>> dp(n+1);

        // 2.base状态初始化
        dp[0].emplace_back(nullptr);

        // 3.状态转移： 节点数从 1 到 n
        for(int length = 1; length <= n; length++){
             //将 不同的数字作为根节点，只需要考虑到 length
            for(int root = 1; root <= length; root++){
                // root - 1是左子树的长度，dp[root - 1]是左子树所有的子树形态
                for(auto& leftTree : dp[root - 1]){
                    // length - root是右子树的长度，dp[length - root]是右子树所有的子树形态
                    for(auto& rightTree : dp[length - root]){
                        TreeNode* treeRoot = new TreeNode(root);
                        treeRoot->left = leftTree;
                        treeRoot->right = clone(rightTree, root);
                        dp[length].emplace_back(treeRoot);
                    }
                }
            }
        }
        return dp[n];
    }
    //复制树的结构并加上偏值
    TreeNode* clone(TreeNode* root, int offset){
        if(!root){
             return NULL;
        }
        TreeNode* newRoot = new TreeNode(root->val+offset);
        newRoot->left=clone(root->left, offset);
        newRoot->right=clone(root->right, offset);
        return newRoot;
    }
};