LeetCode - Unique Binary Search Trees II

Unique Binary Search Trees II

2014.2.10 02:54

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

For example,
Given n = 3, your program should return all 5 unique BST's shown below.

   1         3     3      2      1
    \       /     /      / \      \
     3     2     1      1   3      2
    /     /       \                 \
   2     1         2                 3

confused what "{1,#,2,3}" means? > read more on how binary tree is serialized on OJ.

Solution:

　　You know that the total number of binary search trees of n nodes is the nth Catalan number. But this time you have to build them all. It's hard labor, you know, both for the computer and for you.

　　My solution is recursive, here is the description:

　　　　1. for the sorted array a[1:n], pick some a[x] as the root. Every node a[i] will be the root node for some times. Thus this recursion has n branch.

　　　　2. the left sub-array a[1:x-1] forms the left subtree, the right sub-array a[x+1:n] forms the right subtree.

　　　　3. the left and right recursions return both result sets containing left subtrees and right subtrees.

　　　　4. picking one from the left, and one from the right, together with the root node, you get a larger tree.

　　　　5. put this larger tree in the result set. That's how a tree is built up.

　　I've written a funtion copyTreeRecursive() to do a deep copy of trees, but later I realized that shallow copy of TreeNode pointers works just as fine, and would save a lot of allocated memory. If you're interested, please view the commented code segment below and find out why.

　　Total time and space complexities are both O(n!) scale, as the nth Catalan number is C(2*n, n) / (n+ 1).

　　The time and space usage of this algorithm is explosive, so it's quite easy to get a "Stackoverflow" from this program. You better expect n to be under 10, if you're waiting to see the result.

Accepted code:

// 1WA, 1AC, very good~
// #define MY_MAIN
#include <cstdio>
#include <vector>
using namespace std;
/**
 * Definition for binary tree
 * struct TreeNode {
 *     int val;
 *     TreeNode *left;
 *     TreeNode *right;
 *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
 * };
 */

#ifdef MY_MAIN
struct TreeNode {
    int val;
    TreeNode *left;
    TreeNode *right;
    TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
#endif
class Solution {
public:
    vector<TreeNode *> generateTrees(int n) {
        int i;
        vector<int> num;
        vector<TreeNode *> result;
        
        result.clear();
        if (n == 0) {
            // 1WA here, you should return an empty tree when n=0.
            result.push_back(NULL);
            return result;
        }
        
        for (i = 1; i <= n; ++i) {
            num.push_back(i);
        }
        result = generateTreeRecursive(num);
        return result;
    }
private:
    vector<TreeNode *> generateTreeRecursive(vector<int> num) {
        vector<TreeNode *> res;
        TreeNode *root_ptr;
        
        res.clear();
        if (num.size() == 0) {
            res.push_back(NULL);
            return res;
        } else if (num.size() == 1) {
            root_ptr = new TreeNode(num[0]);
            res.push_back(root_ptr);
            return res;
        }
        
        vector<int> vleft, vright;
        vector<TreeNode *> res_left, res_right;
        int count_left, count_right;
        int i, j, k;
        
        for (i = 0; i < (int)num.size(); ++i) {
            vleft.clear();
            vright.clear();
            res_left.clear();
            res_right.clear();
            // the left subtree
            for (j = 0; j < i; ++j) {
                vleft.push_back(num[j]);
            }
            // the right subtree
            for (j = i + 1; j < (int)num.size(); ++j) {
                vright.push_back(num[j]);
            }
            res_left = generateTreeRecursive(vleft);
            res_right = generateTreeRecursive(vright);
            count_left = (int)res_left.size();
            count_right = (int)res_right.size();
            for (j = 0; j < count_left; ++j) {
                for (k = 0; k < count_right; ++k) {
                    root_ptr = new TreeNode(num[i]);
                    // root_ptr->left = copyTreeRecursive(res_left[j]);
                    // root_ptr->right = copyTreeRecursive(res_right[k]);
                    root_ptr->left = res_left[j];
                    root_ptr->right = res_right[k];
                    res.push_back(root_ptr);
                }
            }
        }
        
        return res;
    }

    TreeNode *copyTreeRecursive(const TreeNode *root)
    {
        TreeNode *new_root;
        
        if (root == NULL) {
            return NULL;
        }
        new_root = new TreeNode(root->val);
        if (root->left != NULL) {
            new_root->left = copyTreeRecursive(root->left);
        }
        if (root->right != NULL) {
            new_root->right = copyTreeRecursive(root->right);
        }

        return new_root;
    }
};

#ifdef MY_MAIN
void preorderTraversal(const TreeNode *root, vector<int> &result)
{
    if (root == NULL) {
        result.push_back(0);
    }
    result.push_back(root->val);
    if (root->left != NULL) {
        preorderTraversal(root->left, result);
    } else {
        result.push_back(0);
    }
    if (root->right != NULL) {
        preorderTraversal(root->right, result);
    } else {
        result.push_back(0);
    }
}

int main()
{
    int n;
    Solution solution;
    vector<int> traversal_result;
    vector<TreeNode *> trees;
    int i, j;
    
    while (scanf("%d", &n) == 1) {
        if (n < 0) {
            continue;
        }
        trees = solution.generateTrees(n);
        for (i = 0; i < (int)trees.size(); ++i) {
            traversal_result.clear();
            preorderTraversal(trees[i], traversal_result);
            for (j = 0; j < (int)traversal_result.size(); ++j) {
                if (j == 0) {
                    printf("%d", traversal_result[j]);
                } else {
                    printf(" %d", traversal_result[j]);
                }
            }
            printf("\n");
        }
        printf("Catalan[%d] = %d\n", n, (int)trees.size());
        printf("\n");
    }
    
    return 0;
}
#endif