[ICE0208] WEEK 10 Solutions

course-schedule/ICE0208.java

@@ -0,0 +1,48 @@
+import java.util.ArrayDeque;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Queue;
+
+class Solution {
+    public boolean canFinish(int numCourses, int[][] prerequisites) {
+        int[] indegree = new int[numCourses];
+
+        List<List<Integer>> graph = new ArrayList<>();
+        for (int course = 0; course < numCourses; course++) {
+            graph.add(new ArrayList<>());
+        }
+
+        for (int[] prerequisite : prerequisites) {
+            int course = prerequisite[0];
+            int prerequisiteCourse = prerequisite[1];
+
+            graph.get(prerequisiteCourse).add(course);
+            indegree[course]++;
+        }
+
+        Queue<Integer> queue = new ArrayDeque<>();
+
+        for (int course = 0; course < numCourses; course++) {
+            if (indegree[course] == 0) {
+                queue.offer(course);
+            }
+        }
+
+        int completedCourses = 0;
+
+        while (!queue.isEmpty()) {
+            int course = queue.poll();
+            completedCourses++;
+
+            for (int nextCourse : graph.get(course)) {
+                indegree[nextCourse]--;
+
+                if (indegree[nextCourse] == 0) {
+                    queue.offer(nextCourse);
+                }
+            }
+        }
+
+        return completedCourses == numCourses;
+    }
+}

invert-binary-tree/ICE0208.java

@@ -0,0 +1,16 @@
+class Solution {
+    public TreeNode invertTree(TreeNode root) {
+        if (root == null) {
+            return null;
+        }
+
+        invertTree(root.left);
+        invertTree(root.right);
+
+        TreeNode temp = root.left;
+        root.left = root.right;
+        root.right = temp;
+
+        return root;
+    }
+}

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

@@ -0,0 +1,34 @@
+class Solution {
+    public int search(int[] nums, int target) {
+        int left = 0;
+        int right = nums.length - 1;
+
+        while (left <= right) {
+            int mid = left + (right - left) / 2;
+
+            if (nums[mid] == target) {
+                return mid;
+            }
+
+            // 왼쪽 절반이 정렬되어 있는 경우
+            if (nums[left] <= nums[mid]) {
+                if (nums[left] <= target && target < nums[mid]) {
+                    right = mid - 1;
+                } else {
+                    left = mid + 1;
+                }
+            }
+
+            // 오른쪽 절반이 정렬되어 있는 경우
+            else {
+                if (nums[mid] < target && target <= nums[right]) {
+                    left = mid + 1;
+                } else {
+                    right = mid - 1;
+                }
+            }
+        }
+
+        return -1;
+    }
+}