let 96

Given n, how many structurally unique BST’s (binary search trees) that store values 1 … n?
解法一：
找规律，这种解法就是要找出一个具有普遍规律的解法，
首先就是把每一个节点作为根节点进行遍历，然后去求左右子树有多少种， 根据乘法原理， 左子树乘以右子树的种类数就是当前的子树个数。

又根据递推原理， 当一个节点作为根节点确定时，他的左子树的节点是有限制的，右子树的节点也是有限制的。 比如对于n=3， 当根节点为3时，左子树，只能由1,2构成， 而1,2构成的左子树数目等于n=2时，以此类推。
比如n=5时， 根节点为3时，左子树由2个节点，1,2右子树也有两个节点4,所以总的就是f(2)*f(2)。 f(x):n=x时的子树数目

class Solution {
    public int numTrees(int n) {
        
        int[] dp=new int[n+1];
        dp[0]=1;
        dp[1]=1;
        for(int level=2;level<=n;level++){
            for(int root=1;root<=level;root++)
                dp[level]+=dp[level-root]*dp[root-1];
        }
        return dp[n];
    }
}

解法二：
这种是个递归的方式，我写出这种解法时，主要考虑的是，不重复计算，比如计算n=4时，用到n=3的，计算n=5时，也会计算n=3的。
为了不避免重复计算，就像计算二叉树高度一样，需要

class Solution {
    public int numTrees(int n) {
        
        List<Integer> ans=new ArrayList<>();
        ans.add(1);//here mean  n=0 is 1
        ans.add(1);
        
        
        return findNum(n,ans);
        
    }
    
    public int findNum(int n,List<Integer> ans){
        
        if(n<=ans.size()-1){
            return ans.get(n);
        }else if(n==ans.size()){
            
            int result=0;
            for(int i=1;i<=n;i++){
                
                int left=ans.get(i-1);
                int right=ans.get(n-i);
                result+=left*right;
            }
            ans.add(result);
        }else{
            int result=0;
            for(int i=1;i<=n;i++){
                
                int left=findNum(i-1,ans);
                int right=findNum(n-i,ans);
                result+=left*right;
            }
            ans.add(result);

        }
        return ans.get(n);
    }
    
}

解法三：
这是一个卡特兰数：
Cn+1=2(2n+1)/(n+1) Cn, 卡特兰数有很多应用，括号匹配，出入栈序列，找零钱，多边形分割等