Leetcode Unique Binary Search Trees problem solution

class Solution(object):
    def numTrees(self, n):
        """
        :type n: int
        :rtype: int
        """
        if n==0 or n==1:
            return 1
        
        dp = [0]*(n+1)
        dp[0] = 1
        dp[1] = 1
        
        
        for i in range(2, n+1):
            for j in range(i):
                dp[i]+=dp[i-j-1] * dp[j]
                
        return dp[n]

public class Solution {
    public int numTrees(int n) {
        int[] record = new int[n+1];
        record[0] = 1;
        record[1] = 1;
        return numTrees(n, record);
    }
    
    public int numTrees(int n, int[] record) {
        int result = 0;
        for(int i=1; i<=n; i++) {
            int tmp = 1;
            int left = i - 1;
            int right = n - i;
            if(record[left] > 0) {
                tmp *= record[left];
            } else {
                tmp *= numTrees(left, record);
            }
            if(record[right] > 0) {
                tmp *= record[right];
            } else {
                tmp *= numTrees(right, record);
            }
            result += tmp;
        }
        record[n] = result;
        return result;
    }
}

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n+1, 0);
        dp[0] = 1;
        dp[1] = 1;
        for (int i = 2; i <= n; ++i) {
            for (int j = 0; j < i; j++) {
                dp[i] += dp[j] * dp[i-j-1];
            }
        }
        return dp[n];
    }
};

int solutions[1024]={1,1,};
int calculated = 1;
int numTrees(int n) {
    if(n<calculated)
        return solutions[n];
    int start = calculated+1;
    for(int loop = start;loop<n+1;loop++){
        int sum = 0;
        for(int i=0;i<loop;i++){
            sum += solutions[i]*solutions[loop-i-1];
        }
        solutions[loop]=sum;
    }
    calculated = n;
    return solutions[n];
}