Merge pull request #564 from TonyKim9401/main

[Tony] WEEK 12 Solutions

merge-intervals/TonyKim9401.java

@@ -0,0 +1,30 @@
+// TC: O(n log n)
+// It takes n log n to sort array, visit all elements in O(n) time, total O(n log n)
+// SC: O(n)
+// Needs max O(n) space to save intervals
+class Solution {
+    public int[][] merge(int[][] intervals) {
+        int n = intervals.length;
+        if (n == 1) return intervals;
+
+        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
+        List<int[]> output = new ArrayList<>();
+        output.add(intervals[0]);
+
+        int[] currentInterval = intervals[0];
+
+        for (int[] interval : intervals) {
+            int currentEnd = currentInterval[1];
+            int nextStart = interval[0];
+            int nextEnd = interval[1];
+            if (currentEnd >= nextStart) {
+                currentInterval[1] = Math.max(currentEnd, nextEnd);
+            } else {
+                currentInterval = interval;
+                output.add(currentInterval);
+            }
+        }
+
+        return output.toArray(new int[output.size()][]);
+    }
+}

number-of-connected-components-in-an-undirected-graph/TonyKim9401.java

@@ -0,0 +1,34 @@
+// TC: O(n + m)
+// n = the number of nodes, m = the number of edges
+// SC: O(n + m)
+// n, m are the each size of the 2 demension array 'edges'
+public class Solution {
+    public int countComponents(int n, int[][] edges) {
+        List<List<Integer>> graph = new ArrayList<>();
+
+        for (int i = 0; i < n; i++) graph.add(new ArrayList<>());
+
+        for (int[] edge : edges) {
+            graph.get(edge[0]).add(edge[1]);
+            graph.get(edge[1]).add(edge[0]);
+        }
+
+        boolean[] visit = new boolean[n];
+        int count = 0;
+
+        for (int i = 0; i < n; i++) {
+            if (!visit[i]) {
+                count += 1;
+                dfs(i, graph, visit);
+            }
+        }
+        return count;
+    }
+
+    private void dfs(int node, List<List<Integer>> graph, boolean[] visit) {
+        visit[node] = true;
+        for (int neighbor : graph.get(node)) {
+            if (!visit[neighbor]) dfs(neighbor, graph, visit);
+        }
+    }
+}

remove-nth-node-from-end-of-list/TonyKim9401.java

@@ -0,0 +1,21 @@
+// TC: O(n)
+// Visit all elements in the worst case
+// SC: O(1)
+// Keep using ready assigned variables only
+class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        ListNode output = new ListNode(0, head);
+        ListNode dummy = output;
+
+        for (int i = 0; i < n; i++) head = head.next;
+
+        while (head != null) {
+            head = head.next;
+            dummy = dummy.next;
+        }
+
+        dummy.next = dummy.next.next;
+
+        return output.next;
+    }
+}

same-tree/TonyKim9401.java

@@ -0,0 +1,17 @@
+// TC: O(n)
+// retreive all given nodes
+// SC: O(1)
+// doesn't require additional space
+class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        if (p == null || q == null) {
+            if (p == null && q == null) return true;
+            return false;
+        }
+
+        if (p.val != q.val) return false;
+
+        return isSameTree(p.left, q.left) &&
+                isSameTree(p.right, q.right);
+    }
+}