【LeetCode 96】Unique Binary Search Trees (C++)

最新推荐文章于 2024-10-01 18:52:56 发布

原创最新推荐文章于 2024-10-01 18:52:56 发布 · 261 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#DP #Unique #递归 #动态规划 #leetcode

算法专栏收录该内容

10 篇文章

订阅专栏

本文探讨了如何计算给定整数n时不同结构的二叉搜索树的数量，并提供了两种解决方案：递归方法和动态规划方法。递归方法虽然直观但效率低下；动态规划方法通过避免重复计算显著提高了效率。

Problem:

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

Solution:

首先考虑用递归实现（但是计算资源消耗较大，会造成TimeExceed错误）

class Solution {
public:
    int cur_node(int small,int large){
        if(small>=large)return 1;
        else{
            int cur_sum=0,i;
            for(i=small;i<=large;i++){
                cur_sum+=(cur_node(small,i-1)*cur_node(i+1,large));
            }
            return cur_sum;
        }
    }
    
    int numTrees(int n) {
        if(n==0)return 0;
        return cur_node(1,n);    
    }
};

为了节省计算资源，最好的办法应该使用动态规划实现

class Solution {
public:
    int numTrees(int n) {
        if(n==0)return 0;
        int i,j,k;
        int num_matrix[n+2][n+2];
        memset(num_matrix,0,sizeof(num_matrix));
        for(i=0;i<n+2;i++){
            num_matrix[i][i]=1;
            if(i!=0)num_matrix[i][i-1]=1;
        }
        for(i=1;i<=n-1;i++){
            for(j=1;j+i<=n;j++){
                for(k=j;k<=j+i;k++){
                    num_matrix[j][j+i]+=(num_matrix[j][k-1]*num_matrix[k+1][j+i]);
                }
            }
        }
        return num_matrix[1][n];
    }
};

此外这里再贴一段引用他人的美丽的代码（思想的亮点在于对于固定长度的任意有序连续数列，其搜索二叉树的Unique情况总数相同，如1,2,3,4和3,4,5,6结果一样）

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