【归并排序】【图论】【动态规划】【深度游戏搜索】1569将子数组重新排序得到同一个二叉搜索树的方案数

本文介绍: 给你一个数组 nums 表示 1 到 n 的一个排列。我们按照元素在 nums 中的顺序依次插入一个初始为空的二叉搜索树（BST）。请你统计将 nums 重新排序后，统计满足如下条件的方案数：重排后得到的二叉搜索树与 nums 原本数字顺序得到的二叉搜索树相同。比方说，给你 nums = [2,1,3]，我们得到一棵 2 为根，1 为左孩子，3 为右孩子的树。数组 [2,3,1] 也能得到相同的 BST，但 [3,2,1] 会得到一棵不同的 BST 。请你返回重排 nums 后，与原数组 nums 得到

本文涉及知识点

动态规划汇总
图论深度游戏搜索归并排序组合

LeetCoce1569将子数组重新排序得到同一个二叉搜索树的方案数

给你一个数组 nums 表示 1 到 n 的一个排列。我们按照元素在 nums 中的顺序依次插入一个初始为空的二叉搜索树（BST）。请你统计将 nums 重新排序后，统计满足如下条件的方案数：重排后得到的二叉搜索树与 nums 原本数字顺序得到的二叉搜索树相同。
比方说，给你 nums = [2,1,3]，我们得到一棵 2 为根，1 为左孩子，3 为右孩子的树。数组 [2,3,1] 也能得到相同的 BST，但 [3,2,1] 会得到一棵不同的 BST 。
请你返回重排 nums 后，与原数组 nums 得到相同二叉搜索树的方案数。
由于答案可能会很大，请将结果对 10^9 + 7 取余数。
示例 1：
输入：nums = [2,1,3]
输出：1
解释：我们将 nums 重排， [2,3,1] 能得到相同的 BST 。没有其他得到相同 BST 的方案了。
示例 2：
输入：nums = [3,4,5,1,2]
输出：5
解释：下面 5 个数组会得到相同的 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]
示例 3：
输入：nums = [1,2,3]
输出：0
解释：没有别的排列顺序能得到相同的 BST 。
提示：
1 <= nums.length <= 1000
1 <= nums[i] <= nums.length
nums 中所有数互不相同。

归并排序

原以为必须用归并排序的思想，其实可以不用归并排序。

原理

对每棵树（子树），只讨论左子树和右子树之间的顺序，不讨论子树内部的顺序。
a，根节点必定是第一个。
b，混略内部顺序后，左子树的节点完全相同，假定其为ln个；右子树的节点也相同，假定其为rn个。就是组合

Large C_{m+n}^n

$C_{m + n}^{n}$
DFS 各子树的结果相乘。

动态规划的状态表示

每个子树的范围是确定，比如：根节点的范围为[1,n]，左子树[1,nums[0]-1] 右子树[nums[0],n]。每根子树，需要三个子状态：最小值(iMin)，最大值(iMax)，根节点的值(nums[iRoot])。由于1到n，都出现且只出现一次，所以此子树的节点数为：最大值-最小值+1。

动态规划的转移方程

左树：iMin,nums[iRoot]-1, nums(iRoot…]中第一个在左树范围的小标。
右树:,nums[iRoot]+1,iMax,nums(iRoot…]中第一个在右树范围的小标。

动态规划的填表顺

深度优先，从根节点开始。

动态规划的返回值

dfs(1,n,0)-1。

代码

核心代码

template<int MOD = 1000000007>
class C1097Int
{
public:
	C1097Int(long long llData = 0) :m_iData(llData% MOD)
	{

	}
	C1097Int  operator+(const C1097Int& o)const
	{
		return C1097Int(((long long)m_iData + o.m_iData) % MOD);
	}
	C1097Int& operator+=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData + o.m_iData) % MOD;
		return *this;
	}
	C1097Int& operator-=(const C1097Int& o)
	{
		m_iData = (m_iData + MOD - o.m_iData) % MOD;
		return *this;
	}
	C1097Int  operator-(const C1097Int& o)
	{
		return C1097Int((m_iData + MOD - o.m_iData) % MOD);
	}
	C1097Int  operator*(const C1097Int& o)const
	{
		return((long long)m_iData * o.m_iData) % MOD;
	}
	C1097Int& operator*=(const C1097Int& o)
	{
		m_iData = ((long long)m_iData * o.m_iData) % MOD;
		return *this;
	}
	bool operator<(const C1097Int& o)const
	{
		return m_iData < o.m_iData;
	}
	C1097Int pow(long long n)const
	{
		C1097Int iRet = 1, iCur = *this;
		while (n)
		{
			if (n & 1)
			{
				iRet *= iCur;
			}
			iCur *= iCur;
			n >>= 1;
		}
		return iRet;
	}
	C1097Int PowNegative1()const
	{
		return pow(MOD - 2);
	}
	int ToInt()const
	{
		return m_iData;
	}
