catalan

Using the method presented here: http://cslibrary.stanford.edu/110/BinaryTrees.html#java 12. countTrees() Solution (Java) /** For the key values 1...numKeys, how many structurally unique binary search trees are possible that store those keys? Strategy: consider that each value could be the root. Recursively find the size of the left and right subtrees. */ public static int countTrees(int numKeys) { if (numKeys <=1) { return(1); } else { // there will be one value at the root, with whatever remains // on the left and right each forming their own subtrees. // Iterate through all the values that

Given the following data type definition: data FormTree = Empty | Node FormTree FormTree deriving Show I want to write a function which generates an infinite list containing all possible trees sorted after length e.g. the amount of nodes. The following code almost does what I need but it only descends the tree on the right side by inserting additional nodes every time but I need it to alternate between both sides. allPossibleTrees :: [FormTree] allPossibleTrees = Empty : [Node x y | x <- recursive, y <- recursive] where recursive = allPossibleTrees Executing take 5 allPossibleTrees gives:

I got homework in school to calculate Catalan number with recursion: 1st without memoization def catalan_rec(n): res = 0 if n == 0: return 1 else: for i in range (n): res += (catalan_rec(i))*(catalan_rec(n-1-i)) return res 2nd with: def catalan_mem(n, memo = None): if memo == None: memo = {0: 1} res = 0 if n not in memo: for i in range (n): res += (catalan_mem(i))*(catalan_mem(n-1-i)) memo[n] = res return memo[n] The weirdest thing happened to me: the memoization takes twice much time! When it should be the other way around! Can someone please explain this to me? This question inspired me to

I tried to do the classical problem to implement an algorithm to print all valid combinations of n pairs of parentheses. And I found this program (which works perfectly) : public static void addParen(ArrayList<String> list, int leftRem, int rightRem, char[] str, int count) { if (leftRem < 0 || rightRem < leftRem) return; // invalid state if (leftRem == 0 && rightRem == 0) { /* all out of left and right parentheses */ String s = String.copyValueOf(str); list.add(s); } else { if (leftRem > 0) { // try a left paren, if there are some available str[count] = '('; addParen(list, leftRem - 1,

This is a homework, I have difficulties in thinking of it. Please give me some ideas on recursions and DP solutions. Thanks a lot generate and print all structurally distinct full binary trees with n leaves in dotted parentheses form， "full" means all internal (non-leaf) nodes have exactly two children. For example, there are 5 distinct full binary trees with 4 leaves each. U can use recursion, on i-th step u consider i-th level of tree and u chose which nodes will be present on this level according to constraints: - there is parent on previous level - no single children present (by your