diff --git a/Week_01/README.md b/Week_01/README.md
index 50de3041..78516b20 100644
--- a/Week_01/README.md
+++ b/Week_01/README.md
@@ -1 +1,130 @@
-学习笔记
\ No newline at end of file
+# 作业
+
+### 简单：
+
+- 用 add first 或 add last 这套新的 API 改写 Deque 的代码
+- 分析 Queue 和 Priority Queue 的源码
+- √  [删除排序数组中的重复项](https://leetcode-cn.com/problems/remove-duplicates-from-sorted-array/)（Facebook、字节跳动、微软在半年内面试中考过）
+- [旋转数组](https://leetcode-cn.com/problems/rotate-array/)（微软、亚马逊、PayPal 在半年内面试中考过）
+- √  [合并两个有序链表](https://leetcode-cn.com/problems/merge-two-sorted-lists/)（亚马逊、字节跳动在半年内面试常考）
+- √  [合并两个有序数组](https://leetcode-cn.com/problems/merge-sorted-array/)（Facebook 在半年内面试常考）
+- √  [两数之和](https://leetcode-cn.com/problems/two-sum/)（亚马逊、字节跳动、谷歌、Facebook、苹果、微软在半年内面试中高频常考）
+- √  [移动零](https://leetcode-cn.com/problems/move-zeroes/)（Facebook、亚马逊、苹果在半年内面试中考过）
+- √  [加一](https://leetcode-cn.com/problems/plus-one/)（谷歌、字节跳动、Facebook 在半年内面试中考过）
+
+### 中等：
+
+- [设计循环双端队列](https://leetcode.com/problems/design-circular-deque)（Facebook 在 1 年内面试中考过）
+
+### 困难：
+
+- [接雨水](https://leetcode.com/problems/trapping-rain-water/)（亚马逊、字节跳动、高盛集团、Facebook 在半年内面试常考）
+
+## 下周预习
+
+### 预习题目：
+
+- [有效的字母异位词](https://leetcode-cn.com/problems/valid-anagram/description/)
+- [二叉树的中序遍历](https://leetcode-cn.com/problems/binary-tree-inorder-traversal/)
+- [最小的 k 个数](https://leetcode-cn.com/problems/zui-xiao-de-kge-shu-lcof/)
+
+
+
+# 我的完成
+
++ 删除排序数组中的重复项
+
+  ```c++
+  class Solution {
+  public:
+      int removeDuplicates(vector<int>& nums) {
+          // 单次遍历，用一个指针控制遍历，一个指针空值nums有效值
+          // 先把第一个元素放进去，从第二个元素开始遍历，只要不相等就加入
+          if (nums.size() < 2) return nums.size();
+          int cur = 0;
+          for (int i = 1; i < nums.size(); i++) {
+              if (nums[i] != nums[cur])
+                  nums[++cur] = nums[i];
+          }
+          return cur + 1;
+      }
+  };
+  ```
+
++ 合并两个有序链表
+
+  ```c++
+  class Solution {
+  public:
+      ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
+          ListNode* newHead = new ListNode(0);
+          ListNode* tem = newHead;
+          // 两个指针一起遍历得到新的链表，然后把遍历结束之后剩下的追加到新链表   
+          while (l1 != nullptr && l2 != nullptr) {
+              if (l1->val <= l2->val) {
+                  tem->next = l1;
+                  l1 = l1->next;
+              } else {
+                  tem->next = l2;
+                  l2 = l2->next;
+              }
+              tem = tem->next;
+          }
+          if (l1 == nullptr) tem->next = l2;
+          else tem->next = l1;
+          return newHead->next;
+      }
+  };
+  ```
+
++ 两数之和
+
+  ```c++
+  class Solution {
+  public:
+      vector<int> twoSum(vector<int>& nums, int target) {
+          // 匹配类型记录值和索引，再遍历查找目标值与当前值得差值
+          map<int, int> hashmap;
+          for (int i=0; i < nums.size(); i++) {
+              if (hashmap.count(target - nums[i]) > 0) {
+                  return {hashmap[target - nums[i]], i};
+              }
+              hashmap[nums[i]] = i;
+          }
+          return {0, -1};
+      }
+  };
+  ```
+
++ 加一
+
+  ```c++
+  class Solution {
+  public:
+      vector<int> plusOne(vector<int>& digits) {
+          // 根据加法的原理，从右向左的加，注意全为9
+          for (int i = digits.size() - 1; i >= 0; i--) {
+              digits[i]++;
+              if (digits[i] == 10) 
+                  digits[i] = 0;
+              else 
+                  return digits;
+          }
+          digits[0] = 1;
+          digits.push_back(0);
+          return digits;
+      }
+  };
+  ```
+
+  
+
+
+
+# 总结
+
++ 在写好题目后会有意识的思考时间和空间复杂度。
++ 了解数组，链表的基本操作。栈的使用在最近相关度问题。以及有关双指针，快慢指针的运用
++ 根据跳表的思想，了解升维的思想
++ 在递归法解决问题中自己还是有些不足。
++ 在本周有目的的刷题过程中，我觉得确实十分有效的在提升自己的解决问题的能力
\ No newline at end of file
diff --git a/Week_02/README.md b/Week_02/README.md
index 50de3041..c63cc675 100644
--- a/Week_02/README.md
+++ b/Week_02/README.md
@@ -1 +1,69 @@
-学习笔记
\ No newline at end of file
+## 本周作业
+
+### 简单：
+
+- [有效的字母异位词](https://leetcode-cn.com/problems/valid-anagram/description/)（亚马逊、Facebook、谷歌在半年内面试中考过）
+
+  ```c++
+  class Solution {
+  public:
+      bool isAnagram(string s, string t) {
+          if (s.length() != t.length()) {
+              return false;
+          }
+          sort(s.begin(), s.end());
+          sort(t.begin(), t.end());
+          return s == t;
+      }
+  };
+  ```
+
+  
+
+- √  [两数之和](https://leetcode-cn.com/problems/two-sum/description/)（近半年内，亚马逊考查此题达到 216 次、字节跳动 147 次、谷歌 104 次，Facebook、苹果、微软、腾讯也在近半年内面试常考）
+
+  ```c++
+  class Solution {
+  public:
+      vector<int> twoSum(vector<int>& nums, int target) {
+          map<int, int>hashmap;
+          for (int i = 0; i < nums.size(); i++) {
+              if (hashmap.count(nums[i]) != 0)
+                  return {hashmap[nums[i]], i};
+              hashmap[target - nums[i]] = i;
+          }
+          return {-1, 1};
+      }
+  };
+  ```
+
+  
+
+- [N 叉树的前序遍历](https://leetcode-cn.com/problems/n-ary-tree-preorder-traversal/description/)（亚马逊在半年内面试中考过）
+
+  ```c++
+  // 迭代法之后待研究
+  class Solution {
+  public:
+      vector<int> res;
+      vector<int> preorder(Node* root) {
+          if(!root)   return res;
+          res.push_back(root -> val);
+          for(auto i : root -> children){
+              preorder(i);
+          }
+          return res;
+      }
+  };
+  ```
+
+  
+
+- HeapSort ：自学 https://www.geeksforgeeks.org/heap-sort/
+
+# 总结
+
++ 集合哈希理论已经看了好几遍，之前有关的题目也都重新刷了
++ 用递归法实现树已经十分了解，已用代码测试，也看了老师发的可视化网站。
++ 迭代法不是太熟，还是要多多熟练。
++ 堆和二叉堆，图理论熟悉，但是相关题目尚未尝试
\ No newline at end of file
diff --git a/Week_03/README.md b/Week_03/README.md
index 50de3041..cc84d5fb 100644
--- a/Week_03/README.md
+++ b/Week_03/README.md
@@ -1 +1,49 @@
-学习笔记
\ No newline at end of file
+# 作业
+
++ [二叉树的最近公共祖先](https://leetcode-cn.com/problems/lowest-common-ancestor-of-a-binary-tree/)
+
+  ```c++
+  class Solution {
+  public:
+      TreeNode* ans;
+      bool dfs(TreeNode* root, TreeNode* p, TreeNode* q) {
+          if (root == nullptr) return false;
+          bool lson = dfs(root->left, p, q);
+          bool rson = dfs(root->right, p, q);
+          if ((lson && rson) || ((root->val == p->val || root->val == q->val) && (lson || rson))) {
+              ans = root;
+          } 
+          return lson || rson || (root->val == p->val || root->val == q->val);
+      }
+      TreeNode* lowestCommonAncestor(TreeNode* root, TreeNode* p, TreeNode* q) {
+          dfs(root, p, q);
+          return ans;
+      }
+  };
+  ```
+
++ [组合](https://leetcode-cn.com/problems/combinations/)
+
+  ```c++
+  class Solution:
+      def combine(self, n: int, k: int) -> List[List[int]]:
+          if n < k or n < 1:
+              return []
+          if k == 0:
+              return [[]]
+          if n == k:
+              return [[i for i in range(1, n+1)]]
+          ans1 = self.combine(n-1, k-1)
+          ans2 = self.combine(n-1, k)
+          print(n, k, ans1, ans2)
+          if ans1:
+              for i in ans1:
+                  i.append(n)
+          return ans1+ans2
+  
+  ```
+
+# 总结
+
++ 本结知识确实比较薄弱，还需要多刷题，多理解。
++ 记住模板之后再刷题效果确实会好很多。
\ No newline at end of file
diff --git a/Week_04/README.md b/Week_04/README.md
index 50de3041..bca7048f 100644
--- a/Week_04/README.md
+++ b/Week_04/README.md
@@ -1 +1,177 @@
-学习笔记
\ No newline at end of file
+# 本周作业
+
+- [柠檬水找零](https://leetcode-cn.com/problems/lemonade-change/description/)（亚马逊在半年内面试中考过）
+
+  ```c++
+  class Solution {
+  public:
+      bool lemonadeChange(vector<int>& bills) {
+          // 贪心
+          map<int, int> have;
+          for (int i = 0; i < bills.size(); i++) {
+              // 模拟 加 贪心
+              if (bills[i] == 5) {
+                  if (have.count(5) == 1) have[5] += 1;
+                  else have[5] = 1;
+              } else if (bills[i] == 10) {
+                  // 先判断是否有钱找
+                  if (have.count(5) == 1 && have[5] > 0) have[5] -= 1;
+                  else return false;
+                  // 拿10元
+                  if (have.count(10) == 1) have[10] += 1;
+                  else have[10] = 1;
+              // 给20的可以贪心，因为希望保留5元 有10元就给10元
+              } else {
+                  // 有10元
+                  if (have.count(10) == 1 && have[10] > 0) {
+                      have[10] -= 1;
+                      // 有5元找5元， 没有五元直接错误
+                      if (have.count(5) == 1 && have[5] > 0) have[5] -= 1;
+                      else return false;
+                  // 没有10元
+                  } else {
+                      if (have.count(5) == 1 && have[5] >= 3) have[5] -= 3;
+                      else return false;
+                  }
+              }  
+          }
+          return true;
+      }
+  };
+  ```
+
+- [买卖股票的最佳时机 II ](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/description/)（亚马逊、字节跳动、微软在半年内面试中考过）
+
+  ```c++
+  class Solution {
+  public:
+      int maxProfit(vector<int>& prices) {
+          // 双指针
+          int left = 0, right, ans = 0;
+          while (left < prices.size()) {
+              // 确定最小的做指针
+              while (left + 1 < prices.size() && prices[left + 1] < prices[left]) left++;
+              right = left + 1;
+              // 确定最大的右指针
+              while (right + 1 < prices.size() && prices[right + 1] > prices[right]) right++;
+              if (right < prices.size()) ans += prices[right] -prices[left];
+              // 下一次从 right + 1 开始
+              left = right + 1;
+          }
+          return ans;
+      }
+  };
+  ```
+
+- [分发饼干](https://leetcode-cn.com/problems/assign-cookies/description/)（亚马逊在半年内面试中考过）
+
+  ```c++
+  class Solution:
+      def findContentChildren(self, g: List[int], s: List[int]) -> int:
+          s.sort()
+          g.sort()
+          len_s = len(s)
+          len_g = len(g)
+          # 贪心
+          i = j = result = 0
+          while i < len_g and j < len_s:
+              if s[j] >= g[i]:
+                  result += 1
+                  i += 1
+              j += 1
+          return result
+  ```
+
+- [岛屿数量](https://leetcode-cn.com/problems/number-of-islands/)（近半年内，亚马逊在面试中考查此题达到 350 次）
+
+  - BFS
+
+  ```c++
+  class Solution {
+  public:
+      int numIslands(vector<vector<char>>& grid) {
+          int count = 0;
+          for (int row = 0; row < grid.size(); row++) {
+              for (int col = 0; col < grid[0].size(); col++) {
+                  if (grid[row][col] == '1') {
+                      bfs(row, col, grid);
+                      count++;
+                  }
+              }
+          }
+          return count;
+      }
+      void bfs(int row, int col, vector<vector<char>>& grid) {
+          queue<pair<int, int>> que;
+          que.push({row, col});
+          // 下面一行是先访问再入队列的写法。
+          grid[row][col] = '0';
+          int maxrow = grid.size();
+          int maxcol = grid[0].size();
+          // 队列保证一层数据在一起   如果每次遍历一层再访问，那么每一层的每一个元素会多很多重复操作（周围），每次入队列的时候就visited会减少时间复杂度
+          while (!que.empty()) {
+              // 访问当前值
+              pair<int, int> cur = que.front();
+              que.pop();
+              int i = cur.first;
+              int j = cur.second;
+              // grid[i][j] = '0';
+              // 下一层入队列 左右上下
+              if (0 <= i - 1 && grid[i - 1][j] == '1') {
+                  que.push({i - 1, j});
+                  grid[i - 1][j] = '0';
+              } 
+              if (i + 1 < maxrow && grid[i + 1][j] == '1') {
+                  que.push({i + 1, j});
+                  grid[i + 1][j] = '0';
+              } 
+              if (0 <= j - 1 && grid[i][j - 1] == '1'){
+                  que.push({i, j - 1});
+                  grid[i][j - 1] = '0';
+              } 
+              if (j + 1 < maxcol && grid[i][j + 1] == '1') {
+                  que.push({i, j + 1});
+                  grid[i][j + 1] = '0';
+              } 
+          }
+      }
+  };
+  ```
+
+  + DFS
+
+    ```c++
+    class Solution:
+        def numIslands(self, grid: List[List[str]]) -> int:
+            result = 0
+            for row in range(len(grid)):
+                for col in range(len(grid[0])):
+                    if grid[row][col] == '1':
+                        self.dfs(row, col, grid)
+                        result += 1
+            return result
+    
+        
+        def dfs(self, row, col, grid):
+            # terminal 
+            if row < 0 or col < 0 or row >= len(grid) or col >= len(grid[0]) or grid[row][col] != '1':
+                return 
+            # visited
+            grid[row][col] = '0'
+    
+            # next
+            self.dfs(row - 1, col, grid)
+            self.dfs(row + 1, col, grid)
+            self.dfs(row, col - 1, grid)
+            self.dfs(row, col + 1, grid) 
+    
+    ```
+
+    
+
+# 本周总结
+
++ 本周是之前一直比较害怕，目前学习自己感觉还是很满意的。
++ 对于分治、回溯感觉还是比较模糊
++ 深度优先于广度优先在做岛屿数量时有了更清晰的理解。
++ 二分查找，小细节很多，思想一直会，但是还是得多敲代码。
\ No newline at end of file
diff --git a/Week_06/README.md b/Week_06/README.md
index 50de3041..4b19813c 100644
--- a/Week_06/README.md
+++ b/Week_06/README.md
@@ -1 +1,61 @@
-学习笔记
\ No newline at end of file
+
+
+# 作业
+
+- [最小路径和](https://leetcode-cn.com/problems/minimum-path-sum/)（亚马逊、高盛集团、谷歌在半年内面试中考过）
+
+  ```c++
+  class Solution {
+  public:
+      int minPathSum(vector<vector<int>>& grid) {
+          int m = grid.size(), n = grid[0].size();
+          for (int i = 0; i < m; i++) {
+              for (int j = 0; j < n; j++) {
+                  // 边界只有一种走法  
+                  if (i == 0) {
+                      if (j > 0) grid[i][j] += grid[i][j - 1];
+                  } 
+                  else if (j == 0) {
+                      if (i > 0) grid[i][j] += grid[i - 1][j];
+                  }
+                  // 内部取最小值走
+                  else {
+                      grid[i][j] += min(grid[i - 1][j], grid[i][j - 1]);
+                  }
+              }
+          }
+          return grid[m - 1][n - 1];
+      }
+  };
+  ```
+
+- [最小覆盖子串](https://leetcode-cn.com/problems/minimum-window-substring/)（Facebook 在半年内面试中常考）
+
+  ```c++
+  class Solution {
+  public:
+      string minWindow(string s, string t) {
+          vector<int> worker(128, 0);
+          for (char &c : t) ++worker[c];
+          int l = 0, r = 0, n = t.size(), len = INT_MAX, start = 0;
+          while (r < s.size()) {
+              // 非t类字母永远 >= 0
+              if (worker[s[r++]]-- > 0) --n; 
+              while (!n) {
+                  if (r - l < len) len = r - (start = l);
+                  // t类字母永远 <= 0
+                  if (++worker[s[l++]] > 0) ++n;
+              }
+          }
+          return len == INT_MAX ? "" : s.substr(start, len);
+      }
+  };
+  
+  ```
+
+# 总结
+
++ 本周一直在刷课上的题目，作业写的少了点。。。
++ 理解上确实比较复杂，所以刷题，思考到最后写出来，以及看优秀题解都花了很久。
++ 视频基本上看了3遍左右。不过确实找到感觉了，后面我会慢慢把这些题目刷完。
++ 爬楼梯，兑换硬币以及最小路径问题，理解的比较深入，也尝试过多种解法。觉得状态和本身的值老是会混淆。现在再看就有种豁然开朗的感觉。
\ No newline at end of file
diff --git a/Week_07/README.md b/Week_07/README.md
index 50de3041..d07361f5 100644
--- a/Week_07/README.md
+++ b/Week_07/README.md
@@ -1 +1,121 @@
-学习笔记
\ No newline at end of file
+# 作业
+
+- [朋友圈](https://leetcode-cn.com/problems/friend-circles)（亚马逊、Facebook、字节跳动在半年内面试中考过）
+
+  ```c++
+  class Solution:
+      def findCircleNum(self, isConnected: List[List[int]]) -> int:
+          def find(index: int) -> int:
+              if parent[index] != index:
+                  parent[index] = find(parent[index])
+              return parent[index]
+          
+          def union(index1: int, index2: int):
+              parent[find(index1)] = find(index2)
+          
+          provinces = len(isConnected)
+          parent = list(range(provinces))
+          
+          for i in range(provinces):
+              for j in range(i + 1, provinces):
+                  if isConnected[i][j] == 1:
+                      union(i, j)
+          
+          circles = sum(parent[i] == i for i in range(provinces))
+          return circles
+  ```
+
+- [岛屿数量](https://leetcode-cn.com/problems/number-of-islands/)（近半年内，亚马逊在面试中考查此题达到 361 次）
+
+  ```c++
+  class Solution {
+  private:
+      void dfs(vector<vector<char>>& grid, int r, int c) {
+          int nr = grid.size();
+          int nc = grid[0].size();
+  
+          grid[r][c] = '0';
+          if (r - 1 >= 0 && grid[r-1][c] == '1') dfs(grid, r - 1, c);
+          if (r + 1 < nr && grid[r+1][c] == '1') dfs(grid, r + 1, c);
+          if (c - 1 >= 0 && grid[r][c-1] == '1') dfs(grid, r, c - 1);
+          if (c + 1 < nc && grid[r][c+1] == '1') dfs(grid, r, c + 1);
+      }
+  
+  public:
+      int numIslands(vector<vector<char>>& grid) {
+          int nr = grid.size();
+          if (!nr) return 0;
+          int nc = grid[0].size();
+  
+          int num_islands = 0;
+          for (int r = 0; r < nr; ++r) {
+              for (int c = 0; c < nc; ++c) {
+                  if (grid[r][c] == '1') {
+                      ++num_islands;
+                      dfs(grid, r, c);
+                  }
+              }
+          }
+  
+          return num_islands;
+      }
+  };
+  ```
+
+- [括号生成](https://leetcode-cn.com/problems/generate-parentheses/)（亚马逊、Facebook、字节跳动在半年内面试中考过）
+
+  ```c++
+  class Solution {
+  public:
+      vector<string> generateParenthesis(int n) {
+          vector<string> res;
+          int lc = 0, rc = 0;
+          dfs(res, "", n, lc, rc);
+          return res;
+      }
+      void dfs(vector<string>& res, string path, int n, int lc, int rc) {
+          if (rc > lc || lc > n || rc > n) return;
+          if (lc == rc && lc == n) {
+              res.push_back(path);
+              return;
+          }
+          dfs(res, path + '(', n, lc + 1, rc);
+          dfs(res, path + ')', n, lc, rc + 1);
+      }
+  };
+  ```
+
+- [单词接龙](https://leetcode-cn.com/problems/word-ladder/)（亚马逊、Facebook、谷歌在半年内面试中考过）
+
+```c++
+class Solution(object):
+    def ladderLength(self, beginWord, endWord, wordList):
+        st=set(wordList)
+        if endWord not in st:
+            return 0
+        m=len(beginWord)        
+
+        queue=collections.deque()        
+        queue.append((beginWord,1))
+
+        visited=set()
+        visited.add(beginWord)
+
+        while queue:
+            cur,step=queue.popleft()
+            if cur==endWord:
+                return step
+            
+            for i in range(m):                
+                for j in range(26):
+                    tmp=cur[:i]+chr(97+j)+cur[i+1:]
+                    if tmp not in visited and tmp in st:
+                        queue.append((tmp,step+1))
+                        visited.add(tmp)
+
+        return 0
+```
+
+# 总结
+
++ 觉得学起来有点难度，最近比较忙时间少。慢慢把题目补起来吧。
\ No newline at end of file
diff --git a/Week_08/README.md b/Week_08/README.md
index 50de3041..b05fa8f9 100644
--- a/Week_08/README.md
+++ b/Week_08/README.md
@@ -1 +1,113 @@
-学习笔记
\ No newline at end of file
+# 第八周学习笔记
+
+## 布隆过滤器和LRU缓存
+
+### 布隆过滤器
+
+布隆过滤器添加元素
+
+1. 将要添加的元素给k个哈希函数
+2. 得到对应于位数组上的k个位置
+3. 将这k个位置设为1
+
+布隆过滤器查询元素
+
+1. 将要查询的元素给k个哈希函数
+2. 得到对应于位数组上的k个位置
+3. 如果k个位置有一个为0，则肯定不在集合中
+4. 如果k个位置全部为1，则可能在集合中
+
+特点
+
+- 空间效率和查询效率高
+- 有一定的误判率（哈希表是精确匹配）
+
+### LRU缓存
+
+```
+class LRUCache(object):
+
+    def __init__(self, capacity):
+        """
+        :type capacity: int
+        """
+        self.dic = OrderedDict()
+        self.remain = capacity
+
+
+    def get(self, key):
+        """
+        :type key: int
+        :rtype: int
+        """
+        if key not in self.dic:
+            return -1
+        value = self.dic.pop(key)
+        self.dic[key] = value
+        return value
+
+
+    def put(self, key, value):
+        """
+        :type key: int
+        :type value: int
+        :rtype: None
+        """
+        if key in self.dic:
+            self.dic.pop(key)
+        else:
+            if self.remain > 0:
+                self.remain -= 1
+            else:
+                self.dic.popitem(last=False)
+        self.dic[key] = value
+```
+
+## 排序算法
+
+### 快速排序
+
+```
+def quick_sort(A,left,right):  # 这个本质思想就是确定中间一个值的位置,并把小于中间值的放到中间值前面，大于的放到后面
+    if left < right:
+        mid = partition(A,left,right)  
+        quick_sort_c(A, left, mid-1) 
+        quick_sort_c(A, mid+1, right)
+    
+def partition(A,left,right):  # 把小于pivot的值放前面，大于q的值放后面
+    pivot = A[right]  # 确定中间值的位置，一般是第一个、中间一个和最后一个数字
+    i = left
+    for j in range(left,right):
+        if A[j] < pivot:
+            A[j],A[i] = A[i],A[j]
+            i+=1
+    A[right],A[i] = A[i],A[right]
+    return i
+```
+
+### 归并排序
+
+```
+def merge(nums,left,mid,right):
+    i, j = left, mid+1
+    tmp=[]
+    while i <= mid and j <= right:
+        if nums[i] <= nums[j]:
+            tmp.append(nums[i])
+            i += 1
+        else:
+            tmp.append(nums[j])
+            j += 1
+    if i > mid:
+        tmp += nums[j:right+1]
+    else:
+        tmp += nums[i:mid+1]
+    nums[left:right+1] = tmp
+
+def merge_sort(nums,left,right):
+    if left >= right:return
+    mid = (left + right) >> 1
+    merge_sort(nums, left, mid)
+    merge_sort(nums, mid+1, right)
+    merge(nums, left, mid, right)
+```
\ No newline at end of file
diff --git a/Week_09/README.md b/Week_09/README.md
index 50de3041..14bd40a1 100644
--- a/Week_09/README.md
+++ b/Week_09/README.md
@@ -1 +1,53 @@
-学习笔记
\ No newline at end of file
+#### 分治法递归模板
+
+```
+private static int divide_conquer(Problem problem, ) {
+  
+  if (problem == NULL) {
+    int res = process_last_result();
+    return res;     
+  }
+  subProblems = split_problem(problem)
+  
+  res0 = divide_conquer(subProblems[0])
+  res1 = divide_conquer(subProblems[1])
+  
+  result = process_result(res0, res1);
+  
+  return result;
+}
+```
+
+#### dp
+
+```
+public void recur(int level, int param) {   
+    // terminator
+    if (level > MAX_LEVEL) {
+        // process result 
+        return;
+    }  
+    // process current logic
+    process(level, param);
+    // drill down
+    recur( level: level + 1, newParam);
+    // restore current status
+}
+```
+
+#### 分治
+
+```
+private static int divide_conquer(Problem problem, ) {
+    if (problem == NULL) {
+        int res = process_last_result();
+        return res;
+    }  
+    subProblems = split_problem(problem);
+    res0 = divide_conquer(subProblems[0]);
+    res1 = divide_conquer(subProblems[1]);
+    // res...
+    result = process_result(res0, res1, ...);
+    return result;
+}
+```
\ No newline at end of file
diff --git "a/Week_\346\257\225\344\270\232\346\200\273\347\273\223/README.md" "b/Week_\346\257\225\344\270\232\346\200\273\347\273\223/README.md"
index 50de3041..e2da3f79 100644
--- "a/Week_\346\257\225\344\270\232\346\200\273\347\273\223/README.md"
+++ "b/Week_\346\257\225\344\270\232\346\200\273\347\273\223/README.md"
@@ -1 +1,19 @@
-学习笔记
\ No newline at end of file
+# 毕业总结
+
+### 做题
+
++ 首先最重要的就是五毒神掌真的十分有用。
++ 其次就是看高票题解，更加追求简洁代码。
++ 通过算法训练营系统的了解所有算法知识点，刷题更有目的性。
++ 最后就是坚持刷题，虽然有一段时间刷题有点跟不上，但是总体上还算是坚持下来了。
+
++ 还有就是背常用的代码模板。在做题上直接写上模板可以提高正确率。
+
+### 计划
+
++ 关于红黑树，背包问题，等知识点还要继续深入学习。
++ 坚持是学习最重要的。一直坚持，希望在将毕业之际可以找到心仪的工作。
+
+### 祝愿
+
+​	是非感谢极客时间，感谢覃超老师，班班，希望可以帮助更多的同学。也很庆幸自己选择了极客大学。
\ No newline at end of file
diff --git a/desktop.ini b/desktop.ini
new file mode 100644
index 00000000..5de1e095
--- /dev/null
+++ b/desktop.ini
@@ -0,0 +1,6 @@
+[.ShellClassInfo]
+IconResource=C:\WINDOWS\System32\SHELL32.dll,4
+[ViewState]
+Mode=
+Vid=
+FolderType=Generic