<p>Given an array <code>nums</code> that represents a permutation of integers from <code>1</code> to <code>n</code>. We are going to construct a binary search tree (BST) by inserting the elements of <code>nums</code> in order into an initially empty BST. Find the number of different ways to reorder <code>nums</code> so that the constructed BST is identical to that formed from the original array <code>nums</code>.</p>

<ul>
	<li>For example, given <code>nums = [2,1,3]</code>, we will have 2 as the root, 1 as a left child, and 3 as a right child. The array <code>[2,3,1]</code> also yields the same BST but <code>[3,2,1]</code> yields a different BST.</li>
</ul>

<p>Return <em>the number of ways to reorder</em> <code>nums</code> <em>such that the BST formed is identical to the original BST formed from</em> <code>nums</code>.</p>

<p>Since the answer may be very large, <strong>return it modulo </strong><code>10<sup>9</sup> + 7</code>.</p>

<p>&nbsp;</p>
<p><strong class="example">Example 1:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/12/bb.png" style="width: 121px; height: 101px;" />
<pre>
<strong>Input:</strong> nums = [2,1,3]
<strong>Output:</strong> 1
<strong>Explanation:</strong> We can reorder nums to be [2,3,1] which will yield the same BST. There are no other ways to reorder nums which will yield the same BST.
</pre>

<p><strong class="example">Example 2:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/12/ex1.png" style="width: 241px; height: 161px;" />
<pre>
<strong>Input:</strong> nums = [3,4,5,1,2]
<strong>Output:</strong> 5
<strong>Explanation:</strong> The following 5 arrays will yield the same BST: 
[3,1,2,4,5]
[3,1,4,2,5]
[3,1,4,5,2]
[3,4,1,2,5]
[3,4,1,5,2]
</pre>

<p><strong class="example">Example 3:</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2020/08/12/ex4.png" style="width: 121px; height: 161px;" />
<pre>
<strong>Input:</strong> nums = [1,2,3]
<strong>Output:</strong> 0
<strong>Explanation:</strong> There are no other orderings of nums that will yield the same BST.
</pre>

<p>&nbsp;</p>
<p><strong>Constraints:</strong></p>

<ul>
	<li><code>1 &lt;= nums.length &lt;= 1000</code></li>
	<li><code>1 &lt;= nums[i] &lt;= nums.length</code></li>
	<li>All integers in <code>nums</code> are <strong>distinct</strong>.</li>
</ul>

class Solution:
    
    # IDEA: Combinatorics + Tree + Divide and Conquer
    # Time: O(n^2)
    # Runtime 104ms Beats 88.68% of users with Python3 
    # Memory 21.68MB Beats 62.26% of users with Python3

    def numOfWays(self, nums: List[int]) -> int:
        # 1 - create pascal triangle 
        # pascal_repo = self.build_pascal_repo(nums + 1)
        
        # 1 - get all permutation or factorial array
        self.factorials = self.factorial(len(nums))

        # 2 - find # of ways to create same BFS with different array peprmutations
        return (self.permutation_ways(nums) - 1) % (10**9 + 7)


    def factorial(self, n):
        factorials = [1] * n
        
        for i in range(1, n):
            factorials[i] = i * factorials[i - 1]
        return factorials


    # calculate the combinations for k choose from n
    @functools.lru_cache(None)
    def combination(self, num_left, num_right):
        return self.factorials[num_left + num_right] // self.factorials[num_left] // self.factorials[num_right]


    def permutation_ways(self, nums) -> int:
        # 1 - base case
        if len(nums) <= 2:
            return 1

        # 2 - build left and right lists for DFS recursive call
        root_val = nums[0]
        left = [ num for num in nums if num < root_val ]
        right = [ num for num in nums if num > root_val ]

        # 3 - make DFS recursive call
        
        subtreeCounts = self.permutation_ways(left) * self.permutation_ways(right)
        rootCounts = self.combination(len(left), len(right)) # current root count
        
        return subtreeCounts * rootCounts

    def build_pascal_repo(self, n: int) -> List[List[int]]:
        # 1 - init
        ans = []
        [ans.append([1] * (i + 1) for i in range(n))]

        # 2 - create full Pascal Triangle for size of n
        for i in range(2, n):   
            # update i row cell values based on i - 1 row data
            for j in range(1, len(ans[i]) - 1):
                ans[i][j] = ans[i-1][j-1] + ans[i-1][j]

        return ans
34500