diff --git a/src/com/blankj/easy/_0053/Solution.java b/src/com/blankj/easy/_0053/Solution.java
index 9e343c79..23eb73cf 100644
--- a/src/com/blankj/easy/_0053/Solution.java
+++ b/src/com/blankj/easy/_0053/Solution.java
@@ -44,5 +44,39 @@ public static void main(String[] args) {
         Solution solution = new Solution();
         int[] nums0 = new int[]{-2, 1, -3, 4, -1, 2, 1, -5, 4};
         System.out.println(solution.maxSubArray(nums0));
+        System.out.println(solution.myMaxSubArray(nums0));
+        int[] nums1 = new int[]{2, 7, 9, 3, 1};
+        System.out.println(solution.maxSubArray(nums1));
+        System.out.println(solution.myMaxSubArray(nums1));
+        int[] nums2 = new int[]{-2, 11, -9, 3, 1};
+        System.out.println(solution.maxSubArray(nums2));
+        System.out.println(solution.myMaxSubArray(nums2));
+        int[] nums3 = new int[]{-2, 12, -9, 3, 1};
+        System.out.println(solution.maxSubArray(nums3));
+        System.out.println(solution.myMaxSubArray(nums3));
+    }
+
+    public int myMaxSubArray(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return Integer.MIN_VALUE;
+        }
+        int max = Integer.MIN_VALUE;
+        int[] f = new int[nums.length];
+        for (int i = 0; i < nums.length; i++) {
+            if (i == 0) {
+                f[i] = nums[i];
+            } else {
+                if (f[i - 1] > 0) {
+                    f[i] = f[i-1] + nums[i];
+                } else {
+                    f[i] = nums[i];
+                }
+            }
+            if (max < f[i]) {
+                max = f[i];
+            }
+        }
+
+        return max;
     }
 }
diff --git a/src/com/blankj/easy/_0055/Solution.java b/src/com/blankj/easy/_0055/Solution.java
new file mode 100644
index 00000000..b9b115a2
--- /dev/null
+++ b/src/com/blankj/easy/_0055/Solution.java
@@ -0,0 +1,39 @@
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution solution = new Solution();
+        System.out.println(solution.canJump2End(new int[]{1, 2, 3, 4}));
+        System.out.println(solution.canJump2End(new int[]{3, 1, 0, 4}));
+        System.out.println(solution.canJump2End(new int[]{3, 2, 1, 0, 4}));
+        System.out.println(solution.canJump2End(new int[]{2, 3, 1, 1, 4}));
+    }
+
+    public boolean canJump2End(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return false;
+        }
+        int step = 1;
+        int index = 0;
+        while (index < nums.length && step > 0) {
+            step = nums[index];
+            int maxIndex = index;
+            int maxStep = index;
+            for (int i = 1; i <= step; i++) {
+                if (index + i >= nums.length) {
+                    return true;
+                }
+                if (nums[index + i] + index + i > maxStep) {
+                    maxIndex = index + i;
+                    maxStep = nums[index + i] + index + i;
+                }
+            }
+            index = maxIndex;
+            step = nums[maxIndex];
+        }
+        if (step == 0) {
+            return false;
+        }
+
+        return true;
+    }
+}
diff --git a/src/com/blankj/easy/_0066/Solution.java b/src/com/blankj/easy/_0066/Solution.java
index e6fad7a6..edb72a6c 100644
--- a/src/com/blankj/easy/_0066/Solution.java
+++ b/src/com/blankj/easy/_0066/Solution.java
@@ -1,6 +1,9 @@
 package com.blankj.easy._066;
 
