diff --git "a/Dynamic Program/\345\256\266/.keep" "b/Dynamic Program/\345\256\266/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/Dynamic Program/\345\256\266/\345\256\266_300.md" "b/Dynamic Program/\345\256\266/\345\256\266_300.md"
new file mode 100644
index 0000000000000000000000000000000000000000..b5a7b3acdd020d0774046581b9c59d6adfd18f13
--- /dev/null
+++ "b/Dynamic Program/\345\256\266/\345\256\266_300.md"	
@@ -0,0 +1,24 @@
+```go
+/**
+ * 作者：家
+ * 思路：两次循环每次找到当前位置的前边是不是有比自己小的，小的位置的值+1即可，随时记录最大值。
+ * 时间复杂度：O(n^2)
+ * 空间复杂度：O(n)
+ */
+ func lengthOfLIS(nums []int) int {
+    l := len(nums)
+    if l <= 1 {return l}
+    res := 1
+    dp := make([]int,l)
+    for i:=0;i<l;i++ {dp[i]=1}
+    for i:=1;i<l;i++ {
+        for j:=0;j<i;j++ {
+            if nums[j] < nums[i] {
+                if dp[j]+1 > dp[i] {dp[i] = dp[j]+1}
+            }
+        }
+        if dp[i] > res {res = dp[i]}
+    }
+    return res
+}
+```
\ No newline at end of file
diff --git "a/Dynamic Program/\345\256\266/\345\256\266_322.md" "b/Dynamic Program/\345\256\266/\345\256\266_322.md"
new file mode 100644
index 0000000000000000000000000000000000000000..3229d0a5b5dab09bc545b514ed767594846dd270
--- /dev/null
+++ "b/Dynamic Program/\345\256\266/\345\256\266_322.md"	
@@ -0,0 +1,25 @@
+```go
+/**
+ * 作者：家
+ * 思路：详细解释可以参照超哥视频。
+ * 时间复杂度：O(n^2)
+ * 空间复杂度：O(n)
+ */
+func coinChange(coins []int, amount int) int {
+    dp := make([]int, amount+1)
+	for v := 1; v <= amount; v++ {
+		dp[v] = amount + 1
+	}
+	for _, coin := range coins {
+		for v := coin; v <= amount; v++ {
+			if dp[v] > dp[v-coin] + 1 {
+				dp[v] = dp[v-coin] + 1
+			}
+		}
+	}
+	if dp[amount] > amount {
+		return -1
+	}
+	return dp[amount]
+}
+```
\ No newline at end of file
diff --git "a/Recursion/\345\256\266/.keep" "b/Recursion/\345\256\266/.keep"
new file mode 100644
index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391
diff --git "a/Recursion/\345\256\266/\345\256\266_46.md" "b/Recursion/\345\256\266/\345\256\266_46.md"
new file mode 100644
index 0000000000000000000000000000000000000000..a5a25d7b1cc06e9289181e26d70ff3f2c47b666c
--- /dev/null
+++ "b/Recursion/\345\256\266/\345\256\266_46.md"
@@ -0,0 +1,32 @@
+```
+/**
+ * 作者：家
+ * 思路：回溯，循环+递归，用一个Map记录访问过的元素即可
+ * 时间复杂度：O(n^2)?不是很确定，用了Map可以保证获取重复元素时为O(1)
+ * 空间复杂度：O(n),递归最多到n层，加上n长度的Map
+ */
+ func permute(nums []int) [][]int {
+    l := len(nums)
+    if l == 0 {
+        return [][]int{}
+    }
+    var dfs func([]int)
+    have := map[int]bool{}
+    re := [][]int{}
+    dfs = func(r []int) {
+        if len(r) == l {
+            re = append(re,append([]int{},r...))
+            return
+        }
+        for i:=0;i<l;i++ {
+            if !have[i]{
+                have[i] = true
+                dfs(append(r,nums[i]))
+                have[i] = false
+            }
+        }
+    }
+    dfs([]int{})
+    return re
+}
+```
\ No newline at end of file
diff --git "a/Recursion/\345\256\266/\345\256\266_69.md" "b/Recursion/\345\256\266/\345\256\266_69.md"
new file mode 100644
index 0000000000000000000000000000000000000000..f7cdc01d3335fa24ff14f5ebcdbaa0355f589142
--- /dev/null
+++ "b/Recursion/\345\256\266/\345\256\266_69.md"
@@ -0,0 +1,23 @@
+```
+/**
+ * 作者：家
+ * 思路：二分法即可，思路比较简单，可以通过牛顿法优化
+ * 时间复杂度：O(logN)
+ * 空间复杂度：O(logN)?不是很确定，貌似最多递归logN层
+ */
+func mySqrt(x int) int {
+    return rec(x,0,x)
+}
+func rec(x int, l int, r int) int{
+    mid := l+(r-l)/2
+    now := mid*mid
+    if now == x || now < x && (mid+1)*(mid+1) > x{
+        return mid
+    }else if now > x {
+        return rec(x,l,mid-1)
+    }
+    return rec(x,mid+1,r)
+}
+
+
+```
\ No newline at end of file
diff --git "a/Recursion/\345\256\266/\345\256\266_77.md" "b/Recursion/\345\256\266/\345\256\266_77.md"
new file mode 100644
index 0000000000000000000000000000000000000000..e2ba412a6c1a42295bd393e221a55fbe3f70df3d
--- /dev/null
+++ "b/Recursion/\345\256\266/\345\256\266_77.md"
@@ -0,0 +1,23 @@
+```
+/**
+ * 作者：家
+ * 思路：回溯，循环+递归标配
+ * 时间复杂度：O(n*k)?不是很确定，循环n次(递减的等差数列)*递归k次
+ * 空间复杂度：O(k),递归最多到k层
+ */
+func combine(n int, k int) [][]int {
+    re := [][]int{}
+    var dfs func(int,[]int)
+    dfs = func(index int,r []int) {
+        if len(r) == k {
+            re = append(re,append([]int{},r...))
+            return
+        }
+        for i:=index;i<=n;i++ {
+            dfs(i+1,append(r,i))
+        }
+    }
+    dfs(1,[]int{})
+    return re
+}
+```
\ No newline at end of file