LeetCode - Medium - 95. Unique Binary Search Trees II

Topic

• Dynamic Programming
• Tree

Description

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

Given an integer n, return all the structurally unique BST’s (binary search trees), which has exactly n nodes of unique values from 1 to n. Return the answer in any order.

Example 1:

Input: n = 3
Output: [[1,null,2,null,3],[1,null,3,2],[2,1,3],[3,1,null,null,2],[3,2,null,1]]

Example 2:

Input: n = 1
Output: [[1]]

Constraints:

• 1 <= n <= 8

Analysis

I start by noting that 1…n is the in-order traversal for any BST with nodes 1 to n. So if I pick i-th node as my root, the left subtree will contain elements 1 to (i-1), and the right subtree will contain elements (i+1) to n. I use recursive calls to get back all possible trees for left and right subtrees and combine them in all possible ways with the root. link

Submission

import java.util.ArrayList;
import java.util.List;

import com.lun.util.BinaryTree.TreeNode;

public class UniqueBinarySearchTreesII {
    public List<TreeNode> generateTrees(int n) {
        return generateTrees(1, n);
    }
    
    private List<TreeNode> generateTrees(int start, int end) {
    	List<TreeNode> result = new ArrayList<>();
    	if(start > end) {
    		result.add(null);
    		return result;
    	}
    	
    	for(int i = start; i <= end; i++) {
    		List<TreeNode> leftSubTrees = generateTrees(start, i - 1);
    		List<TreeNode> rightSubTrees = generateTrees(i + 1, end);
    		
    		for(TreeNode ln : leftSubTrees) {
    			for(TreeNode rn : rightSubTrees) {
    				TreeNode node = new TreeNode(i);
    				node.left = ln;
    				node.right = rn;
    				result.add(node);
    			}
    		}
    	}
    	
    	return result;
    }
    
}

Test

import static org.junit.Assert.*;
import static com.lun.util.BinaryTree.*;

import java.util.List;

import org.junit.Test;

import com.lun.util.BinaryTree;
import com.lun.util.BinaryTree.TreeNode;

public class UniqueBinarySearchTreesIITest {

	@Test
	public void test() {
		UniqueBinarySearchTreesII obj = new UniqueBinarySearchTreesII();

		List<TreeNode> result = obj.generateTrees(3);
		TreeNode[] expected = {integers2BinaryTree(1,null,2,null,3),//
								integers2BinaryTree(1,null,3,2),//
								integers2BinaryTree(2,1,3),//
								integers2BinaryTree(3,1,null,null,2),//
								integers2BinaryTree(3,2,null,1)};
		int count = 0;
		for(TreeNode r : result) {
			for(TreeNode e : expected) {
				if(BinaryTree.equals(r, e))
					count++;
			}
		}
		assertEquals(5, count);
		
		
		List<TreeNode> result2 = obj.generateTrees(1);
		assertTrue(BinaryTree.equals(new TreeNode(1), result2.get(0)));
	}
}