+import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
 
 /**
  * <pre>
@@ -33,5 +36,57 @@ public static void main(String[] args) {
         Solution solution = new Solution();
         int[] digits = solution.plusOne(new int[]{9, 9, 9});
         System.out.println(Arrays.toString(digits));
+        digits = solution.myPlusOne(new int[]{9, 9, 9});
+        System.out.println(Arrays.toString(digits));
+        digits = solution.myPlusOne2(new int[]{9, 9, 9});
+        System.out.println(Arrays.toString(digits));
+        digits = solution.myPlusOne2(new int[]{8, 9, 9});
+        System.out.println(Arrays.toString(digits));
+        digits = solution.myPlusOne2(new int[]{8, 9, 8});
+        System.out.println(Arrays.toString(digits));
+
+    }
+
+    public int[] myPlusOne(int[] digits) {
+        if (digits == null || digits.length == 0) {
+            return null;
+        }
+        int[] res = new int[digits.length];
+        int carry = 1;
+        for (int i = digits.length - 1; i >= 0; i--) {
+            res[i] = (digits[i] + carry) % 10;
+            carry = (digits[i] + carry) / 10;
+        }
+        if (carry > 0) {
+            int[] tmp = new int[digits.length + 1];
+            tmp[0] = carry;
+            for (int i = 0; i < res.length; i++) {
+                tmp[i + 1] = res[i];
+            }
+            res = tmp;
+        }
+
+        return res;
+    }
+
+    public int[] myPlusOne2(int[] digits) {
+        if (digits == null || digits.length == 0) {
+            return null;
+        }
+        int i = digits.length - 1;
+        for (; i >= 0; i--) {
+            if (digits[i] == 9) {
+                digits[i] = 0;
+            } else {
+                break;
+            }
+        }
+        if (i < 0) {
+            digits = new int[digits.length + 1];
+            digits[0] = 1;
+        } else {
+            digits[i] ++;
+        }
+        return digits;
     }
 }
diff --git a/src/com/blankj/easy/_0067/Solution.java b/src/com/blankj/easy/_0067/Solution.java
index 71e953b9..1eb0d3e1 100644
--- a/src/com/blankj/easy/_0067/Solution.java
+++ b/src/com/blankj/easy/_0067/Solution.java
@@ -49,5 +49,51 @@ public String addBinary(String a, String b) {
     public static void main(String[] args) {
         Solution solution = new Solution();
         System.out.println(solution.addBinary("11", "1"));
+        System.out.println(solution.myAddBinary("11", "1"));
+        System.out.println(solution.addBinary("11", "111"));
+        System.out.println(solution.myAddBinary("11", "111"));
+        System.out.println(solution.addBinary("101", "1110"));
+        System.out.println(solution.myAddBinary("101", "1110"));
+
+    }
+
+    public String myAddBinary(String a, String b) {
+        if (a == null || a.length() == 0) {
+            return b;
+        }
+        if (b == null || b.length() == 0) {
+            return null;
+        }
+        StringBuilder sb = new StringBuilder();
+        int aLength = a.length();
+        int bLength = b.length();
+        int minLength = Math.min(aLength, bLength);
+        int carry = 0;
+        for (int i = 0; i < minLength; i++) {
+            char aChar = a.charAt(aLength - 1 - i);
+            char bChar = b.charAt(bLength - 1 - i);
+            carry += aChar - '0' + bChar - '0';
+            sb.insert(0, (char)('0' + carry % 2));
+            carry >>= 1;
+        }
+        String leftStr = a;
+        if (aLength < bLength) {
+            leftStr = b;
+        }
+        carry = addLeft(sb, leftStr, minLength, carry);
+        if (carry != 0) {
+            sb.insert(0, '1');
+        }
+        return sb.toString();
+    }
+
+    private int addLeft(StringBuilder sb, String leftStr, int minLength, int carry) {
+        for (int i = minLength; i < leftStr.length(); i++) {
+            char aChar = leftStr.charAt(leftStr.length() - 1 - i);
+            carry += aChar - '0';
+            sb.insert(0, (char)('0' + carry % 2));
+            carry >>= 1;
+        }
+        return carry;
     }
 }
diff --git a/src/com/blankj/easy/_0069/Solution.java b/src/com/blankj/easy/_0069/Solution.java
index daa57d4d..c81bdef5 100644
--- a/src/com/blankj/easy/_0069/Solution.java
+++ b/src/com/blankj/easy/_0069/Solution.java
@@ -20,5 +20,57 @@ public int mySqrt(int x) {
     public static void main(String[] args) {
         Solution solution = new Solution();
         System.out.println(solution.mySqrt(10));
+        System.out.println(solution.sqrt(10));
+        System.out.println(solution.sqrt2(10));
+        System.out.println(solution.mySqrt(4));
+        System.out.println(solution.sqrt(4));
+        System.out.println(solution.sqrt2(4));
+        System.out.println(solution.mySqrt(3));
+        System.out.println(solution.sqrt(3));
+        System.out.println(solution.sqrt2(3));
+        System.out.println(solution.mySqrt(100));
+        System.out.println(solution.sqrt(100));
+        System.out.println(solution.sqrt2(100));
+
+    }
+
+    public int sqrt(int x) {
+        if (x <= 0) {
+            return 0;
+        }
+        for (int i = 0; i < x/2; i++) {
+            if (i * i <= x && (i + 1) * (i * 1) > x) {
+                return i;
+            }
+        }
+
+        return x/2;
+    }
+
+    public int sqrt2(int x) {
+        if (x <= 0) {
+            return 0;
+        }
+        int low = 0;
+        int high = x/2;
+        while (low <= high) {
+            int mid = (low + high) / 2;
+            if (mid*mid == x) {
+                return mid;
+            } else if (mid*mid < x) {
+                if (low == mid) {
+                    if (high * high > x) {
+                        return mid;
+                    } else {
+                        return high;
+                    }
+                }
+                low = mid;
+            } else {
+                high = mid;
+            }
+        }
+
+        return -1;
     }
 }
diff --git a/src/com/blankj/easy/_0070/Solution.java b/src/com/blankj/easy/_0070/Solution.java
index 8ab9d5a6..6e892aa8 100644
--- a/src/com/blankj/easy/_0070/Solution.java
+++ b/src/com/blankj/easy/_0070/Solution.java
@@ -21,5 +21,59 @@ public int climbStairs(int n) {
     public static void main(String[] args) {
         Solution solution = new Solution();
         System.out.println(solution.climbStairs(3));
+        System.out.println(solution.myClimbStairs(3));
+        System.out.println(solution.myClimbStairs2(3));
+        System.out.println(solution.myClimbStairs3(3));
+        System.out.println(solution.climbStairs(4));
+        System.out.println(solution.myClimbStairs(4));
+        System.out.println(solution.myClimbStairs2(4));
+        System.out.println(solution.myClimbStairs3(4));
+    }
+
+    public int myClimbStairs(int n) {
+        if (n <= 0) {
+            return 0;
+        }
+        if (n == 1) {
+            return 1;
+        }
+        if (n == 2) {
+            return 2;
+        }
+        return myClimbStairs(n - 1) + myClimbStairs(n - 2);
+    }
+
+    public int myClimbStairs2(int n) {
+        if (n <= 0) {
+            return 0;
+        }
+        if (n == 1) {
+            return 1;
+        }
+        if (n == 2) {
+            return 2;
+        }
+        int[] f = new int[n];
+        f[0] = 1;
+        f[1] = 2;
+        for (int i = 2; i < n; i++) {
+            f[i] = f[i - 1] + f[i - 2];
+        }
+
+        return f[n - 1];
+    }
+
+    public int myClimbStairs3(int n) {
+        if (n <= 0) {
+            return 0;
+        }
+        int f0 = 1;
+        int f1 = 1;
+        while (--n > 0) {
+            int tmp = f1;
+            f1 = f1 + f0;
+            f0 = tmp;
+        }
+        return f1;
     }
 }
diff --git a/src/com/blankj/easy/_0071/Solution.java b/src/com/blankj/easy/_0071/Solution.java
new file mode 100644
index 00000000..c643c9fd
--- /dev/null
+++ b/src/com/blankj/easy/_0071/Solution.java
@@ -0,0 +1,39 @@
+package com.blankj.easy._071;
+
+import java.util.LinkedList;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        System.out.println(s.simplifyPath("/a/b/c/"));
+        System.out.println(s.simplifyPath("/home//foo/"));
+        System.out.println(s.simplifyPath("/a/./b/../../c/"));
+        System.out.println(s.simplifyPath("/a/../../b/../c//.//"));
+        System.out.println(s.simplifyPath("/a//b////c/d//././/.."));
+    }
+
+    public String simplifyPath(String path) {
+        if (path == null || path == "") {
+            return "";
+        }
+        String[] dirs = path.split("/");
+        LinkedList<String> simplifyDirs = new LinkedList<>();
+        for (String dir : dirs) {
+            if ("..".equals(dir)) {
+                if (!simplifyDirs.isEmpty()) {
+                    simplifyDirs.removeLast();
+                }
+            } else if (!"".equals(dir) && !".".equals(dir)) {
+                simplifyDirs.add(dir);
+            }
+        }
+        StringBuilder res = new StringBuilder("");
+        for (String dir : simplifyDirs) {
+            res.append("/");
+            res.append(dir);
+        }
+
+        return res.toString();
+    }
+}
diff --git a/src/com/blankj/medium/_0054/Solution.java b/src/com/blankj/medium/_0054/Solution.java
new file mode 100644
index 00000000..4e12528c
--- /dev/null
+++ b/src/com/blankj/medium/_0054/Solution.java
@@ -0,0 +1,56 @@
+import java.util.List;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        System.out.println(List.of(s.spiralTravel(new int[][]{{1, 2, 3}, {4, 5, 6}})));
+        System.out.println(List.of(s.spiralTravel(new int[][]{{1, 2, 3}, {4, 5, 6}, {7, 8, 9}})));
+        System.out.println(List.of(s.spiralTravel(new int[][]{{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}, {13, 14, 15, 16}})));
+    }
+
+    public Integer[] spiralTravel(int[][] numsArray) {
+        if (numsArray == null || numsArray.length == 0 || numsArray[0] == null) {
+            return null;
+        }
+        int total = 0;
+        int length = numsArray[0].length;
+        for (int[] nums : numsArray) {
+            if (nums == null) {
+                throw new IllegalArgumentException("have null arrays");
+            }
+            if (nums.length != length) {
+                throw new IllegalArgumentException("not have same length");
+            }
+            total += nums.length;
+        }
+        int top = 0, left = numsArray[0].length, bottom = numsArray.length, right = 0;
+        int count = 0;
+        Integer[] res = new Integer[total];
+        while (count < total) {
+            int j = top;
+            int i = right;
+            for (; i < left; i++) {
+                res[count++] = numsArray[j][i];
+            }
+            i = left - 1;
+            for (j = top + 1; j < bottom; j++) {
+                res[count++] = numsArray[j][i];
+            }
+            j = bottom - 1;
+            for (i = left - 2; i >= right; i--) {
+                res[count++] = numsArray[j][i];
+            }
+            i = right;
+            for (j = bottom - 2; j > top; j--) {
+                res[count++] = numsArray[j][i];
+            }
+            top = top + 1;
+            left = left - 1;
+            bottom = bottom -1;
+            right = right + 1;
+        }
+
+        return res;
+    }
+}
diff --git a/src/com/blankj/medium/_0056/Solution.java b/src/com/blankj/medium/_0056/Solution.java
index dc84ea42..af96c6ee 100644
--- a/src/com/blankj/medium/_0056/Solution.java
+++ b/src/com/blankj/medium/_0056/Solution.java
@@ -2,9 +2,7 @@
 
 import com.blankj.structure.Interval;
 
-import java.util.ArrayList;
-import java.util.Comparator;
-import java.util.List;
+import java.util.*;
 
 /**
  * <pre>
@@ -44,5 +42,35 @@ public int compare(Interval o1, Interval o2) {
     public static void main(String[] args) {
         Solution solution = new Solution();
         Interval.print(solution.merge(Interval.createTestData("[1,3],[2,6],[8,10],[15,18]")));
+        Interval.print(solution.myMergeOverlap(Interval.createTestData("[1,3],[2,6],[8,10],[15,18]")));
+        Interval.print(solution.merge(Interval.createTestData("[1,3],[2,6],[8,15],[15,18]")));
+        Interval.print(solution.myMergeOverlap(Interval.createTestData("[1,3],[2,6],[8,15],[15,18]")));
+
+    }
+    public List<Interval> myMergeOverlap(List<Interval> intervals) {
+        if (intervals == null || intervals.size() == 0) {
+            return null;
+        }
+        Collections.sort(intervals, new Comparator<Interval>() {
+            @Override
+            public int compare(Interval o1, Interval o2) {
+                return o1.start - o2.start;
+            }
+        });
+        LinkedList<Interval> res = new LinkedList<>();
+        for (Interval interval : intervals) {
+            if (res.isEmpty()) {
+                res.add(interval);
+            } else {
+                Interval lastInterval = res.getLast();
+                if (lastInterval.end >= interval.start) {
+                    lastInterval.end = interval.end;
+                } else {
+                    res.add(interval);
+                }
+            }
+        }
+
+        return res;
     }
 }
diff --git a/src/com/blankj/medium/_0059/Solution.java b/src/com/blankj/medium/_0059/Solution.java
new file mode 100644
index 00000000..922bf100
--- /dev/null
+++ b/src/com/blankj/medium/_0059/Solution.java
@@ -0,0 +1,56 @@
+package com.blankj.medium._059;
+
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        s.displayMatrix(s.generateSpiralMatrix(3));
+        s.displayMatrix(s.generateSpiralMatrix(4));
+    }
+
+    private void displayMatrix(int[][] matrix) {
+        for (int[] column : matrix) {
+            for (int e : column) {
+                System.out.print(e);
+                System.out.print(" ");
+            }
+            System.out.println("\n");
+        }
+    }
+
+    public int[][] generateSpiralMatrix(int n) {
+        int[][] res = new int[n][n];
+        int count = 1;
+        int top = 0;
+        int right = 0;
+        int left = n;
+        int bottom = n;
+        int total = n * n;
+        while (count <= total) {
+            int i = top;
+            int j = right;
+            for (; j < left; j++) {
+                res[i][j] = count++;
+            }
+            j = left - 1;
+            for (i = top + 1; i < bottom; i++) {
+                res[i][j] = count++;
+            }
+            i = bottom - 1;
+            for (j = left - 2; j >= right; j--) {
+                res[i][j] = count++;
+            }
+            j = right;
+            for (i = bottom - 2; i > top; i--) {
+                res[i][j] = count++;
+            }
+            top = top + 1;
+            left = left - 1;
+            bottom = bottom - 1;
+            right = right + 1;
+        }
+
+        return res;
+    }
+}
diff --git a/src/com/blankj/medium/_0060/Solution.java b/src/com/blankj/medium/_0060/Solution.java
new file mode 100644
index 00000000..def13223
--- /dev/null
+++ b/src/com/blankj/medium/_0060/Solution.java
@@ -0,0 +1,53 @@
+package com.blankj.medium._060;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        System.out.println(s.permutationSequence(4, 9));
+    }
+
+    public String permutationSequence(int n, int k) {
+        if (n <= 0 || k <= 0) {
+            return "";
+        }
+
+        List<String> elements = new ArrayList<>();
+        for (int i = 1; i <= n; i++) {
+            elements.add(String.valueOf(i));
+        }
+        List<String> res = dfsPermutation(elements);
+        if (k > res.size()) {
+            throw new IllegalArgumentException("k is bigger than permutation list size");
+        }
+
+        return res.get(k);
+    }
+
+    public List<String> dfsPermutation(List<String> elements) {
+        List<String> res = new ArrayList<>();
+        if (elements.size() == 1) {
+            res.add(elements.get(0));
+        } else {
+            for (String e : elements) {
+                List<String> left = new ArrayList<>();
+                for (String l : elements) {
+                    if (l != e) {
+                        left.add(l);
+                    }
+                }
+                List<String> subsequences = dfsPermutation(left);
+                for (String sub : subsequences) {
+                    res.add(e + sub);
+                }
+            }
+        }
+
+        return res;
+    }
+
+
+}
diff --git a/src/com/blankj/medium/_0061/Solution.java b/src/com/blankj/medium/_0061/Solution.java
new file mode 100644
index 00000000..e565df32
--- /dev/null
+++ b/src/com/blankj/medium/_0061/Solution.java
@@ -0,0 +1,37 @@
+package com.blankj.medium._061;
+
+
+import com.blankj.structure.ListNode;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        ListNode listNode = ListNode.createTestData("[1,2,3,4,5]");
+        ListNode.print(s.rotate(listNode, 2));
+        listNode = ListNode.createTestData("[0,1,2]");
+        ListNode.print(s.rotate(listNode, 4));
+    }
+
+    public ListNode rotate(ListNode head, int k) {
+        if (head == null || k <= 0) {
+            return head;
+        }
+
+        int length = 1;
+        ListNode tmp = head;
+        while (tmp.next != null) {
+            tmp = tmp.next;
+            length++;
+        }
+        ListNode end = tmp;
+        tmp = head;
+        for (int i = 0; i < length - k % length - 1; i++) {
+            tmp = tmp.next;
+        }
+        end.next = head;
+        head = tmp.next;
+        tmp.next = null;
+        return head;
+    }
+}
diff --git a/src/com/blankj/medium/_0062/Solution.java b/src/com/blankj/medium/_0062/Solution.java
new file mode 100644
index 00000000..e1dbbf64
--- /dev/null
+++ b/src/com/blankj/medium/_0062/Solution.java
@@ -0,0 +1,31 @@
+package com.blankj.medium._062;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        System.out.println(s.uniquePath(3, 2));
+        System.out.println(s.uniquePath(3, 3));
+        System.out.println(s.uniquePath(7, 3));
+    }
+
+    public int uniquePath(int m, int n) {
+        if (m <= 0 || n <= 0) {
+            return -1;
+        }
+
+        int[][] f = new int[m][n];
+        for (int i = 0; i < m; i++) {
+            f[i][0] = 1;
+        }
+        for (int j = 0; j < n; j++) {
+            f[0][j] = 1;
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                f[i][j] = f[i][j - 1] + f[i - 1][j];
+            }
+        }
+        return f[m - 1][n - 1];
+    }
+}
diff --git a/src/com/blankj/medium/_0063/Solution.java b/src/com/blankj/medium/_0063/Solution.java
new file mode 100644
index 00000000..bf53e05b
--- /dev/null
+++ b/src/com/blankj/medium/_0063/Solution.java
@@ -0,0 +1,49 @@
+package com.blankj.medium._063;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        int[][] matrix = new int[][]{
+                {0, 0, 0},
+                {0, 1, 0},
+                {0, 0, 0}
+        };
+        System.out.println(s.uniquePath(matrix));
+        matrix = new int[][]{
+                {0, 0, 0},
+                {0, 0, 0},
+                {0, 0, 0}
+        };
+        System.out.println(s.uniquePath(matrix));
+    }
+
+    public int uniquePath(int[][] matrix) {
+        if (matrix == null || matrix.length == 0) {
+            return -1;
+        }
+
+        int m = matrix.length;
+        int n = matrix[0].length;
+
+        int[][] f = new int[m][n];
+        for (int i = 0; i < m; i++) {
+            f[i][0] = 1;
+        }
+        for (int j = 0; j < n; j++) {
+            f[0][j] = 1;
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                f[i][j] = 0;
+                if (matrix[i][j - 1] == 0) {
+                    f[i][j] += f[i][j - 1];
+                }
+                if (matrix[i - 1][j] == 0) {
+                    f[i][j] += f[i - 1][j];
+                }
+            }
+        }
+        return f[m - 1][n - 1];
+    }
+}
diff --git a/src/com/blankj/medium/_0064/Solution.java b/src/com/blankj/medium/_0064/Solution.java
new file mode 100644
index 00000000..e7d2c682
--- /dev/null
+++ b/src/com/blankj/medium/_0064/Solution.java
@@ -0,0 +1,48 @@
+package com.blankj.medium._064;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        int[][] matrix = new int[][]{
+                {1,3,1},
+                {1,5,1},
+                {4,2,1}
+        };
+        System.out.println(s.minimumPath(matrix));
+        matrix = new int[][]{
+                {1,3,1},
+                {1,5,4},
+                {4,2,1}
+        };
+        System.out.println(s.minimumPath(matrix));
+    }
+
+    public int minimumPath(int[][] matrix) {
+        if (matrix == null || matrix.length == 0) {
+            return -1;
+        }
+
+        int m = matrix.length;
+        int n = matrix[0].length;
+
+        int[][] f = new int[m][n];
+        f[0][0] = matrix[0][0];
+        for (int i = 1; i < m; i++) {
+            f[i][0] = f[i - 1][0] + matrix[i][0];
+        }
+        for (int j = 1; j < n; j++) {
+            f[0][j] = f[0][j - 1] + matrix[0][j];
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                if (f[i - 1][j] > f[i][j - 1]) {
+                    f[i][j] = f[i][j - 1] + matrix[i][j];
+                } else {
+                    f[i][j] = f[i - 1][j] + matrix[i][j];
+                }
+            }
+        }
+        return f[m - 1][n - 1];
+    }
+}
diff --git a/src/com/blankj/medium/_0102/Solution.java b/src/com/blankj/medium/_0102/Solution.java
new file mode 100644
index 00000000..cf12eb97
--- /dev/null
+++ b/src/com/blankj/medium/_0102/Solution.java
@@ -0,0 +1,44 @@
+package com.blankj.medium._0102;
+
+import com.blankj.structure.TreeNode;
+
+import java.util.*;
+
+public class Solution {
+
+    public static void main(String[] args) {
+        Solution s = new Solution();
+        System.out.println(s.levelOrderTraversal(TreeNode.createTestData("[1,9,20,null,null,15,7]")));
+    }
+
+    public List<List<Integer>> levelOrderTraversal(TreeNode head) {
+        if (head == null) {
+            return Collections.emptyList();
+        }
+        TreeMap<Integer, List<Integer>> levelValuesMap = new TreeMap<>();
+        levelValuesMap.put(0, List.of(head.val));
+        travelOneTree(head.left, 1, levelValuesMap);
+        travelOneTree(head.right, 1, levelValuesMap);
+        List<List<Integer>> res = new ArrayList<>();
+        for (List<Integer> value : levelValuesMap.values()) {
+            res.add(value);
+        }
+        return res;
+    }
+
+    private void travelOneTree(TreeNode node, int level, Map<Integer, List<Integer>> levelValuesMap) {
+        if (node == null) {
+            return;
+        }
+        List<Integer> values = levelValuesMap.get(level);
+        if (values == null) {
+            values = new ArrayList<>();
+            levelValuesMap.put(level, values);
+        }
+        values.add(node.val);
+        travelOneTree(node.left, level + 1, levelValuesMap);
+        travelOneTree(node.right, level + 1, levelValuesMap);
+    }
+
+
+}