leetcode

题目：Unique Binary Search Trees

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

个人思路：

1、二叉搜索树的中序遍历是有序的（从小到大），这里是1-n，那么我就从1-n遍历根节点，将每个情况下的BST个数相加，便是结果

2、根节点左边的便是左子树，右边的便是右子树，再用相同的方法去处理左右子树，左子树的个数乘以右子树的个数便是以该节点为根节点的BST的个数，这是一个递归的过程，递归的基本条件是空树的情况返回1

代码：

#include <iostream>

class Solution
{
public:
    int numTrees(int n)
    {
        int num = 0;

        for (int i = 1; i <= n; ++i)
        {
            num += partNumTrees(1, i - 1) * partNumTrees(i + 1, n);
        }

        return num;
    }
private:
    int partNumTrees(int start, int end)
    {
        if (start > end)
        {
            return 1;
        }

        int num = 0;
        for (int i = start; i <= end; ++i)
        {
            num += partNumTrees(start, i - 1) * partNumTrees(i + 1, end);
        }

        return num;
    }
};

int main()
{
    Solution s;
    std::cout << s.numTrees(4) << std::endl;
    system("pause");

    return 0;
}

按照惯例，上网搜寻更优的算法，发现有利用动态规划思想解决该问题的算法，链接：http://www.blogjava.net/menglee/archive/2013/12/20/407801.html

思路：

1、先开辟一个n+1大小的数组dp，dp[i]记录了有i个节点的BTS的个数，这样就可以在需要时直接读取数值，而不是当场去计算，用空间换取时间

2、主要目的是要计算出dp[n]，可从dp[2]开始计算，先预设几个dp初值，如dp[0]=1,dp[1]=1等，计算dp[i]的思路与我上面的思路相同

代码：

#include <iostream>

class Solution
{
public:
    int numTrees(int n)
    {
        /*
        int num = 0;

        for (int i = 1; i <= n; ++i)
        {
            num += partNumTrees(1, i - 1) * partNumTrees(i + 1, n);
        }
        */

        int *dp = new int[n + 1];
        dp[0] = 1;
        dp[1] = 1;

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

        return dp[n];
    }
private:
    /*
    int partNumTrees(int start, int end)
    {
        if (start > end)
        {
            return 1;
        }

        int num = 0;
        for (int i = start; i <= end; ++i)
        {
            num += partNumTrees(start, i - 1) * partNumTrees(i + 1, end);
        }

        return num;
    }
    */
};

int main()
{
    Solution s;
    std::cout << s.numTrees(4) << std::endl;
    system("pause");

    return 0;
}