diff --git a/Week_01/homework1.java b/Week_01/homework1.java
new file mode 100644
index 0000000..30e54e2
--- /dev/null
+++ b/Week_01/homework1.java
@@ -0,0 +1,15 @@
+//88. 合并两个有序数组
+
+class Solution {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+        int i = m - 1, j = n - 1;
+        int idx = m + n - 1;
+        while(j >= 0){
+            if(i >= 0 && nums1[i] >= nums2[j]){
+                nums1[idx--] = nums1[i--];
+            }else{
+                nums1[idx--] = nums2[j--];
+            }
+        }    
+    }
+}
diff --git a/Week_01/homework2.java b/Week_01/homework2.java
new file mode 100644
index 0000000..0fe2a04
--- /dev/null
+++ b/Week_01/homework2.java
@@ -0,0 +1,16 @@
+//26. 删除排序数组中的重复项
+
+class Solution {
+    public int removeDuplicates(int[] nums) {
+        if(nums.length == 0)
+            return 0;
+        int j = 0;
+        for(int i = 1;i<nums.length;i++){
+            if(nums[i]!=nums[j]){
+                j++;
+                nums[j] = nums[i];
+            }
+        }
+        return j+1;
+    }  
+}
diff --git a/Week_02/homework1.java b/Week_02/homework1.java
new file mode 100644
index 0000000..2648fd2
--- /dev/null
+++ b/Week_02/homework1.java
@@ -0,0 +1,21 @@
+//242. 有效的字母异位词
+class Solution {
+    public boolean isAnagram(String s, String t) {
+        if (s.length() != t.length()) {
+            return false;
+        }
+        Map<Character, Integer> table = new HashMap<Character, Integer>();
+        for (int i = 0; i < s.length(); i++) {
+            char ch = s.charAt(i);
+            table.put(ch, table.getOrDefault(ch, 0) + 1);
+        }
+        for (int i = 0; i < t.length(); i++) {
+            char ch = t.charAt(i);
+            table.put(ch, table.getOrDefault(ch, 0) - 1);
+            if (table.get(ch) < 0) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Week_02/homework2.java b/Week_02/homework2.java
new file mode 100644
index 0000000..0b7972b
--- /dev/null
+++ b/Week_02/homework2.java
@@ -0,0 +1,26 @@
+//49. 字母异位词分组
+class Solution {
+    public List<List<String>> groupAnagrams(String[] strs) {
+        Map<String, List<String>> map = new HashMap<String, List<String>>();
+        for (String str : strs) {
+            int[] counts = new int[26];
+            int length = str.length();
+            for (int i = 0; i < length; i++) {
+                counts[str.charAt(i) - 'a']++;
+            }
+            
+            StringBuffer sb = new StringBuffer();
+            for (int i = 0; i < 26; i++) {
+                if (counts[i] != 0) {
+                    sb.append((char) ('a' + i));
+                    sb.append(counts[i]);
+                }
+            }
+            String key = sb.toString();
+            List<String> list = map.getOrDefault(key, new ArrayList<String>());
+            list.add(str);
+            map.put(key, list);
+        }
+        return new ArrayList<List<String>>(map.values());
+    }
+}
diff --git a/Week_03/homework1.java b/Week_03/homework1.java
new file mode 100644
index 0000000..018680f
--- /dev/null
+++ b/Week_03/homework1.java
@@ -0,0 +1,14 @@
+//236. 二叉树的最近公共祖先
+class Solution {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(root==null)return null;
+        if(root==p||root==q)return root;
+        TreeNode left=lowestCommonAncestor(root.left,p,q);
+        TreeNode right=lowestCommonAncestor(root.right,p,q);
+        if(left!=null&&right!=null)return root;
+        if(left!=null)return left;
+        if(right!=null)return right;
+        return null;
+    }
+}
+
diff --git a/Week_03/homework2.java b/Week_03/homework2.java
new file mode 100644
index 0000000..b406a95
--- /dev/null
+++ b/Week_03/homework2.java
@@ -0,0 +1,15 @@
+ //105. 从前序与中序遍历序列构造二叉树
+class Solution {
+    public TreeNode buildTree(int[] preorder, int[] inorder) {
+        return create(preorder,0,preorder.length-1,inorder,0,inorder.length-1);
+    }
+    public TreeNode create(int[] preorder,int l1,int r1,int[] inorder,int l2,int r2){
+        if(l1>r1) return null;
+        int val = preorder[l1], i=0;
+        TreeNode node = new TreeNode(val);
+        while(inorder[l2+i]!=val) i++;
+        node.left = create(preorder,l1+1,l1+i,inorder,l2,l2+i-1);
+        node.right = create(preorder,l1+i+1,r1,inorder,l2+i+1,+r2);
+        return node;
+    }
+}
diff --git a/Week_04/homework1.java b/Week_04/homework1.java
new file mode 100644
index 0000000..4280690
--- /dev/null
+++ b/Week_04/homework1.java
@@ -0,0 +1,66 @@
+//127. 单词接龙
+public class Solution {
+
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+       
+        Set<String> wordSet = new HashSet<>(wordList);
+        if (wordSet.size() == 0 || !wordSet.contains(endWord)) {
+            return 0;
+        }
+       
+        Set<String> visited = new HashSet<>();       
+        Set<String> beginVisited = new HashSet<>();
+        beginVisited.add(beginWord);
+        Set<String> endVisited = new HashSet<>();
+        endVisited.add(endWord);
+       
+        int step = 1;
+        while (!beginVisited.isEmpty() && !endVisited.isEmpty()) {
+            if (beginVisited.size() > endVisited.size()) {
+                Set<String> temp = beginVisited;
+                beginVisited = endVisited;
+                endVisited = temp;
+            }
+
+            
+            Set<String> nextLevelVisited = new HashSet<>();
+            for (String word : beginVisited) {
+                if (changeWordEveryOneLetter(word, endVisited, visited, wordSet, nextLevelVisited)) {
+                    return step + 1;
+                }
+            }
+            beginVisited = nextLevelVisited;
+            step++;
+        }
+        return 0;
+    }
+
+    private boolean changeWordEveryOneLetter(String word, Set<String> endVisited,
+                                             Set<String> visited,
+                                             Set<String> wordSet,
+                                             Set<String> nextLevelVisited) {
+        char[] charArray = word.toCharArray();
+        for (int i = 0; i < word.length(); i++) {
+            char originChar = charArray[i];
+            for (char c = 'a'; c <= 'z'; c++) {
+                if (originChar == c) {
+                    continue;
+                }
+                charArray[i] = c;
+                String nextWord = String.valueOf(charArray);
+                if (wordSet.contains(nextWord)) {
+                    if (endVisited.contains(nextWord)) {
+                        return true;
+                    }
+                    if (!visited.contains(nextWord)) {
+                        nextLevelVisited.add(nextWord);
+                        visited.add(nextWord);
+                    }
+                }
+            }
+            
+            charArray[i] = originChar;
+        }
+        return false;
+    }
+}
diff --git a/Week_04/homework2.java b/Week_04/homework2.java
new file mode 100644
index 0000000..1741029
--- /dev/null
+++ b/Week_04/homework2.java
@@ -0,0 +1,18 @@
+//55. 跳跃游戏
+class Solution {
+    public boolean canJump(int[] nums) {
+       
+        int minFlag = nums.length-1;
+        for (int i = nums.length - 2; i >= 1; i--) {
+           
+            if(i+nums[i]>=minFlag){
+                minFlag = i;
+            }
+        }
+        
+        if(nums[0]>=minFlag) {
+            return true;
+        }
+        return false;
+    }
+}
diff --git a/Week_06/homework1.java b/Week_06/homework1.java
new file mode 100644
index 0000000..ad6bf35
--- /dev/null
+++ b/Week_06/homework1.java
@@ -0,0 +1,28 @@
+//64. 最小路径和
+
+class Solution {
+    private int M;
+    private int N;
+    private int[][] memo;
+    public int minPathSum(int[][] grid) {
+        M = grid.length;
+        N = grid[0].length;
+        memo = new int[M][N];
+        for (int i = 0; i < M; i++) {
+            Arrays.fill(memo[i], -1);
+        }
+        return dfs(grid, 0, 0);
+    }
+
+    private int dfs(int[][] grid, int r, int c) {
+    
+        if (r < 0 || r >= M || c < 0 || c >= N) return Integer.MAX_VALUE;
+        if (memo[r][c] > -1) return memo[r][c];
+        if (r == M - 1 && c== N - 1) return grid[M - 1][N - 1];
+        int right = dfs(grid, r, c + 1);
+        int down = dfs(grid, r + 1, c);
+        int ans = Math.min(right, down) + grid[r][c];
+        memo[r][c] = ans;
+        return ans;
+    }
+}
diff --git a/Week_06/homework2.java b/Week_06/homework2.java
new file mode 100644
index 0000000..57b597a
--- /dev/null
+++ b/Week_06/homework2.java
@@ -0,0 +1,18 @@
+//32. 最长有效括号
+
+class Solution {
+    public int longestValidParentheses(String s) {
+        char[] str = s.toCharArray();
+        int[] dp = new int[str.length];
+        int max = 0;
+        for (int i = 0; i < str.length; i++) {
+            if(str[i] == '(') dp[i] = 0;
+            else if(i > 0) {
+                if(str[i - 1] == '(') dp[i] = i - 2 >= 0? dp[i - 2] + 2 : 2;
+                else if(i - dp[i - 1] - 1 >= 0 && str[i - dp[i - 1] - 1] == '(') dp[i] = i - dp[i - 1] - 2 >= 0 ? dp[i - 1] + 2 + dp[i - dp[i - 1] - 2] : dp[i - 1] + 2;
+            }else dp[i] = 0;
+            max = Math.max(max, dp[i]);
+        }
+        return max;
+    }
+}
diff --git a/Week_07/homework1.java b/Week_07/homework1.java
new file mode 100644
index 0000000..58a014b
--- /dev/null
+++ b/Week_07/homework1.java
@@ -0,0 +1,63 @@
+//208. 实现 Trie (前缀树)
+
+class Trie {
+
+    class TrieNode {
+        private int v;
+        boolean end;
+        TrieNode[] next = new TrieNode[26];
+
+        TrieNode(char ch) {
+            v = 1 << (ch - 'a');
+        }
+
+        TrieNode add(char ch) {
+            int k = ch - 'a';
+            if (next[k] != null) {
+                next[k].v |= 1 << k;
+            } else {
+                next[k] = new TrieNode((ch));
+            }
+            return next[k];
+        }
+
+        TrieNode get(char ch) {
+            return next[ch - 'a'];
+        }
+    }
+
+    TrieNode root = new TrieNode('a');
+  
+    public Trie() {}
+
+    public void insert(String word) {
+        TrieNode p = root;
+        for (char c : word.toCharArray()) {
+            p = p.add(c);
+        }
+        p.end = true;
+    }
+   
+    public boolean search(String word) {
+        TrieNode p = root;
+        for (char c : word.toCharArray()) {
+            p = p.get(c);
+            if (p == null) {
+                return false;
+            }
+        }
+        return p.end;
+    }
+
+    
+    public boolean startsWith(String prefix) {
+        TrieNode p = root;
+        for (char c : prefix.toCharArray()) {
+            p = p.get(c);
+            if (p == null) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
diff --git a/Week_07/homework2.java b/Week_07/homework2.java
new file mode 100644
index 0000000..ca16593
--- /dev/null
+++ b/Week_07/homework2.java
@@ -0,0 +1,34 @@
+ //200. 岛屿数量
+ 
+class Solution {
+    private int M;
+    private int N;
+    
+    private void dfs(char[][] grid, int i, int j) {
+        if (i < 0 || j < 0 || i == M || j == N || grid[i][j] == '0') {
+            return;
+        }
+        grid[i][j] = '0';
+        dfs(grid, i + 1, j);
+        dfs(grid, i - 1, j);
+        dfs(grid, i, j + 1);
+        dfs(grid, i, j - 1);
+    }
+    
+    public int numIslands(char[][] grid) {
+        int res = 0;
+        if (grid.length == 0) return res;
+        
+        this.M = grid.length;
+        this.N = grid[0].length;
+        for (int i = 0; i < M; i++) {
+            for (int j = 0; j < N; j++) {
+                if (grid[i][j] == '1') {
+                    dfs(grid, i, j);
+                    res++;
+                }
+            }
+        }
+        return res;
+    }
+}
diff --git a/Week_08/homework1.java b/Week_08/homework1.java
new file mode 100644
index 0000000..dd1c74a
--- /dev/null
+++ b/Week_08/homework1.java
@@ -0,0 +1,38 @@
+//56. 合并区间
+
+
+public class Solution {
+
+    public int[][] merge(int[][] intervals) {
+        int len = intervals.length;
+        if (len < 2) {
+            return intervals;
+        }      
+        Arrays.sort(intervals, Comparator.comparingInt(o -> o[0]));
+
+        List<int[]> res = new ArrayList<>();
+        res.add(intervals[0]);
+
+        for (int i = 1; i < len; i++) {
+            int[] curInterval = intervals[i];         
+            int[] peek = res.get(res.size() - 1);
+            if (curInterval[0] > peek[1]) {
+                res.add(curInterval);
+            } else {
+               
+                peek[1] = Math.max(curInterval[1], peek[1]);
+            }
+        }
+        return res.toArray(new int[res.size()][]);
+    }
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        int[][] intervals = {{1, 3}, {2, 6}, {8, 10}, {15, 18}};
+        int[][] res = solution.merge(intervals);
+        for (int i = 0; i < res.length; i++) {
+            System.out.println(Arrays.toString(res[i]));
+        }
+    }
+}
+
diff --git a/Week_08/homework2.java b/Week_08/homework2.java
new file mode 100644
index 0000000..b9d63ea
--- /dev/null
+++ b/Week_08/homework2.java
@@ -0,0 +1,26 @@
+//1122. 数组的相对排序
+
+class Solution {
+    public int[] relativeSortArray(int[] arr1, int[] arr2) {
+        int[] tmp=new int [1001];
+        int n=arr1.length;
+        for(int num:arr1){
+            tmp[num]++;
+        }
+        int pos=0;      
+        for(int num:arr2){
+            while(tmp[num]>0){
+                arr1[pos++]=num;
+                tmp[num]--;
+            }
+        }
+        for(int i=0;i<1001;++i){
+            while(tmp[i]>0){
+                arr1[pos++]=i;
+                tmp[i]--;
+            }
+        }
+        return arr1;
+    }
+}
+
diff --git a/Week_09/homework1.java b/Week_09/homework1.java
new file mode 100644
index 0000000..c25466b
--- /dev/null
+++ b/Week_09/homework1.java
@@ -0,0 +1,38 @@
+//438. 找到字符串中所有字母异位词
+
+class Solution {
+    public List<Integer> findAnagrams(String s, String p) {
+        if(s == null || s.length() == 0) return new ArrayList<>();
+        List<Integer> res = new ArrayList<>();
+        int[] needs = new int[26]; 
+        int[] window = new int[26];
+        int left = 0, right = 0, total = p.length(); 
+        for(char ch : p.toCharArray()){
+            needs[ch - 'a'] ++;
+        }
+        while(right < s.length()){
+            char chr = s.charAt(right);
+            if(needs[chr - 'a'] > 0){
+                window[chr - 'a'] ++;
+                if(window[chr - 'a'] <= needs[chr - 'a']){
+                    total --;
+                } 
+            }
+            while(total == 0){
+                if(right-left+1 == p.length()){
+                    res.add(left);
+                } 
+                char chl = s.charAt(left);
+                if(needs[chl - 'a'] > 0){
+                    window[chl - 'a'] --;
+                    if(window[chl - 'a'] < needs[chl - 'a']){
+                        total ++;
+                    } 
+                }
+                left ++;
+            }
+            right ++;
+        }
+        return res;
+    }
+}
diff --git a/Week_09/homework2.java b/Week_09/homework2.java
new file mode 100644
index 0000000..11ac89a
--- /dev/null
+++ b/Week_09/homework2.java
@@ -0,0 +1,23 @@
+//300. 最长递增子序列
+
+public class Solution {
+    public int lengthOfLIS(int[] nums) {
+        if(nums==null || nums.length==0) {
+            return 0;
+        }
+        int[] dp = new int[nums.length];
+        for(int i=0;i<dp.length;++i) {
+            dp[i] = 1;
+        }
+        for(int i=0;i<nums.length;++i) {
+            for(int j=0;j<i;++j) {
+               
+                if(nums[i]>nums[j]) {
+                    dp[i] = Math.max(dp[i],dp[j]+1);
+                }
+            }
+        }
+
+        return Arrays.stream(dp).max().getAsInt();
+    }
+}
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..8bd4139 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,17 @@
-学习笔记
\ No newline at end of file
+8周的算法训练营，收获很大
+1：锻炼了学习方法
+2：对算法、数据结构有了一个全面的认识
+3：知识进一步巩固和掌握
+
+数据结构认识
+一维
+基础: 数组 array (string)，链表 linked list
+高级: 栈 stack，队列 queue，双端队列 deque，集合 set，映射 map (hash or map)，etc
+二维
+基础: 树 tree，图 graph
+高级: 二叉搜索树 binary search tree (red-black tree,AVL)，堆 heap，并查集 disjoint set，字典树 Trie，etc
+
+学习要点
+1：五毒神掌
+2：刻意练习 - 练习缺陷弱点地方
+3：反馈 - 看题解、看国际版的高票回答