leetcode1569 将子数组重新排序得到同一个二叉查找树的方案数

思路：

对于给定bst，需要保证根节点出现在最前面，而左子树节点和右子树节点的相对位置可以进行排列组合。左子树和右子树内部需要递归地满足同样的条件。可以通过后续遍历逐层计算，最后将可能的方案数乘起来。学习了一种利用并查集优化时间复杂度的方法：https://leetcode-cn.com/problems/number-of-ways-to-reorder-array-to-get-same-bst/solution/jiang-zi-shu-zu-zhong-xin-pai-xu-de-dao-tong-yi-2/。

实现：

class DSU
{
    int _n;
    vector<int> p;
public:
    DSU(int n):_n(n + 1)
    {   
        p.resize(_n);
        for (int i = 1; i < _n; i++) p[i] = i;
    }
    int find(int x)
    {
        if (p[x] == x) return x;
        return p[x] = find(p[x]);
    }
    void uni(int x, int y)
    {
        x = find(x); y = find(y);
        p[x] = y;
    }
    int get_root()
    {
        int res = 0;
        for (int i = 1; i < _n; i++)
        {
            if (p[i] == i) { res = i; break; }
        }
        return res;
    }
};
class Comb
{
    int _n, MOD;
    vector<int> inv, fac, fac_inv;
public:
    Comb(int n, int mod):_n(n + 1), MOD(mod)
    {
        inv.resize(_n); fac.resize(_n); fac_inv.resize(_n);
        for (int i = 0; i < _n; i++)
        {
            if (i < 2) { fac[i] = fac_inv[i] = inv[i] = 1; continue; }
            inv[i] = ((long long)MOD - MOD / i) * inv[MOD % i] % MOD;
            fac[i] = (long long)fac[i - 1] * i % MOD;
            fac_inv[i] = (long long)fac_inv[i - 1] * inv[i] % MOD;
        }
    }
    int C(int i, int j)
    {
        return (long long)fac[i] * fac_inv[j] % MOD * fac_inv[i - j] % MOD;
    }
};
class Solution
{
    int MOD = 1e9 + 7;
public:
    int dfs(int root, vector<int>& left, vector<int>& right, vector<int>& siz, Comb& c)
    {
        if (root == 0) return 1;
        int l = dfs(left[root], left, right, siz, c);
        int r = dfs(right[root], left, right, siz, c);
        int lc = siz[left[root]], rc = siz[right[root]];
        return (long long)l * r % MOD * c.C(lc + rc, lc) % MOD;
    }
    int numOfWays(vector<int>& nums)
    {
        int n = nums.size();
        DSU d(n); Comb c(n, MOD);
        vector<bool> vis(n + 1, false);
        vector<int> left(n + 1, 0), right(n + 1, 0), siz(n + 1, 1);
        siz[0] = 0;
        for (int i = n - 1; i >= 0; i--)
        {
            if (nums[i] + 1 <= n && vis[nums[i] + 1])
            {
                int x = d.find(nums[i] + 1);
                d.uni(x, nums[i]); //须将x合并到nums[i]
                siz[nums[i]] += siz[x];
                right[nums[i]] = x;
            }
            if (nums[i] - 1 >= 1 && vis[nums[i] - 1])
            {
                int x = d.find(nums[i] - 1);
                d.uni(x, nums[i]); //须将x合并到nums[i]
                siz[nums[i]] += siz[x];
                left[nums[i]] = x;
            }
            vis[nums[i]] = true;
        }
        int root = d.get_root();
        return max(dfs(root, left, right, siz, c) - 1, 0);
    }
};