diff --git a/binary-tree-maximum-path-sum/minji-go.java b/binary-tree-maximum-path-sum/minji-go.java
new file mode 100644
index 000000000..7acc3c38a
--- /dev/null
+++ b/binary-tree-maximum-path-sum/minji-go.java
@@ -0,0 +1,26 @@
+/**
+ * <a href="https://leetcode.com/problems/binary-tree-maximum-path-sum/">week11-5. binary-tree-maximum-path-sum</a>
+ * <li>Description: Given the root of a binary tree, return the maximum path sum of any non-empty path</li>
+ * <li>Topics: Dynamic Programming, Tree, Depth-First Search, Binary Tree</li>
+ * <li>Time Complexity: O(N), Runtime 0ms   </li>
+ * <li>Space Complexity: O(H), Memory 44.1MB</li>
+ */
+class Solution {
+    public int maxPathSum(TreeNode root) {
+        dfs(root);
+        return max;
+    }
+
+    int max = Integer.MIN_VALUE;
+    public int dfs(TreeNode head) {
+        if (head == null) return 0;
+
+        int left = Math.max(0, dfs(head.left));
+        int right = Math.max(0, dfs(head.right));
+
+        max = Math.max(max, head.val + left + right);
+
+        return head.val + Math.max(left, right);
+    }
+
+}
diff --git a/course-schedule/minji-go.java b/course-schedule/minji-go.java
new file mode 100644
index 000000000..2554d7c58
--- /dev/null
+++ b/course-schedule/minji-go.java
@@ -0,0 +1,45 @@
+/**
+ * <a href="https://leetcode.com/problems/course-schedule/">week10-3. course-schedule   </a>
+ * <li>Description: Return true if you can finish all courses. Otherwise, return false  </li>
+ * <li>Topics: Depth-First Search, Breadth-First Search, Graph, Topological Sort        </li>
+ * <li>Time Complexity: O(N+E), Runtime 7ms        </li>
+ * <li>Space Complexity: O(N+E), Memory 45.68MB    </li>
+ * <li>Note : refer to the answer. remember the topic of topological sort </li>
+ */
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] inDegree = new int[numCourses];
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int i=0; i<numCourses; i++){
+            graph.add(new ArrayList<>());
+        }
+
+        for(int[] pre : prerequisites) {
+            int dest = pre[0], src = pre[1];
+            graph.get(src).add(dest);
+            inDegree[dest]++;
+        }
+
+        Queue<Integer> queue = new LinkedList<>();
+        for (int i=0; i<numCourses; i++) {
+            if(inDegree[i] == 0) {
+                queue.offer(i);
+            }
+        }
+
+        int count = 0;
+        while(!queue.isEmpty()){
+            int node = queue.poll();
+            count++;
+
+            for(int neighbor : graph.get(node)) {
+                inDegree[neighbor]--;
+                if(inDegree[neighbor] == 0) {
+                    queue.offer(neighbor);
+                }
+            }
+        }
+
+        return count == numCourses;
+    }
+}
diff --git a/invert-binary-tree/minji-go.java b/invert-binary-tree/minji-go.java
new file mode 100644
index 000000000..1bf759396
--- /dev/null
+++ b/invert-binary-tree/minji-go.java
@@ -0,0 +1,26 @@
+/**
+ * <a href="https://leetcode.com/problems/invert-binary-tree/">week10-1. invert-binary-tree </a>
+ * <li>Description: Design an algorithm to serialize and deserialize a binary tree </li>
+ * <li>Topics: Tree, Depth-First Search, Breadth-First Search, Binary Tree </li>
+ * <li>Time Complexity: O(N), Runtime 0ms      </li>
+ * <li>Space Complexity: O(N), Memory 41.28MB   </li>
+ */
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) return null;
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.offer(root);
+
+        while (!queue.isEmpty()) {
+            TreeNode parent = queue.poll();
+            TreeNode temp = parent.left;
+            parent.left = parent.right;
+            parent.right = temp;
+            if (parent.left != null) queue.offer(parent.left);
+            if (parent.right != null) queue.offer(parent.right);
+        }
+
+        return root;
+    }
+}
diff --git a/jump-game/minji-go.java b/jump-game/minji-go.java
new file mode 100644
index 000000000..2a00b0540
--- /dev/null
+++ b/jump-game/minji-go.java
@@ -0,0 +1,19 @@
+/**
+ * <a href="https://leetcode.com/problems/jump-game/">week10-4. jump-game</a>
+ * <li>Description: Return true if you can reach the last index, or false otherwise</li>
+ * <li>Topics: Array, Dynamic Programming, Greedy           </li>
+ * <li>Time Complexity: O(N), Runtime 2ms                   </li>
+ * <li>Space Complexity: O(1), Memory 45.66MB               </li>
+ */
+class Solution {
+    public boolean canJump(int[] nums) {
+        int jump = 0;
+        for (int i = 0; i <= jump; i++) {
+            jump = Math.max(jump, i + nums[i]);
+            if (jump >= nums.length - 1) {
+                return true;
+            }
+        }
+        return false;
+    }
+}
diff --git a/merge-intervals/minji-go.java b/merge-intervals/minji-go.java
new file mode 100644
index 000000000..036a9bddd
--- /dev/null
+++ b/merge-intervals/minji-go.java
@@ -0,0 +1,28 @@
+/**
+ * <a href="https://leetcode.com/problems/merge-intervals/">week11-4. merge-intervals</a>
+ * <li>Description: return an array of the non-overlapping intervals</li>
+ * <li>Topics: Array, Sorting                   </li>
+ * <li>Time Complexity: O(NlogN), Runtime 10ms  </li>
+ * <li>Space Complexity: O(N), Memory 46.18MB   </li>
+ */
+class Solution {
+    public int[][] merge(int[][] intervals) {
+        Arrays.sort(intervals, (i1, i2) -> i1[0] - i2[0]);
+
+        List<int[]> merge = new ArrayList<>();
+        merge.add(intervals[0]);
+
+        for (int i = 1; i < intervals.length; i++) {
+            int[] prev = merge.get(merge.size() - 1);
+            int[] curr = intervals[i];
+
+            if (curr[0] <= prev[1]) {
+                prev[1] = Math.max(prev[1], curr[1]);
+            } else {
+                merge.add(curr);
+            }
+        }
+
+        return merge.toArray(new int[merge.size()][]);
+    }
+}
diff --git a/merge-k-sorted-lists/minji-go.java b/merge-k-sorted-lists/minji-go.java
new file mode 100644
index 000000000..d0446a6db
--- /dev/null
+++ b/merge-k-sorted-lists/minji-go.java
@@ -0,0 +1,51 @@
+/**
+ * <a href="https://leetcode.com/problems/https://leetcode.com/problems/merge-k-sorted-lists/">week10-5. merge-k-sorted-lists</a>
+ * <li>Description: Merge all the linked-lists into one sorted linked-list          </li>
+ * <li>Topics: Linked List, Divide and Conquer, Heap (Priority Queue), Merge Sort   </li>
+ * <li>Time Complexity: O(NlogK), Runtime 1ms   </li>
+ * <li>Space Complexity: O(K), Memory 44.7MB   </li>
+ */
+class Solution {
+    public ListNode mergeKLists(ListNode[] lists) {
+        if (lists == null || lists.length == 0) {
+            return null;
+        }
+        return mergeKLists(lists, 0, lists.length - 1);
+    }
+
+    private ListNode mergeKLists(ListNode[] lists, int start, int end) {
+        if (start == end) {
+            return lists[start];
+        }
+
+        int mid = (start + end) / 2;
+        ListNode node1 = mergeKLists(lists, start, mid);
+        ListNode node2 = mergeKLists(lists, mid + 1, end);
+        return mergeTwoLists(node1, node2);
+    }
+
+    private ListNode mergeTwoLists(ListNode node1, ListNode node2) {
+        ListNode dummy = new ListNode(-10_001);
+        ListNode merge = dummy;
+
+        while (node1 != null && node2 != null) {
+            if (node1.val < node2.val) {
+                merge.next = node1;
+                merge = merge.next;
+                node1 = node1.next;
+            } else {
+                merge.next = node2;
+                merge = merge.next;
+                node2 = node2.next;
+            }
+        }
+
+        if (node1 != null && node2 == null) {
+            merge.next = node1;
+        } else {
+            merge.next = node2;
+        }
+
+        return dummy.next;
+    }
+}
diff --git a/missing-number/minji-go.java b/missing-number/minji-go.java
index 61cc2894f..933c149f8 100644
--- a/missing-number/minji-go.java
+++ b/missing-number/minji-go.java
@@ -1,19 +1,16 @@
-/*
-    Problem: https://leetcode.com/problems/missing-number/
-    Description: return the only number in the range that is missing from the array.
-    Concept: Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting
-    Time Complexity: O(N), Runtime 0ms
-    Space Complexity: O(1), Memory 45.71MB
-*/
+/**
+ * <a href="https://leetcode.com/problems/missing-number/">week11-1. missing-number</a>
+ * <li>Description: Return the only number in the range that is missing from the array</li>
+ * <li>Topics: Array, Hash Table, Math, Binary Search, Bit Manipulation, Sorting </li>
+ * <li>Time Complexity: O(N), Runtime 0ms       </li>
+ * <li>Space Complexity: O(1), Memory 45.67MB   </li>
+ */
 class Solution {
     public int missingNumber(int[] nums) {
-        int n = nums.length;
-        int missing = n;
-
-        for(int i=0; i<n; i++){
-            missing ^= i;
-            missing ^= nums[i];
+        int sum = (nums.length) * (nums.length + 1) / 2;
+        for (int i = 0; i < nums.length; i++) {
+            sum -= nums[i];
         }
-        return missing;
+        return sum;
     }
 }
diff --git a/non-overlapping-intervals/minji-go.java b/non-overlapping-intervals/minji-go.java
new file mode 100644
index 000000000..5432df3a0
--- /dev/null
+++ b/non-overlapping-intervals/minji-go.java
@@ -0,0 +1,26 @@
+/**
+ * <a href="https://leetcode.com/problems/non-overlapping-intervals/">week12-3. non-overlapping-intervals</a>
+ * <li>Description: return the minimum number of intervals you need to remove to make the rest of the intervals non-overlapping</li>
+ * <li>Topics: Array, Dynamic Programming, Greedy, Sorting  </li>
+ * <li>Time Complexity: O(N), Runtime 45ms                  </li>
+ * <li>Space Complexity: O(1), Memory 73.45MB               </li>
+ * <li>Note : refer to the answer                           </li>
+ */
+class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, (i1, i2) -> i1[1] - i2[1]);
+
+        int skip = 0;
+        int end = Integer.MIN_VALUE;
+
+        for (int[] interval : intervals) {
+            if (interval[0] < end) {
+                skip++;
+            } else {
+                end = interval[1];
+            }
+        }
+
+        return skip;
+    }
+}
diff --git a/remove-nth-node-from-end-of-list/minji-go.java b/remove-nth-node-from-end-of-list/minji-go.java
new file mode 100644
index 000000000..37a6e9efb
--- /dev/null
+++ b/remove-nth-node-from-end-of-list/minji-go.java
@@ -0,0 +1,27 @@
+/**
+ * <a href="https://leetcode.com/problems/remove-nth-node-from-end-of-list/">week12-2. remove-nth-node-from-end-of-list</a>
+ * <li>Description: Given the head of a linked list, remove the nth node from the end of the list and return its head</li>
+ * <li>Topics: Linked List, Two Pointers        </li>
+ * <li>Time Complexity: O(N), Runtime 0ms       </li>
+ * <li>Space Complexity: O(1), Memory 41.95MB   </li>
+ */
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        ListNode dummy = new ListNode(0, head);
+        ListNode fast = dummy;
+        ListNode slow = dummy;
+
+        for(int i=0; i<=n; i++){
+            fast = fast.next;
+        }
+
+        while (fast != null) {
+            slow = slow.next;
+            fast = fast.next;
+        }
+
+        slow.next = slow.next.next;
+
+        return dummy.next;
+    }
+}
diff --git a/reorder-list/minji-go.java b/reorder-list/minji-go.java
new file mode 100644
index 000000000..b99f6b77c
--- /dev/null
+++ b/reorder-list/minji-go.java
@@ -0,0 +1,29 @@
+/**
+ * <a href="https://leetcode.com/problems/reorder-list/">week11-2. reorder-list</a>
+ * <li>Description: Reorder the list to be on the following form: L0 → Ln → L1 → Ln - 1 → L2 → ... </li>
+ * <li>Topics: Linked List, Two Pointers, Stack, Recursion </li>
+ * <li>Time Complexity: O(N), Runtime 5ms       </li>
+ * <li>Space Complexity: O(N), Memory 47.96MB   </li>
+ */
+class Solution {
+    public void reorderList(ListNode head) {
+        Deque<ListNode> deque = new ArrayDeque<>();
+
+        ListNode node = head;
+        while (node != null) {
+            deque.addLast(node);
+            node = node.next;
+        }
+
+        ListNode curr = deque.removeFirst();
+        while (!deque.isEmpty()) {
+            curr.next = deque.removeLast();
+            curr = curr.next;
+            if (!deque.isEmpty()) {
+                curr.next = deque.removeFirst();
+                curr = curr.next;
+            }
+        }
+        curr.next = null;
+    }
+}
diff --git a/same-tree/minji-go.java b/same-tree/minji-go.java
new file mode 100644
index 000000000..9a09ef02d
--- /dev/null
+++ b/same-tree/minji-go.java
@@ -0,0 +1,36 @@
+import leetcode_study.TreeNode;
+
+import java.util.AbstractMap;
+import java.util.Map;
+
+/**
+ * <a href="https://leetcode.com/problems/same-tree/description/">week12-1. same-tree</a>
+ * <li>Description: Given the roots of two binary trees p and q, check if they are the same or not </li>
+ * <li>Topics: Tree, Depth-First Search, Breadth-First Search, Binary Tree </li>
+ * <li>Time Complexity: O(N), Runtime 0ms     </li>
+ * <li>Space Complexity: O(N), Memory 41.14MB </li>
+ */
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        Queue<Map.Entry<TreeNode, TreeNode>> queue = new LinkedList<>();
+        queue.add(new AbstractMap.SimpleEntry<>(p, q));
+
+        while (!queue.isEmpty()) {
+            Map.Entry<TreeNode, TreeNode> nodeMap = queue.poll();
+            TreeNode nodeP = nodeMap.getKey();
+            TreeNode nodeQ = nodeMap.getValue();
+
+            if (nodeP == null && nodeQ == null) {
+                continue;
+            }
+            if (nodeP == null || nodeQ == null || nodeP.val != nodeQ.val) {
+                return false;
+            }
+
+            queue.add(new AbstractMap.SimpleEntry<>(nodeP.left, nodeQ.left));
+            queue.add(new AbstractMap.SimpleEntry<>(nodeP.right, nodeQ.right));
+        }
+
+        return true;
+    }
+}
diff --git a/search-in-rotated-sorted-array/minji-go.java b/search-in-rotated-sorted-array/minji-go.java
new file mode 100644
index 000000000..702dbc85c
--- /dev/null
+++ b/search-in-rotated-sorted-array/minji-go.java
@@ -0,0 +1,60 @@
+/**
+ * <a href="https://leetcode.com/problems/search-in-rotated-sorted-array/">week10-2. search-in-rotated-sorted-array</a>
+ * <li>Description: nums is sorted in ascending order and is possibly rotated at an unknown pivot index. return the index of target if it is in nums, or -1 </li>
+ * <li>Topics: Array, Binary Search </li>
+ * <li>Time Complexity: O(logN), Runtime 1ms      </li>
+ * <li>Space Complexity: O(logN), Memory 43.23MB </li>
+ */
+class Solution {
+    public int search(int[] nums, int target) {
+        if(nums.length==1) {
+            if(nums[0]==target) return 0;
+            return -1;
+        }
+
+        Queue<int[]> queue = new LinkedList<>();
+        queue.add(new int[]{0, nums.length-1});
+
+        int pivot = -1;
+        if(nums[0]<nums[nums.length-1]) {
+            pivot=nums.length-1;
+        }
+
+        while(pivot==-1 && !queue.isEmpty()){
+            int[] q = queue.poll();
+            int mid = (q[0]+q[1])/2;
+            if(mid+1 > nums.length-1) {
+                continue;
+            }
+            if(nums[mid]>nums[mid+1]) {
+                pivot=mid;
+                break;
+            }
+            queue.add(new int[]{q[0], mid});
+            queue.add(new int[]{mid+1, q[1]});
+        }
+
+        int left = 0, right = nums.length-1;
+        if(target>=nums[0] && target<=nums[pivot]) {
+            right = pivot;
+        } else {
+            left = pivot+1;
+        }
+
+
+        while(left<=right){
+            int mid = (left+right)/2;
+            if(target < nums[mid]) {
+                right=mid-1;
+            } else {
+                left=mid+1;
+            }
+        }
+
+        if(nums[right] == target) {
+            return right;
+        }
+
+        return -1;
+    }
+}
diff --git a/serialize-and-deserialize-binary-tree/minji-go.java b/serialize-and-deserialize-binary-tree/minji-go.java
new file mode 100644
index 000000000..b7a6c1980
--- /dev/null
+++ b/serialize-and-deserialize-binary-tree/minji-go.java
@@ -0,0 +1,65 @@
+/**
+ * <a href="https://leetcode.com/problems/serialize-and-deserialize-binary-tree/">week12-4. serialize-and-deserialize-binary-tree </a>
+ * <li>Description: Design an algorithm to serialize and deserialize a binary tree          </li>
+ * <li>Topics: String, Tree, Depth-First Search, Breadth-First Search, Design, Binary Tree  </li>
+ * <li>Time Complexity: O(N), Runtime 14ms      </li>
+ * <li>Space Complexity: O(N), Memory 45.44MB   </li>
+ */
+public class Codec {
+
+    public String serialize(TreeNode root) {
+        if (root == null) {
+            return null;
+        }
+
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        StringBuilder sb = new StringBuilder();
+        while (!queue.isEmpty()) {
+            TreeNode node = queue.poll();
+            if (node == null) {
+                sb.append("null,");
+                continue;
+            }
+            sb.append(node.val).append(",");
+            queue.add(node.left);
+            queue.add(node.right);
+        }
+
+        return sb.toString();
+    }
+
+    public TreeNode deserialize(String data) {
+        if (data == null) {
+            return null;
+        }
+
+        String[] values = data.split(",");
+
+        TreeNode root = new TreeNode(Integer.parseInt(values[0]));
+        Queue<TreeNode> queue = new LinkedList<>();
+        queue.add(root);
+
+        int i = 1;
+        while (!queue.isEmpty()) {
+            TreeNode parent = queue.poll();
+
+            if (!values[i].equals("null")) {
+                TreeNode left = new TreeNode(Integer.parseInt(values[i]));
+                parent.left = left;
+                queue.add(left);
+            }
+            i++;
+
+            if (!values[i].equals("null")) {
+                TreeNode right = new TreeNode(Integer.parseInt(values[i]));
+                parent.right = right;
+                queue.add(right);
+            }
+            i++;
+        }
+
+        return root;
+    }
+}