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

mod = int(1e9) + 7
fact = [1] * 1002
for i in range(1, 1002):
    fact[i] = (fact[i - 1] * i) % mod

def inv(x):
    return pow(x, mod - 2, mod)

def choose(n, r):
    x = fact[n]
    y = fact[r]
    z = fact[n - r]
    ans = (((x * inv(y)) % mod) * inv(z)) % mod
    return ans

def choose_with_repetition(n, r):
    return choose(n + r - 1, r)

class Node:
    def __init__(self, v):
        self.v = v
        self.l = None
        self.r = None
        self.sz = 1
        self.cnt = 1  # how many ways to arrange this subtree's numbers to get the same subtree structure

class Solution:
    def numOfWays(self, nums: List[int]) -> int:
        # Make a graph of each node to its children nodes.
        # For each node, count how many ways to order children.
        # Use "choose with repetition" or "stars and bars" to count ways to "weave" 2 child nodes.
        # Eg. [3, 4, 5, 1, 2]
        # 3 -> x -> 4 -> x -> 5 -> x
        # Count ways to "squeeze" 1, 2 into the x'es.
        
        n = len(nums)
        
        # build BST
        root = Node(nums[0])
        topo = [root]
        for i in range(1, n):
            x = nums[i]
            new_u = Node(x)
            u = root
            while True:
                if x < u.v:
                    if u.l is None:
                        u.l = new_u
                        break
                    else:
                        u = u.l
                else:
                    if u.r is None:
                        u.r = new_u
                        break
                    else:
                        u = u.r
            topo.append(new_u)
        
        # update sz and cnt
        for u in topo[::-1]:
            if u.l is not None:
                u.sz += u.l.sz
            if u.r is not None:
                u.sz += u.r.sz
            if not ((u.l is None) and (u.r is None)):
                if u.l is None:
                    u.cnt = u.r.cnt
                elif u.r is None:
                    u.cnt = u.l.cnt
                else:
                    sz1 = u.l.sz
                    sz2 = u.r.sz
                    c1 = u.l.cnt
                    c2 = u.r.cnt
                    u.cnt = (choose_with_repetition(sz1 + 1, sz2) * c1) % mod
                    u.cnt = (u.cnt * c2) % mod
        
        return (topo[0].cnt - 1 + mod) % mod
        
17000