diff --git a/code/lc1028.java b/code/lc1028.java
new file mode 100644
index 0000000000000000000000000000000000000000..b4f670844aa37932f67ef9d04175654ea5a365bc
--- /dev/null
+++ b/code/lc1028.java
@@ -0,0 +1,49 @@
+package code;
+
+import java.util.Stack;
+/*
+ * 1028. Recover a Tree From Preorder Traversal
+ * 题意：从先序遍历恢复二叉树
+ * 难度：Hard
+ * 分类：Depth-first Search
+ * 思路：用栈存储，迭代比较就可以了
+ * Tips：
+ */
+public class lc1028 {
+    public class TreeNode {
+        int val;
+        TreeNode left;
+        TreeNode right;
+        TreeNode(int x) {
+            val = x;
+        }
+    }
+    public TreeNode recoverFromPreorder(String S) {
+        int level, val;
+        Stack<TreeNode> stack = new Stack<>();
+        for (int i = 0; i < S.length();) {
+            for (level = 0; S.charAt(i) == '-'; i++) {
+                level++;
+            }
+            for (val = 0; i < S.length() && S.charAt(i) != '-'; i++) {  //数字可能是大于9
+                val = val * 10 + (S.charAt(i) - '0');
+            }
+            while (stack.size() > level) {  //用stack的size和depth比就可以了
+                stack.pop();
+            }
+            TreeNode node = new TreeNode(val);
+            if (!stack.isEmpty()) {
+                if (stack.peek().left == null) {
+                    stack.peek().left = node;
+                } else {
+                    stack.peek().right = node;
+                }
+            }
+            stack.add(node);
+        }
+        while (stack.size() > 1) {
+            stack.pop();
+        }
+        return stack.pop();
+    }
+}
diff --git a/code/lc1093.java b/code/lc1093.java
new file mode 100644
index 0000000000000000000000000000000000000000..3ec8fbf8001af41b5522127c3f62248fc54d93b4
--- /dev/null
+++ b/code/lc1093.java
@@ -0,0 +1,45 @@
+package code;
+/*
+ * 1093. Statistics from a Large Sample
+ * 题意：从数组里统计出均值，最大，最小，中位数，众数
+ * 难度：Medium
+ * 分类：
+ * 思路：
+ * Tips：中位数记住可能是两个数的均值，可能是中间的一个数，用 pos/2 来处理
+ */
+public class lc1093 {
+    public double[] sampleStats(int[] count) {
+        double[] res = new double[5];
+        res[0] = -1;
+        res[1] = -1;
+        int mode_num = 0;
+        int count_num = 0;
+        for (int i = 0; i < count.length ; i++) {
+            if(res[0]==-1 && count[i]>0) res[0] = i;
+            if(count[i]>0 && i>res[1]) res[1] = i;
+            res[2] += count[i]*i;
+            count_num += count[i];
+            if(count[i]>mode_num) {
+                res[4] = i;
+                mode_num = count[i];
+            }
+        }
+        int medium_pos1 = (count_num+1)/2;  //中位数
+        int medium_pos2 = (count_num+2)/2;
+        count_num = 0;
+        for (int i = 0; i < count.length ; i++) {
+            count_num += count[i];
+            if(medium_pos1>0&&medium_pos1<=count_num) {
+                res[3]+= i;
+                medium_pos1 = -1;
+            }
+            if(medium_pos2>0&&medium_pos2<=count_num) {
+                res[3]+= i;
+                medium_pos2 = -1;
+            }
+        }
+        res[2] = res[2]/count_num;
+        res[3] = res[3]/2;
+        return res;
+    }
+}
diff --git a/code/lc1094.java b/code/lc1094.java
new file mode 100644
index 0000000000000000000000000000000000000000..b9692988a094a20d6b963a29e1c9f057266163d6
--- /dev/null
+++ b/code/lc1094.java
@@ -0,0 +1,44 @@
+package code;
+/*
+ * 1094. Car Pooling
+ * 题意：
+ * 难度：Medium
+ * 分类：
+ * 思路：lc56 类似的题，但该题的集合没有传递覆盖的特性，所以遍历的时候又加了个循环，N^2
+ *       非常巧妙的方法，每次记录上车，下车人数，然后遍历一遍进行模拟上下车
+ * Tips：lc253, lc56
+ */
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class lc1094 {
+    public boolean carPooling(int[][] trips, int capacity) {
+        Arrays.sort(trips, new Comparator<int[]>() {  // 记住这种写法
+            @Override
+            public int compare(int[] o1, int[] o2) {
+                if(o1[1]!=o2[1])
+                    return o1[1] - o2[1];
+                else
+                    return o2[2] - o1[2];
+            }
+        });
+        for (int i = 0; i < trips.length ; i++) {
+            int current = trips[i][0];
+            for (int j = i-1; j >=0 ; j--) { //往前找是否重叠
+                if(trips[j][2]>trips[i][1]) current += trips[j][0];
+            }
+            if(current>capacity) return false;
+        }
+        return true;
+    }
+
+    public boolean carPooling2(int[][] trips, int capacity) {
+        int stops[] = new int[1001];
+        for (int t[] : trips) {
+            stops[t[1]] += t[0];
+            stops[t[2]] -= t[0];
+        }
+        for (int i = 0; capacity >= 0 && i < 1001; ++i) capacity -= stops[i];
+        return capacity >= 0;
+    }
+}
diff --git a/code/lc139.java b/code/lc139.java
index 1e056637d7fb341c9c8263c93de942eb87fd3bb0..67ac6a61c0adb0d377bddb46367e11561a7d6218 100644
--- a/code/lc139.java
+++ b/code/lc139.java
@@ -20,6 +20,6 @@ public class lc139 {
                     dp[i] = true;
             }
         }
