[Tony] WEEK 10 Solutions

course-schedule/TonyKim9401.java

@@ -0,0 +1,37 @@
+// TC: O(n + p)
+// n -> number of courses, p -> the length of prerequisites
+// SC: O(n + m)
+// n -> the length of the graph size, m -> the length of nested list's size
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        List<List<Integer>> graph = new ArrayList<>();
+        int[] inDegree = new int[numCourses];
+
+        for (int i = 0; i < numCourses; i++) graph.add(new ArrayList<>());
+
+        for (int[] prerequisite : prerequisites) {
+            int course = prerequisite[0];
+            int pre = prerequisite[1];
+            graph.get(pre).add(course);
+            inDegree[course] += 1;
+        }
+
+        Queue<Integer> q = new LinkedList<>();
+        for (int i = 0; i < numCourses; i++) {
+            if (inDegree[i] == 0) q.offer(i);
+        }
+
+        int visitedCourses = 0;
+        while (!q.isEmpty()) {
+            int course = q.poll();
+            visitedCourses += 1;
+
+            for (int nextCourse : graph.get(course)) {
+                inDegree[nextCourse] -= 1;
+                if (inDegree[nextCourse] == 0) q.offer(nextCourse);
+            }
+        }
+
+        return visitedCourses == numCourses;
+    }
+}

invert-binary-tree/TonyKim9401.java

@@ -0,0 +1,16 @@
+// TC: O(n)
+// -> visit all nodes to invert
+// SC: O(n)
+// -> create all nodes again to exchange
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) return null;
+        invertTree(root.left);
+        invertTree(root.right);
+        TreeNode left = root.left;
+        TreeNode right = root.right;
+        root.left = right;
+        root.right = left;
+        return root;
+    }
+}

jump-game/TonyKim9401.java

@@ -0,0 +1,13 @@
+// TC: O(n)
+// SC: O(1)
+class Solution {
+    public boolean canJump(int[] nums) {
+        int jump = 0;
+
+        for (int i = 0; i < nums.length; i++) {
+            if (i > jump) return false;
+            jump = Math.max(jump, i + nums[i]);
+        }
+        return true;
+    }
+}

merge-k-sorted-lists/TonyKim9401.java

@@ -0,0 +1,30 @@
+// TC: O(n * log m)
+// m -> the number of the lists, n -> the number of node
+// SC: O(m)
+// m -> the number of the lists (max m)
+class Solution {
+    public ListNode mergeKLists(ListNode[] lists) {
+        if (lists == null || lists.length == 0) return null;
+
+        PriorityQueue<ListNode> pq = new PriorityQueue<>((a, b) -> a.val - b.val);
+
+        for (ListNode node : lists) {
+            if (node != null) pq.offer(node);
+        }
+
+        ListNode dummy = new ListNode(0);
+        ListNode current = dummy;
+
+        while (!pq.isEmpty()) {
+            ListNode minNode = pq.poll();
+            current.next = minNode;
+            current = current.next;
+
+            if (minNode.next != null) {
+                pq.offer(minNode.next);
+            }
+        }
+
+        return dummy.next;
+    }
+}

search-in-rotated-sorted-array/TonyKim9401.java

@@ -0,0 +1,25 @@
+// TC: O(log n)
+// -> binary search
+// SC: O(1)
+class Solution {
+    public int search(int[] nums, int target) {
+
+        int start = 0;
+        int end = nums.length - 1;
+
+        while (start <= end) {
+            int mid = start + (end - start) / 2;
+
+            if (nums[mid] == target) return mid;
+
+            if (nums[start] <= nums[mid]) {
+                if (nums[start] <= target && target < nums[mid]) end = mid - 1;
+                else start = mid + 1;
+            } else {
+                if (nums[mid] < target && target <= nums[end]) start = mid + 1;
+                else end = mid - 1;
+            }
+        }
+        return -1;
+    }
+}