96. Unique Binary Search Trees --继续研究-CSDN博客

Given n, how many structurally unique BST’s (binary search trees) that store values 1…n?

For example,
Given n = 3, there are a total of 5 unique BST’s.

1 3 3 2 1
\ / / / \ \
3 2 1 1 3 2
/ / \ \
2 1 2 3
Subscribe to see which companies asked this question
递归的方法：
参见链接：http://blog.csdn.net/tzh476/article/details/52510343?locationNum=2
根据它们的特征列出一些值，就可以发现其规律了,其中f(0)=1,f(1)=1：
f(2)=f(0)*f(1)+f(1)*f(0);
f(3)=f(0)*f(2)+f(1)*f(1)+f(2)*f(1);
f(4)=f(0)*f(3)+f(1)*f(2)+f(2)*f(1)+f(3)*f(0);
……..
未改进之前：

public class Solution {  
    public int numTrees(int n) {  
        if(n<=1)  
        return 1;  
        int i,sum=0;  
        for(i=0;i<n;i++){  
            sum=sum+numTrees(i)*numTrees(n-1-i);  
        }  
        return sum;  
    }  
}

改进之后：

public class Solution {  
    public int numTrees(int n) {  
        if(n<=1)  
        return 1;  
        int i,sum=0;  
        for(i=0;i<(n+1)/2;i++){  
            if(i==n-1-i)  
                sum=sum+numTrees(i)*numTrees(n-1-i);  
            else  
                sum=sum+2*numTrees(i)*numTrees(n-1-i);  
        }  
        return sum;  
    }  
}

非递归的方法，采用动态规划来实现，参考链接：http://www.cnblogs.com/ccsccs/articles/4204677.html
代码：

public int numTrees(int n) {  
    if(n<=0)  
        return 0;  
    int[] res = new int[n+1];  
    res[0] = 1;  
    res[1] = 1;  
    for(int i=2;i<=n;i++)  
    {  
        for(int j=0;j<i;j++)  
        {  
            res[i] += res[j]*res[i-j-1];  
        }  
    }  
    return res[n];  
}

代码二：
/**
* Taking 1~n as root respectively:
* 1 as root: # of trees = F(0) * F(n-1) // F(0) == 1
* 2 as root: # of trees = F(1) * F(n-2)
* 3 as root: # of trees = F(2) * F(n-3)
* …
* n-1 as root: # of trees = F(n-2) * F(1)
* n as root: # of trees = F(n-1) * F(0)
*
* So, the formulation is:
* F(n) = F(0) * F(n-1) + F(1) * F(n-2) + F(2) * F(n-3) + … + F(n-2) * F(1) + F(n-1) * F(0)
*/

 int numTrees(int n) {
        int dp[n+1];
        dp[0] = dp[1] = 1;
        for(int i=2; i<=n; i++)
        {
            dp[i] = 0;
            for(int j=1; j<=i; j++)
                dp[i] += dp[j-1]*dp[i-j];
        }

        return dp[n];
    }