diff --git "a/week01/week01\345\255\246\344\271\240\346\200\273\347\273\223.txt" "b/week01/week01\345\255\246\344\271\240\346\200\273\347\273\223.txt"
new file mode 100644
index 00000000..95f41db0
--- /dev/null
+++ "b/week01/week01\345\255\246\344\271\240\346\200\273\347\273\223.txt"
@@ -0,0 +1,2 @@
+学习总结
+经过算法训练营第一周的学习和刷题，其实最大的感受是自己不再害怕做算法题了，当一个题目拿到手的时候，如果完全没有思路，可以去参考答案和其他人的解答，并不是想不出来就是自己笨，有些解法那确实不是一般人可以想出来的，自己不能想出来情有可原。然后就是其实算法这个东西跟别的知识点还真的不一样，必须动手敲代码，看是永远看不会的，它不像数据库，计算机网络这些东西一样。然后是具体的知识点，对于树之类的题目，用递归用得多，然后对于数组的题目，一般可以采取先排序的方式来降低算法的时间复杂度，而且双指针的用法也很常见，另外还有链表的题目，要熟悉链表交换节点的代码写法，相当于一个模板代码。道阻且长，算法题肯定有一个量变到质变的过程，希望70天后我也是一个刷了300道leetcode的大佬。
\ No newline at end of file
diff --git "a/week01/\345\220\210\345\271\266\345\215\207\345\272\217\351\223\276\350\241\250.java" "b/week01/\345\220\210\345\271\266\345\215\207\345\272\217\351\223\276\350\241\250.java"
new file mode 100644
index 00000000..188f73ab
--- /dev/null
+++ "b/week01/\345\220\210\345\271\266\345\215\207\345\272\217\351\223\276\350\241\250.java"
@@ -0,0 +1,24 @@
+class Solution {
+    public ListNode mergeTwoLists(ListNode l1, ListNode l2) {
+     if(l1==null)return l2;
+     if(l2==null)return l1;
+     ListNode pre = new ListNode(-1);
+     ListNode prehead = pre;
+     while(l1!=null && l2!=null){
+        if(l1.val > l2.val){
+            pre.next = l2;
+            l2 = l2.next;
+        }
+        else{
+            pre.next = l1;
+            l1 = l1.next;
+        }
+
+        pre = pre.next;
+     }
+
+     pre.next = (l1==null)?l2:l1;
+
+     return prehead.next;
+    }
+}
\ No newline at end of file
diff --git "a/week01/\345\220\210\345\271\266\346\234\211\345\272\217\346\225\260\347\273\204.java" "b/week01/\345\220\210\345\271\266\346\234\211\345\272\217\346\225\260\347\273\204.java"
new file mode 100644
index 00000000..c310b834
--- /dev/null
+++ "b/week01/\345\220\210\345\271\266\346\234\211\345\272\217\346\225\260\347\273\204.java"
@@ -0,0 +1,12 @@
+class Solution {
+    public void merge(int[] nums1, int m, int[] nums2, int n) {
+       int p = m+n-1;
+       int p1 = m-1;
+       int p2 = n-1;
+
+       while(p1>=0 && p2>=0)
+           nums1[p--] = nums1[p1]>nums2[p2] ? nums1[p1--]:nums2[p2--];
+
+       System.arraycopy(nums2,0,nums1,0,p2+1);
+    }
+}
\ No newline at end of file
diff --git "a/week02/week02\347\254\224\350\256\260.docx" "b/week02/week02\347\254\224\350\256\260.docx"
new file mode 100644
index 00000000..4fa6ff6e
Binary files /dev/null and "b/week02/week02\347\254\224\350\256\260.docx" differ
diff --git "a/week03/week03\347\254\224\350\256\260.docx" "b/week03/week03\347\254\224\350\256\260.docx"
new file mode 100644
index 00000000..e69de29b
diff --git "a/week04/102_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.java" "b/week04/102_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.java"
new file mode 100644
index 00000000..60441f3a
--- /dev/null
+++ "b/week04/102_\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\345\272\217\351\201\215\345\216\206.java"
@@ -0,0 +1,42 @@
+ /*
+ 思路：
+ 1.创建结果res保存，创建queue用于操作树的结点
+ 2.特判，将根节点添加到queue中
+ 3.开始循环：
+    队列不为空时，获取每层节点数n，循环n次
+        每次将节点弹出，送入level内，遍历左右子节点
+        循环结束时将level添加到结果res中
+4.返回res
+ */
+class Solution {
+    public List<List<Integer>> levelOrder(TreeNode root) {
+        List<List<Integer>> res = new ArrayList<>();
+        Deque<TreeNode> queue = new ArrayDeque<>();
+
+        if(root != null){
+            queue.add(root);
+        }
+
+        while(!queue.isEmpty()){
+            int n = queue.size();
+            List<Integer> level = new ArrayList<>();//特别注意这个level的定义位置，如果写在for循环里面的话，结果就不对了
+            for(int i=0;i<n;i++){  
+                TreeNode node = queue.poll();
+                level.add(node.val);
+
+                if(node.left!=null){
+                    queue.add(node.left);
+                }
+                if(node.right!=null){
+                    queue.add(node.right);
+                    
+                }            
+            }
+            res.add(level);
+            
+        }
+
+        return res;
+    }
+
+}
\ No newline at end of file
diff --git "a/week04/200_\345\262\233\345\261\277\346\225\260\351\207\217.java" "b/week04/200_\345\262\233\345\261\277\346\225\260\351\207\217.java"
new file mode 100644
index 00000000..0dd07ff4
--- /dev/null
+++ "b/week04/200_\345\262\233\345\261\277\346\225\260\351\207\217.java"
@@ -0,0 +1,37 @@
+/*
+哔哩哔哩上讲解链接：https://www.bilibili.com/video/BV1ra411c7nJ?from=search&seid=8418894508800694895
+
+这里有个要注意的点就是，在声明row和col两个变量时，要设置成全局的，因为在dfs方法中会用到。
+
+
+*/
+
+class Solution {
+
+    int row,col;
+    public int numIslands(char[][] grid) {
+        row = grid.length;
+        col = grid[0].length;
+
+        int res = 0;
+        for(int i=0;i<row;i++){
+            for(int j=0;j<col;j++){
+                if(grid[i][j] == '1'){
+                    res++;
+                    dfs(grid,i,j);
+                }
+            }
+        }
+        return res;
+    }
+
+    public void dfs(char[][] grid,int i,int j ){
+        if(i<0 || j<0 || i >= row || j >= col || 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);
+    }
+}
\ No newline at end of file
diff --git "a/week04/22_\346\213\254\345\217\267\347\224\237\346\210\220.java" "b/week04/22_\346\213\254\345\217\267\347\224\237\346\210\220.java"
new file mode 100644
index 00000000..6446e31d
--- /dev/null
+++ "b/week04/22_\346\213\254\345\217\267\347\224\237\346\210\220.java"
@@ -0,0 +1,36 @@
+/*
+回溯法：每次可以添加左括号或者右括号，添加过程中如果出现右括号比左括号多的情况，进行剪枝，退出条件为左括号和右括号都用完了
+
+
+*/
+class Solution {
+    public List<String> generateParenthesis(int n) {
+        List<String> res = new ArrayList<>();
+
+        if(n == 0){
+            return res;
+        }
+
+        dfs("",n,n,res);
+        return res;
+    }
+
+    public void dfs(String curStr,int left,int right,List<String> res){
+        if(left==0 && right==0){
+            res.add(curStr);
+            return;
+        }
+
+        if(left > right){
+            return;
+        }
+	//注意这里的dfs进行下一步的时候是有条件判断的
+        if(left > 0){
+            dfs(curStr+"(",left-1,right,res);
+        }
+
+        if(right > 0){
+            dfs(curStr+")",left,right-1,res);
+        }
+    }
+}
\ No newline at end of file
diff --git "a/week04/46_\345\205\250\346\216\222\345\210\227.java" "b/week04/46_\345\205\250\346\216\222\345\210\227.java"
new file mode 100644
index 00000000..0d1a822d
--- /dev/null
+++ "b/week04/46_\345\205\250\346\216\222\345\210\227.java"
@@ -0,0 +1,75 @@
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.Deque;
+import java.util.List;
+/*
+思路：
+1.特判
+2.结果res，保存
+	used[] 布尔数组，保存值是否被使用
+	path，双端队列，Deque保存临时值
+3.dfs(传入数组nums，depth，
+		path,used,res)
+4.写dfs
+	写终止条件：
+	if(depth == nums.length){
+		res.add(new ArrayList<>(path));
+		return;
+	}
+	for(i从0到nums.length){
+		if(!used[i]){
+			添加元素；
+			used[i] = true;
+			
+			dfs(  ,depth+1,  );
+			
+			去除元素；
+			used[i] = false;
+			
+		}
+	}
+	
+	return;
+
+*/
+public class Solution {
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        if(nums.length == 0){
+            return res;
+        }
+
+        boolean[] used = new boolean[nums.length];
+        Deque<Integer> path = new ArrayDeque<>(nums.length);
+
+        dfs(nums,0,used,path,res);
+
+        return res;
+
+    }
+
+    private void dfs(int[] nums, int depth, boolean[] used, Deque<Integer> path,
+                     List<List<Integer>> res) {
+
+        if(depth == nums.length){
+            res.add(new ArrayList<>(path));
+            return;
+        }
+
+        for(int i=0;i<nums.length;i++){
+            if(!used[i]){
+                path.addLast(nums[i]);
+                used[i] = true;
+
+                dfs(nums,depth+1,used,path,res);
+                path.removeLast();
+                used[i] = false;
+            }
+
+        }
+
+        return;
+    }
+
+
+}
diff --git "a/week04/515_ \345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.java" "b/week04/515_ \345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.java"
new file mode 100644
index 00000000..aa19a387
--- /dev/null
+++ "b/week04/515_ \345\234\250\346\257\217\344\270\252\346\240\221\350\241\214\344\270\255\346\211\276\346\234\200\345\244\247\345\200\274.java"	
@@ -0,0 +1,32 @@
+/*
+这题的思路和二叉树的层序遍历的思路很像，在逐层遍历的过程中，对节点求最大值，并缓存在max中
+*/
+
+class Solution {
+    public List<Integer> largestValues(TreeNode root) {
+        //首先对二叉树进行层序遍历，这是必须的步骤，也有手动维护一个队列的过程
+        List<Integer> res = new ArrayList<>();
+        Queue<TreeNode> queue = new ArrayDeque<>();
+        if (root != null) {
+            queue.add(root);
+        }
+        while (!queue.isEmpty()) {
+            int n = queue.size();
+            int maxVal = Integer.MIN_VALUE; 
+            List<Integer> level = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                TreeNode node = queue.poll();
+                maxVal = Math.max(maxVal,node.val);
+                if (node.left != null) {
+                    queue.add(node.left);
+                }
+                if (node.right != null) {
+                    queue.add(node.right);
+                }
+            }
+            res.add(maxVal);
+        
+        }
+        return res;
+    }
+}
\ No newline at end of file
diff --git "a/week04/529_\346\211\253\351\233\267\346\270\270\346\210\217.java" "b/week04/529_\346\211\253\351\233\267\346\270\270\346\210\217.java"
new file mode 100644
index 00000000..b2aa2ec0
--- /dev/null
+++ "b/week04/529_\346\211\253\351\233\267\346\270\270\346\210\217.java"
@@ -0,0 +1,68 @@
+/*
+哔哩哔哩视频讲解：
+https://www.bilibili.com/video/BV1wV411S7SY?from=search&seid=8418894508800694895
+小姐姐视频讲解哦！
+
+
+思路：
+1.点击的如果是炸弹，把'M'改为'X',返回原数组即可
+2.如果点击的是别的地方，进行dfs
+3.dfs的过程呢就是：
+*/
+
+class Solution {
+   // int[] dx = {0, 1, 0, -1, 1, 1, -1, -1};
+   // int[] dy = {1, 0, -1, 0, 1, -1, 1, -1};
+   //这是官方给出的偏移坐标
+
+    int[] dx = {0,0,-1,-1,-1,1,1,1};
+    int[] dy = {-1,1,0,1,-1,0,1,-1};
+
+    public char[][] updateBoard(char[][] board, int[] click) {
+        
+        int n = board.length;
+        int m = board[0].length;
+
+        int x = click[0];
+        int y = click[1];
+        if(board[x][y] == 'M'){
+            board[x][y] = 'X';
+        }
+        else{
+            dfs(board,x,y);
+        }
+
+        return board;
+    }
+
+    public void dfs(char[][] b,int x,int y){
+        int count = 0;
+        int n = b.length;
+        int m = b[0].length;
+        for(int i=0;i<8;i++){
+            int nx = x + dx[i];
+            int ny = y + dy[i];        
+            if(nx>=0 && nx<n && ny>=0 && ny<m && b[nx][ny]=='M'){
+                count++;
+                b[x][y] = (char)('0'+count);
+            }
+        }
+        if(count==0){
+            b[x][y] = 'B';
+            for(int i=0;i<8;i++){
+                int nx = x + dx[i];
+                int ny = y + dy[i];    
+/*          //起点,如果这里这样写的话，会导致栈溢出。
+               if(nx>=0 && nx<n && ny>=0 && ny<m){ 
+                dfs(b,nx,ny);
+                 }
+            //终点
+*/
+             if(nx>=0 && nx<n && ny>=0 && ny<m && b[nx][ny]=='E'){
+                dfs(b,nx,ny);
+            }
+
+            }
+        }
+    }
+}
\ No newline at end of file
diff --git "a/week04/week04\347\254\224\350\256\260.docx" "b/week04/week04\347\254\224\350\256\260.docx"
new file mode 100644
index 00000000..5241d791
Binary files /dev/null and "b/week04/week04\347\254\224\350\256\260.docx" differ
diff --git "a/week05/1143_\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.java" "b/week05/1143_\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.java"
new file mode 100644
index 00000000..0e571e07
--- /dev/null
+++ "b/week05/1143_\346\234\200\351\225\277\345\205\254\345\205\261\345\255\220\345\272\217\345\210\227.java"
@@ -0,0 +1,27 @@
+
+/*
+https://leetcode-cn.com/problems/longest-common-subsequence/solution/dong-tai-gui-hua-tu-wen-jie-xi-by-yijiaoqian/       leetcode高赞回答
+
+
+
+*/
+
+class Solution {
+    public int longestCommonSubsequence(String text1, String text2) {
+        int m = text1.length(),n = text2.length();
+
+        int[][] dp = new int[m+1][n+1];
+        for(int i=0;i<m;i++){
+            for(int j=0; j<n;j++){
+                char c1 = text1.charAt(i),c2 = text2.charAt(j);
+                if(c1 == c2){
+                    dp[i+1][j+1] = dp[i][j] + 1;
+                }else{
+                    dp[i+1][j+1] = Math.max(dp[i+1][j],dp[i][j+1]);
+                }
+            }
+        }
+
+        return dp[m][n];
+    }
+}
\ No newline at end of file
diff --git "a/week05/62_\344\270\215\345\220\214\350\267\257\345\276\204.java" "b/week05/62_\344\270\215\345\220\214\350\267\257\345\276\204.java"
new file mode 100644
index 00000000..c9f094f9
--- /dev/null
+++ "b/week05/62_\344\270\215\345\220\214\350\267\257\345\276\204.java"
@@ -0,0 +1,26 @@
+/*
+思路：首先把第一行和第一列的值赋为1
+		然后从第二行第二列开始操作
+		每个点的值为   它上方的值  和   它左边的值相加的和
+
+
+*/
+
+class Solution {
+    public int uniquePaths(int m, int n) {
+        int[][] dp = new int[m][n];
+
+        for(int i = 0; i<m; i++)
+            dp[i][0] = 1;
+        for(int i = 0; i<n; i++)
+            dp[0][i] = 1;
+
+        for(int i=1;i<m;i++){
+            for(int j=1;j<n;j++){
+                dp[i][j] = dp[i-1][j] + dp[i][j-1];
+            }
+        }
+        return dp[m-1][n-1];
+  
+    }
+}
\ No newline at end of file
diff --git "a/week05/63_\344\270\215\345\220\214\350\267\257\345\276\204 II.java" "b/week05/63_\344\270\215\345\220\214\350\267\257\345\276\204 II.java"
new file mode 100644
index 00000000..75bcdc48
--- /dev/null
+++ "b/week05/63_\344\270\215\345\220\214\350\267\257\345\276\204 II.java"	
@@ -0,0 +1,45 @@
+class Solution {
+    public int uniquePathsWithObstacles(int[][] obstacleGrid) {
+        //获取路径数组的长宽  
+        int m = obstacleGrid.length;
+        int n = obstacleGrid[0].length;
+
+        int[][] dp = new int[m][n];
+        //判断路径数组的第一个格子，给dp首元素赋值
+        if(obstacleGrid[0][0]==1)
+            return 0;
+        else{
+            dp[0][0] = 1;
+        }
+
+        //把dp的第一行和第一列赋值，条件是：若该处没有石头且它前面的那个格子可以到达，则此处可以到达，dp赋值为1
+        for(int i =1;i<m;i++){    
+            if(obstacleGrid[i][0]==0 &&  dp[i-1][0]==1 )
+                dp[i][0] = 1;
+            else{
+                dp[i][0] = 0;   
+            }
+        }
+
+        for(int i =1;i<n;i++){    
+            if(obstacleGrid[0][i]==0 &&  dp[0][i-1]==1)
+                dp[0][i] = 1;
+            else{
+                dp[0][i] = 0;   
+            }
+        }
+
+        //循环过程中，碰到石头就赋值为0，其他的情况都是由 （左边值+上边值）
+        for(int i = 1;i<m;i++){
+            for(int j = 1; j < n; j++){
+                if(obstacleGrid[i][j] == 1){
+                    dp[i][j] = 0;
+                }else{
+                    dp[i][j] = dp[i-1][j] + dp[i][j-1];
+                }
+                
+            }
+        }
+        return dp[m-1][n-1];
+    }
+}
\ No newline at end of file
diff --git "a/week05/64_\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.java" "b/week05/64_\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.java"
new file mode 100644
index 00000000..1a7a09af
--- /dev/null
+++ "b/week05/64_\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.java"
@@ -0,0 +1,24 @@
+class Solution {
+    public int minPathSum(int[][] grid) {
+        int m = grid.length,n = grid[0].length;
+        int[][] dp  = new int[m][n];  
+
+
+        dp[0][0] = grid[0][0];
+
+        for(int i = 1; i < m ; i++){
+            dp[i][0] = grid[i][0] + dp[i-1][0];
+        }
+        for(int i = 1; i < n ; i++){
+            dp[0][i] = grid[0][i] + dp[0][i-1];
+        }
+
+        for(int i=1;i<m;i++){
+            for(int j=1;j<n;j++){
+                dp[i][j] = grid[i][j] + Math.min(dp[i-1][j],dp[i][j-1]);
+            }
+        }
+
+        return dp[m-1][n-1];
+    }
+}
\ No newline at end of file
diff --git "a/week05/980_\344\270\215\345\220\214\350\267\257\345\276\204 III.java" "b/week05/980_\344\270\215\345\220\214\350\267\257\345\276\204 III.java"
new file mode 100644
index 00000000..a0803ad2
--- /dev/null
+++ "b/week05/980_\344\270\215\345\220\214\350\267\257\345\276\204 III.java"	
@@ -0,0 +1,43 @@
+class Solution {
+    int res = 0;
+    int cnt = 1,sx,sy,ex,ey;//这里一定要用cnt为1来初始化，因为走到2还需要一步路
+    public int uniquePathsIII(int[][] grid) {
+        int m = grid.length,n = grid[0].length;
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                if(grid[i][j] == 0){
+                    cnt++;
+                }
+                else if(grid[i][j] == 1){
+                    sx = i;
+                    sy = j; 
+                }
+                else if(grid[i][j] == 2){
+                    ex = i;
+                    ey = j;
+                }
+            }
+        }
+
+        dfs(grid,sx,sy);
+        return res;
+    }
+
+    public void dfs(int[][] grid, int x , int y){
+        if(x < 0 || x >= grid.length || y < 0 || y >= grid[0].length || grid[x][y] < 0)return;
+        if(x == ex && y == ey){
+            if(cnt == 0)res++;
+            return;
+        }
+        cnt--;
+        grid[x][y] = -1;
+        
+        dfs(grid,x-1,y);
+        dfs(grid,x+1,y);
+        dfs(grid,x,y-1);
+        dfs(grid,x,y+1);
+        grid[x][y] = 0;
+        cnt++;
+
+    }
+}
\ No newline at end of file
diff --git "a/week05/week05\351\242\230\347\233\256\345\215\225.txt" "b/week05/week05\351\242\230\347\233\256\345\215\225.txt"
new file mode 100644
index 00000000..6111d333
--- /dev/null
+++ "b/week05/week05\351\242\230\347\233\256\345\215\225.txt"
@@ -0,0 +1,34 @@
+70. 爬楼梯
+120. 三角形最小路径和
+53. 最大子序和
+152. 乘积最大子数组
+322. 零钱兑换
+518. 零钱兑换 II
+198. 打家劫舍
+213. 打家劫舍 II
+121. 买卖股票的最佳时机
+122. 买卖股票的最佳时机 II
+123. 买卖股票的最佳时机 III
+309. 最佳买卖股票时机含冷冻期
+188. 买卖股票的最佳时机 IV
+714. 买卖股票的最佳时机含手续费
+279. 完全平方数
+72. 编辑距离
+55. 跳跃游戏
+45. 跳跃游戏 II
+91. 解码方法
+221. 最大正方形
+621. 任务调度器
+647. 回文子串
+32. 最长有效括号
+363. 矩形区域不超过 K 的最大数值和
+403. 青蛙过河
+410. 分割数组的最大值
+552. 学生出勤记录 II
+76. 最小覆盖子串
+312. 戳气球
+208. 实现 Trie (前缀树)
+212. 单词搜索 II
+36. 有效的数独
+127. 单词接龙
+1091. 二进制矩阵中的最短路径
\ No newline at end of file