Merge pull request #1606 from sora0319/main

[sora0349] Week 12 Solutions

Author: sora0319

non-overlapping-intervals/sora0319.java

@@ -0,0 +1,20 @@
+public class Solution {
+    public int eraseOverlapIntervals(int[][] intervals) {
+        Arrays.sort(intervals, (a, b) -> Integer.compare(a[0], b[0]));
+        int count = 0;
+
+        int prv_end = intervals[0][1];
+        for (int i = 1; i < intervals.length; i++) {
+            int start = intervals[i][0];
+            int end = intervals[i][1];
+            if (prv_end > start) {
+                count++;
+                prv_end = Math.min(end, prv_end);
+            } else {
+                prv_end = end;
+            }
+        }
+        return count;
+    }
+}
+

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

@@ -0,0 +1,37 @@
+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) {
+            int node = edge[0];
+            int adj = edge[1];
+            graph.get(node).add(adj);
+            graph.get(adj).add(node);
+        }
+
+        int count = 0;
+        Set<Integer> visited = new HashSet<>();
+        for (int node = 0; node < n; node++) {
+            if (visited.contains(node)) {
+                continue;
+            }
+            count++;
+            Deque<Integer> queue = new ArrayDeque<>();
+            queue.push(node);
+            while (!queue.isEmpty()) {
+                int cur = queue.pop();
+                if (visited.contains(cur)) continue;
+                visited.add(cur);
+                for (int g : graph.get(cur)) {
+                    if (!visited.contains(g)) {
+                        queue.push(g);
+                    }
+                }
+            }
+        }
+        return count;
+    }
+}
+

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

@@ -0,0 +1,24 @@
+public class Solution {
+    public ListNode removeNthFromEnd(ListNode head, int n) {
+        Queue<ListNode> queue = new LinkedList<>();
+        ListNode temp = new ListNode(0, head);
+        ListNode node = temp;
+
+        for (int i = 0; i < n + 1; i++) {
+            queue.offer(node);
+            node = node.next;
+        }
+
+        while (node != null) {
+            queue.poll();
+            queue.offer(node);
+            node = node.next;
+        }
+
+        ListNode prev = queue.poll();
+        prev.next = prev.next.next;
+
+        return temp.next;
+    }
+}
+

same-tree/sora0319.java

@@ -0,0 +1,26 @@
+public class Solution {
+    public boolean isSameTree(TreeNode p, TreeNode q) {
+        Stack<TreeNode[]> stack = new Stack<>();
+        stack.push(new TreeNode[]{p, q});
+
+        while (!stack.isEmpty()) {
+            TreeNode[] nodes = stack.pop();
+            TreeNode n1 = nodes[0];
+            TreeNode n2 = nodes[1];
+
+            if (n1 == null && n2 == null) {
+                continue;
+            }
+            if (n1 == null || n2 == null) {
+                return false;
+            }
+            if (n1.val != n2.val) {
+                return false;
+            }
+            stack.push(new TreeNode[]{n1.left, n2.left});
+            stack.push(new TreeNode[]{n1.right, n2.right});
+        }
+        return true;
+    }
+}
+

serialize-and-deserialize-binary-tree/sora0319.java

@@ -0,0 +1,27 @@
+public class Codec {
+    public String serialize(TreeNode root) {
+        if (root == null) {
+            return "N";
+        }
+        String left = serialize(root.left);
+        String right = serialize(root.right);
+        return root.val + "," + left + "," + right;
+    }
+
+    public TreeNode deserialize(String data) {
+        Deque<String> values = new ArrayDeque<>(Arrays.asList(data.split(",")));
+        return dfs(values);
+    }
+
+    private TreeNode dfs(Deque<String> values) {
+        String value = values.pollFirst();
+        if (value.equals("N")) {
+            return null;
+        }
+        TreeNode node = new TreeNode(Integer.parseInt(value));
+        node.left = dfs(values);
+        node.right = dfs(values);
+        return node;
+    }
+}
+