From 2122f12ead0ddce253a4822044c535a4ae9d445b Mon Sep 17 00:00:00 2001 From: hsskey Date: Sat, 21 Jun 2025 10:50:25 +0900 Subject: [PATCH 1/2] =?UTF-8?q?12=EC=A3=BC=EC=B0=A8=20solved?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- non-overlapping-intervals/hsskey.js | 24 ++++++++ .../hsskey.js | 44 +++++++++++++++ remove-nth-node-from-end-of-list/hsskey.js | 36 ++++++++++++ same-tree/hsskey.js | 24 ++++++++ .../hsskey.js | 56 +++++++++++++++++++ 5 files changed, 184 insertions(+) create mode 100644 non-overlapping-intervals/hsskey.js create mode 100644 number-of-connected-components-in-an-undirected-graph/hsskey.js create mode 100644 remove-nth-node-from-end-of-list/hsskey.js create mode 100644 same-tree/hsskey.js create mode 100644 serialize-and-deserialize-binary-tree/hsskey.js diff --git a/non-overlapping-intervals/hsskey.js b/non-overlapping-intervals/hsskey.js new file mode 100644 index 000000000..cfbc94798 --- /dev/null +++ b/non-overlapping-intervals/hsskey.js @@ -0,0 +1,24 @@ +/** + * @param {number[][]} intervals + * @return {number} + */ +var eraseOverlapIntervals = function(intervals) { + intervals.sort((a, b) => a[0] - b[0]); + + let res = 0; + let prevEnd = intervals[0][1]; + + for (let i = 1; i < intervals.length; i++) { + const [start, end] = intervals[i]; + + if (start >= prevEnd) { + prevEnd = end; + } else { + res += 1; + prevEnd = Math.min(end, prevEnd); + } + } + + return res; +}; + diff --git a/number-of-connected-components-in-an-undirected-graph/hsskey.js b/number-of-connected-components-in-an-undirected-graph/hsskey.js new file mode 100644 index 000000000..b08cd9f20 --- /dev/null +++ b/number-of-connected-components-in-an-undirected-graph/hsskey.js @@ -0,0 +1,44 @@ +export class Solution { + /** + * @param {number} n - the number of vertices + * @param {number[][]} edges - the edges of undirected graph + * @return {number} - the number of connected components + */ + countComponents(n, edges) { + const par = Array.from({ length: n }, (_, i) => i); + const rank = Array(n).fill(1); + + const find = (n1) => { + let res = n1; + while (res !== par[res]) { + par[res] = par[par[res]]; // path compression + res = par[res]; + } + return res; + }; + + const union = (n1, n2) => { + const p1 = find(n1); + const p2 = find(n2); + if (p1 === p2) return 0; + + if (rank[p2] > rank[p1]) { + par[p1] = p2; + rank[p2] += rank[p1]; + } else { + par[p2] = p1; + rank[p1] += rank[p2]; + } + + return 1; + }; + + let res = n; + for (const [n1, n2] of edges) { + res -= union(n1, n2); + } + + return res; + } + } + \ No newline at end of file diff --git a/remove-nth-node-from-end-of-list/hsskey.js b/remove-nth-node-from-end-of-list/hsskey.js new file mode 100644 index 000000000..c4383477b --- /dev/null +++ b/remove-nth-node-from-end-of-list/hsskey.js @@ -0,0 +1,36 @@ +/** + * Definition for singly-linked list. + * function ListNode(val, next) { + * this.val = (val===undefined ? 0 : val) + * this.next = (next===undefined ? null : next) + * } + */ + +/** + * @param {ListNode} head + * @param {number} n + * @return {ListNode} + */ +var removeNthFromEnd = function(head, n) { + const dummy = new ListNode(0, head); + let left = dummy; + let right = head; + + // advance right pointer n steps ahead + while (n > 0 && right) { + right = right.next; + n--; + } + + // move both pointers until right reaches the end + while (right) { + left = left.next; + right = right.next; + } + + // delete the nth node from end + left.next = left.next.next; + + return dummy.next; +}; + diff --git a/same-tree/hsskey.js b/same-tree/hsskey.js new file mode 100644 index 000000000..4fbc62a2b --- /dev/null +++ b/same-tree/hsskey.js @@ -0,0 +1,24 @@ +/** + * Definition for a binary tree node. + * function TreeNode(val, left, right) { + * this.val = (val===undefined ? 0 : val) + * this.left = (left===undefined ? null : left) + * this.right = (right===undefined ? null : right) + * } + */ + +/** + * @param {TreeNode} p + * @param {TreeNode} q + * @return {boolean} + */ +var isSameTree = function(p, q) { + if (!p && !q) { + return true; + } + if (!p || !q || p.val !== q.val) { + return false; + } + return isSameTree(p.left, q.left) && isSameTree(p.right, q.right); +}; + diff --git a/serialize-and-deserialize-binary-tree/hsskey.js b/serialize-and-deserialize-binary-tree/hsskey.js new file mode 100644 index 000000000..f9b216290 --- /dev/null +++ b/serialize-and-deserialize-binary-tree/hsskey.js @@ -0,0 +1,56 @@ +/** + * Definition for a binary tree node. + * function TreeNode(val) { + * this.val = val; + * this.left = this.right = null; + * } + */ + +/** + * Encodes a tree to a single string. + * + * @param {TreeNode} root + * @return {string} + */ +var serialize = function(root) { + const res = []; + + const dfs = (node) => { + if (!node) { + res.push("N"); + return; + } + res.push(String(node.val)); + dfs(node.left); + dfs(node.right); + }; + + dfs(root); + return res.join("."); +}; + +/** + * Decodes your encoded data to tree. + * + * @param {string} data + * @return {TreeNode} + */ +var deserialize = function(data) { + const vals = data.split("."); + let i = 0; + + const dfs = () => { + if (vals[i] === "N") { + i++; + return null; + } + const node = new TreeNode(parseInt(vals[i])); + i++; + node.left = dfs(); + node.right = dfs(); + return node; + }; + + return dfs(); +}; + From aec0ed198438fff7704d025f17e55b48b05e2e46 Mon Sep 17 00:00:00 2001 From: hsskey Date: Sun, 22 Jun 2025 15:53:07 +0900 Subject: [PATCH 2/2] =?UTF-8?q?=EC=88=98=EC=A0=95?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- .../hsskey.js | 78 +++++++++---------- 1 file changed, 39 insertions(+), 39 deletions(-) diff --git a/number-of-connected-components-in-an-undirected-graph/hsskey.js b/number-of-connected-components-in-an-undirected-graph/hsskey.js index b08cd9f20..b9118670d 100644 --- a/number-of-connected-components-in-an-undirected-graph/hsskey.js +++ b/number-of-connected-components-in-an-undirected-graph/hsskey.js @@ -1,44 +1,44 @@ export class Solution { - /** - * @param {number} n - the number of vertices - * @param {number[][]} edges - the edges of undirected graph - * @return {number} - the number of connected components - */ - countComponents(n, edges) { - const par = Array.from({ length: n }, (_, i) => i); - const rank = Array(n).fill(1); - - const find = (n1) => { - let res = n1; - while (res !== par[res]) { - par[res] = par[par[res]]; // path compression - res = par[res]; - } - return res; - }; - - const union = (n1, n2) => { - const p1 = find(n1); - const p2 = find(n2); - if (p1 === p2) return 0; - - if (rank[p2] > rank[p1]) { - par[p1] = p2; - rank[p2] += rank[p1]; - } else { - par[p2] = p1; - rank[p1] += rank[p2]; - } - - return 1; - }; - - let res = n; - for (const [n1, n2] of edges) { - res -= union(n1, n2); + /** + * @param {number} n - the number of vertices + * @param {number[][]} edges - the edges of undirected graph + * @return {number} - the number of connected components + */ + countComponents(n, edges) { + const par = Array.from({ length: n }, (_, i) => i); + const rank = Array(n).fill(1); + + const find = (n1) => { + let res = n1; + while (res !== par[res]) { + par[res] = par[par[res]]; // path compression + res = par[res]; } - return res; + }; + + const union = (n1, n2) => { + const p1 = find(n1); + const p2 = find(n2); + if (p1 === p2) return 0; + + if (rank[p2] > rank[p1]) { + par[p1] = p2; + rank[p2] += rank[p1]; + } else { + par[p2] = p1; + rank[p1] += rank[p2]; + } + + return 1; + }; + + let res = n; + for (const [n1, n2] of edges) { + res -= union(n1, n2); } + + return res; } - \ No newline at end of file +} +