leetcode【95】Unique Binary Search Trees II

问题描述

Given an integer n, generate all structurally unique BST's (binary search trees) that store values 1 ... n.

大概意思就是给定一个正整数n，然后写出所有可能的二叉树。

解决方案

递归方法：

二叉树由左子树和右子树组成，那么左子树和右子树就是子问题。递归过程中每次选一个点作为父节点，然后求其左右子树。

class Solution {
public:
	vector<TreeNode*> generateTrees(int n) {
		if (!n) return{};
		return generate(1, n);
	}
private:
	vector<TreeNode*> generate(int start, int end) {
		vector<TreeNode*> res;
		if (start > end) res.push_back(nullptr);
		else if (start == end) res.push_back(new TreeNode(start));
		else {
			for (int i = start; i <= end; ++i) {
				vector<TreeNode*> l = generate(start, i - 1);
				vector<TreeNode*> r = generate(i + 1, end);
				for(int j=0;j<l.size();++j)
					for (int k = 0; k < r.size(); ++k) {
						TreeNode* h = new TreeNode(i);
						h->left = l[j];
						h->right = r[k];
						res.push_back(h);
					}
			}
		}
		return res;
	}
};

非递归方法：

用了一个动态规划的二维vector dp，其中dp[i]表示前i-1个值得所有组合。代码中有一个小细节，就是其右子树可以通过复制得到，代码如下：

class Solution {
public:
	vector<TreeNode*> generateTrees(int n) {
		if(n==0)    return {};
        vector<vector<TreeNode*>> dp(n+1);
        dp[0] = vector<TreeNode*>{nullptr};
        dp[1] = vector<TreeNode*>{new TreeNode(1)};
        for(int i=2; i<=n; i++){
            for(int j=0; j<i; j++){
                for(TreeNode* nodel:dp[j]){
                    for(TreeNode* noder:dp[i-j-1]){
                        TreeNode* node = new TreeNode(j+1);
                        node->left = nodel;
                        node->right = clone(noder, j+1);
                        dp[i].push_back(node);
                    }
                }
            }
        }
        return dp.back();
	}
    
    TreeNode* clone(TreeNode* root, int offset){
        if(!root)   return nullptr;
        TreeNode *tmp = new TreeNode(root->val+offset);
        tmp->left = clone(root->left, offset);
        tmp->right = clone(root->right, offset);
        return tmp;
    }
};