diff --git a/.idea/.gitignore b/.idea/.gitignore
new file mode 100644
index 00000000..26d33521
--- /dev/null
+++ b/.idea/.gitignore
@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml
diff --git a/Week_01/java/PlusOne.java b/Week_01/java/PlusOne.java
new file mode 100644
index 00000000..c41a1407
--- /dev/null
+++ b/Week_01/java/PlusOne.java
@@ -0,0 +1,21 @@
+public class PlusOne {
+    public int[] plusOne(int[] digits) {
+        int index = digits.length-1;
+        while(true){
+            if(index>=0&&digits[index]==9){
+                digits[index--]=0;
+            }else if (index >= 0){
+                digits[index] = digits[index]+1;
+                break;
+            }else{
+                break;
+            }
+        }
+        if(index == -1){
+            digits = new int[digits.length + 1];
+            digits[0] = 1;
+        }
+        return digits;
+    }
+
+}
diff --git a/Week_01/java/RotateArray.java b/Week_01/java/RotateArray.java
new file mode 100644
index 00000000..6bbbb040
--- /dev/null
+++ b/Week_01/java/RotateArray.java
@@ -0,0 +1,29 @@
+//旋转数组
+public class RotateArray {
+    public static void rotate(int[] nums, int k) {
+
+        int len = nums.length;
+        k = k % len;
+        rever(nums,0,len-1);
+        rever(nums,0,k-1);
+        rever(nums,k,len-1);
+    }
+
+    public static void rever(int[]nums, int start, int end){
+        int len = end-start+1;
+        for(int i=0;i<len/2;i++){
+            int tmp = nums[start+i];
+            nums[start+i] = nums[end-i];
+            nums[end-i] = tmp;
+        }
+    }
+
+    public static void main(String[] args) {
+        int nums[] = new int[]{1,2,3,4,5,6,7};
+        rotate(nums, 3);
+        for(int i :nums){
+            System.out.println(i);
+        }
+    }
+
+}
diff --git a/Week_01/java/TrappingRainWater.java b/Week_01/java/TrappingRainWater.java
new file mode 100644
index 00000000..768f9969
--- /dev/null
+++ b/Week_01/java/TrappingRainWater.java
@@ -0,0 +1,42 @@
+import java.util.Deque;
+import java.util.LinkedList;
+
+//接雨水 使用栈
+public class TrappingRainWater {
+    public static int trap(int[] height) {
+        int max = 0;
+        Deque<Integer> stack = new LinkedList<Integer>();
+
+        for(int i=0;i<height.length;i++){
+            if(stack.isEmpty()&&height[i]>0){
+                stack.push(i);
+                continue;
+            }else if(stack.isEmpty()&&height[i]==0){
+                continue;
+            }
+
+            while(!stack.isEmpty()&&height[stack.peek()]<height[i]){
+                int cur = stack.pop();
+
+                if(stack.isEmpty()) break;
+                int left = stack.peek();
+                int min = Math.min(height[left],height[i]);
+                int high = min - height[cur];
+                int len = i - left-1;
+                max += high*len;
+            }
+            stack.push(i);
+
+        }
+
+        return max;
+
+    }
+
+    public static void main(String[] args) {
+        int[] ints = {4,2,0,3,2,5};
+        int trap = trap(ints);
+        System.out.println(trap);
+    }
+
+}
diff --git a/Week_01/java/ValidPerfectSquare.java b/Week_01/java/ValidPerfectSquare.java
new file mode 100644
index 00000000..171c47cb
--- /dev/null
+++ b/Week_01/java/ValidPerfectSquare.java
@@ -0,0 +1,29 @@
+public class ValidPerfectSquare {
+    /**
+     * 367. 有效的完全平方数
+     */
+    public static boolean isPerfectSquare(int num) {
+        //正整数 num 的平方根一定落在 [1, num/2 + 1] 区间
+        //防止 mid * mid 太大而发生溢出（超出整型的范围），取 mid 跟 num / mid 进行比较；
+        int left = 1;
+        int right = num/2+1;
+        while(left<=right){
+            int mid = left+((right-left)>>1);
+            int target = num/mid;
+            if(target==mid) {
+                if (num % mid == 0) //如果取余为0说明相等
+                    return true;
+                right = mid - 1;   //缩小上边界
+            } else if(target>mid){
+                left = mid+1;
+            } else{
+                right = mid-1;
+            }
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+        System.out.println(isPerfectSquare(16));
+    }
+}
diff --git a/Week_01/java/submissions.java b/Week_01/java/submissions.java
new file mode 100644
index 00000000..7998a4ea
--- /dev/null
+++ b/Week_01/java/submissions.java
@@ -0,0 +1,26 @@
+import java.util.ArrayList;
+import java.util.List;
+
+public class submissions {
+    public List<String> generateParenthesis(int n) {
+        List<String> rst= new ArrayList<String>();
+        subFun(rst,0,0,n,"");
+        return rst;
+    }
+
+    public void subFun(List<String> rst,int left, int right,int n, String subRst){
+        if(left==n&&right==n) {
+            rst.add(subRst);
+            return;
+        }
+
+        if(left<n){
+            subFun(rst,left+1,right,n, subRst+"(");
+        }
+        if(right<left){
+            subFun(rst,left,right+1,n, subRst+")");
+        }
+
+
+    }
+}
diff --git a/Week_02/java/AddDigits.java b/Week_02/java/AddDigits.java
new file mode 100644
index 00000000..c3b4e2a2
--- /dev/null
+++ b/Week_02/java/AddDigits.java
@@ -0,0 +1,16 @@
+
+public class AddDigits {
+    public static int addDigits(int num) {
+        if(num<10) return num;
+        int rst = 0;
+        while(num != 0){
+            rst += num % 10;
+            num = num/10;
+        }
+        return addDigits(rst);
+    }
+
+    public static void main(String[] args) {
+        System.out.println(addDigits(38));
+    }
+}
diff --git a/Week_02/java/Intersection.java b/Week_02/java/Intersection.java
new file mode 100644
index 00000000..5c20e514
--- /dev/null
+++ b/Week_02/java/Intersection.java
@@ -0,0 +1,29 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class Intersection {
+    public int[] intersect(int[] nums1, int[] nums2) {
+        List<Integer> rstList = new ArrayList<>();
+        Map<Integer,Integer> numMap = new HashMap<>();
+        for(int i : nums1){
+            if(numMap.containsKey(i)){
+                numMap.put(i,numMap.get(i)+1);
+            }else{
+                numMap.put(i,1);
+            }
+        }
+        for(int j:nums2){
+            if(numMap.get(j)!=null && numMap.get(j)!=0){
+                rstList.add(j);
+                numMap.put(j,numMap.get(j)-1);
+            }
+        }
+        int[] rstNums= new int[rstList.size()];
+        for(int k=0;k<rstList.size();k++){
+            rstNums[k]=rstList.get(k);
+        }
+        return rstNums;
+    }
+}
diff --git a/Week_02/java/RemoveOuterParentheses.java b/Week_02/java/RemoveOuterParentheses.java
new file mode 100644
index 00000000..055f8963
--- /dev/null
+++ b/Week_02/java/RemoveOuterParentheses.java
@@ -0,0 +1,29 @@
+public class RemoveOuterParentheses {
+    public String removeOuterParentheses(String S) {
+        StringBuilder rst = new StringBuilder();
+
+        int left = 0;
+        int right = 0;
+        for(char c: S.toCharArray()){
+            if(right>left) return "";
+
+            if(c == '('){
+                ++left;
+                if(left>=2){
+                    rst.append('(');
+                }
+            }
+            if(c == ')'){
+                ++right;
+                if(right == left){
+                    left = 0;
+                    right = 0;
+                }else{
+                    rst.append(')');
+                }
+            }
+        }
+        return rst.toString();
+
+    }
+}
diff --git a/Week_02/java/ReverseStringII.java b/Week_02/java/ReverseStringII.java
new file mode 100644
index 00000000..62e7d2a3
--- /dev/null
+++ b/Week_02/java/ReverseStringII.java
@@ -0,0 +1,25 @@
+public class ReverseStringII {
+    public String reverseStr(String s, int k) {
+        char[] chars = s.toCharArray();
+        int len = chars.length;
+
+        for(int i =0;i<len ;i+=2*k){
+            int start = i;
+            int end = (i+k<len)?i+k-1:len-1;
+            while(start<=end){
+                char tmp = chars[start];
+                chars[start] = chars[end];
+                chars[end] = tmp;
+                start++;
+                end--;
+            }
+        }
+        return String.valueOf(chars);
+    }
+
+    public static void main(String[] args) {
+        ReverseStringII reverseStringII = new ReverseStringII();
+        System.out.println(reverseStringII.reverseStr("dcba", 4));
+    }
+
+}
diff --git a/Week_02/java/SlidingWindow.java b/Week_02/java/SlidingWindow.java
new file mode 100644
index 00000000..e618b97e
--- /dev/null
+++ b/Week_02/java/SlidingWindow.java
@@ -0,0 +1,47 @@
+
+public class SlidingWindow {
+    public static int[] maxSlidingWindow(int[] nums, int k) {
+
+        int len = nums.length;
+        if(len==0){
+            return new int[]{};
+        }
+        if(len<k){
+            int maxIndex = max(nums, 0,len-1);
+            return new int[]{nums[maxIndex]};
+        }
+
+        int[] rst = new int[len-k+1];
+        int maxIndex;
+        maxIndex = max(nums,0,k-1);
+        rst[0] = nums[maxIndex];
+        for(int i=k;i<nums.length;i++){
+            if(maxIndex+k==i){
+                maxIndex = max(nums,maxIndex+1,i);
+            }
+            if(nums[maxIndex]<nums[i]) maxIndex = i;
+
+            rst[i-k+1] = nums[maxIndex];
+
+
+        }
+        return rst;
+    }
+
+    public static int max(int[] nums, int start, int end){
+        int maxIndex = start;
+        for(int i = start+1;i<=end;i++){
+            if(nums[i]> nums[maxIndex]) maxIndex= i;
+        }
+        return maxIndex;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{1,3,-1,-3,5,3,6,7};
+        int[] rsts = maxSlidingWindow(nums, 3);
+        for(int i =0;i<rsts.length;i++){
+            System.out.println(rsts[i]);
+        }
+    }
+
+}
diff --git a/Week_02/java/ThreeSum.java b/Week_02/java/ThreeSum.java
new file mode 100644
index 00000000..7516577d
--- /dev/null
+++ b/Week_02/java/ThreeSum.java
@@ -0,0 +1,45 @@
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class ThreeSum {
+
+    public static List<List<Integer>> threeSum(int[] nums) {
+        Arrays.sort(nums);
+        List<List<Integer>> rst = new ArrayList<>();
+        int len = nums.length;
+        if(len<3||nums[0]>0) return rst;
+
+        for(int i=0;i<len;i++){
+            if(i>0&&nums[i]==nums[i-1]) continue;
+            sumSub(nums[i],i+1,len-1,nums,rst);
+        }
+        return rst;
+    }
+
+    public static void sumSub(int target, int start, int end, int[] nums, List<List<Integer>> rst){
+        while(start<end){
+            int tmp = nums[start]+nums[end]+target;
+            if(tmp==0){
+                List<Integer> singleRst = Arrays.asList(target,nums[start],nums[end]);
+                rst.add(singleRst);
+                while(start<end&&nums[++start]==nums[start-1]); //去重，继续向下循环
+                while(start<end&&nums[--end]==nums[end+1]);
+            }
+            if(tmp<0){
+                start++;
+            }
+            if(tmp>0){
+                end--;
+            }
+        }
+    }
+
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{-1,0,1,2,-1,-4};
+        System.out.println(threeSum(nums));
+    }
+
+
+}
diff --git a/Week_02/java/TopK.java b/Week_02/java/TopK.java
new file mode 100644
index 00000000..3ff2f575
--- /dev/null
+++ b/Week_02/java/TopK.java
@@ -0,0 +1,75 @@
+import java.util.*;
+
+public class TopK {
+    // 使用Map和数组处理 效率差
+    public static int[] topKFrequent(int[] nums, int k) {
+        Map<Integer,Integer> numCountMap = new HashMap<>();
+        for(int num : nums){
+            numCountMap.put(num, numCountMap.getOrDefault(num, 0) + 1);
+        }
+        int[] rst = new int[k];
+        int minIndex=0;
+        int i=0;
+        for(Integer key: numCountMap.keySet()){
+            if(i<k){
+                rst[i++]=key; //先填满数组
+                continue;
+            }
+            if(i==k){ //填充完毕
+                minIndex = minNumIndex(rst, numCountMap); //第一次寻找出K高中的最小值
+                i++; // 使其不再生效
+            }
+            if(numCountMap.get(key) > numCountMap.get(rst[minIndex])){//如果此元素是否比数组最小值大
+                rst[minIndex] = key;
+                minIndex = minNumIndex(rst, numCountMap); //重新寻找出K高中的最小值
+            }
+        }
+        return rst;
+    }
+    public static int minNumIndex(int[] nums, Map<Integer,Integer> map){
+        int tmpIndex = 0;
+        for(int i=1;i<nums.length;i++){
+            if(map.get(nums[i])< map.get(nums[tmpIndex])) tmpIndex = i;
+        }
+        return tmpIndex;
+    }
+
+    //使用堆处理
+    public static int[] topKFrequent1(int[] nums, int k) {
+        Map<Integer,Integer> numCountMap = new HashMap<>();
+        for(int num : nums){
+            numCountMap.put(num, numCountMap.getOrDefault(num, 0) + 1);
+        }
+
+        PriorityQueue<Integer> priQueue = new PriorityQueue<>(new Comparator<Integer>() {
+            @Override
+            public int compare(Integer o1, Integer o2) {
+                return numCountMap.get(o1) - numCountMap.get(o2) ;//升序排列，最前面是最小值
+            }
+        });
+        for(Integer key: numCountMap.keySet()){
+            if(priQueue.size() < k) priQueue.add(key);
+
+            else if(numCountMap.get(key) >numCountMap.get(priQueue.peek())){
+                priQueue.remove();
+                priQueue.add(key);
+            }
+        }
+        int rst[] = new int[k];
+        for(int i=0;i<k;i++){
+            rst[i] = priQueue.remove();
+        }
+        return rst;
+    }
+
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{6,0,1,4,9,7,-3,1,-4,-8,4,-7,-3,3,2,-3,9,5,-4,0};
+        int[] result = topKFrequent1(nums, 6);
+        for(int i:result){
+            System.out.println(i);
+        }
+    }
+
+}
+//-3 0 1 -4 4 9
\ No newline at end of file
diff --git a/Week_03/java/BestTimeToBuyAndSellStock.java b/Week_03/java/BestTimeToBuyAndSellStock.java
new file mode 100644
index 00000000..48e44c7c
--- /dev/null
+++ b/Week_03/java/BestTimeToBuyAndSellStock.java
@@ -0,0 +1,21 @@
+public class BestTimeToBuyAndSellStock {
+    public int maxProfit(int[] prices) {
+        int len = prices.length;
+        int[][] dp = new int[len][2];
+        dp[0][0] = 0;
+        dp[0][1] = -prices[0];
+
+        for(int i=1;i<len;i++){
+            dp[i][1] = Math.max(dp[i-1][1], -prices[i]);
+            dp[i][0] = Math.max(dp[i-1][0], prices[i]+dp[i-1][1]);
+        }
+        return Math.max(dp[len-1][0], dp[len-1][1]);
+    }
+
+    public static void main(String[] args) {
+        BestTimeToBuyAndSellStock bestTimeToBuyAndSellStock = new BestTimeToBuyAndSellStock();
+        int[] prices = new int[]{7,6,4,3,1};
+        System.out.println(bestTimeToBuyAndSellStock.maxProfit(prices));
+
+    }
+}
diff --git a/Week_03/java/BestTimeToBuyAndSellStockII.java b/Week_03/java/BestTimeToBuyAndSellStockII.java
new file mode 100644
index 00000000..5916df75
--- /dev/null
+++ b/Week_03/java/BestTimeToBuyAndSellStockII.java
@@ -0,0 +1,23 @@
+public class BestTimeToBuyAndSellStockII {
+    public int maxProfit(int[] prices) {
+        int len = prices.length;
+        if(len<2) return 0;
+        int[][] dp = new int[len][2];
+
+        dp[0][0]=0;
+        dp[0][1]= -prices[0];
+        for(int i=1; i<len;i++){
+            dp[i][0] = Math.max(dp[i-1][0],dp[i-1][1]+prices[i]);
+            dp[i][1] = Math.max(dp[i-1][0]-prices[i],dp[i-1][1]);
+        }
+        return dp[len-1][0];
+    }
+
+    public static void main(String[] args) {
+        int[] prices = new int[]{7,1,5,3,6,4};
+        BestTimeToBuyAndSellStockII bestTimeToBuyAndSellStockII = new BestTimeToBuyAndSellStockII();
+        System.out.println(bestTimeToBuyAndSellStockII.maxProfit(prices));
+    }
+
+
+}
diff --git a/Week_03/java/ConsturctBinary.java b/Week_03/java/ConsturctBinary.java
new file mode 100644
index 00000000..1f4fafab
--- /dev/null
+++ b/Week_03/java/ConsturctBinary.java
@@ -0,0 +1,40 @@
+//105. 从前序与中序遍历序列构造二叉树
+class TreeNode {
+    int val;
+    TreeNode left;
+    TreeNode right;
+    TreeNode(int x) { val = x; }
+}
+
+
+public class ConsturctBinary {
+
+    public static TreeNode buildTree(int[] preorder, int[] inorder) {
+        if(preorder.length==0) return null;
+        return buildTreeSub(preorder, inorder, 0, preorder.length-1, 0 ,inorder.length-1);
+    }
+    public static TreeNode buildTreeSub(int[] preorder, int[] inorder, int pStart, int pEnd, int iStart, int iEnd){
+        if(pStart > pEnd) return null;
+        TreeNode root = new TreeNode(preorder[pStart]);
+
+        int rootIndex;
+        for(rootIndex = iStart; rootIndex < iEnd;rootIndex++){
+            if(inorder[rootIndex]==preorder[pStart])
+                break;
+        }
+        int leftNodeNum = rootIndex - iStart;
+        root.left = buildTreeSub(preorder, inorder, pStart+1, pStart+leftNodeNum, iStart, rootIndex-1);
+        root.right = buildTreeSub(preorder, inorder, pStart+leftNodeNum+1, pEnd, rootIndex+1, iEnd);
+        return root;
+    }
+
+    public static void main(String[] args) {
+//        int[] preorder = new int[]{3,9,20,15,7};
+//        int[] inorder = new int[]{9,3,15,20,7};
+        int[] preorder = new int[]{1,2};
+        int[] inorder = new int[]{2,1};
+        TreeNode treeNode = buildTree(preorder, inorder);
+        System.out.println(treeNode);
+    }
+
+}
diff --git a/Week_03/java/LowestComNode.java b/Week_03/java/LowestComNode.java
new file mode 100644
index 00000000..a10ee85f
--- /dev/null
+++ b/Week_03/java/LowestComNode.java
@@ -0,0 +1,21 @@
+
+//class TreeNode {
+//    int val;
+//    TreeNode left;
+//    TreeNode right;
+//    TreeNode(int x) { val = x; }
+// }
+
+public class LowestComNode {
+    public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
+        if(root==null || root==p || root==q) return root; // 找到目标节点 或 到叶子尽头
+
+        TreeNode left = lowestCommonAncestor(root.left, p, q);  // 现在左子树找
+        TreeNode right = lowestCommonAncestor(root.right, p, q); // 找右子树
+
+        if(left==null) return right; // 此子树包含右节点 或 返回null
+        if(right==null) return left; // 此子树包含左节点 不包含右节点
+        return root;  //此节点为目标值 包含左右节点
+    }
+
+}
diff --git a/Week_03/java/NQueens.java b/Week_03/java/NQueens.java
new file mode 100644
index 00000000..e68c9088
--- /dev/null
+++ b/Week_03/java/NQueens.java
@@ -0,0 +1,46 @@
+import java.util.*;
+
+public class NQueens {
+    static List<List<String>> rst = new ArrayList<>();
+
+    public static List<List<String>> solveNQueens(int n) {
+        if(n<=0) return null;
+        List<Integer> row = new ArrayList<>();
+        List<Integer> pie = new ArrayList<>();
+        List<Integer> na  = new ArrayList<>();
+        solveNQueensSub(n,0, new ArrayList<>(), row, pie, na);
+        return rst;
+    }
+
+    public static void solveNQueensSub(int totalN, int curLevel, List<Integer> singleLine, List<Integer> row, List<Integer> pie, List<Integer> na){
+        if(curLevel == totalN ){
+            char[] chars = new char[totalN];
+            List<String> rstFir = new ArrayList<>();
+            for(Integer i:singleLine){
+                Arrays.fill(chars, '.');
+                chars[i] = 'Q';
+                rstFir.add(new String(chars));
+            }
+            rst.add(rstFir);
+            return;
+        }
+        for(int queenRow=0;queenRow<totalN;queenRow++) {
+            if (row.contains(queenRow) || pie.contains(curLevel - queenRow) || na.contains(curLevel + queenRow)) continue;
+            singleLine.add(queenRow);
+            row.add(queenRow);
+            pie.add(curLevel - queenRow);
+            na.add(curLevel+queenRow);
+            solveNQueensSub(totalN, curLevel+1, singleLine, row, pie, na);
+            singleLine.remove((Object) queenRow);
+            row.remove((Object)queenRow);
+            pie.remove((Object)(curLevel - queenRow));
+            na.remove((Object)(curLevel+queenRow));
+        }
+    }
+
+    public static void main(String[] args) {
+        List<List<String>> lists = solveNQueens(4);
+        System.out.println(lists.toString());
+    }
+
+}
diff --git a/Week_03/java/PhoneNumber.java b/Week_03/java/PhoneNumber.java
new file mode 100644
index 00000000..80679db0
--- /dev/null
+++ b/Week_03/java/PhoneNumber.java
@@ -0,0 +1,42 @@
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+public class PhoneNumber {
+    public static List<String> letterCombinations(String digits) {
+        Map<String, String> numMap = new HashMap<>();
+        numMap.put("2","abc");
+        numMap.put("3","def");
+        numMap.put("4","ghi");
+        numMap.put("5","jkl");
+        numMap.put("6","mno");
+        numMap.put("7","pqrs");
+        numMap.put("8","tuv");
+        numMap.put("9","wxyz");
+        List<String> rstList = new ArrayList<>();
+        if(digits.equals("")) return rstList;
+        letterCombinSub(digits, 0, "", rstList, numMap);
+        return rstList;
+    }
+    public static void letterCombinSub(String digits, int numLevel, String curLetter, List<String> rstList, Map<String, String> numMap){
+        if(numLevel == digits.length()){
+            rstList.add(curLetter);
+            return;
+        }
+        char c = digits.charAt(numLevel);
+        String letters = numMap.get(String.valueOf(c));
+        for(int i =0; i<letters.length();i++){
+            letterCombinSub(digits, numLevel+1, curLetter+ letters.charAt(i),rstList, numMap);
+        }
+
+    }
+
+    public static void main(String[] args) {
+        List<String> strings = letterCombinations("23");
+        System.out.println(strings.toString());
+
+    }
+
+
+}
diff --git a/Week_03/java/SwapNode.java b/Week_03/java/SwapNode.java
new file mode 100644
index 00000000..e270fba2
--- /dev/null
+++ b/Week_03/java/SwapNode.java
@@ -0,0 +1,34 @@
+public class SwapNode {
+    /**
+     * Definition for singly-linked list.
+     */
+     public class ListNode {
+         int val;
+         ListNode next;
+         ListNode() {}
+         ListNode(int val) { this.val = val; }
+         ListNode(int val, ListNode next) { this.val = val; this.next = next; }
+     }
+
+
+    public ListNode swapPairs(ListNode head) {
+        ListNode preHead = new ListNode(0);
+        preHead.next = head;
+
+        ListNode curNode = preHead;
+        while(curNode.next!=null&&curNode.next.next!=null){
+            ListNode first = curNode.next;
+            ListNode second = first.next;
+
+            curNode.next = second;
+            first.next =second.next;
+            second.next = first;
+
+
+            curNode = first;
+        }
+        return preHead.next;
+    }
+
+
+}
diff --git a/Week_04/java/FirstUniqueChar.java b/Week_04/java/FirstUniqueChar.java
new file mode 100644
index 00000000..8e6a9242
--- /dev/null
+++ b/Week_04/java/FirstUniqueChar.java
@@ -0,0 +1,20 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class FirstUniqueChar {
+
+    public int firstUniqChar(String s) {
+        Map<Character, Integer> wordMap = new HashMap<>();
+        char[] chars = s.toCharArray();
+        for(char ch: chars){
+            wordMap.put(ch,wordMap.getOrDefault(ch,0)+1);
+        }
+
+        for (int i = 0; i < chars.length; i++) {
+            if (wordMap.get(chars[i])==1) return i;
+        }
+        return -1;
+
+    }
+
+}
diff --git a/Week_04/java/LemonadeChange.java b/Week_04/java/LemonadeChange.java
new file mode 100644
index 00000000..c5b5cc05
--- /dev/null
+++ b/Week_04/java/LemonadeChange.java
@@ -0,0 +1,40 @@
+import java.util.HashMap;
+import java.util.Map;
+
+public class LemonadeChange {
+    public static boolean lemonadeChange(int[] bills) {
+        if(bills.length==0) return true;
+        int five = 0;
+        int ten = 0;
+        for(int money: bills){
+            switch(money){
+                case 5:
+                    five++;
+                    break;
+                case 10:
+                    if(five==0)
+                        return false;
+                    five--;
+                    ten++;
+                    break;
+                case 20:
+                    if(ten>0&&five>0){
+                        ten--;
+                        five--;
+                    }else if(five>2){
+                        five-=3;
+                    }else{
+                        return false;
+                    }
+                    break;
+            }
+        }
+        return true;
+    }
+
+    public static void main(String[] args) {
+        int[] bills = new int[]{5,5,5,10,20};
+        boolean b = lemonadeChange(bills);
+        System.out.println(b);
+    }
+}
diff --git a/Week_04/java/NumberOfIslands.java b/Week_04/java/NumberOfIslands.java
new file mode 100644
index 00000000..533f95c3
--- /dev/null
+++ b/Week_04/java/NumberOfIslands.java
@@ -0,0 +1,37 @@
+/**
+ * 计算岛屿数量，深度优先遍历
+ */
+public class NumberOfIslands {
+    public static int numIslands(char[][] grid) {
+        int h = grid.length;
+        int count = 0;
+        if(h == 0) return 0;
+        int l = grid[0].length;
+        for(int i=0;i<h;i++){
+            for(int j=0;j<l;j++){
+                if(grid[i][j]=='1'){
+                    removeIsland(grid, i, j);
+                    count++;
+                }
+            }
+        }
+        return count;
+    }
+    public static void removeIsland(char[][] grid, int i, int j){
+        if(i<0||i>=grid.length||j<0||j>=grid[0].length||grid[i][j]!='1')
+            return;
+        grid[i][j]='0';
+        removeIsland(grid,i-1,j);
+        removeIsland(grid,i+1,j);
+        removeIsland(grid,i,j-1);
+        removeIsland(grid,i,j+1);
+    }
+
+    public static void main(String[] args) {
+//        char[][] grid = new char[][]{{'1','1','1','1','0'}, {'1','1','0','1','0'},{'1','1','0','0','0'},{'0','0','0','0','0'}};
+        char[][] grid = new char[][]{{'1','1','0','0','0'}, {'1','1','0','0','0'},{'0','0','1','0','0'},{'0','0','0','1','1'}};
+
+        int i = numIslands(grid);
+        System.out.println(i);
+    }
+}
diff --git a/Week_04/java/Permute.java b/Week_04/java/Permute.java
new file mode 100644
index 00000000..7d272aa1
--- /dev/null
+++ b/Week_04/java/Permute.java
@@ -0,0 +1,28 @@
+import java.util.ArrayList;
+import java.util.List;
+
+//全排列
+public class Permute {
+    public List<List<Integer>> permute(int[] nums) {
+        List<List<Integer>> res = new ArrayList<>();
+        int[] used = new int[nums.length];
+        permuteSub(nums, 0, used, new ArrayList<>(), res);
+        return res;
+
+    }
+
+    private void permuteSub( int[] nums, int level, int[] used, ArrayList<Integer> rstSingle, List<List<Integer>> result) {
+        if (level == nums.length) {
+            result.add(new ArrayList<>(rstSingle));
+            return;
+        }
+        for (int i = 0; i < nums.length; i++) {
+            if (used[i] == 1) continue;
+            used[i] = 1;
+            rstSingle.add(nums[i]);
+            permuteSub(nums, level+1, used, rstSingle, result);
+            used[i] = 0;
+            rstSingle.remove(level);
+        }
+    }
+}
diff --git a/Week_04/java/SearchMatrix.java b/Week_04/java/SearchMatrix.java
new file mode 100644
index 00000000..6eda54d1
--- /dev/null
+++ b/Week_04/java/SearchMatrix.java
@@ -0,0 +1,33 @@
+import java.util.Arrays;
+
+public class SearchMatrix {
+    //74. 搜索二维矩阵
+    public static boolean searchMatrix(int[][] matrix, int target) {
+        int x = matrix.length;
+        if(x==0) return false;
+        int y = matrix[0].length;
+        int begin =0;
+        int end = x*y-1;
+        while(begin <= end){
+            int mid = (begin + end)/2;          //mid 为矩阵元素长度的一半（即将二维数组看成一维数组，求mid的值一样）
+            int mid_element = matrix[mid/y][mid%y]; //找二维数组中间位置的元素，行的值是 mid的值除以列取整， 列的值是mid的值除以列取
+                                                    //  #余数（判断该行的第几个元素）
+            if(mid_element == target)
+                return true;
+            else if(mid_element >=target)
+                end = mid - 1;
+            else
+                begin = mid + 1;
+
+        }
+        return false;
+
+    }
+
+    public static void main(String[] args) {
+//        int[][]tmp = new int[][]{{1,3,5,7},{10,11,16,20},{23,30,34,60}};
+        int[][]tmp = new int[][]{{1,1}};
+        boolean b = searchMatrix(tmp, 2);
+        System.out.println(b);
+    }
+}
diff --git a/Week_04/java/WordLadder.java b/Week_04/java/WordLadder.java
new file mode 100644
index 00000000..5c883417
--- /dev/null
+++ b/Week_04/java/WordLadder.java
@@ -0,0 +1,69 @@
+import java.util.*;
+import java.util.zip.CheckedOutputStream;
+
+public class WordLadder {
+    public static int ladderLength(String beginWord, String endWord, List<String> wordList) {
+        if(beginWord.isEmpty()||endWord.isEmpty()||!wordList.contains(endWord))
+            return 0;
+
+        Set<String> wordSet = new HashSet<>(wordList); //set判断contains 优于List 很多
+        wordSet.remove(beginWord);
+        Queue<String> queue = new LinkedList<>();
+        queue.offer(beginWord);
+        Set<String> visitedSet = new HashSet<>();
+        visitedSet.add(beginWord);
+        int count = 0;
+        while(!queue.isEmpty()){
+            System.out.println("======:"+count);
+            int curSize = queue.size(); // 确定当前轮次处理值的个数
+            count++;
+            for(int i=0;i<curSize;i++) {
+                String curWord = queue.poll();
+                System.out.println(String.format("===第%s次==poll的值：%s",count,curWord));
+                if (ladderLengthSub(curWord, endWord, visitedSet, queue, wordSet)) {
+                    return count + 1;
+                }
+            }
+        }
+        return 0;
+    }
+
+    public static boolean ladderLengthSub(String curWord, String endWord, Set<String> visitedSet, Queue<String> queue, Set<String> wordList){
+        char[] chars = curWord.toCharArray();
+        for(int i=0;i<curWord.length();i++){
+            char tmp = chars[i];
+            for(char ch ='a';ch<='z';ch++){
+                if (ch == tmp) {
+                    continue;
+                }
+                chars[i] = ch;
+                String nextStr = String.valueOf(chars);
+                if(wordList.contains(nextStr)){
+                    if(nextStr.equals(endWord))
+                        return true;
+                    if(!visitedSet.contains(nextStr)) {
+                        queue.add(nextStr);
+                        visitedSet.add(nextStr);
+                        System.out.println(nextStr);
+                    }
+                }
+            }
+            chars[i] = tmp;
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+//        List<String> wordList = Arrays.asList("hot","dot","dog","lot","log","cog");
+//        System.out.println(ladderLength("hit", "cog", wordList));
+//        List<String> wordList = Arrays.asList("a","b","c");
+//        System.out.println(ladderLength("a", "c", wordList));
+        List<String> wordList = Arrays.asList("slit","bunk","wars","ping","viva","wynn","wows","irks","gang","pool","mock","fort","heel","send","ship","cols","alec","foal","nabs","gaze","giza","mays","dogs","karo","cums","jedi","webb","lend","mire","jose","catt","grow","toss","magi","leis","bead","kara","hoof","than","ires","baas","vein","kari","riga","oars","gags","thug","yawn","wive","view","germ","flab","july","tuck","rory","bean","feed","rhee","jeez","gobs","lath","desk","yoko","cute","zeus","thus","dims","link","dirt","mara","disc","limy","lewd","maud","duly","elsa","hart","rays","rues","camp","lack","okra","tome","math","plug","monk","orly","friz","hogs","yoda","poop","tick","plod","cloy","pees","imps","lead","pope","mall","frey","been","plea","poll","male","teak","soho","glob","bell","mary","hail","scan","yips","like","mull","kory","odor","byte","kaye","word","honk","asks","slid","hopi","toke","gore","flew","tins","mown","oise","hall","vega","sing","fool","boat","bobs","lain","soft","hard","rots","sees","apex","chan","told","woos","unit","scow","gilt","beef","jars","tyre","imus","neon","soap","dabs","rein","ovid","hose","husk","loll","asia","cope","tail","hazy","clad","lash","sags","moll","eddy","fuel","lift","flog","land","sigh","saks","sail","hook","visa","tier","maws","roeg","gila","eyes","noah","hypo","tore","eggs","rove","chap","room","wait","lurk","race","host","dada","lola","gabs","sobs","joel","keck","axed","mead","gust","laid","ends","oort","nose","peer","kept","abet","iran","mick","dead","hags","tens","gown","sick","odis","miro","bill","fawn","sumo","kilt","huge","ores","oran","flag","tost","seth","sift","poet","reds","pips","cape","togo","wale","limn","toll","ploy","inns","snag","hoes","jerk","flux","fido","zane","arab","gamy","raze","lank","hurt","rail","hind","hoot","dogy","away","pest","hoed","pose","lose","pole","alva","dino","kind","clan","dips","soup","veto","edna","damp","gush","amen","wits","pubs","fuzz","cash","pine","trod","gunk","nude","lost","rite","cory","walt","mica","cart","avow","wind","book","leon","life","bang","draw","leek","skis","dram","ripe","mine","urea","tiff","over","gale","weir","defy","norm","tull","whiz","gill","ward","crag","when","mill","firs","sans","flue","reid","ekes","jain","mutt","hems","laps","piss","pall","rowe","prey","cull","knew","size","wets","hurl","wont","suva","girt","prys","prow","warn","naps","gong","thru","livy","boar","sade","amok","vice","slat","emir","jade","karl","loyd","cerf","bess","loss","rums","lats","bode","subs","muss","maim","kits","thin","york","punt","gays","alpo","aids","drag","eras","mats","pyre","clot","step","oath","lout","wary","carp","hums","tang","pout","whip","fled","omar","such","kano","jake","stan","loop","fuss","mini","byrd","exit","fizz","lire","emil","prop","noes","awed","gift","soli","sale","gage","orin","slur","limp","saar","arks","mast","gnat","port","into","geed","pave","awls","cent","cunt","full","dint","hank","mate","coin","tars","scud","veer","coax","bops","uris","loom","shod","crib","lids","drys","fish","edit","dick","erna","else","hahs","alga","moho","wire","fora","tums","ruth","bets","duns","mold","mush","swop","ruby","bolt","nave","kite","ahem","brad","tern","nips","whew","bait","ooze","gino","yuck","drum","shoe","lobe","dusk","cult","paws","anew","dado","nook","half","lams","rich","cato","java","kemp","vain","fees","sham","auks","gish","fire","elam","salt","sour","loth","whit","yogi","shes","scam","yous","lucy","inez","geld","whig","thee","kelp","loaf","harm","tomb","ever","airs","page","laud","stun","paid","goop","cobs","judy","grab","doha","crew","item","fogs","tong","blip","vest","bran","wend","bawl","feel","jets","mixt","tell","dire","devi","milo","deng","yews","weak","mark","doug","fare","rigs","poke","hies","sian","suez","quip","kens","lass","zips","elva","brat","cosy","teri","hull","spun","russ","pupa","weed","pulp","main","grim","hone","cord","barf","olav","gaps","rote","wilt","lars","roll","balm","jana","give","eire","faun","suck","kegs","nita","weer","tush","spry","loge","nays","heir","dope","roar","peep","nags","ates","bane","seas","sign","fred","they","lien","kiev","fops","said","lawn","lind","miff","mass","trig","sins","furl","ruin","sent","cray","maya","clog","puns","silk","axis","grog","jots","dyer","mope","rand","vend","keen","chou","dose","rain","eats","sped","maui","evan","time","todd","skit","lief","sops","outs","moot","faze","biro","gook","fill","oval","skew","veil","born","slob","hyde","twin","eloy","beat","ergs","sure","kobe","eggo","hens","jive","flax","mons","dunk","yest","begs","dial","lodz","burp","pile","much","dock","rene","sago","racy","have","yalu","glow","move","peps","hods","kins","salk","hand","cons","dare","myra","sega","type","mari","pelt","hula","gulf","jugs","flay","fest","spat","toms","zeno","taps","deny","swag","afro","baud","jabs","smut","egos","lara","toes","song","fray","luis","brut","olen","mere","ruff","slum","glad","buds","silt","rued","gelt","hive","teem","ides","sink","ands","wisp","omen","lyre","yuks","curb","loam","darn","liar","pugs","pane","carl","sang","scar","zeds","claw","berg","hits","mile","lite","khan","erik","slug","loon","dena","ruse","talk","tusk","gaol","tads","beds","sock","howe","gave","snob","ahab","part","meir","jell","stir","tels","spit","hash","omit","jinx","lyra","puck","laue","beep","eros","owed","cede","brew","slue","mitt","jest","lynx","wads","gena","dank","volt","gray","pony","veld","bask","fens","argo","work","taxi","afar","boon","lube","pass","lazy","mist","blot","mach","poky","rams","sits","rend","dome","pray","duck","hers","lure","keep","gory","chat","runt","jams","lays","posy","bats","hoff","rock","keri","raul","yves","lama","ramp","vote","jody","pock","gist","sass","iago","coos","rank","lowe","vows","koch","taco","jinn","juno","rape","band","aces","goal","huck","lila","tuft","swan","blab","leda","gems","hide","tack","porn","scum","frat","plum","duds","shad","arms","pare","chin","gain","knee","foot","line","dove","vera","jays","fund","reno","skid","boys","corn","gwyn","sash","weld","ruiz","dior","jess","leaf","pars","cote","zing","scat","nice","dart","only","owls","hike","trey","whys","ding","klan","ross","barb","ants","lean","dopy","hock","tour","grip","aldo","whim","prom","rear","dins","duff","dell","loch","lava","sung","yank","thar","curl","venn","blow","pomp","heat","trap","dali","nets","seen","gash","twig","dads","emmy","rhea","navy","haws","mite","bows","alas","ives","play","soon","doll","chum","ajar","foam","call","puke","kris","wily","came","ales","reef","raid","diet","prod","prut","loot","soar","coed","celt","seam","dray","lump","jags","nods","sole","kink","peso","howl","cost","tsar","uric","sore","woes","sewn","sake","cask","caps","burl","tame","bulk","neva","from","meet","webs","spar","fuck","buoy","wept","west","dual","pica","sold","seed","gads","riff","neck","deed","rudy","drop","vale","flit","romp","peak","jape","jews","fain","dens","hugo","elba","mink","town","clam","feud","fern","dung","newt","mime","deem","inti","gigs","sosa","lope","lard","cara","smug","lego","flex","doth","paar","moon","wren","tale","kant","eels","muck","toga","zens","lops","duet","coil","gall","teal","glib","muir","ails","boer","them","rake","conn","neat","frog","trip","coma","must","mono","lira","craw","sled","wear","toby","reel","hips","nate","pump","mont","died","moss","lair","jibe","oils","pied","hobs","cads","haze","muse","cogs","figs","cues","roes","whet","boru","cozy","amos","tans","news","hake","cots","boas","tutu","wavy","pipe","typo","albs","boom","dyke","wail","woke","ware","rita","fail","slab","owes","jane","rack","hell","lags","mend","mask","hume","wane","acne","team","holy","runs","exes","dole","trim","zola","trek","puma","wacs","veep","yaps","sums","lush","tubs","most","witt","bong","rule","hear","awry","sots","nils","bash","gasp","inch","pens","fies","juts","pate","vine","zulu","this","bare","veal","josh","reek","ours","cowl","club","farm","teat","coat","dish","fore","weft","exam","vlad","floe","beak","lane","ella","warp","goth","ming","pits","rent","tito","wish","amps","says","hawk","ways","punk","nark","cagy","east","paul","bose","solo","teed","text","hews","snip","lips","emit","orgy","icon","tuna","soul","kurd","clod","calk","aunt","bake","copy","acid","duse","kiln","spec","fans","bani","irma","pads","batu","logo","pack","oder","atop","funk","gide","bede","bibs","taut","guns","dana","puff","lyme","flat","lake","june","sets","gull","hops","earn","clip","fell","kama","seal","diaz","cite","chew","cuba","bury","yard","bank","byes","apia","cree","nosh","judo","walk","tape","taro","boot","cods","lade","cong","deft","slim","jeri","rile","park","aeon","fact","slow","goff","cane","earp","tart","does","acts","hope","cant","buts","shin","dude","ergo","mode","gene","lept","chen","beta","eden","pang","saab","fang","whir","cove","perk","fads","rugs","herb","putt","nous","vane","corm","stay","bids","vela","roof","isms","sics","gone","swum","wiry","cram","rink","pert","heap","sikh","dais","cell","peel","nuke","buss","rasp","none","slut","bent","dams","serb","dork","bays","kale","cora","wake","welt","rind","trot","sloe","pity","rout","eves","fats","furs","pogo","beth","hued","edam","iamb","glee","lute","keel","airy","easy","tire","rube","bogy","sine","chop","rood","elbe","mike","garb","jill","gaul","chit","dons","bars","ride","beck","toad","make","head","suds","pike","snot","swat","peed","same","gaza","lent","gait","gael","elks","hang","nerf","rosy","shut","glop","pain","dion","deaf","hero","doer","wost","wage","wash","pats","narc","ions","dice","quay","vied","eons","case","pour","urns","reva","rags","aden","bone","rang","aura","iraq","toot","rome","hals","megs","pond","john","yeps","pawl","warm","bird","tint","jowl","gibe","come","hold","pail","wipe","bike","rips","eery","kent","hims","inks","fink","mott","ices","macy","serf","keys","tarp","cops","sods","feet","tear","benz","buys","colo","boil","sews","enos","watt","pull","brag","cork","save","mint","feat","jamb","rubs","roxy","toys","nosy","yowl","tamp","lobs","foul","doom","sown","pigs","hemp","fame","boor","cube","tops","loco","lads","eyre","alta","aged","flop","pram","lesa","sawn","plow","aral","load","lied","pled","boob","bert","rows","zits","rick","hint","dido","fist","marc","wuss","node","smog","nora","shim","glut","bale","perl","what","tort","meek","brie","bind","cake","psst","dour","jove","tree","chip","stud","thou","mobs","sows","opts","diva","perm","wise","cuds","sols","alan","mild","pure","gail","wins","offs","nile","yelp","minn","tors","tran","homy","sadr","erse","nero","scab","finn","mich","turd","then","poem","noun","oxus","brow","door","saws","eben","wart","wand","rosa","left","lina","cabs","rapt","olin","suet","kalb","mans","dawn","riel","temp","chug","peal","drew","null","hath","many","took","fond","gate","sate","leak","zany","vans","mart","hess","home","long","dirk","bile","lace","moog","axes","zone","fork","duct","rico","rife","deep","tiny","hugh","bilk","waft","swig","pans","with","kern","busy","film","lulu","king","lord","veda","tray","legs","soot","ells","wasp","hunt","earl","ouch","diem","yell","pegs","blvd","polk","soda","zorn","liza","slop","week","kill","rusk","eric","sump","haul","rims","crop","blob","face","bins","read","care","pele","ritz","beau","golf","drip","dike","stab","jibs","hove","junk","hoax","tats","fief","quad","peat","ream","hats","root","flak","grit","clap","pugh","bosh","lock","mute","crow","iced","lisa","bela","fems","oxes","vies","gybe","huff","bull","cuss","sunk","pups","fobs","turf","sect","atom","debt","sane","writ","anon","mayo","aria","seer","thor","brim","gawk","jack","jazz","menu","yolk","surf","libs","lets","bans","toil","open","aced","poor","mess","wham","fran","gina","dote","love","mood","pale","reps","ines","shot","alar","twit","site","dill","yoga","sear","vamp","abel","lieu","cuff","orbs","rose","tank","gape","guam","adar","vole","your","dean","dear","hebe","crab","hump","mole","vase","rode","dash","sera","balk","lela","inca","gaea","bush","loud","pies","aide","blew","mien","side","kerr","ring","tess","prep","rant","lugs","hobo","joke","odds","yule","aida","true","pone","lode","nona","weep","coda","elmo","skim","wink","bras","pier","bung","pets","tabs","ryan","jock","body","sofa","joey","zion","mace","kick","vile","leno","bali","fart","that","redo","ills","jogs","pent","drub","slaw","tide","lena","seep","gyps","wave","amid","fear","ties","flan","wimp","kali","shun","crap","sage","rune","logs","cain","digs","abut","obit","paps","rids","fair","hack","huns","road","caws","curt","jute","fisk","fowl","duty","holt","miss","rude","vito","baal","ural","mann","mind","belt","clem","last","musk","roam","abed","days","bore","fuze","fall","pict","dump","dies","fiat","vent","pork","eyed","docs","rive","spas","rope","ariz","tout","game","jump","blur","anti","lisp","turn","sand","food","moos","hoop","saul","arch","fury","rise","diss","hubs","burs","grid","ilks","suns","flea","soil","lung","want","nola","fins","thud","kidd","juan","heps","nape","rash","burt","bump","tots","brit","mums","bole","shah","tees","skip","limb","umps","ache","arcs","raft","halo","luce","bahs","leta","conk","duos","siva","went","peek","sulk","reap","free","dubs","lang","toto","hasp","ball","rats","nair","myst","wang","snug","nash","laos","ante","opal","tina","pore","bite","haas","myth","yugo","foci","dent","bade","pear","mods","auto","shop","etch","lyly","curs","aron","slew","tyro","sack","wade","clio","gyro","butt","icky","char","itch","halt","gals","yang","tend","pact","bees","suit","puny","hows","nina","brno","oops","lick","sons","kilo","bust","nome","mona","dull","join","hour","papa","stag","bern","wove","lull","slip","laze","roil","alto","bath","buck","alma","anus","evil","dumb","oreo","rare","near","cure","isis","hill","kyle","pace","comb","nits","flip","clop","mort","thea","wall","kiel","judd","coop","dave","very","amie","blah","flub","talc","bold","fogy","idea","prof","horn","shoo","aped","pins","helm","wees","beer","womb","clue","alba","aloe","fine","bard","limo","shaw","pint","swim","dust","indy","hale","cats","troy","wens","luke","vern","deli","both","brig","daub","sara","sued","bier","noel","olga","dupe","look","pisa","knox","murk","dame","matt","gold","jame","toge","luck","peck","tass","calf","pill","wore","wadi","thur","parr","maul","tzar","ones","lees","dark","fake","bast","zoom","here","moro","wine","bums","cows","jean","palm","fume","plop","help","tuba","leap","cans","back","avid","lice","lust","polo","dory","stew","kate","rama","coke","bled","mugs","ajax","arts","drug","pena","cody","hole","sean","deck","guts","kong","bate","pitt","como","lyle","siam","rook","baby","jigs","bret","bark","lori","reba","sups","made","buzz","gnaw","alps","clay","post","viol","dina","card","lana","doff","yups","tons","live","kids","pair","yawl","name","oven","sirs","gyms","prig","down","leos","noon","nibs","cook","safe","cobb","raja","awes","sari","nerd","fold","lots","pete","deal","bias","zeal","girl","rage","cool","gout","whey","soak","thaw","bear","wing","nagy","well","oink","sven","kurt","etna","held","wood","high","feta","twee","ford","cave","knot","tory","ibis","yaks","vets","foxy","sank","cone","pius","tall","seem","wool","flap","gird","lore","coot","mewl","sere","real","puts","sell","nuts","foil","lilt","saga","heft","dyed","goat","spew","daze","frye","adds","glen","tojo","pixy","gobi","stop","tile","hiss","shed","hahn","baku","ahas","sill","swap","also","carr","manx","lime","debs","moat","eked","bola","pods","coon","lacy","tube","minx","buff","pres","clew","gaff","flee","burn","whom","cola","fret","purl","wick","wigs","donn","guys","toni","oxen","wite","vial","spam","huts","vats","lima","core","eula","thad","peon","erie","oats","boyd","cued","olaf","tams","secs","urey","wile","penn","bred","rill","vary","sues","mail","feds","aves","code","beam","reed","neil","hark","pols","gris","gods","mesa","test","coup","heed","dora","hied","tune","doze","pews","oaks","bloc","tips","maid","goof","four","woof","silo","bray","zest","kiss","yong","file","hilt","iris","tuns","lily","ears","pant","jury","taft","data","gild","pick","kook","colt","bohr","anal","asps","babe","bach","mash","biko","bowl","huey","jilt","goes","guff","bend","nike","tami","gosh","tike","gees","urge","path","bony","jude","lynn","lois","teas","dunn","elul","bonn","moms","bugs","slay","yeah","loan","hulk","lows","damn","nell","jung","avis","mane","waco","loin","knob","tyke","anna","hire","luau","tidy","nuns","pots","quid","exec","hans","hera","hush","shag","scot","moan","wald","ursa","lorn","hunk","loft","yore","alum","mows","slog","emma","spud","rice","worn","erma","need","bags","lark","kirk","pooh","dyes","area","dime","luvs","foch","refs","cast","alit","tugs","even","role","toed","caph","nigh","sony","bide","robs","folk","daft","past","blue","flaw","sana","fits","barr","riot","dots","lamp","cock","fibs","harp","tent","hate","mali","togs","gear","tues","bass","pros","numb","emus","hare","fate","wife","mean","pink","dune","ares","dine","oily","tony","czar","spay","push","glum","till","moth","glue","dive","scad","pops","woks","andy","leah","cusp","hair","alex","vibe","bulb","boll","firm","joys","tara","cole","levy","owen","chow","rump","jail","lapp","beet","slap","kith","more","maps","bond","hick","opus","rust","wist","shat","phil","snow","lott","lora","cary","mote","rift","oust","klee","goad","pith","heep","lupe","ivan","mimi","bald","fuse","cuts","lens","leer","eyry","know","razz","tare","pals","geek","greg","teen","clef","wags","weal","each","haft","nova","waif","rate","katy","yale","dale","leas","axum","quiz","pawn","fend","capt","laws","city","chad","coal","nail","zaps","sort","loci","less","spur","note","foes","fags","gulp","snap","bogs","wrap","dane","melt","ease","felt","shea","calm","star","swam","aery","year","plan","odin","curd","mira","mops","shit","davy","apes","inky","hues","lome","bits","vila","show","best","mice","gins","next","roan","ymir","mars","oman","wild","heal","plus","erin","rave","robe","fast","hutu","aver","jodi","alms","yams","zero","revs","wean","chic","self","jeep","jobs","waxy","duel","seek","spot","raps","pimp","adan","slam","tool","morn","futz","ewes","errs","knit","rung","kans","muff","huhs","tows","lest","meal","azov","gnus","agar","sips","sway","otis","tone","tate","epic","trio","tics","fade","lear","owns","robt","weds","five","lyon","terr","arno","mama","grey","disk","sept","sire","bart","saps","whoa","turk","stow","pyle","joni","zinc","negs","task","leif","ribs","malt","nine","bunt","grin","dona","nope","hams","some","molt","smit","sacs","joan","slav","lady","base","heck","list","take","herd","will","nubs","burg","hugs","peru","coif","zoos","nick","idol","levi","grub","roth","adam","elma","tags","tote","yaws","cali","mete","lula","cubs","prim","luna","jolt","span","pita","dodo","puss","deer","term","dolt","goon","gary","yarn","aims","just","rena","tine","cyst","meld","loki","wong","were","hung","maze","arid","cars","wolf","marx","faye","eave","raga","flow","neal","lone","anne","cage","tied","tilt","soto","opel","date","buns","dorm","kane","akin","ewer","drab","thai","jeer","grad","berm","rods","saki","grus","vast","late","lint","mule","risk","labs","snit","gala","find","spin","ired","slot","oafs","lies","mews","wino","milk","bout","onus","tram","jaws","peas","cleo","seat","gums","cold","vang","dewy","hood","rush","mack","yuan","odes","boos","jami","mare","plot","swab","borg","hays","form","mesh","mani","fife","good","gram","lion","myna","moor","skin","posh","burr","rime","done","ruts","pays","stem","ting","arty","slag","iron","ayes","stub","oral","gets","chid","yens","snub","ages","wide","bail","verb","lamb","bomb","army","yoke","gels","tits","bork","mils","nary","barn","hype","odom","avon","hewn","rios","cams","tact","boss","oleo","duke","eris","gwen","elms","deon","sims","quit","nest","font","dues","yeas","zeta","bevy","gent","torn","cups","worm","baum","axon","purr","vise","grew","govs","meat","chef","rest","lame");
+        System.out.println(ladderLength("sand", "acne", wordList));
+
+        Queue<Integer> q = new PriorityQueue<>((o1,o2)-> o2-o1);
+
+
+    }
+
+}
diff --git a/Week_05/java/LastStone.java b/Week_05/java/LastStone.java
new file mode 100644
index 00000000..e33f10f9
--- /dev/null
+++ b/Week_05/java/LastStone.java
@@ -0,0 +1,57 @@
+import java.util.Arrays;
+import java.util.Comparator;
+import java.util.PriorityQueue;
+
+public class LastStone {
+
+    public static int lastStoneWeight(int[] stones) {
+        Arrays.sort(stones);
+        while(stones.length>=2){
+            int len = stones.length;
+            if(stones[len-1]==stones[len-2]) {
+                stones = Arrays.copyOf(stones, len - 2);
+            }else {
+                stones[len-2] = stones[len-1] - stones[len-2];
+                stones = Arrays.copyOf(stones, len - 1);
+            }
+            Arrays.sort(stones);
+            System.out.println(Arrays.toString(stones));
+        }
+        if(stones.length==1) return stones[0];
+        else return 0;
+
+    }
+
+    public static int lastStoneWeight1(int[] stones) {
+
+//        Comparator<Integer> comparator = new Comparator<Integer>() {
+//            @Override
+//            public int compare(Integer o1, Integer o2) {
+//                return (o2 - o1);
+//            }
+//        };
+        PriorityQueue<Integer> pq = new PriorityQueue<>(
+                (o1, o2) -> o2-o1
+        );
+        for(Integer stone: stones){
+            pq.add(stone);
+        }
+        while(pq.size()>1){
+            int last1 = pq.poll();
+            int last2 = pq.poll();
+            if(last1!=last2)pq.add(last1-last2);
+        }
+        if(pq.size()==1) return pq.poll();
+        return 0;
+    }
+
+
+
+
+
+    public static void main(String[] args) {
+        int[] stones = new int[]{2,7,4,1,8,1};
+        int i = lastStoneWeight1(stones);
+        System.out.println(i);
+    }
+}
diff --git a/Week_05/java/LongestCommonSubsequence.java b/Week_05/java/LongestCommonSubsequence.java
new file mode 100644
index 00000000..935d3acc
--- /dev/null
+++ b/Week_05/java/LongestCommonSubsequence.java
@@ -0,0 +1,23 @@
+public class LongestCommonSubsequence {
+    //1143. 最长公共子序列
+    public static int longestCommonSubsequence(String text1, String text2) {
+        int m = text1.length();
+        int 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++){
+                if(text1.charAt(i)==text2.charAt(j)){
+                    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];
+    }
+
+    public static void main(String[] args) {
+        int i = longestCommonSubsequence("abcde", "ace");
+        System.out.println(i);
+    }
+}
diff --git a/Week_05/java/LongestIncreasingSubsequence.java b/Week_05/java/LongestIncreasingSubsequence.java
new file mode 100644
index 00000000..1d642403
--- /dev/null
+++ b/Week_05/java/LongestIncreasingSubsequence.java
@@ -0,0 +1,34 @@
+import java.util.Arrays;
+
+public class LongestIncreasingSubsequence {
+    public int lengthOfLIS(int[] nums) {
+        int len = nums.length;
+        if(len<2) {
+            return len;
+        }
+        int[] dp = new int[len];
+        int rst = 0;
+        Arrays.fill(dp,1);
+        for(int i=1;i<len;i++){
+            for(int j = 0;j<i;j++){
+                if(nums[i]>nums[j]){
+                    dp[i]=Math.max(dp[i],dp[j]+1);
+                }
+            }
+            rst = Math.max(rst, dp[i]);
+
+        }
+        return rst;
+
+
+    }
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{1,3,6,7,9,4,10,5,6};
+        LongestIncreasingSubsequence obj = new LongestIncreasingSubsequence();
+        System.out.println(obj.lengthOfLIS(nums));
+
+    }
+
+
+}
diff --git a/Week_05/java/Mininum.java b/Week_05/java/Mininum.java
new file mode 100644
index 00000000..70fa4d37
--- /dev/null
+++ b/Week_05/java/Mininum.java
@@ -0,0 +1,47 @@
+import java.util.*;
+
+public class Mininum {
+    /**
+     * 433. 最小基因变化 //广度优先遍历
+     */
+    public int minMutation(String start, String end, String[] bank) {
+        Set<String> bankSet = new HashSet<String>(Arrays.asList(bank));
+        if(!bankSet.contains(end)) return -1;
+        Queue<String> queue = new LinkedList<>();
+        queue.offer(start);
+        Set<String> visited = new HashSet<>();
+        visited.add(start);
+        int count = 1;
+        while(!queue.isEmpty()){
+            int len = queue.size();
+            for(int i=0;i<len;i++){
+                String curStr = queue.poll();
+                if(minSub(curStr, end, bankSet, queue, visited))
+                    return count;
+            }
+            count++;
+        }
+        return -1;
+    }
+    public boolean minSub(String curStr, String end, Set<String> bankSet, Queue<String> queue, Set<String> visited){
+        char[] chars = curStr.toCharArray();
+        char[] charBank = new char[]{'A','C','G','T'};
+        for(int i=0;i<chars.length;i++){
+            char tmp = chars[i];
+            for(char ch : charBank){
+                chars[i] = ch;
+                String nextStr = String.copyValueOf(chars);
+                if(bankSet.contains(nextStr)){
+                    if(end.equals(nextStr))
+                        return true;
+                    if(!visited.contains(nextStr)){
+                        queue.add(nextStr);
+                        visited.add(nextStr);
+                    }
+                }
+            }
+            chars[i] = tmp;
+        }
+        return false;
+    }
+}
diff --git a/Week_05/java/NonOverlappingIntervals.java b/Week_05/java/NonOverlappingIntervals.java
new file mode 100644
index 00000000..8721a55e
--- /dev/null
+++ b/Week_05/java/NonOverlappingIntervals.java
@@ -0,0 +1,41 @@
+import java.util.Arrays;
+import java.util.Comparator;
+
+/**
+ * 435. 无重叠区间
+ * 贪心算法
+ * 排序 + 比较尾部
+ */
+public class NonOverlappingIntervals {
+    public static int eraseOverlapIntervals(int[][] intervals) {
+
+        Arrays.sort(intervals, new Comparator<int[]>() {
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                return o1[1]-o2[1];
+            }
+        });
+
+        if(intervals.length==0) return 0;
+        int count = 1;
+        int x_end = intervals[0][1];
+        for(int i =1;i<intervals.length;i++){
+            System.out.println(intervals[i][0]);
+            if(intervals[i][0]>=x_end){
+                count++;
+                x_end = intervals[i][1];
+            }
+        }
+        return intervals.length-count;
+    }
+
+    public static void main(String[] args) {
+
+        int[][] secArray = new int[][]{{1,2}, {2,3}};
+//        int[][] secArray = new int[][]{{1,100},{11,22},{1,11},{2,12}};
+        int i = eraseOverlapIntervals(secArray);
+        System.out.println(i);
+    }
+
+
+}
diff --git a/Week_05/java/Struct.java b/Week_05/java/Struct.java
new file mode 100644
index 00000000..92a96c04
--- /dev/null
+++ b/Week_05/java/Struct.java
@@ -0,0 +1,18 @@
+import java.util.*;
+
+public class Struct {
+    public static void main(String[] args) {
+
+        String[] strArray = new String[3];
+        List<String> strList = new ArrayList<>();
+        Map<String,String> map = new HashMap<>();
+        Set<String> set = new HashSet<>();
+        Stack<String> stack = new Stack<>();
+        Queue<String> queue = new LinkedList<>();
+        //PriorityQueue 优先队列 java用其实现大小根堆
+        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(
+                (o1, o2) -> (o2-o1) //升序排列
+        );
+
+    }
+}
diff --git a/Week_05/java/UniquePaths.java b/Week_05/java/UniquePaths.java
new file mode 100644
index 00000000..27ba9f6a
--- /dev/null
+++ b/Week_05/java/UniquePaths.java
@@ -0,0 +1,16 @@
+public class UniquePaths {
+    //62. 不同路径
+    public int uniquePaths(int m, int n) {
+        int[][] dp = new int[m][n];
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                if(i==0||j==0){
+                    dp[i][j] = 1;
+                }else {
+                    dp[i][j]=dp[i][j-1]+dp[i-1][j];
+                }
+            }
+        }
+        return dp[m-1][n-1];
+    }
+}
diff --git a/Week_05/java/slidingWindowMax.java b/Week_05/java/slidingWindowMax.java
new file mode 100644
index 00000000..6384ee18
--- /dev/null
+++ b/Week_05/java/slidingWindowMax.java
@@ -0,0 +1,40 @@
+import java.util.*;
+
+/**
+ * 滑动窗口
+ * 使用双端对列，头放最大的数
+ */
+public class slidingWindowMax {
+    public static int[] maxSlidingWindow(int[] nums, int k) {
+        Deque<Integer> deque = new LinkedList<>();
+        int len = nums.length;
+        int[] rst = new int[len-k+1];
+        int index = 0;
+        for(int i=0; i<len; i++){
+            if(!deque.isEmpty()&&deque.peekFirst()+k<=i) { //判断头部数据的是否还满足滑动窗口的要求
+                deque.pollFirst();
+            }
+
+            while(!deque.isEmpty() && nums[deque.peekLast()]<nums[i]){ //从后向前判断，将小的数据全部删除
+                deque.pollLast();
+            }
+            deque.addLast(i);
+            if(index+k-1==i) {
+                rst[index++] = nums[deque.peekFirst()]; //头部是最大值
+            }
+        }
+
+        return rst;
+
+    }
+
+
+    public static void main(String[] args) {
+//        int[] nums = new int[]{9,11,15,2,18};
+        int[] nums = new int[]{1,3,1,2,0,5};
+        int[] rst = maxSlidingWindow(nums, 3);
+        for(int i:rst){
+            System.out.println(i);
+        }
+    }
+}
diff --git a/Week_06/java/CoinChange.java b/Week_06/java/CoinChange.java
new file mode 100644
index 00000000..9101d0c4
--- /dev/null
+++ b/Week_06/java/CoinChange.java
@@ -0,0 +1,53 @@
+import java.util.Arrays;
+import java.util.List;
+
+/**
+ * 322. 零钱兑换
+ *  使用动态规划
+ */
+public class CoinChange {
+    public static int coinChange(int[] coins, int amount) {
+        int[] store = new int[amount+1];
+        store[0]=0;
+        for(int i=1;i<=amount;i++){
+            int min = Integer.MAX_VALUE;
+            for(int coin : coins){
+                if(i>=coin && store[i-coin]<min){
+                    min = store[i-coin]+1;
+                }
+            }
+            store[i] = min;
+        }
+        return store[amount]==Integer.MAX_VALUE ? -1: store[amount];
+    }
+
+    /**
+     * 第二种方式 使用贪心+DFS
+     * 先使用最大面值的币去换 -> 然后回溯减少较大面值的币
+     *
+     */
+    public static int min=Integer.MAX_VALUE;
+    public static int coinChange1(int[] coins, int amount) {
+        if(amount == 0) return 0;
+        Arrays.sort(coins);
+        coinChangeSun(coins, amount, coins.length-1,0);
+        return min==Integer.MAX_VALUE ? -1 : min;
+    }
+    public static void coinChangeSun(int[] coins, int amount, int coinIndex, int coinNum){
+        if(amount==0)
+            min = Math.min(min, coinNum);
+        if(coinIndex<0)
+            return;
+
+        for(int i=amount/coins[coinIndex]; i>=0 && i+coinNum<min; i--){
+            coinChangeSun(coins, amount-coins[coinIndex]*i, coinIndex-1,i+coinNum);
+        }
+
+    }
+
+
+    public static void main(String[] args) {
+        int[] coins = new int[]{1, 2, 5};
+        System.out.println(coinChange(coins, 11));
+    }
+}
diff --git a/Week_06/java/FrogJump.java b/Week_06/java/FrogJump.java
new file mode 100644
index 00000000..66137b84
--- /dev/null
+++ b/Week_06/java/FrogJump.java
@@ -0,0 +1,33 @@
+/**
+ * 青蛙过河
+ * dp[i][k] 表示能否由前面的某一个石头 j 通过跳 k 步到达当前这个石头 i ，这个 j 的范围是 [1, i - 1]
+ *          当然，这个 k 步是 i 石头 和 j 石头之间的距离
+ *          那么对于 j 石头来说，跳到 j 石头的上一个石头的步数就必须是这个 k - 1 || k || k + 1
+ *          由此可得状态转移方程：dp[i][k] = dp[j][k - 1] || dp[j][k] || dp[j][k + 1]
+ */
+public class FrogJump {
+
+    public boolean canCross(int[] stones) {
+        int len = stones.length;
+        if(stones[1] != 1){
+            return false;
+        }
+        boolean[][] dp = new boolean[len][len+1];
+        dp[0][0]= true;
+
+        for(int i=1;i<len;i++){
+            for(int j=0; j<i; j++){
+                int k = stones[i]-stones[j];
+                if(k <= j + 1){
+                    dp[i][k] = dp[j][k - 1] || dp[j][k] || dp[j][k + 1];
+                    //提前结束循环直接返回结果
+                    if(i == len - 1 && dp[i][k]){
+                        return true;
+                    }
+                }
+            }
+
+        }
+        return false;
+    }
+}
diff --git a/Week_06/java/HouseRobber.java b/Week_06/java/HouseRobber.java
new file mode 100644
index 00000000..1888ae11
--- /dev/null
+++ b/Week_06/java/HouseRobber.java
@@ -0,0 +1,107 @@
+import java.util.Arrays;
+
+/**
+ * 213. 打家劫舍 II
+ * 使用动态规划
+ */
+public class HouseRobber {
+    /**
+     * 使用二维数组， 二维使用0,1表示偷或不偷
+     * @param nums
+     * @return
+     */
+    public static int rob(int[] nums) {
+        int len = nums.length;
+        if (len==1){
+            return nums[0];
+        }
+        int[][] house1 = new int[nums.length][2];
+        int[][] house2 = new int[nums.length][2];
+        house1[0][0] = 0;
+        house1[0][1] = nums[0];
+        house2[1][0] = 0;
+        house2[1][1] = nums[1];
+        for(int i=1;i<len-1;i++){
+            house1[i][0] = Math.max(house1[i-1][0],house1[i-1][1]);
+            house1[i][1] = house1[i-1][0]+nums[i];
+        }
+        int first = Math.max(house1[len-2][0], house1[len-2][1]);
+        for(int i=2;i<len;i++){
+            house2[i][0] = Math.max(house2[i-1][0],house2[i-1][1]);
+            house2[i][1] = house2[i-1][0]+nums[i];
+        }
+        int second = Math.max(house2[len-1][0],house2[len-1][1]);
+        return Math.max(first, second);
+    }
+
+    /**
+     * 使用一维数组
+     * @param nums
+     * @return
+     */
+    public static int rob1(int[] nums) {
+        int len = nums.length;
+        if (len<=2){
+            Arrays.sort(nums);
+            return nums[len-1];
+        }
+
+        int[] house1 = new int[nums.length];
+        int[] house2 = new int[nums.length];
+        house1[0] = nums[0];
+        house1[1] = Math.max(nums[0],nums[1]);
+
+        house2[1] = nums[1];
+        house2[2] = Math.max(nums[1],nums[2]);
+
+        for(int i=2;i<len-1;i++){
+            house1[i] = Math.max(house1[i-1],house1[i-2]+nums[i]);
+        }
+        for(int i=3;i<len;i++){
+            house2[i] = Math.max(house2[i-1],house2[i-2]+nums[i]);
+        }
+        return Math.max(house1[len-2],house2[len-1]);
+    }
+
+    /**
+     * 使用数字 （只存前面两家能偷的钱）
+     * @param nums
+     * @return
+     */
+    public static int rob2(int[] nums) {
+        int len = nums.length;
+        if (len<=2){
+            Arrays.sort(nums);
+            return nums[len-1];
+        }
+        int housePre1 = nums[0];
+        int houseNow1 = Math.max(nums[0],nums[1]);
+
+
+        int housePre2 = nums[1];
+        int houseNow2 = Math.max(nums[1],nums[2]);
+
+        for(int i=2;i<len-1;i++){
+            int tmp = houseNow1;
+            houseNow1 = Math.max(housePre1+nums[i], houseNow1);
+            housePre1 = tmp;
+        }
+        int house1 = Math.max(housePre1, houseNow1);
+        for(int i=3;i<len;i++){
+            int tmp = houseNow2;
+            houseNow2 = Math.max(housePre2+nums[i], houseNow2);
+            housePre2 = tmp;
+        }
+        int house2 = Math.max(housePre2, houseNow2);
+        return Math.max(house1,house2);
+    }
+
+
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{2,3,2,0};
+        System.out.println(rob(nums));
+        System.out.println(rob1(nums));
+        System.out.println(rob2(nums));
+    }
+}
diff --git a/Week_06/java/HouseRobber1.java b/Week_06/java/HouseRobber1.java
new file mode 100644
index 00000000..ff4e6022
--- /dev/null
+++ b/Week_06/java/HouseRobber1.java
@@ -0,0 +1,25 @@
+import java.util.Arrays;
+
+public class HouseRobber1 {
+    public static int rob(int[] nums) {
+        int len = nums.length;
+        if(len==0) return 0;
+
+        int[] house = new int[len+1];
+
+        house[0] = 0; //偷第一家
+        house[1] = nums[0];
+
+        for(int i=2;i<=len;i++){
+            house[i] = Math.max(house[i-2]+nums[i-1], house[i-1]);
+        }
+
+        return house[len];
+    }
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{2,7,9,3,1};
+        System.out.println(rob(nums));
+    }
+
+}
diff --git a/Week_06/java/JumpGameII.java b/Week_06/java/JumpGameII.java
new file mode 100644
index 00000000..81c7341f
--- /dev/null
+++ b/Week_06/java/JumpGameII.java
@@ -0,0 +1,26 @@
+/**
+ * 跳跃游戏II
+ * 贪心算法
+ */
+public class JumpGameII {
+    public static int jump(int[] nums) {
+        int length = nums.length;
+        int end = 0;
+        int maxPosition = 0;
+        int steps = 0;
+        for (int i = 0; i < length - 1; i++) {
+            maxPosition = Math.max(maxPosition, i + nums[i]);
+            if (i == end) { //end 是这一轮能到的最远距离
+                end = maxPosition; //更新下一轮能到达的最远距离
+                steps++;
+            }
+        }
+        return steps;
+    }
+
+    public static void main(String[] args) {
+//        int[] nums = new int[]{1,2,3};
+        int[] nums = new int[]{2,3,1,1,4};
+        System.out.println(jump(nums));
+    }
+}
diff --git a/Week_06/java/MaximalSquare.java b/Week_06/java/MaximalSquare.java
new file mode 100644
index 00000000..59e5e2eb
--- /dev/null
+++ b/Week_06/java/MaximalSquare.java
@@ -0,0 +1,30 @@
+/**
+ * 最大正方形 三者取最小+1
+ */
+public class MaximalSquare {
+    public static int maximalSquare(char[][] matrix) {
+        int m = matrix.length;
+        if(m==0) return 0;
+        int n = matrix[0].length;
+        int[][] dp = new int[m+1][n+1];
+        int maxSquare = Integer.MIN_VALUE;
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                if(matrix[i][j] == '1'){
+                    dp[i+1][j+1] = Math.min(dp[i][j] ,Math.min(dp[i][j+1],dp[i+1][j]))+1;
+                    maxSquare = Math.max(maxSquare, dp[i+1][j+1]);
+                }
+            }
+        }
+        return maxSquare*maxSquare;
+    }
+
+    public static void main(String[] args) {
+        char [][]matrix = new char[][]{{'1','0','1','0','0'},{'1','0','1','1','1'},{'1','1','1','1','1'},{'1','0','0','1','0'}};
+        System.out.println(maximalSquare(matrix));
+
+
+    }
+
+
+}
diff --git a/Week_06/java/MaximumProductSubarray.java b/Week_06/java/MaximumProductSubarray.java
new file mode 100644
index 00000000..cfb56384
--- /dev/null
+++ b/Week_06/java/MaximumProductSubarray.java
@@ -0,0 +1,31 @@
+/**
+ * 152. 乘积最大子数组
+ * 使用动态规划
+ * 维护两极元素
+ */
+public class MaximumProductSubarray {
+    public static int maxProduct(int[] nums) {
+        int max = nums[0];
+        int maxNum = nums[0];
+        int minNum = nums[0];
+        for(int i=1;i<nums.length;i++){
+            if(nums[i]<0){
+                int tmp = minNum;
+                minNum = maxNum;
+                maxNum = tmp;
+            }
+            maxNum = Math.max(maxNum*nums[i],nums[i]);
+            minNum = Math.min(minNum*nums[i],nums[i]);
+
+            max = Math.max(maxNum, max);
+        }
+        return Math.max(max, minNum);
+
+    }
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{2,3,-2,4};
+        System.out.println(maxProduct(nums));
+    }
+
+}
diff --git a/Week_07/java/ShortestPathInBinaryMatrix.java b/Week_07/java/ShortestPathInBinaryMatrix.java
new file mode 100644
index 00000000..a2dffbdd
--- /dev/null
+++ b/Week_07/java/ShortestPathInBinaryMatrix.java
@@ -0,0 +1,68 @@
+import java.util.*;
+
+//class Node implements Comparable<Node>{
+//    int x;
+//    int y;
+//    int step;
+//
+//    @Override
+//    public int compareTo(Node o) {
+//        return this.step-o.step;
+//    }
+//}
+
+/**
+ * 1091. 二进制矩阵中的最短路径
+ * BFS 慢
+ */
+public class ShortestPathInBinaryMatrix {
+    public static int shortestPathBinaryMatrix(int[][] grid) {
+//        PriorityQueue<Integer> pq = new PriorityQueue<>();
+        int m = grid.length;
+        int n = grid[0].length;
+        if(grid[0][0]==1||grid[m-1][n-1]==1) return -1;
+        if(m==1&&n==1) return 1;
+
+        int[][] directions = {{1,1},{-1,1},{1,-1},{-1,-1},{0,1},{0,-1},{1,0},{-1,0}};
+        Queue<int[]> queue = new LinkedList<>();
+        grid[0][0]=1;
+
+        queue.offer(new int[]{0,0});
+        int pathLen = 1;
+        while (!queue.isEmpty()){
+            int size = queue.size();
+            while(size-->0) {
+                int[] xy = queue.poll();
+                for (int[] d : directions) {
+                    int nextX = xy[0] + d[0];
+                    int nextY = xy[1] + d[1];
+                    if (nextX < 0 || nextX >= m || nextY < 0 || nextY >= n)
+                        continue;
+                    if (grid[nextX][nextY] != 1) {
+                        grid[nextX][nextY] = 1;
+                        System.out.println(nextX + ":" + nextY);
+                        queue.offer(new int[]{nextX, nextY});
+                    }
+                    if (nextX == m - 1 && nextY == n - 1) {
+                        return pathLen + 1;
+                    }
+                }
+            }
+            pathLen++;
+        }
+        return -1;
+    }
+
+    public static void main(String[] args) {
+//        int[][] grid = new int[][]{{0,0,0},{1,1,0},{1,1,0}};
+//        int[][] grid = new int[][]{{0,0,0},{1,1,0},{1,1,0}};
+        int[][] grid = new int[][]{{0}};
+        System.out.println(shortestPathBinaryMatrix(grid));
+    }
+
+}
+//"""
+//000
+//110
+//110
+//"""
diff --git a/Week_07/java/WordLadder1.java b/Week_07/java/WordLadder1.java
new file mode 100644
index 00000000..e2cc1e57
--- /dev/null
+++ b/Week_07/java/WordLadder1.java
@@ -0,0 +1,110 @@
+import java.util.*;
+
+/**
+ * 单词接龙
+ */
+public class WordLadder1 {
+    /**
+     * BFS
+     */
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+
+        Set<String> wordSet = new HashSet<>(wordList);
+        if (!wordList.contains(endWord)) return 0;
+
+        Queue<String> queue = new LinkedList<>();
+        queue.offer(beginWord);
+        Set<String> visitedSet = new HashSet<>();
+        visitedSet.add(beginWord);
+        int count=1;
+        while(!queue.isEmpty()){
+            int len = queue.size();
+            for(int i=0;i<len;i++){
+                String curStr = queue.poll();
+                if(ladderLengthSub(curStr, endWord, wordSet, queue, visitedSet)){
+                    return count +1;
+                }
+            }
+            count++;
+        }
+        return 0;
+
+    }
+
+    public boolean ladderLengthSub(String curStr, String endWord, Set<String> wordSet, Queue<String> queue, Set<String> visitedSet) {
+        char[] curChars = curStr.toCharArray();
+        for(int i = 0;i<curChars.length;i++){
+            char tmp = curChars[i];
+            for(char ch = 'a';ch<='z';ch++){
+                curChars[i]=ch;
+                String nextStr = String.valueOf(curChars);
+                if(wordSet.contains(nextStr)){
+                    if(endWord.equals(nextStr))
+                        return true;
+                    if(!visitedSet.contains(nextStr)){
+                        queue.offer(nextStr);
+                        visitedSet.add(nextStr);
+                    }
+                }
+            }
+            curChars[i] = tmp;
+        }
+        return false;
+    }
+
+    /**
+     * 双向BFS
+     */
+    public static int ladderLength2(String beginWord, String endWord, List<String> wordList) {
+        Set<String> wordSet = new HashSet<>(wordList);
+        if(!wordSet.contains(endWord))
+            return 0;
+        Set<String> beginSet = new HashSet<>();
+        Set<String> endSet = new HashSet<>();
+        Set<String> visitedSet = new HashSet<>();
+        int count = 1;
+        beginSet.add(beginWord);
+        endSet.add(endWord);
+        while(!beginSet.isEmpty()||!endSet.isEmpty()){
+            if(beginSet.size()>endSet.size()||beginSet.isEmpty()){
+                Set<String> tmpset = beginSet;
+                beginSet = endSet;
+                endSet = tmpset;
+            }
+
+            Set<String> nextBeginSet = new HashSet<>();
+            if(ladderLengthSub2(wordSet, beginSet,endSet,visitedSet, nextBeginSet))
+                return count+1;
+            beginSet = nextBeginSet;
+            count++;
+        }
+        return 0;
+    }
+
+    public static boolean ladderLengthSub2(Set<String> wordSet, Set<String> beginSet, Set<String> endSet, Set<String> visitedSet, Set<String> nextBeginSet) {
+        for(String curStr:beginSet) {
+            char[] curChars = curStr.toCharArray();
+            for(int i = 0;i<curChars.length;i++){
+                char tmp = curChars[i];
+                for(char ch = 'a';ch<='z';ch++){
+                    curChars[i]=ch;
+                    String nextStr = String.valueOf(curChars);
+                    if(endSet.contains(nextStr))
+                        return true;
+                    if(!visitedSet.contains(nextStr)&&wordSet.contains(nextStr)){
+                        nextBeginSet.add(nextStr);
+                        visitedSet.add(nextStr);
+                    }
+                }
+                curChars[i] = tmp;
+            }
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+//        List<String> wordList = Arrays.asList("hot", "dot", "dog", "lot", "log");
+        List<String> wordList = Arrays.asList("hot", "dog");
+        System.out.println(ladderLength2("hot", "dog", wordList));
+    }
+}
diff --git a/Week_07/java/WordLadder2.java b/Week_07/java/WordLadder2.java
new file mode 100644
index 00000000..b2a5cc01
--- /dev/null
+++ b/Week_07/java/WordLadder2.java
@@ -0,0 +1,110 @@
+import java.util.*;
+
+/**
+ * 单词接龙
+ */
+public class WordLadder2 {
+    /**
+     * BFS
+     */
+    public int ladderLength(String beginWord, String endWord, List<String> wordList) {
+
+        Set<String> wordSet = new HashSet<>(wordList);
+        if (!wordList.contains(endWord)) return 0;
+
+        Queue<String> queue = new LinkedList<>();
+        queue.offer(beginWord);
+        Set<String> visitedSet = new HashSet<>();
+        visitedSet.add(beginWord);
+        int count=1;
+        while(!queue.isEmpty()){
+            int len = queue.size();
+            for(int i=0;i<len;i++){
+                String curStr = queue.poll();
+                if(ladderLengthSub(curStr, endWord, wordSet, queue, visitedSet)){
+                    return count +1;
+                }
+            }
+            count++;
+        }
+        return 0;
+
+    }
+
+    public boolean ladderLengthSub(String curStr, String endWord, Set<String> wordSet, Queue<String> queue, Set<String> visitedSet) {
+        char[] curChars = curStr.toCharArray();
+        for(int i = 0;i<curChars.length;i++){
+            char tmp = curChars[i];
+            for(char ch = 'a';ch<='z';ch++){
+                curChars[i]=ch;
+                String nextStr = String.valueOf(curChars);
+                if(wordSet.contains(nextStr)){
+                    if(endWord.equals(nextStr))
+                        return true;
+                    if(!visitedSet.contains(nextStr)){
+                        queue.offer(nextStr);
+                        visitedSet.add(nextStr);
+                    }
+                }
+            }
+            curChars[i] = tmp;
+        }
+        return false;
+    }
+
+    /**
+     * 双向BFS
+     */
+    public static int ladderLength2(String beginWord, String endWord, List<String> wordList) {
+        Set<String> wordSet = new HashSet<>(wordList);
+        if(!wordSet.contains(endWord))
+            return 0;
+        Set<String> beginSet = new HashSet<>();
+        Set<String> endSet = new HashSet<>();
+        Set<String> visitedSet = new HashSet<>();
+        int count = 1;
+        beginSet.add(beginWord);
+        endSet.add(endWord);
+        while(!beginSet.isEmpty()||!endSet.isEmpty()){
+            if(beginSet.size()>endSet.size()||beginSet.isEmpty()){
+                Set<String> tmpset = beginSet;
+                beginSet = endSet;
+                endSet = tmpset;
+            }
+
+            Set<String> nextBeginSet = new HashSet<>();
+            if(ladderLengthSub2(wordSet, beginSet,endSet,visitedSet, nextBeginSet))
+                return count+1;
+            beginSet = nextBeginSet;
+            count++;
+        }
+        return 0;
+    }
+
+    public static boolean ladderLengthSub2(Set<String> wordSet, Set<String> beginSet, Set<String> endSet, Set<String> visitedSet, Set<String> nextBeginSet) {
+        for(String curStr:beginSet) {
+            char[] curChars = curStr.toCharArray();
+            for(int i = 0;i<curChars.length;i++){
+                char tmp = curChars[i];
+                for(char ch = 'a';ch<='z';ch++){
+                    curChars[i]=ch;
+                    String nextStr = String.valueOf(curChars);
+                    if(endSet.contains(nextStr))
+                        return true;
+                    if(!visitedSet.contains(nextStr)&&wordSet.contains(nextStr)){
+                        nextBeginSet.add(nextStr);
+                        visitedSet.add(nextStr);
+                    }
+                }
+                curChars[i] = tmp;
+            }
+        }
+        return false;
+    }
+
+    public static void main(String[] args) {
+//        List<String> wordList = Arrays.asList("hot", "dot", "dog", "lot", "log");
+        List<String> wordList = Arrays.asList("hot", "dog");
+        System.out.println(ladderLength2("hot", "dog", wordList));
+    }
+}
diff --git a/Week_07/java/WordSearchII.java b/Week_07/java/WordSearchII.java
new file mode 100644
index 00000000..3dff8bfd
--- /dev/null
+++ b/Week_07/java/WordSearchII.java
@@ -0,0 +1,165 @@
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+class Trie {
+    public boolean isEnd;
+    public Trie[] next;
+    public String val;
+
+    /**
+     * Initialize your data structure here.
+     */
+    public Trie() {
+        isEnd = false;
+        next = new Trie[26];
+    }
+
+    /**
+     * Inserts a word into the trie.
+     * @return
+     */
+    public void insert(String word) {
+        if (word == null || word.length() == 0) return ;
+        Trie curr = this;
+        char[] words = word.toCharArray();
+        for (int i = 0; i < words.length; i++) {
+            int n = words[i] - 'a';
+            if (curr.next[n] == null) curr.next[n] = new Trie();
+            curr = curr.next[n];
+        }
+        curr.isEnd = true;
+        curr.val = word;
+    }
+
+    public boolean search(String word) {
+        Trie node = searchPrefix(word);
+        return node != null && node.isEnd;
+    }
+
+    /** Returns if there is any word in the trie that starts with the given prefix. */
+    public boolean startsWith(String prefix) {
+        Trie node = searchPrefix(prefix);
+        return node != null;
+    }
+
+    private Trie searchPrefix(String word) {
+        Trie node = this;
+        char[] words = word.toCharArray();
+        for (int i = 0;i < words.length;i++) {
+            node = node.next[words[i] - 'a'];
+            if (node == null) return null;
+        }
+        return node;
+    }
+}
+
+public class WordSearchII {
+    Set<String> ans = new HashSet<>();
+
+    /**
+     * 成功实现，速度很慢
+     * @param board
+     * @param words
+     * @return
+     */
+    public List<String> findWords(char[][] board, String[] words) {
+
+        Trie trie = new Trie();
+        for(String word: words){
+            trie.insert(word);
+        }
+
+        int m = board.length;
+        int n = board[0].length;
+        for(int i=0;i<m;i++){
+            for(int j=0;j<n;j++){
+                findDfs(i, j, board, "",trie);
+            }
+        }
+        return new ArrayList<>(ans);
+    }
+
+    public void findDfs(int i, int j, char[][] board, String singleRst, Trie trie){
+        int [][] site = {{1,0},{0,1},{-1,0},{0,-1}};
+
+        if(i<0||i>=board.length||j<0||j>=board[0].length) return;
+
+        char ch = board[i][j];
+        if(ch=='@'||trie.next[ch-'a']==null)
+            return;
+        board[i][j] ='@';
+        trie = trie.next[ch-'a'];
+//        singleRst = singleRst+ch;
+        if(trie.isEnd){
+            ans.add(trie.val);
+//            return; //不能返回同组其他元素还需要遍历
+        }
+        for(int[] index:site) {
+            findDfs(i+index[0],j+index[1], board, singleRst,trie);
+        }
+//        findDfs(i+1,j, board, singleRst+ch,trie);
+//        findDfs(i-1,j, board, singleRst+ch,trie);
+//        findDfs(i,j+1, board, singleRst+ch,trie);
+//        findDfs(i,j-1, board, singleRst+ch,trie);
+        board[i][j] = ch;
+    }
+
+
+    /**
+     * 可以实现 太慢了
+     * @param board
+     * @param words
+     * @return
+     */
+    public List<String> findWords2(char[][] board, String[] words) {
+        Trie trie = new Trie();
+        for (String word : words) {
+            trie.insert(word);
+        }
+        int m = board.length;
+        int n = board[0].length;
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                dfs(board, "", i, j, trie);
+            }
+        }
+        return new ArrayList<>(ans);
+    }
+
+    public void dfs(char[][] board, String str, int x, int y, Trie trie) {
+        if (x < 0 || x >= board.length || y < 0 || y >= board[0].length) return;
+
+        str += board[x][y];
+        if (board[x][y]=='@'||!trie.startsWith(str)) return;
+
+        if (trie.search(str)) {
+            ans.add(str);
+        }
+        char ch = board[x][y];
+
+        board[x][y] ='@';
+        dfs(board, str, x - 1, y, trie);
+        dfs(board, str, x + 1, y, trie);
+        dfs(board, str, x, y - 1, trie);
+        dfs(board, str, x, y + 1, trie);
+        board[x][y] = ch;
+    }
+
+
+    public static void main(String[] args) {
+        char[][] board = {{'o','a','a','n'},{'e','t','a','e'},{'i','h','k','r'},{'i','f','l','v'}};
+        String[] words = {"oath","pea","eat","rain","hklf", "hf"};
+
+
+//        char[][] board = {{'o','a','a','n'},{'e','t','a','e'},{'i','h','k','r'},{'i','f','l','v'}};
+//        String[] words = {"oath","pea","eat","rain"};
+//        char[][] board ={{'a'}};
+//        String[] words ={"a"};
+        WordSearchII wordSearchII = new WordSearchII();
+        System.out.println(wordSearchII.findWords(board, words));
+
+
+    }
+}
diff --git a/Week_08/java/RelativeSortArray.java b/Week_08/java/RelativeSortArray.java
new file mode 100644
index 00000000..067d2d2d
--- /dev/null
+++ b/Week_08/java/RelativeSortArray.java
@@ -0,0 +1,47 @@
+import java.util.*;
+
+public class RelativeSortArray {
+    /**
+     * 使用Map、List实现
+     * @param arr1
+     * @param arr2
+     * @return
+     */
+    public int[] relativeSortArray(int[] arr1, int[] arr2) {
+        Map<Integer, Integer> arr1Map = new HashMap<>();
+        for(int num: arr1){
+            arr1Map.put(num,arr1Map.getOrDefault(num,0)+1);
+        }
+        List<Integer> rst = new ArrayList<>();
+        for(int num2: arr2){
+            if(arr1Map.containsKey(num2)){
+                for(int i=0;i<arr1Map.get(num2);i++){
+                    rst.add(num2);
+                }
+                arr1Map.remove(num2);
+            }
+        }
+        List<Integer> rst2 = new ArrayList<>();
+        for (Integer key : arr1Map.keySet()) {
+            for (int j = 0; j < arr1Map.get(key); j++) {
+                rst2.add(key);
+            }
+        }
+        rst2.sort(Integer::compareTo);
+        rst.addAll(rst2);
+        return rst.stream().mapToInt(i->i).toArray();
+    }
+
+
+
+    public static void main(String[] args) {
+        int[] arr1 = new int[]{2,3,1,3,2,4,6,7,9,2,19};
+        int[] arr2 = new int[]{2,1,4,3,9,6};
+        RelativeSortArray relativeSortArray = new RelativeSortArray();
+        int[] ints = relativeSortArray.relativeSortArray(arr1, arr2);
+        for(int i :ints){
+            System.out.println(i);
+        }
+
+    }
+}
diff --git a/Week_08/java/ReversePairs.java b/Week_08/java/ReversePairs.java
new file mode 100644
index 00000000..4144e52d
--- /dev/null
+++ b/Week_08/java/ReversePairs.java
@@ -0,0 +1,42 @@
+public class ReversePairs {
+    /**
+     * 翻转对
+     * @param nums
+     * @return
+     */
+    public int reversePairs(int[] nums) {
+        return merger(nums, 0, nums.length-1);
+    }
+
+    public int merger(int[] nums, int left, int right){
+        if(left>=right) return 0;
+        int mid = left+(right-left)/2;
+        int count = merger(nums,left,mid) + merger(nums,mid+1,right);
+        int[] tmp = new int[right-left+1];
+        int i = left, t=left, k=0;
+        for(int j = mid+1;j<=right;j++){
+            while (i<=mid && nums[i]<=(long) 2*nums[j]) i++; //正着数会丢掉数据，所以选择算差
+            while (t<=mid && nums[t]<nums[j]) tmp[k++] = nums[t++];
+            tmp[k++] = nums[j];
+            count+= mid-i+1;
+        }
+        while (t<=mid) tmp[k++] = nums[t++];
+
+        System.arraycopy(tmp,0,nums,left,right-left+1);
+        return count;
+    }
+
+
+
+
+    public static void main(String[] args) {
+//        int[] nums = new int[]{1,3,2,3,1};
+        int[] nums = new int[]{2,4,3,5,1};
+        ReversePairs obj = new ReversePairs();
+        System.out.println(obj.reversePairs(nums));
+    }
+
+
+
+
+}
diff --git a/Week_09/java/DistinctSubsequences.java b/Week_09/java/DistinctSubsequences.java
new file mode 100644
index 00000000..7e38156c
--- /dev/null
+++ b/Week_09/java/DistinctSubsequences.java
@@ -0,0 +1,26 @@
+public class DistinctSubsequences {
+    /**
+     * 115. 不同的子序列
+     * @param s
+     * @param t
+     * @return
+     */
+    public int numDistinct(String s, String t) {
+        int[][] dp = new int[t.length() + 1][s.length() + 1];
+        for (int j = 0; j < s.length() + 1; j++) dp[0][j] = 1;
+        for (int i = 1; i < t.length() + 1; i++) {
+            for (int j = 1; j < s.length() + 1; j++) {
+                if (t.charAt(i - 1) == s.charAt(j - 1)) dp[i][j] = dp[i - 1][j - 1] + dp[i][j - 1];
+                else dp[i][j] = dp[i][j - 1];
+            }
+        }
+        return dp[t.length()][s.length()];
+
+    }
+
+    public static void main(String[] args) {
+        DistinctSubsequences longestValidParentheses = new DistinctSubsequences();
+        System.out.println(longestValidParentheses.numDistinct("babgbag","bag"));
+    }
+
+}
diff --git a/Week_09/java/LongestIncreasingSubsequence.java b/Week_09/java/LongestIncreasingSubsequence.java
new file mode 100644
index 00000000..9f1f7c04
--- /dev/null
+++ b/Week_09/java/LongestIncreasingSubsequence.java
@@ -0,0 +1,30 @@
+import java.util.Arrays;
+
+public class LongestIncreasingSubsequence {
+    public int lengthOfLIS(int[] nums) {
+
+        int len = nums.length;
+        if(len<2){
+            return len;
+        }
+        int[] dp = new int[len];
+        Arrays.fill(dp,1);
+        int rst=0;
+        for(int i=1;i<len;i++){
+            for(int j=0;j<i;j++){
+                if(nums[i]>nums[j]){
+                    dp[i] = Math.max(dp[i],dp[j]+1);
+                }
+            }
+            rst = Math.max(rst,dp[i]);
+        }
+
+        return rst;
+    }
+
+    public static void main(String[] args) {
+        int[] nums = new int[]{1,3,6,7,9,4,10,5,6};
+        LongestIncreasingSubsequence longestIncreasingSubsequence = new LongestIncreasingSubsequence();
+        System.out.println(longestIncreasingSubsequence.lengthOfLIS(nums));
+    }
+}
diff --git "a/Week_\346\257\225\344\270\232\346\200\273\347\273\223/README.md" b/Week_end/README.md
similarity index 100%
rename from "Week_\346\257\225\344\270\232\346\200\273\347\273\223/README.md"
rename to Week_end/README.md
diff --git a/Week_end/java/KthLargestElementInAnArray.java b/Week_end/java/KthLargestElementInAnArray.java
new file mode 100644
index 00000000..edbe85dc
--- /dev/null
+++ b/Week_end/java/KthLargestElementInAnArray.java
@@ -0,0 +1,49 @@
+import java.util.PriorityQueue;
+
+/**
+ * 第K大的数
+ */
+public class KthLargestElementInAnArray {
+    public int findKthLargest(int[] nums, int k) {
+        int len = nums.length;
+        PriorityQueue<Integer> maxHeap = new PriorityQueue<>(len, (a, b) -> b - a);
+
+        for(int i=0;i<len;i++){
+            maxHeap.add(nums[i]);
+        }
+        for(int j=0;j<k-1; j++){
+            maxHeap.poll();
+        }
+        return maxHeap.peek();
+    }
+
+    public int findKthLargest2(int[] nums, int k) {
+        int len = nums.length;
+        int left = 0;
+        int right = len-1;
+
+        int target = len - k;
+        while (left<=right){
+            int index = parttion(nums, left,right);
+            if(index==target){
+                return nums[target];
+            }else if(index<target){
+                left= index+1;
+            }else {
+                right = index-1;
+            }
+        }
+        return -1;
+    }
+    public int parttion(int[]nums, int begin, int end){
+        int pivot = end, counter = begin;
+        for (int i = begin; i < end; i++) {
+            if (nums[i] < nums[pivot]) {
+                int temp = nums[counter]; nums[counter] = nums[i]; nums[i] = temp;
+                counter++;
+            }
+        }
+        int temp = nums[pivot]; nums[pivot] = nums[counter]; nums[counter] = temp;
+        return counter;
+    }
+}
diff --git a/Week_end/java/LengthOfLongestSubstring.java b/Week_end/java/LengthOfLongestSubstring.java
new file mode 100644
index 00000000..cc24de1c
--- /dev/null
+++ b/Week_end/java/LengthOfLongestSubstring.java
@@ -0,0 +1,31 @@
+import java.nio.charset.Charset;
+import java.util.HashMap;
+import java.util.Map;
+
+public class LengthOfLongestSubstring {
+    /**
+     * 3. 无重复字符的最长子串
+     * @param s
+     * @return
+     */
+    public int lengthOfLongestSubstring(String s) {
+        if(s.length()<2) return s.length();
+        Map<Character, Integer> map = new HashMap<>();
+//        char[] chars = s.toCharArray();
+        int max = 0;
+        int start=0;
+        for(int i=0;i<s.length();i++){
+            if(map.containsKey(s.charAt(i))){
+                start = Math.max(start, map.get(s.charAt(i))+1);
+            }
+            map.put(s.charAt(i),i);
+            max = Math.max(max,i-start+1);
+        }
+        return max;
+    }
+
+    public static void main(String[] args) {
+        LengthOfLongestSubstring obj = new LengthOfLongestSubstring();
+        System.out.println(obj.lengthOfLongestSubstring("pwwkew"));
+    }
+}
diff --git a/Week_end/java/Triangle.java b/Week_end/java/Triangle.java
new file mode 100644
index 00000000..b2a7ee27
--- /dev/null
+++ b/Week_end/java/Triangle.java
@@ -0,0 +1,30 @@
+import java.util.List;
+
+public class Triangle {
+    /**
+     * 120. 三角形最小路径和
+     * @param triangle
+     * @return
+     */
+    public int minimumTotal(List<List<Integer>> triangle) {
+        int size = triangle.size();
+        int[][]dp = new int[size+1][size+1];
+        for(int i=size-1;i>=0;i--){
+            for(int j=0;j<=i;j++){
+                dp[i][j] = Math.min(dp[i+1][j],dp[i+1][j+1])+triangle.get(i).get(j);
+            }
+        }
+        return dp[0][0];
+    }
+
+    public int minimumTotal2(List<List<Integer>> triangle) {
+        int size = triangle.size();
+        int[]dp = new int[size+1];
+        for(int i=size-1;i>=0;i--){
+            for(int j=0;j<=i;j++){
+                dp[j] = Math.min(dp[j],dp[j+1])+triangle.get(i).get(j);
+            }
+        }
+        return dp[0];
+    }
+}