-        return dp[s.length()+1];
+        return dp[s.length()];
     }
 }
diff --git a/code/lc22.java b/code/lc22.java
index ab6d94cacc605ad76bec2b1a44017770e3ef0be8..bbeb2e259be4eb1864dd6a3ae22779e2dcd1c30d 100644
--- a/code/lc22.java
+++ b/code/lc22.java
@@ -12,7 +12,7 @@ import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 
-public class lc22 {
+public class  lc22 {
     public static void main(String[] args) {
         System.out.println(generateParenthesis2(4));
     }
diff --git a/code/lc3.java b/code/lc3.java
index 198f6ca64ba9f844f83adc78b4ee2ae6a47d073a..1b56f97ce6428d155bf0b04e42c164689620a2c4 100644
--- a/code/lc3.java
+++ b/code/lc3.java
@@ -1,7 +1,7 @@
 package code;
 /*
 * 3. Longest Substring Without Repeating Characters
-* 题意：找出字符串中没有重复子串的最大长度
+* 题意：找出字符串中没有重复字母的最大长度
 * 难度：Medium
 * 分类：Hash Table, Two Pointers, String
 * 算法：两个指针，记录没有重复字母的子串的首和尾
diff --git a/code/lc32.java b/code/lc32.java
index e9a07f9f48446c41b016e0e542274df3c6a6b604..4d611d8b643a10f0dce4fd40087aa77f50eff81d 100644
--- a/code/lc32.java
+++ b/code/lc32.java
@@ -40,12 +40,12 @@ public class lc32 {
     public static int longestValidParentheses2(String s) {
         //栈方法  ()(())
         Stack<Integer> st = new Stack();
-        st.add(-1);
+        st.add(-1); //栈内先入-1
         int res = 0;
         for (int i = 0; i < s.length() ; i++) {
             char ch = s.charAt(i);
             if(ch=='(')
-                st.add(i);
+                st.push(i);
             else if(ch==')'){
                 st.pop();
                 if(st.isEmpty())
diff --git a/code/lc49.java b/code/lc49.java
index 1eb480c18e7576e27c7f971442de851fbc269467..cafcee22c0a940215fabc7cbe376fb94ae19931c 100644
--- a/code/lc49.java
+++ b/code/lc49.java
@@ -24,6 +24,6 @@ public class lc49 {
                 m.put(key,l);
             }
         }
-        return new ArrayList(m.values());
+        return new ArrayList(m.values());   //学下这句的语法
     }
 }
diff --git a/code/lc50.java b/code/lc50.java
index 43230be7d3afc880dd8d0ab8052c5a8e7bb2744a..bf6e8e9a645e4c9cb4ec45615327335fefd4573a 100644
--- a/code/lc50.java
+++ b/code/lc50.java
@@ -10,7 +10,7 @@ package code;
 public class lc50 {
     public double myPow(double x, int n) {
         if(n == 0) return 1;
-        if(n==Integer.MIN_VALUE && x!=1 && x!=-1) return 0;
+        if(n==Integer.MIN_VALUE && x!=1 && x!=-1) return 0; //负数最小值，结果溢出
         if(n<0){
             n = -n;
             x = 1/x;    //负数变成 1/x
diff --git a/code/lc63.java b/code/lc63.java
index fe81415a172b5a9065982208e350f26c49772f42..c92b0c18db95711aa73d96e63a7f3ca4b7d48ed9 100644
--- a/code/lc63.java
+++ b/code/lc63.java
@@ -2,7 +2,7 @@ package code;
 
 /*
  * 63. Unique Paths II
- * 题意：路径数
+ * 题意：路径数，添加了障碍
  * 难度：Medium
  * 分类：Array, Dynamic Programming
  * 思路：和lc64, lc62思路一样
diff --git a/code/lc81.java b/code/lc81.java
index 6c089e03b2381763681f365b507d692f94f36f61..46012dd32c0c824f20115e1e937bed4b25670c12 100644
--- a/code/lc81.java
+++ b/code/lc81.java
@@ -1,6 +1,6 @@
 package code;
 /*
- * 31. Search in Rotated Sorted Array II
+ * 81. Search in Rotated Sorted Array II
  * 题意：在翻转有序数组中查找指定数，数组中可能有相等的元素
  * 难度：Medium
  * 分类：Array, Binary Search
diff --git a/interview/byte1.java b/interview/byte1.java
new file mode 100644
index 0000000000000000000000000000000000000000..1ca217db11ce0059c0bce994203a4dfef5441e2d
--- /dev/null
+++ b/interview/byte1.java
@@ -0,0 +1,43 @@
+package interview;
+
+import java.util.Scanner;
+
+public class byte1 {
+    public static void main (String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = sc.nextInt();
+        }
+
+        int res = Integer.MIN_VALUE;
+        int[] dp = new int[n];
+        dp[0] = arr[0];
+        for (int i = 1; i < n; i++) {
+            dp[i] = Math.max(dp[i-1], arr[i]+i);
+        }
+        for (int i = 1; i < n ; i++) {
+            res = Math.max(arr[i]-i+dp[i-1], res);
+        }
+        System.out.println(res);
+    }
+
+    public static void main2 (String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int[] arr = new int[n];
+        for (int i = 0; i < n; i++) {
+            arr[i] = sc.nextInt();
+        }
+        int res = 0;
+        for (int i = 0; i < n ; i++) {
+            for (int j = 0; j < i ; j++) {
+                int temp = arr[i]+arr[j]-i+j;
+                res = Math.max(res, temp);
+            }
+        }
+        System.out.println(res);
+    }
+}
+
diff --git a/interview/byte2.java b/interview/byte2.java
new file mode 100644
index 0000000000000000000000000000000000000000..b26be85fe856f2e2d2fc5faf6175cf70da439cfb
--- /dev/null
+++ b/interview/byte2.java
@@ -0,0 +1,68 @@
+package interview;
+
+import java.util.Scanner;
+
+public class byte2 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int n = sc.nextInt();
+        int m = sc.nextInt();
+        if(m*n==0) {
+            System.out.println(0);
+            return;
+        }
+        int[][] grid = new int[n][m];
+        for(int i = 0; i < n; i++){
+            for(int j = 0; j < m; j++){
+                grid[i][j] = sc.nextInt();
+            }
+        }
+        int count = 0;
+        for (int i = 0; i < n ; i++) {
+            for (int j = 0; j < m ; j++) {
+                if( grid[i][j]==1 ){
+                    count++;
+                    grid[i][j] = 0;   //置0， 下次不用考虑
+                    search(grid,i,j);
+                }
+            }
+        }
+        System.out.println(count);
+    }
+
+    public static void search(int[][] grid, int i, int j){
+        if( i>0 && grid[i-1][j]==1) {
+            grid[i-1][j] = 0;     //置0， 下次不用考虑
+            search(grid, i - 1, j);
+        }
+        if( j>0 && grid[i][j-1]==1) {
+            grid[i][j-1] = 0;
+            search(grid, i, j-1);
+        }
+        if( i+1<grid.length && grid[i+1][j]==1) {
+            grid[i+1][j] = 0;
+            search(grid, i + 1, j);
+        }
+        if( j+1<grid[0].length && grid[i][j+1]==1) {
+            grid[i][j+1] = 0;
+            search(grid, i, j+1);
+        }
+        if( i>0 && j>0 && grid[i-1][j-1]==1){
+            grid[i-1][j-1] = 0;
+            search(grid, i-1, j-1);
+        }
+        if( i+1<grid.length && j+1<grid[0].length && grid[i+1][j+1]==1){
+            grid[i+1][j+1] = 0;
+            search(grid, i+1, j+1);
+        }
+        if( i>0 && j+1<grid[0].length && grid[i-1][j+1]==1){
+            grid[i-1][j+1] = 0;
+            search(grid, i-1, j+1);
+        }
+        if( i+1<grid.length && j>0 && grid[i+1][j-1]==1){
+            grid[i+1][j-1] = 0;
+            search(grid, i+1, j-1);
+        }
+        return;
+    }
+}
diff --git a/interview/byte21.java b/interview/byte21.java
new file mode 100644
index 0000000000000000000000000000000000000000..1624bf3156e2153515ff9f68fe41125a75ed2c1c
--- /dev/null
+++ b/interview/byte21.java
@@ -0,0 +1,32 @@
+package interview;
+
+import java.util.Scanner;
+
+public class byte21 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        int w = sc.nextInt();
+        int b = sc.nextInt();
+        int[][] dp = new int[5000][2];
+        int i = 1;
+        dp[0][0] = 1;
+        dp[0][1] = 1;
+        for (; i < 5000; i++) {
+            if(w-i>=0){
+                dp[i][0] = dp[i-1][0] + dp[i-1][1];//白
+                w=w-i;
+            }else{
+                dp[i][0] = 0;
+            }
+            if(b-i>=0){
+                dp[i][1] = dp[i-1][0] + dp[i-1][1];//黑
+                b = b-i;
+            }else{
+                dp[i][1] = 0;
+            }
+            if(dp[i][0]==0&&dp[i][1]==0) break;
+        }
+        System.out.println(i-1);
+        System.out.println(dp[i-1][0]+dp[i-1][1]);
+    }
+}
diff --git a/interview/byte22.java b/interview/byte22.java
new file mode 100644
index 0000000000000000000000000000000000000000..79d998afba0cac1d2bb49f027209b54a9b9814d3
--- /dev/null
+++ b/interview/byte22.java
@@ -0,0 +1,33 @@
+package interview;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Scanner;
+
+public class byte22 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        String str1 = sc.nextLine();
+        String str2 = sc.nextLine();
+        String[] str_arr = str2.split(" ");
+        List<String> str_list = new ArrayList<>();
+        for(String s : str_arr) str_list.add(s);
+        System.out.println(helper(str1, str_list));
+    }
+
+
+
+    public static String helper(String s, List<String> wordDict) {
+        boolean[] dp = new boolean[s.length()+1];
+        dp[0] = true;
+        for (int i = 1; i < dp.length ; i++) {
+            for (int j = 0; j < i ; j++) {  //遍历之前计算出来的结果
+                if( dp[j]==true && wordDict.contains(s.substring(j,i)))
+                    dp[i] = true;
+            }
+        }
+        if(dp[s.length()]) return "True";
+        return "Fales";
+    }
+
+}
diff --git a/interview/byte23.java b/interview/byte23.java
new file mode 100644
index 0000000000000000000000000000000000000000..5880a1d5754d285e73df4e98f1fbc306ab1841b7
--- /dev/null
+++ b/interview/byte23.java
@@ -0,0 +1,9 @@
+package interview;
+
+import java.util.Scanner;
+
+public class byte23 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+    }
+}
diff --git a/interview/byte3.java b/interview/byte3.java
new file mode 100644
index 0000000000000000000000000000000000000000..76221bdc842d1e24dc8bbfa630b6503156bcc09c
--- /dev/null
+++ b/interview/byte3.java
@@ -0,0 +1,46 @@
+package interview;
+import java.util.Scanner;
+import java.util.Stack;
+
+public class byte3 {
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
+        String s = sc.nextLine();
+        Stack<Character> st = new Stack();
+        int i = 0;
+        char[] str_arr = s.toCharArray();
+        StringBuilder res = new StringBuilder();
+
+        while(i<s.length()){
+            if(str_arr[i]=='#'){
+                StringBuilder temp = new StringBuilder();
+                StringBuilder num = new StringBuilder();
+                while(st.peek()!='%'){
+                    temp.insert(0, st.pop());
+                }
+                st.pop();   // pop出 [
+                while(!st.isEmpty() && Character.isDigit(st.peek())){
+                    num.insert(0, st.pop());
+                }
+                StringBuilder temp2 = new StringBuilder();
+                for (int j = 0; j < Integer.valueOf(num.toString()) ; j++) {
+                    temp2.append(temp.toString());
+                }
+                //入栈
+                for (int j = 0; j < temp2.toString().length() ; j++) {
+                    st.push(temp2.toString().toCharArray()[j]);
+                }
+            }else{
+                st.push(str_arr[i]);
+            }
+            i++;
+        }
+        // 别忘了末尾的
+        StringBuilder sb1 = new StringBuilder();
+        while(!st.isEmpty()){
+            sb1.insert(0, st.pop());
+        }
+        res.append(sb1);
+        System.out.println(res.toString());
+    }
+}
diff --git a/readme.md b/readme.md
index 8d4be9c4a890b46a25bc39b8527d60d81ae1ab48..a98d0f5631e1de7d995a34e2a79dbe46a477de63 100644
--- a/readme.md
+++ b/readme.md
@@ -235,3 +235,4 @@ LeetCode 指南
 | 1025 [Java](./code/lc1025.java)
 | 1026 [Java](./code/lc1026.java)
 | 1027 [Java](./code/lc1027.java)
+| 1028 [Java](./code/lc1028.java)