diff --git a/Week_01/W01#0011_maxArea.cpp b/Week_01/W01#0011_maxArea.cpp
new file mode 100644
index 0000000..6cc564a
--- /dev/null
+++ b/Week_01/W01#0011_maxArea.cpp
@@ -0,0 +1,34 @@
+class Solution {
+public:
+    int maxArea(vector<int>& height) {
+        int i, j;
+        int hi, hj;
+        int s;
+
+        i = 0;
+        hi = height[i];
+        j = height.size() - 1;
+        hj = height[j];
+
+        s = 0;
+
+        while (i < j)
+        {
+            s = max(s, (j-i)*min(hi, hj));
+
+            if (hi <= hj)
+            {
+                ++i;
+                hi = height[i];
+            }
+            else
+            {
+                --j;
+                hj = height[j];
+            }
+        }
+
+        return s;
+    }
+};
+
diff --git a/Week_01/W01#0020_isValid.cpp b/Week_01/W01#0020_isValid.cpp
new file mode 100644
index 0000000..4ec343e
--- /dev/null
+++ b/Week_01/W01#0020_isValid.cpp
@@ -0,0 +1,26 @@
+class Solution {
+public:
+    bool isValid(string s) {
+        stack<char> stck;
+        int n = s.size();
+
+        for (int i = 0; i < n; ++i)
+        {
+            if (s[i] == '(' || s[i] == '[' || s[i] == '{')
+                stck.push(s[i]);
+            else if (stck.empty())
+                return false;
+            else if (s[i] == ')' && stck.top() == '(')
+                stck.pop();
+            else if (s[i] == ']' && stck.top() == '[')
+                stck.pop();
+            else if (s[i] == '}' && stck.top() == '{')
+                stck.pop();
+            else
+                return false;
+        }
+
+        return stck.empty();
+    }
+};
+
diff --git a/Week_01/W01#0155_minStack.cpp b/Week_01/W01#0155_minStack.cpp
new file mode 100644
index 0000000..84ec0c5
--- /dev/null
+++ b/Week_01/W01#0155_minStack.cpp
@@ -0,0 +1,39 @@
+class MinStack {
+public:
+    /** initialize your data structure here. */
+    int minStack[7500], mn[7500];
+    int i = 0;
+
+    MinStack() {
+        
+    }
+    
+    void push(int x) {
+        minStack[i] = x;
+        if (i) mn[i] = min(mn[i-1], x);
+        else mn[i] = x;
+        ++i;
+    }
+    
+    void pop() {
+        --i;
+    }
+    
+    int top() {
+        return minStack[i-1];
+    }
+    
+    int getMin() {
+        return mn[i-1];
+    }
+};
+
+/**
+ * Your MinStack object will be instantiated and called as such:
+ * MinStack* obj = new MinStack();
+ * obj->push(x);
+ * obj->pop();
+ * int param_3 = obj->top();
+ * int param_4 = obj->getMin();
+ */
+
diff --git a/Week_02/W02#0001_twoSum.cpp b/Week_02/W02#0001_twoSum.cpp
new file mode 100644
index 0000000..cf56011
--- /dev/null
+++ b/Week_02/W02#0001_twoSum.cpp
@@ -0,0 +1,20 @@
+class Solution {
+public:
+    vector<int> twoSum(vector<int>& nums, int target) {
+       int i, j, k;
+       for (i=0; i<nums.size(); ++i) 
+       {
+           for (j=i+1; j<nums.size(); ++j)
+           {
+               //if (j == i)  continue;
+               if (nums[i] + nums[j] == target)
+               {
+                   return {j, i};
+               }
+           }
+       }
+
+       return {};
+    }
+};
+
diff --git a/Week_02/W02#0049_groupAnagrams.cpp b/Week_02/W02#0049_groupAnagrams.cpp
new file mode 100644
index 0000000..aea3c39
--- /dev/null
+++ b/Week_02/W02#0049_groupAnagrams.cpp
@@ -0,0 +1,36 @@
+class Solution {
+public:
+    vector<vector<string> > groupAnagrams(vector<string>& strs)
+    {
+        vector<pair<string, int> > str2;
+        vector<vector<string> > ans;
+        vector<string> temp;
+        string tmp;
+        int n = strs.size();
+        int l, r;
+        int i, j;
+
+        for (i = 0; i < n; ++i)
+        {
+            tmp = strs[i];
+            sort(tmp.begin(), tmp.end());
+            str2.emplace_back(make_pair(tmp, i));
+        }
+        sort(str2.begin(), str2.end());
+        
+        l = 0; r = 0;
+        for (i = 0; r < n; ++i)
+        {
+            while (r < n && str2[l].first == str2[r].first)
+                ++r;
+            for (j = l; j < r; ++j)
+                temp.emplace_back(strs[str2[j].second]);
+            ans.emplace_back(temp);
+            temp.clear();
+            l = r;
+        }
+
+        return ans;
+    }
+};
+
diff --git a/Week_03/W03#0046_permute.py b/Week_03/W03#0046_permute.py
new file mode 100644
index 0000000..d376614
--- /dev/null
+++ b/Week_03/W03#0046_permute.py
@@ -0,0 +1,4 @@
+class Solution:
+    def permute(self, nums: List[int]) -> List[List[int]]:
+        return list(itertools.permutations(nums))
+
diff --git a/Week_03/W03#0047_permuteUnique.py b/Week_03/W03#0047_permuteUnique.py
new file mode 100644
index 0000000..e8f52bd
--- /dev/null
+++ b/Week_03/W03#0047_permuteUnique.py
@@ -0,0 +1,19 @@
+class Solution:
+    def permuteUnique(self, nums: List[int]) -> List[List[int]]:
+
+        def backtrack(current_len = 0):
+            if current_len == n:  
+                res.append(nums[:])
+                return
+            backtrack(current_len + 1)
+            for i in range(0, current_len):
+                nums[current_len], nums[i] = nums[i], nums[current_len]
+                backtrack(current_len + 1)
+                nums[current_len], nums[i] = nums[i], nums[current_len]
+        
+        nums.sort()
+        n = len(nums)
+        res = []
+        backtrack()
+        return res
+
diff --git a/Week_04/W04#0045_jump.cpp b/Week_04/W04#0045_jump.cpp
new file mode 100644
index 0000000..6217603
--- /dev/null
+++ b/Week_04/W04#0045_jump.cpp
@@ -0,0 +1,21 @@
+class Solution {
+public:
+    int jump(vector<int>& nums) {
+        int end = 0;  //最远可及处
+        int currend;
+        int size = nums.size();
+        int step = 0;
+        for (int i = 0; (i < size) && (i <= end); ) {
+            if (end >= size - 1)  return step;
+            currend = end;
+            while (i <= currend) {
+                end = max(end, nums[i] + i);
+                ++i;
+            }
+            ++step;
+            // if (end >= size - 1)  return step;
+        }
+
+        return -1; //不可及
+    }
+};
diff --git a/Week_04/W04#0055_canJump.cpp b/Week_04/W04#0055_canJump.cpp
new file mode 100644
index 0000000..a6f99ad
--- /dev/null
+++ b/Week_04/W04#0055_canJump.cpp
@@ -0,0 +1,13 @@
+class Solution {
+public:
+    bool canJump(vector<int>& nums) {
+        int end = 0;
+        int size = nums.size();
+        for (int i = 0; (i < size) && (i <= end); ++i) {
+            end = max(end, nums[i] + i);
+            if (end >= (size - 1))  return true;
+        }
+        return false;
+    }
+};
+
diff --git a/Week_06/README.md b/Week_06/README.md
index 50de304..d71cf6f 100644
--- a/Week_06/README.md
+++ b/Week_06/README.md
@@ -1 +1,64 @@
-瀛︿範绗旇
\ No newline at end of file
+学习笔记
+
+DP五步骤：
+
+1、定义状态
+
+2、状态转移方程（含边界条件）
+
+3、初始化
+
+4、计算顺序（注意避免下标越界）
+
+5、结果
+
+-------------
+
+以 leetcode#63 “不同路径2” 为例：
+
+1、定义状态
+
+    dp[i][j] = 从左上角(0,0)到(i,j)的路径条数
+
+2、状态转移方程（含边界条件）
+
+    if obstacleGrid[i][j] == 1:
+
+        dp[i][j] = 0
+    
+    else:
+
+        dp[i][j] = dp[i][j-1] + dp[i-1][j]
+    
+    (边界条件：需满足i-1/j-1>=0)
+
+3、初始化
+
+    m = len(obstacleGrid)
+
+    n = len(obstacleGrid[0])
+
+    dp = [[0 for _ in range(n)] for _ in range(m)]
+
+    dp[0][0] = 1 if obstacleGrid[0][0] == 0 else 0
+
+4、计算顺序（注意避免下标越界）
+
+    for i in range(1, m):
+
+        dp[i][0] = 0 if obstacleGrid[i][0] == 1 else min(1, dp[i-1][0])
+    
+    for j in range(1, n):
+    
+        dp[0][j] = 0 if obstacleGrid[0][j] == 1 else min(1, dp[0][j-1])
+    
+    for i in range(1, m):
+
+        for j in range(1, n):
+    
+            状态转移方程（按以上顺序，已自然满足边界条件 i-1/j-1 >= 0）
+5、结果
+
+    dp[m-1][n-1]
+
+
diff --git a/Week_06/W06#0064_minPathSum.py b/Week_06/W06#0064_minPathSum.py
new file mode 100644
index 0000000..e478401
--- /dev/null
+++ b/Week_06/W06#0064_minPathSum.py
@@ -0,0 +1,45 @@
+class Solution:
+    def minPathSum(self, grid: List[List[int]]) -> int:
+        m = len(grid)
+        n = len(grid[0])
+
+        if m==0 or n==0: return 0
+
+        dp = [[0 for _ in range(n)]  for _ in range(m)]
+        dp[0][0] = grid[0][0]
+
+        for i in range(1,m): dp[i][0] = dp[i-1][0] + grid[i][0]
+        for j in range(1,n): dp[0][j] = dp[0][j-1] + grid[0][j]
+
+        for i in range(1,m):
+            for j in range(1,n):
+                dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1])
+        
+        return dp[m-1][n-1]
+
+        """
+1、定义状态
+   dp[i,j]表示从左上角(0,0)到坐标（i,j）的最小路径和
+  m = len(grid)
+  n = len(grid[0])
+  左上角dp[0][0]
+  右下角dp[m][n]
+2、状态转移（描述边界条件）
+  dp[i][j] = grid[i][j] + min(dp[i-1][j], dp[i][j-1])
+  （边界条件：要保证 i-1>=0, j-1>=0 即 i>0, j>0）
+3、初始化
+  dp[0][0] = grid[0][0]
+4、计算顺序
+  为保证第2点中的边界条件，
+  应首先单独计算dp[0][j]及dp[i][0]
+  后续双重循环迭代即可，无须再判边界条件
+  注：形如
+                  dp[i][j] = grid[i][j] + \
+                            min( dp[i-1][j] if i>0 else float('inf'), \
+                                 dp[i][j-1] if j>0 else float('inf')  )
+   这样的语句会list index out of range，
+   因为在执行if子句前已经先执行了dp[i-1][j]
+   故而只能采取上述 先首行首列 再迭代 的顺序
+5、结果
+    dp[m-1][n-1]
+"""
diff --git a/Week_06/W06#0091_numDecodings.py b/Week_06/W06#0091_numDecodings.py
new file mode 100644
index 0000000..69f61c5
--- /dev/null
+++ b/Week_06/W06#0091_numDecodings.py
@@ -0,0 +1,71 @@
+class Solution:
+    def numDecodings(self, s: str) -> int:
+        n = len(s)
+
+        if n==0: return 0
+        if s[0]=='0': return 0
+
+        dp = [0]*(n+1)
+        dp[0], dp[1] = 1, 1
+
+        for i in range(2, n+1):
+            if s[i-1]=='0':                 #XXXXXXXXX[0]
+                if s[i-2] in {'1','2'}:         #XXXX[1-2][0]
+                    dp[i] = dp[i-2]
+                else:                           #XXXX[3-9,0][0]
+                    return 0
+            elif s[i-1]<='6':               #XXXXXXXXX[1-6]
+                if s[i-2] in {'1','2'}:         #XXXX[1-2][1-6]
+                    dp[i] = dp[i-2] + dp[i-1]
+                else:                           #XXXX[3-9,0][1-6]
+                    dp[i] = dp[i-1]
+            else:                           #XXXXXXXXX[7-9]
+                if s[i-2] == '1':               #XXXX[1][7-9]
+                    dp[i] = dp[i-2] + dp[i-1]
+                else:                           #XXXX[0,2-9][7-9]
+                    dp[i] = dp[i-1]
+            print(s[:i],dp)
+
+        print(dp)
+        return dp[n]
+
+        """
+1、定义状态
+  dp[i]为s[0:i]的，即0..(i-1)数字序列的解码总数
+  其中，dp[0]特定为1
+2、状态转移（描述边界条件）
+  计算dp[i]时，
+    if s[i-1]=='0':                 #XXXXXXXXX[0]
+        if s[i-2] in {'1','2'}:         #XXXX[1-2][0]
+            dp[i] = dp[i-2]
+        else:                           #XXXX[3-9,0][0]
+            return 0
+    elif s[i-1]<='6':               #XXXXXXXXX[1-6]
+        if s[i-2] in {'1','2'}:         #XXXX[1-2][1-6]
+            dp[i] = dp[i-2] + dp[i-1]
+        else:                           #XXXX[3-9,0][1-6]
+            dp[i] = dp[i-1]
+    else:                           #XXXXXXXXX[7-9]
+        if s[i-2] == '1':               #XXXX[1][7-9]
+            dp[i] = dp[i-2] + dp[i-1]
+        else:                           #XXXX[0,2-9][7-9]
+            dp[i] = dp[i-1]
+    
+    （由于初始化时特设dp[0],dp[1]且i从2算起，边界条件肯定满足，无需额外判定）
+
+  注1：根据示例3，以下两种特判直接返回 0
+       a)s[0]=='0' 则直接输出 0
+       b)中间出现'0'而必须与前数字结合时，只能是'10'/'20'，其他情况直接输出 0
+  注2：本题为使满足边界条件，使dp[i]与s[i-1]错了一位来对应，如下示意：
+           X  X    A         B         C         D      X  X  X
+     s[?]    ..   ...     s[i-3]    s[i-2]    s[i-1]  ...
+     dp[?]  ... dp[i-3]  dp[i-2]   dp[i-1]    dp[i]   ...
+        带来的另一影响是：dp数组共需n+1个元素[0..n]
+3、初始化
+  特判 if s[0]=='0': return 0
+  dp[0], dp[1] = 1, 1
+4、计算顺序及范围
+  i in range(2,n+1)
+5、结果
+  dp[n]
+"""
diff --git a/Week_07/W070036_isValidSudoku.py b/Week_07/W070036_isValidSudoku.py
new file mode 100644
index 0000000..2faff75
--- /dev/null
+++ b/Week_07/W070036_isValidSudoku.py
@@ -0,0 +1,33 @@
+class Solution:
+    def isValidSudoku(self, board: List[List[str]]) -> bool:
+        def judge(grid: str, ss: set) -> bool:
+            # print(grid, ss)
+            if grid==".": return True
+            if grid in ss: return False
+            ss.add(grid)
+            return True
+
+        for i in range(9):
+            set_c = set()
+            set_r = set()
+            set_b = set()
+            for j in range(9):
+                # print("3sets befor ij:",set_c, set_r, set_b)
+                if not judge(board[i][j], set_c): 
+                    print(i,j,"i,j,False!")
+                    return False
+                # print("3sets befor ji:",set_c, set_r, set_b)
+                if not judge(board[j][i], set_r): 
+                    print(i,j,"j,i,False!")
+                    return False
+                # print("3sets befor bl:",set_c, set_r, set_b)
+                block_ul_x = 3 * (i % 3)
+                block_ul_y = 3 * (i // 3)
+                grid_x = block_ul_x + (j % 3)
+                grid_y = block_ul_y + (j // 3)
+                if not judge(board[grid_x][grid_y], set_b): 
+                    # print(i,j,block_ul_x,block_ul_y,grid_x,grid_y,"block False!")
+                    return False
+        return True
+    
+
diff --git a/Week_07/W070208_Trie.py b/Week_07/W070208_Trie.py
new file mode 100644
index 0000000..216c070
--- /dev/null
+++ b/Week_07/W070208_Trie.py
@@ -0,0 +1,51 @@
+class Trie:
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        self.root = {}
+        self.end_of_word = "#"
+
+
+    def insert(self, word: str) -> None:
+        """
+        Inserts a word into the trie.
+        """
+        node = self.root
+        for char in word:
+            node = node.setdefault(char, {})
+        node[self.end_of_word] = self.end_of_word
+
+
+    def search(self, word: str) -> bool:
+        """
+        Returns if the word is in the trie.
+        """
+        node = self.root
+        for char in word:
+            if char not in node:
+                return False
+            node = node[char]
+        return self.end_of_word in node
+
+
+    def startsWith(self, prefix: str) -> bool:
+        """
+        Returns if there is any word in the trie that starts with the given prefix.
+        """
+        node = self.root
+        for char in prefix:
+            if char not in node:
+                return False
+            node = node[char]
+        return True
+
+
+
+# Your Trie object will be instantiated and called as such:
+# obj = Trie()
+# obj.insert(word)
+# param_2 = obj.search(word)
+# param_3 = obj.startsWith(prefix)
+
diff --git a/Week_07/W070212_findWords.py b/Week_07/W070212_findWords.py
new file mode 100644
index 0000000..f9bab48
--- /dev/null
+++ b/Week_07/W070212_findWords.py
@@ -0,0 +1,35 @@
+class Solution:
+    def findWords(self, board: List[List[str]], words: List[str]) -> List[str]:
+        # 鏍规嵁words寤虹珛Trie鏍�
+        trie = {}
+        for word in words:
+            node = trie
+            for char in word:
+                node = node.setdefault(char, {})
+            node['#'] = True
+
+        # dfs锛氭悳绱� board 涓槸鍚﹀瓨鍦ㄤ笌 words 鍒楄〃鐩稿悓鐨勫崟璇�
+        def dfs(i, j, node, pre, visited):  #(i,j)褰撳墠鍧愭爣锛宯ode褰撳墠缁撶偣锛宲re鍓嶉潰鐨勫瓧绗︿覆锛寁isited宸茶闂潗鏍�
+            if '#' in node:
+                # res.add(pre)
+                res.append(pre) ; node.pop('#')       #pop key鍘婚噸锛屽垯res鍙洿鎺ョ敤list
+            for (di, dj) in ((-1, 0), (1, 0), (0, -1), (0, 1)):            #Py鎶�宸э細浠ュ厓缁勬潵瀹炵幇鍒嗙粍閬嶅巻
+                _i, _j = i+di, j+dj
+                if 0 <= _i < m and 0 <= _j < n:                            #Py璇硶锛氭敮鎸� a<b<c
+                    _b = board[_i][_j]
+                    if _b in node and (_i, _j) not in visited:
+                        dfs(_i, _j, node[_b], pre+_b, visited+((_i,_j),))  #Py瀹炶返锛氬厓缁勬瘮闆嗗悎蹇�5%宸﹀彸
+                        # dfs(_i, _j, node[_b], pre+_b, visited.union({(_i,_j)}))
+                        # dfs(_i, _j, node[_b], pre+_b, visited|{(_i,_j)})
+
+        # 瀵� board 閬嶅巻鎼滅储
+        # res, m, n = set(), len(board), len(board[0])
+        res, m, n = [], len(board), len(board[0])
+        for i in range(m):
+            for j in range(n):
+                if board[i][j] in trie:
+                    dfs(i, j, trie[board[i][j]], board[i][j], ((i,j),))    #Py瀹炶返锛氬厓缁勬瘮闆嗗悎蹇�5%宸﹀彸
+                    # dfs(i, j, trie[board[i][j]], board[i][j], {(i,j)})
+        # return list(res)
+        return res
+
diff --git a/Week_08/W080051_solveNQueens.py b/Week_08/W080051_solveNQueens.py
new file mode 100644
index 0000000..31f1b7d
--- /dev/null
+++ b/Week_08/W080051_solveNQueens.py
@@ -0,0 +1,23 @@
+class Solution:
+    def solveNQueens(self, n: int) -> List[List[str]]:
+        mask = ~((~ 0) << n)
+        ans = []
+
+        # 鍙傛暟sol涓簊tr鍨嬶紝渚濇鏀炬鐩樻渶涓婃柟level琛屽凡瑙ｅ嚭鐨囧悗鎵�鍦ㄥ垪鏁帮紝鍒楁暟浠庢渶鍙�0鍒楀悜宸﹂�掑璁℃暟
+        def dfs(sol, level, cols, pies, nas):  
+            if level == n:
+                ans.append(sol)
+                return
+            possible = ~(cols | pies | nas) & mask
+            while possible:
+                next_possible = possible & (possible-1)
+                curr_col = possible ^ next_possible
+                possible = next_possible
+                dfs(sol + chr(45 + len(bin(curr_col))), level + 1, \
+                      cols | curr_col, \
+                      (pies | curr_col) << 1, \
+                      (nas | curr_col) >> 1 )
+
+        dfs('', 0, 0, 0, 0)
+        return [["."*(n-ord(C)+48-1) + "Q" + "."*(ord(C)-48) for C in sol] for sol in ans]
+
diff --git a/Week_08/W080052_totalNQueens.py b/Week_08/W080052_totalNQueens.py
new file mode 100644
index 0000000..4732b1f
--- /dev/null
+++ b/Week_08/W080052_totalNQueens.py
@@ -0,0 +1,22 @@
+class Solution:
+    def totalNQueens(self, n: int) -> int:
+        mask = ~((~ 0) << n)
+        self.ans = 0
+
+        def dfs(level, cols, pies, nas):  
+            if level == n:
+                self.ans += 1
+                return
+            possible = ~(cols | pies | nas) & mask
+            while possible:
+                next_possible = possible & (possible-1)
+                curr_col = possible ^ next_possible
+                possible = next_possible
+                dfs(level + 1, \
+                      cols | curr_col, \
+                      (pies | curr_col) << 1, \
+                      (nas | curr_col) >> 1 )
+
+        dfs(0, 0, 0, 0)
+        return self.ans
+
diff --git a/Week_08/W080190_reverseBits.py b/Week_08/W080190_reverseBits.py
new file mode 100644
index 0000000..ed7c97c
--- /dev/null
+++ b/Week_08/W080190_reverseBits.py
@@ -0,0 +1,12 @@
+class Solution:
+    def reverseBits(self, n: int) -> int:
+        res = 0
+        for _ in range(32):
+            bit = n & 1
+            res <<= 1
+            res += bit
+            n >>= 1
+        return res
+
+        # 涓�琛屼唬鐮侊細
+        # return int("0b"+("0"*32+bin(n)[2:])[-32:][::-1], base=2)
diff --git a/Week_08/W080191_hammingWeight.py b/Week_08/W080191_hammingWeight.py
new file mode 100644
index 0000000..4a0bd15
--- /dev/null
+++ b/Week_08/W080191_hammingWeight.py
@@ -0,0 +1,8 @@
+class Solution:
+    def hammingWeight(self, n: int) -> int:
+        s = 0
+        while n != 0:
+            n &= n-1
+            s += 1
+        return s
+
diff --git a/Week_08/W080231_isPowerOfTwo.py b/Week_08/W080231_isPowerOfTwo.py
new file mode 100644
index 0000000..7b16265
--- /dev/null
+++ b/Week_08/W080231_isPowerOfTwo.py
@@ -0,0 +1,4 @@
+class Solution:
+    def isPowerOfTwo(self, n: int) -> bool:
+        if 0 == n:  return False
+        return n & n-1 == 0
diff --git a/Week_09/README.md b/Week_09/README.md
index 50de304..1d43e8d 100644
--- a/Week_09/README.md
+++ b/Week_09/README.md
@@ -1 +1,65 @@
-瀛︿範绗旇
\ No newline at end of file
+ 
+学习笔记
+
+DP五步骤：
+
+1、定义状态
+
+2、状态转移方程（含边界条件）
+
+3、初始化
+
+4、计算顺序（注意避免下标越界）
+
+5、结果
+
+-------------
+
+以 leetcode#63 “不同路径2” 为例：
+
+1、定义状态
+
+    dp[i][j] = 从左上角(0,0)到(i,j)的路径条数
+
+2、状态转移方程（含边界条件）
+
+    if obstacleGrid[i][j] == 1:
+
+        dp[i][j] = 0
+    
+    else:
+
+        dp[i][j] = dp[i][j-1] + dp[i-1][j]
+    
+    (边界条件：需满足i-1/j-1>=0)
+
+3、初始化
+
+    m = len(obstacleGrid)
+
+    n = len(obstacleGrid[0])
+
+    dp = [[0 for _ in range(n)] for _ in range(m)]
+
+    dp[0][0] = 1 if obstacleGrid[0][0] == 0 else 0
+
+4、计算顺序（注意避免下标越界）
+
+    for i in range(1, m):
+
+        dp[i][0] = 0 if obstacleGrid[i][0] == 1 else min(1, dp[i-1][0])
+    
+    for j in range(1, n):
+    
+        dp[0][j] = 0 if obstacleGrid[0][j] == 1 else min(1, dp[0][j-1])
+    
+    for i in range(1, m):
+
+        for j in range(1, n):
+    
+            状态转移方程（按以上顺序，已自然满足边界条件 i-1/j-1 >= 0）
+5、结果
+
+    dp[m-1][n-1]
+
+
diff --git a/Week_09/W090044_isMatch.py b/Week_09/W090044_isMatch.py
new file mode 100644
index 0000000..fa34459
--- /dev/null
+++ b/Week_09/W090044_isMatch.py
@@ -0,0 +1,19 @@
+class Solution:
+    def isMatch(self, s: str, p: str) -> bool:
+        if not p:  return not s
+        first_match = bool(s) and (p[0] in {s[0], '?'})
+        if p[0] == '*':
+            return self.isMatch(s, p[1:]) or \
+                    bool(s) and self.isMatch(s[1:], p)
+        else:
+            return first_match and self.isMatch(s[1:], p[1:])
+
+        """
+        注： leetcode上于 1601 / 1811 个通过测试用例 超时。 待改进
+            超时用例：
+
+"ababaaabbaabbabbababbaabbaababbaaabaabbaabbbbaabbaabab"
+"*b**a"
+
+        """
+
diff --git a/Week_09/W090387_firstUniqChar.py b/Week_09/W090387_firstUniqChar.py
new file mode 100644
index 0000000..152f637
--- /dev/null
+++ b/Week_09/W090387_firstUniqChar.py
@@ -0,0 +1,11 @@
+class Solution:
+    def firstUniqChar(self, s: str) -> int:
+        if len(s) == 0: return -1
+        dict = [0 for _ in range(256)]
+        for ch in s:
+            dict[ord(ch)] += 1
+        for i in range(len(s)):
+            ch = s[i]
+            if dict[ord(ch)] == 1: return i
+        return -1
+
diff --git a/Week_09/W090917_reverseOnlyLetters.py b/Week_09/W090917_reverseOnlyLetters.py
new file mode 100644
index 0000000..6f749df
--- /dev/null
+++ b/Week_09/W090917_reverseOnlyLetters.py
@@ -0,0 +1,27 @@
+class Solution:
+    def reverseOnlyLetters(self, S: str) -> str:
+        def isAlpha(ch):
+            return "A" <= ch <= "Z" or "a" <= ch <= "z"
+
+        n = len(S)
+        i = 0
+        j = n - 1
+        ans = ""
+        while j >= 0:
+            while i < n and not isAlpha(S[i]):
+                ans += S[i]
+                i += 1
+
+            while j >= 0 and not isAlpha(S[j]):
+                j -= 1
+            
+            if j >= 0:
+                ans += S[j]
+                j -= 1
+                i += 1
+        
+        while i < n:
+            ans += S[i]
+            i += 1
+        
+        return ans
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 50de304..f411e9a 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,32 @@
-瀛︿範绗旇
\ No newline at end of file
+
+# 毕业总结：
+
+
+## 关键方法：五毒神掌
+
+
+## 算法3阶梯：
+### 一、基础
+#### 1、基础数据结构及实现：
+   * 线性表：数组、链表、栈、队列
+   * 哈希表、映射、集合
+   * 树、图
+#### 2、编程基本功：
+   * 熟练掌握特定语言的上述基础数据结构的实现代码
+   * 掌握函数调用时嵌套的局部变量作用域、传值vs传引用、数组深拷贝vs浅拷贝等机制
+#### 3、时间、空间复杂度分析方法
+
+### 二、递归思维方式
+  * 背熟递归模板，通过树图遍历、分治、回溯等算法的练习，循序渐进地掌握、熟练运用递归思维方式。
+  * 很多算法是递归实现。这类似数学归纳法思想，关键是找到重复性，避免人肉递归。递归思维是理解高级算法的基础。
+  * BFS、DFS。DFS也用到递归思想；BFS形式上与DFS有相似处，可对照学。
+
+### 三、动态规划
+ * 动态规划初级到高级：升维、状态转移方程更复杂
+ （字符串查找、编辑距离等）
+
+### 其他算法及进阶
+ * 算法进阶：剪枝、去重优化；双向BFS；启发式搜索
+
+* 相对独立的算法：贪心、二分、字典树、并查集、位运算、布隆过滤器、LRU、AVL树与红黑树、排序
+