D. J.:

- Added the leetcode problem and solution for 95 and 96

Author: nobodyPerfecZ

README.md

@@ -122,6 +122,8 @@ This repository contains awesome LeetCode problems and solutions written in Pyth
 - [88 Merge Sorted Array](https://leetcode.com/problems/merge-sorted-array/description/)
 - [91 Decode Ways](https://leetcode.com/problems/decode-ways/description/)
 - [92 Reverse Linked List II](https://leetcode.com/problems/reverse-linked-list-ii/description/)
+- [95 Unique Binary Search Trees II](https://leetcode.com/problems/unique-binary-search-trees-ii/description/)
+- [96 Unique Binary Search Trees](https://leetcode.com/problems/unique-binary-search-trees/description/)
 - [97 Interleaving String](https://leetcode.com/problems/interleaving-string/description/)
 - [98 Validate Binary Search Tree](https://leetcode.com/problems/validate-binary-search-tree/description/)
 - [100 Same Tree](https://leetcode.com/problems/same-tree/description/)

awesome_python_leetcode/_95_unique_binary_search_trees_II.py

@@ -0,0 +1,35 @@
+from typing import List, Optional, Tuple
+
+from awesome_python_leetcode.tree import TreeNode
+
+
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def generateTrees(self, n: int) -> List[Optional[TreeNode]]:
+        """
+        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.
+        """
+        dp = {}
+
+        def dfs(remain: Tuple[int]):
+            if not remain:
+                return [None]
+            if remain in dp:
+                return dp[remain]
+            trees = []
+            for i in range(len(remain)):
+                left = dfs(remain[:i])
+                right = dfs(remain[i + 1 :])
+                for left_ in left:
+                    for right_ in right:
+                        node = TreeNode(val=remain[i])
+                        node.left = left_
+                        node.right = right_
+                        trees.append(node)
+            dp[remain] = trees
+            return trees
+
+        return dfs(tuple([i for i in range(1, n + 1)]))

awesome_python_leetcode/_96_unique_binary_search_trees.py

@@ -0,0 +1,20 @@
+class Solution:
+    """Base class for all LeetCode Problems."""
+
+    def numTrees(self, n: int) -> int:
+        """
+        Given an integer n, return the number of structurally unique BST's
+        (binary search trees) which has exactly n nodes of unique values from 1 to n.
+        """
+        dp = [0 for _ in range(n)]
+        dp[0] = 1
+        for i in range(1, n):
+            for k in range((i + 1) // 2):
+                if k == 0:
+                    dp[i] += dp[i - k - 1]
+                else:
+                    dp[i] += dp[i - k - 1] * dp[k - 1]
+            dp[i] *= 2
+            if (i + 1) % 2:
+                dp[i] += dp[i - ((i + 1) // 2) - 1] ** 2
+        return dp[-1]

tests/test_95_unique_binary_search_trees_II.py

@@ -0,0 +1,29 @@
+from typing import List
+
+import pytest
+
+from awesome_python_leetcode._95_unique_binary_search_trees_II import Solution
+from awesome_python_leetcode.tree import TreeNode
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (
+            3,
+            [
+                [1, None, 2, None, 3],
+                [1, None, 3, 2],
+                [2, 1, 3],
+                [3, 1, None, None, 2],
+                [3, 2, None, 1],
+            ],
+        ),
+        (1, [[1]]),
+    ],
+)
+def test_func(n: int, expected: List[List[int]]):
+    """Tests the solution of a LeetCode problem."""
+    expected = [TreeNode.build(tree) for tree in expected]
+    bsts = Solution().generateTrees(n)
+    assert all(actual == expected for actual, expected in zip(bsts, expected))

tests/test_96_unique_binary_search_trees.py

@@ -0,0 +1,17 @@
+import pytest
+
+from awesome_python_leetcode._96_unique_binary_search_trees import Solution
+
+
+@pytest.mark.parametrize(
+    argnames=["n", "expected"],
+    argvalues=[
+        (3, 5),
+        (1, 1),
+        (6, 132),
+    ],
+)
+def test_func(n: int, expected: int):
+    """Tests the solution of a LeetCode problem."""
+    num_bsts = Solution().numTrees(n)
+    assert num_bsts == expected