diff --git a/3 Hash Table/LinkedHashMap.md b/3 Hash Table/LinkedHashMap.md
index 515225a..4a3db88 100644
--- a/3 Hash Table/LinkedHashMap.md	
+++ b/3 Hash Table/LinkedHashMap.md	
@@ -100,6 +100,64 @@ protected boolean removeEldestEntry(Map.Entry eldest) {
 ```
 
 
+基于 LinkedHashMap实现的 LRU Cache
+
+
+```Java
+class LRUCache {
+    int cap;
+    LinkedHashMap<Integer, Integer> cache = new LinkedHashMap<>();
+    public LRUCache(int capacity) { 
+        this.cap = capacity;
+    }
+    
+    //访问元素
+    public int get(int key) {
+        if (!cache.containsKey(key)) {
+            return -1;
+        }
+        // 将 key 变为最近使用
+        makeRecently(key);
+        return cache.get(key);
+    }
+    
+    //添加元素到cache
+    public void put(int key, int val) {
+        if (cache.containsKey(key)) {
+            // 修改 key 的值
+            cache.put(key, val);
+            // 将 key 变为最近使用
+            makeRecently(key);
+            return;
+        }
+        
+        if (cache.size() >= this.cap) {
+            // 链表头部就是最久未使用的 key
+            int oldestKey = cache.keySet().iterator().next();
+            cache.remove(oldestKey);
+        }
+        // 将新的 key 添加链表尾部
+        cache.put(key, val);
+    }
+    
+    private void makeRecently(int key) {
+        int val = cache.get(key);
+        // 删除 key，重新插入到队尾
+        cache.remove(key);
+        cache.put(key, val);
+    }
+}
+
+```
+
+
+
+
+
+
+
+
+
 
 
 
diff --git a/8 Algorithms Analysis/动态规划.md b/8 Algorithms Analysis/动态规划.md
index b7d41f0..01a2222 100644
--- a/8 Algorithms Analysis/动态规划.md	
+++ b/8 Algorithms Analysis/动态规划.md	
@@ -57,6 +57,7 @@ DP通常基于一个递推公式及一个(或多个)初始状态，当前子问
 
 ### DP VS 回溯法
 
+DP 和 回溯法 都会用到递归
 
 动态规划的暴力求解阶段就是回溯算法。只是有的问题具有重叠子问题性质，可以用 dp table 或者备忘录优化，将递归树大幅剪枝，这就变成了动态规划；而有些问题没有重叠子问题，也就是[回溯算法](回溯法.md)问题了，复杂度非常高是不可避免的
 
diff --git a/8 Algorithms Analysis/回溯法.md b/8 Algorithms Analysis/回溯法.md
index 9275b8a..1a7fd91 100644
--- a/8 Algorithms Analysis/回溯法.md	
+++ b/8 Algorithms Analysis/回溯法.md	
@@ -20,7 +20,6 @@
 
 
 
-
 ## 代码框架
 
 ```python
@@ -43,6 +42,33 @@ def backtrack(路径, 选择列表):
 > n 个不重复的数，全排列共有 n! 个
 
 
+```Java
+	// 路径：记录在 track 中
+    // 选择列表：nums 中不存在于 track 的那些元素
+    // 结束条件：nums 中的元素全都在 track 中出现
+    void backtrack(int[] nums, LinkedList<Integer> track) {
+        // 触发结束条件
+        if (track.size() == nums.length) {
+            res.add(new LinkedList(track));
+            return;
+        }
+
+        for (int i = 0; i < nums.length; i++) {
+            // 排除不合法的选择
+            if (track.contains(nums[i]))
+                continue;
+
+            // 做选择
+            track.add(nums[i]);
+            
+            // 进入下一层决策树
+            backtrack(nums, track);
+            // 取消选择
+            track.removeLast();
+        }
+    }
+```
+
 
 
 ## 八皇后问题
diff --git a/8 Algorithms Analysis/递归.md b/8 Algorithms Analysis/递归.md
index 2b3f933..0d36733 100644
--- a/8 Algorithms Analysis/递归.md	
+++ b/8 Algorithms Analysis/递归.md	
@@ -6,7 +6,7 @@
 在  `回归` 阶段，获得最简单问题的解后，逐级返回，依次得到稍微复杂情况的解，知道获得最终的结果
 
 1） 确定递归公式 ,  比如  斐波那契数列 问题中的 `fib(n)=fib(n-1)+fib(n-2)`
-2） 确定边界条件   
+2） 确定边界条件 bad case  
 
 > 自顶向下的递归，自底向上是迭代