private:
	int m_iData = 0;;
};

template<class Result = C1097Int<> >
class CCombination
{
public:
	CCombination()
	{
		m_v.assign(1, vector<Result>(1,1));
	}
	Result Get(int sel, int total)
	{
		while (m_v.size() <= total)
		{
			int iSize = m_v.size();
			m_v.emplace_back(iSize + 1, 1);
			for (int i = 1; i < iSize; i++)
			{
				m_v[iSize][i] = m_v[iSize - 1][i] + m_v[iSize - 1][i - 1];
			}
		}
		return m_v[total][sel];
	}
protected:
	vector<vector<Result>> m_v;
};

class Solution {
public:
	int numOfWays(vector<int>& nums) {
		m_nums = nums;
		return (DFS(1, nums.size(), 0) - 1).ToInt();
	}
	C1097Int<> DFS(int iMin, int iMax, int iRoot)
	{
		int iLeftRoot = -1, iRightRoot = -1;
		for (int i = (int)m_nums.size()-1; i > iRoot; i--)
		{
			if ((m_nums[i] < m_nums[iRoot])&&(m_nums[i] >= iMin ))
			{
				iLeftRoot = i;
			}
			if ((m_nums[i] > m_nums[iRoot])&& (m_nums[i] <= iMax))
			{
				iRightRoot = i;
			}
		}
		C1097Int<> biRet = m_com.Get(m_nums[iRoot]-iMin,iMax-iMin);
		if (-1 != iLeftRoot)
		{
			biRet *= DFS(iMin, m_nums[iRoot] - 1, iLeftRoot);
		}
		if (-1 != iRightRoot)
		{
			biRet *= DFS(m_nums[iRoot] + 1,iMax, iRightRoot);
		}
		return biRet;
	}
	vector<int> m_nums;
	CCombination<> m_com;
};

2023年6月

class Solution {
public:
int numOfWays(vector& nums) {
m_vFact.emplace_back(1);
for (int i = 1; i < nums.size(); i++)
{
m_vFact.emplace_back(m_vFact.back()*i);
}
for (const auto& i : m_vFact )
{
m_vRevFact.emplace_back(i.PowNegative1());
}
return (Rev(nums) – 1).ToInt();
}
C1097Int<> Rev(vector& nums)
{
if (0 == nums.size())
{
return 1;
}
vector vLeft, vRight;
for (int i = 1; i < nums.size(); i++)
{
const int& n = nums[i];
if (n < nums[0])
{
vLeft.emplace_back(n);
}
else
{
vRight.emplace_back(n);
}
}
C1097Int<> iRet = m_vFact[vLeft.size() + vRight.size()] * m_vRevFact[vLeft.size()] * m_vRevFact[vRight.size()];
return iRet * Rev(vLeft) * Rev(vRight);
}
vector<C1097Int<>> m_vFact, m_vRevFact;
};

扩展阅读

视频课程

有效学习：明确的目标及时的反馈拉伸区（难度合适），可以先学简单的课程，请移步CSDN学院，听白银讲师（也就是鄙人）的讲解。
https://edu.csdn.net/course/detail/38771

如何你想快

速形成战斗了，为老板分忧，请学习C#入职培训、C++入职培训等课程
https://edu.csdn.net/lecturer/6176

我想对大家说的话
闻缺陷则喜是一个美好的愿望，早发现问题，早修改问题，给老板节约钱。
子墨子言之：事无终始，无务多业。也就是我们常说的专业的人做专业的事。
如果程序是一条龙，那算法就是他的是睛