unique-binary-search-trees

https://www.nowcoder.com/practice/b2b6734cbc0b43088f6084785046b861?tpId=46&tqId=29083&tPage=1&rp=1&ru=/ta/leetcode&qru=/ta/leetcode/question-ranking

思路：对于通过一个根来说，唯一二叉树的数量是其左子树的数量乘以右子树的数量。其实答案只是关心这个树的形态，而不是节点的数值，只要树的形态是一样，不管节点的值同不同，都把他看做同一树。

 

记忆化递归版本：

 class Solution {
public:
	
	
    int numTrees(int n) {
        if(n <= 1)
			return 1;
		bool * mark = new bool[n+1];//标记数组
		int * f = new int[n+1];//储存结果数组
		init( mark, n + 1, f);//初始化
		int res = solve(n, mark, f);//求解

		delete []f;//释放空间
		delete[]mark;
		return res;
    }
	void init(bool * mark, int len, int * f)
	{
		for(int i = 0; i < len; i++)
		{
			mark[i] = false;
			f[i] = 0;
		}
		

	}
	int solve(int n, bool * mark, int * f)
	{
		if(n <= 1)
			return 1;
		int sum = 0;
		for(int i = 1; i <= n; i++)
		{
			int x1 = 0, x2 = 0;
			if(!mark[i - 1])//根节点左边的i - 1 个点构成的二叉树的数量没有求过
			{
					x1 = solve(i-1, mark, f);//求出来
					f[i - 1] = x1;//储存结果
					mark[i - 1] = true;//标记求过
					
			}
			else
				x1 = f[i - 1];//求过直接就不搜了
			if(!mark[n - i])//根节点右边的n- i 个点构成的二叉树的数量没有求过
			{
				//同上
				x2 = solve(n - i, mark, f);
				f[n - i] = x2;
				mark[n - i] = true;
			}
			else
				x2 = f[n - i];

			sum += x1 * x2;//左子树二叉树数量*右子树二叉树数量
		}

		return sum;
	}
};

 其实记忆化递归写出来后，可以模拟记忆化递归的 逆过程 就是动态规划版本了。

f【n】表示n个节点的二叉搜索树数量

 

 class Solution {
public:
    int numTrees(int n) {
        int * f = new int[n + 1];
		for(int i = 0; i < n + 1;i++)//记得初始化，不初始化答案会是随机数的。。。
			f[i] = 0;
		f[0] = 1;
		f[1] = 1;
		for(int i = 2; i <= n; i++)
		{
			for(int j = 1; j <= i; j++)
			{
				f[i] += (f[j - 1] * f[i - j]);

			}
		}
		return f[n];

    }
};