[Berrnuda] 24.11.26 (#105)

* 150 / Evaluate Reverse Polish Notation / Meium / 12m 01s

* 56 / Merge Intervals / Medium / 12m 58s

* 235 / Lowest Common Ancestor of a Binary Search Tree / Medium / 14m 45s

* 139 / Word Break / Medium / 18m 22s

* 215 / Kth Largest Element in an Array / Medium / 20m 19s

Author: Berrnuda

berrnuda/10week/139_Word_Break.js

@@ -0,0 +1,26 @@
+/**
+ * @param {string} s
+ * @param {string[]} wordDict
+ * @return {boolean}
+ */
+var wordBreak = function (s, wordDict) {
+  const wordSet = new Set(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 wordSet) {
+      if (
+        i >= word.length &&
+        dp[i - word.length] &&
+        s.slice(i - word.length, i) === word
+      ) {
+        dp[i] = true;
+        break;
+      }
+    }
+  }
+
+  return dp[s.length];
+};

berrnuda/10week/215_Kth_Largest_Element_in_an_Array.js

@@ -0,0 +1,15 @@
+/**
+ * @param {number[]} nums
+ * @param {number} k
+ * @return {number}
+ */
+var findKthLargest = function (nums, k) {
+  const minPriQue = new MinPriorityQueue();
+  for (let i = 0; i < nums.length; i++) {
+    minPriQue.enqueue(nums[i]);
+    if (minPriQue.size() > k) {
+      minPriQue.dequeue();
+    }
+  }
+  return minPriQue.front().element;
+};

berrnuda/10week/235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree.js

@@ -0,0 +1,26 @@
+/**
+ * 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) {
+  while (root) {
+    if (p.val < root.val && q.val < root.val) {
+      root = root.left;
+    } else if (p.val > root.val && q.val > root.val) {
+      root = root.right;
+    } else {
+      return root;
+    }
+  }
+  return null;
+};

berrnuda/10week/56_Merge_Intervals.js

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