[citrussoda] 24.11.26 (#106)

* 56 / Merge Intervals / Medium / 22m 31s

* 1584 / Min Cost to Connect All Points / Medium / >25m

* 235 / Lowest Common Ancestor of a Binary Search Tree / Medium / 13m 12s

* 139 / Word Break / Medium / 23m 19s

* 215 / Kth Largest Element in an Array / Medium / 2m

Author: CitrusSoda

citrussoda/10week/139_word-break.js

@@ -0,0 +1,23 @@
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+var wordBreak = function (s, wordDict) {
+  const dp = new Array(s.length + 1).fill(false);
+  dp[0] = true;
+
+  for (let i = 1; i <= s.length; i++) {
+    for (let word of wordDict) {
+      if (i >= word.length && dp[i - word.length]) {
+        const sub = s.slice(i - word.length, i);
+        if (sub === word) {
+          dp[i] = true;
+          break;
+        }
+      }
+    }
+  }
+
+  return dp[s.length];
+};

citrussoda/10week/1584_min-cost-to-connect-all-points.js

@@ -0,0 +1,45 @@
+/**
+ * @param {number[][]} points
+ * @return {number}
+ */
+// Prim's Algorithm
+var minCostConnectPoints = function (points) {
+  const n = points.length;
+
+  // 방문 여부를 체크하는 배열
+  const visited = new Set();
+
+  // 각 점까지의 최소 거리를 저장하는 배열
+  const distances = new Array(n).fill(Infinity);
+  distances[0] = 0;
+
+  let totalCost = 0;
+
+  for (let i = 0; i < n; i++) {
+    let minDist = Infinity;
+    let minIndex = -1;
+
+    // 아직 방문하지 않은 점들 중에서 최소 거리를 가진 점을 찾음
+    for (let j = 0; j < n; j++) {
+      if (!visited.has(j) && distances[j] < minDist) {
+        minDist = distances[j];
+        minIndex = j;
+      }
+    }
+
+    visited.add(minIndex);
+    totalCost += minDist;
+
+    // 선택된 점에서 다른 모든 점까지의 거리를 업데이트
+    for (let j = 0; j < n; j++) {
+      if (!visited.has(j)) {
+        const distance =
+          Math.abs(points[minIndex][0] - points[j][0]) +
+          Math.abs(points[minIndex][1] - points[j][1]);
+        distances[j] = Math.min(distances[j], distance);
+      }
+    }
+  }
+
+  return totalCost;
+};

citrussoda/10week/215_kth-largest-element-in-an-array.js

@@ -0,0 +1,10 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findKthLargest = function (nums, k) {
+  nums.sort((a, b) => b - a);
+
+  return nums[k - 1];
+};

citrussoda/10week/235_lowest-common-ancestor-of-a-binary-search-tree.js

@@ -0,0 +1,29 @@
+/**
+ * Definition for a binary tree node.
+ * function TreeNode(val) {
+ *     this.val = val;
+ *     this.left = this.right = null;
+ * }
+ */
+
+/**
+ * @param {TreeNode} root
+ * @param {TreeNode} p
+ * @param {TreeNode} q
+ * @return {TreeNode}
+ */
+var lowestCommonAncestor = function (root, p, q) {
+  if (root.val > p.val && root.val < q.val) {
+    return root;
+  }
+
+  if (root.val > p.val && root.val > q.val) {
+    return lowestCommonAncestor(root.left, p, q);
+  }
+
+  if (root.val < p.val && root.val < q.val) {
+    return lowestCommonAncestor(root.right, p, q);
+  }
+
+  return root;
+};

citrussoda/10week/56_merge-intervals.js

@@ -0,0 +1,24 @@
+/**
+ * @param {number[][]} intervals
+ * @return {number[][]}
+ */
+var merge = function (intervals) {
+  intervals.sort((a, b) => a[0] - b[0]);
+
+  const ans = [];
+  let prev = intervals[0];
+
+  for (let i = 1; i < intervals.length; i++) {
+    let interval = intervals[i];
+
+    if (interval[0] <= prev[1]) {
+      prev[1] = Math.max(prev[1], interval[1]);
+    } else {
+      ans.push(prev);
+      prev = interval;
+    }
+  }
+
+  ans.push(prev);
+  return ans;
+};