[HoonDongKang] week 12 solutions

non-overlapping-intervals/HoonDongKang.ts

@@ -0,0 +1,25 @@
+/**
+ * [Problem]: [435] Non-overlapping Intervals
+ * (https://leetcode.com/problems/non-overlapping-intervals/description/)
+ */
+
+//시간복잡도 O(n log n)
+//공간복잡도 O(1)
+function eraseOverlapIntervals(intervals: number[][]): number {
+    intervals.sort((a, b) => a[1] - b[1]);
+
+    let count = 0;
+    let prev = intervals[0][1];
+
+    for (let i = 1; i < intervals.length; i++) {
+        let [start, end] = intervals[i];
+
+        if (prev > start) {
+            count++;
+        } else {
+            prev = end;
+        }
+    }
+
+    return count;
+}

number-of-connected-components-in-an-undirected-graph/HoonDongKang.ts

@@ -0,0 +1,73 @@
+/**
+ * [Problem]: [3651] Number of Connected Components in an Undirected Graph
+ * (https://www.lintcode.com/problem/3651/)
+ */
+export class Solution {
+    /**
+     * @param n: the number of vertices
+     * @param edges: the edges of undirected graph
+     * @return: the number of connected components
+     */
+    countComponents(n: number, edges: number[][]): number {
+        //시간복잡도 O(n + e)
+        // 공간복잡도 O(n + e)
+        function dfsFunc(n: number, edges: number[][]): number {
+            const visited = new Array(n).fill(false);
+            const graph: number[][] = Array.from({ length: n }, () => []);
+
+            for (const [node, adjacent] of edges) {
+                graph[node].push(adjacent);
+                graph[adjacent].push(node);
+            }
+
+            function dfs(node: number) {
+                visited[node] = true;
+                for (const neighbor of graph[node]) {
+                    if (!visited[neighbor]) {
+                        dfs(neighbor);
+                    }
+                }
+            }
+
+            let count = 0;
+
+            for (let i = 0; i < n; i++) {
+                if (!visited[i]) {
+                    count++;
+                    dfs(i);
+                }
+            }
+
+            return count;
+        }
+        // 시간복잡도 O(n + e)
+        // 공간복잡도 O(n + e)
+        function stackFunc(n: number, edges: number[][]): number {
+            const visited = new Array(n).fill(false);
+            const graph: number[][] = Array.from({ length: n }, () => []);
+            let count = 0;
+
+            for (const [node, adjacent] of edges) {
+                graph[node].push(adjacent);
+                graph[adjacent].push(node);
+            }
+
+            for (let i = 0; i < n; i++) {
+                if (visited[i]) continue;
+                count++;
+                const stack = [i];
+
+                while (stack.length) {
+                    const node = stack.pop()!;
+                    visited[node] = true;
+
+                    for (let adj of graph[node]) {
+                        if (!visited[adj]) stack.push(adj);
+                    }
+                }
+            }
+
+            return count;
+        }
+    }
+}

remove-nth-node-from-end-of-list/HoonDongKang.ts

@@ -0,0 +1,58 @@
+/**
+ * [Problem]: [19] Remove Nth Node From End of List
+ * (https://leetcode.com/problems/remove-nth-node-from-end-of-list/description/)
+ */
+
+class ListNode {
+    val: number;
+    next: ListNode | null;
+    constructor(val?: number, next?: ListNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.next = next === undefined ? null : next;
+    }
+}
+
+function removeNthFromEnd(head: ListNode | null, n: number): ListNode | null {
+    // 시간복잡도 O(N)
+    // 공간복잡도 O(1)
+    function lengthFunc(head: ListNode | null, n: number): ListNode | null {
+        let length = 0;
+        let current = head;
+        while (current) {
+            length++;
+            current = current.next;
+        }
+
+        let dummy = new ListNode(0, head);
+        current = dummy;
+
+        for (let i = 0; i < length - n; i++) {
+            current = current?.next!;
+        }
+
+        current.next = current.next!.next || null;
+
+        return dummy.next;
+    }
+
+    // 시간복잡도 O(N)
+    // 공간복잡도 O(1)
+    function twoPointerFunc(head: ListNode | null, n: number): ListNode | null {
+        let first = head;
+
+        for (let i = 0; i < n; i++) {
+            first = first?.next!;
+        }
+
+        let dummy = new ListNode(0, head);
+        let second = dummy;
+
+        while (first) {
+            first = first.next;
+            second = second.next!;
+        }
+
+        second.next = second.next?.next || null;
+        return dummy.next;
+    }
+}

same-tree/HoonDongKang.ts

@@ -0,0 +1,43 @@
+/**
+ * [Problem]: [100] Same Tree
+ * (https://leetcode.com/problems/same-tree/description/)
+ */
+
+class TreeNode {
+    val: number;
+    left: TreeNode | null;
+    right: TreeNode | null;
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+    }
+}
+
+function isSameTree(p: TreeNode | null, q: TreeNode | null): boolean {
+    // 시간복잡도  O(N)
+    // 공간복잡도  O(N)
+    function recursiveFunc(p: TreeNode | null, q: TreeNode | null): boolean {
+        if (!p && !q) return true;
+        if (!p || !q) return false;
+        if (p.val !== q.val) return false;
+        return recursiveFunc(p.left, q.left) && recursiveFunc(p.right, q.right);
+    }
+
+    // 시간복잡도  O(N)
+    // 공간복잡도  O(N)
+    function stackFunc(p: TreeNode | null, q: TreeNode | null): boolean {
+        const stack = [[p, q]];
+        while (stack.length) {
+            const [p, q] = stack.pop()!;
+            if (!p && !q) continue;
+            if (!p || !q) return false;
+            if (p.val !== q.val) return false;
+
+            stack.push([p.left, q.left]);
+            stack.push([p.right, q.right]);
+        }
+
+        return true;
+    }
+}

serialize-and-deserialize-binary-tree/HoonDongKang.ts

@@ -0,0 +1,54 @@
+/**
+ * [Problem]: [297] Serialize and Deserialize Binary Tree
+ * (\https://leetcode.com/problems/serialize-and-deserialize-binary-tree/description/)
+ */
+
+class TreeNode {
+    val: number;
+    left: TreeNode | null;
+    right: TreeNode | null;
+    constructor(val?: number, left?: TreeNode | null, right?: TreeNode | null) {
+        this.val = val === undefined ? 0 : val;
+        this.left = left === undefined ? null : left;
+        this.right = right === undefined ? null : right;
+    }
+}
+
+/*
+ * Encodes a tree to a single string.
+ */
+//시간복잡도 O(N)
+//공간복잡도 O(N)
+function serialize(root: TreeNode | null): string {
+    if (!root) return "NULL";
+
+    const left = serialize(root.left);
+    const right = serialize(root.right);
+
+    return `${root.val},${left},${right}`;
+}
+
+/*
+ * Decodes your encoded data to tree.
+ */
+//시간복잡도 O(N)
+//공간복잡도 O(N)
+function deserialize(data: string): TreeNode | null {
+    const values = data.split(",");
+    let index = 0;
+
+    function dfs(): TreeNode | null {
+        if (values[index] === "NULL") {
+            index++;
+            return null;
+        }
+        const node = new TreeNode(+values[index++]);
+
+        node.left = dfs();
+        node.right = dfs();
+
+        return node;
+    }
+
+    return dfs();
+}