diff --git a/solutions/96. Unique Binary Search Trees.md b/solutions/96. Unique Binary Search Trees.md
new file mode 100644
index 0000000..e13dd03
--- /dev/null
+++ b/solutions/96. Unique Binary Search Trees.md	
@@ -0,0 +1,88 @@
+# [96. Unique Binary Search Trees](https://leetcode.com/problems/unique-binary-search-trees/)
+
+# 思路
+由节点1,2,...,n可以组成多少棵二叉搜索树。         
+先来看看二叉搜索树的定义。它或者是一棵空树，或者是具有下列性质的二叉树： 
+* 若它的左子树不空，则左子树上所有结点的值均小于它的根结点的值； 
+* 若它的右子树不空，则右子树上所有结点的值均大于它的根结点的值； 
+* 它的左、右子树也分别为二叉排序树。
+
+## 思路一、动归
+先来看一个例子，当n=3时:
+```
+ 1               1                   2                    3             3
+  \               \                /   \                 /             / 
+   3               2              1     3               2             1
+  /                 \                                  /               \
+ 2                   3                                1                 2
+ ```
+
+我们可以看到，以1为根的树有几个，完全取决于有二个元素的子树有几种。同理，以2为根的子树取决于一个元素的子树有几个。以3为根的情况，则与1相同。
+
+定义`dp[i]`为用1,2,...,i能构成Unique Binary Tree的数目，特别的`dp[0] = dp[1] = 1`。
+
+如果数组有两个元素{1,2}， 那么有如下两种可能
+```
+1                    2
+ \                  /
+  2                1
+```
+即
+```
+dp[2] = dp[0] * dp[1]  (1为根的情况)
+      + dp[1] * dp[0]  (2为根的情况)
+```
+
+再看一遍三个元素的数组，可以发现BST的取值方式如下：
+```
+dp[3] = dp[0]*dp[2]  (1为根的情况)
+      + dp[1]*dp[1]  (2为根的情况)
+      + dp[2]*dp[0]  (3为根的情况)
+```
+
+所以，由此观察，可以得出递推公式为
+```
+dp[i] =  dp[0]*dp[i-1] + dp[1]*dp[i-2] + ... + dp[i-1]*dp[0]
+```
+
+## 思路二
+我们知道前序遍历序列和中序遍历序列可以确定唯一一颗二叉树，中序遍历是递增的即1,2,...n的话一定是二叉搜索树，所以问题可以转换成给定中序序列，有多少种可能的前序序列？
+根据中序和前序的递归算法，这个问题等价于给定进栈顺序，有多少种出栈的顺序。答案就是卡特兰数，即`C(2n,n) / (n + 1)`。所以我们可以直接计算这个值。
+
+# C++
+## 思路一
+``` C++
+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 - 1 - j];
+        
+        return dp[n];
+    }
+};
+```
+
+## 思路二
+``` C++
+class Solution {
+public:
+    int numTrees(int n) {
+        long long res = 1, tmp = 1; // 注意用long long
+        for(int i = 1; i <= n; i++){
+            res *= (2 * n - i + 1);
+            if(res % i == 0) res /= i;
+            else tmp *= i;
+            if(res % tmp == 0){
+                res /= tmp;
+                tmp = 1;
+            }
+            
+        }
+        return int((res / tmp) / (n + 1));
+    }
+};
+```