<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 TreeNode:

    def __init__(self, val):
        self.val = val
        self.left = None
        self.right = None

class Solution:
    def numOfWays(self, nums: List[int]) -> int:
        n = len(nums)
        p = 10**9 + 7
        root = TreeNode(nums[0])
        
        for a in nums[1:]:
            parent, node = None, root
            while node:
                parent = node
                if a > node.val:
                    node = node.right
                else:
                    node = node.left
            if a > parent.val:
                parent.right = TreeNode(a)
            else:
                parent.left = TreeNode(a)

        def factorial_mod_p(m, p):
            f = 1
            for i in range(2, m + 1):
                f = (f * i) % p

            return f

        def binomial_mod_p(m, k, p):
            a = factorial_mod_p(m, p)
            b = factorial_mod_p(k, p)
            c = factorial_mod_p(m - k, p)

            return (a * pow(b, -1, p) * pow(c, -1, p)) % p

        def count_BST(head, num_nodes, lo, hi):
            if head is None:
                return 1
            head_val = head.val
            lo_left, hi_left = lo, head_val - 1
            lo_right, hi_right = head_val + 1, hi
            left_size = head_val - lo
            right_size = hi - head_val
            count = (count_BST(head.left, left_size, lo_left, hi_left) * count_BST(head.right, right_size, lo_right, hi_right)) % p
            count = (count * binomial_mod_p(left_size + right_size, left_size, p)) % p
    
            return count

        return count_BST(root, n, 1, n) - 1

17200