Add week 12 solutions: longestIncreasingSubsequence, uniquePaths

Author: yolophg

longest-increasing-subsequence/yolophg.js

@@ -0,0 +1,38 @@
+// Time Complexity: O(n log n)
+// Space Complexity: O(n)
+
+var lengthOfLIS = function (nums) {
+  // array to store the smallest tail of all increasing subsequences of various lengths
+  let subsequence = [];
+
+  for (let num of nums) {
+    // iterate through each number in the input array
+    let left = 0,
+      right = subsequence.length;
+
+    // use binary search to find the position of the current number in the subsequence array
+    while (left < right) {
+      // calculate the middle index
+      let mid = Math.floor((left + right) / 2);
+      if (subsequence[mid] < num) {
+        // move the left boundary to the right
+        left = mid + 1;
+      } else {
+        // move the right boundary to the left
+        right = mid;
+      }
+    }
+
+    // if left is equal to the length of subsequence, it means num is greater than any element in subsequence
+    if (left === subsequence.length) {
+      // append num to the end of the subsequence array
+      subsequence.push(num);
+    } else {
+      // replace the element at the found position with num
+      subsequence[left] = num;
+    }
+  }
+
+  // the length of the subsequence array is the length of the longest increasing subsequence
+  return subsequence.length;
+};

unique-paths/yolophg.js

@@ -0,0 +1,18 @@
+// Time Complexity: O(m * n) m : the number of rows, n : the number of columns
+// Space Complexity: O(m * n)
+
+var uniquePaths = function (m, n) {
+  // dp[i][j] will store the number of unique paths to reach the cell (i, j)
+  let dp = Array.from({ length: m }, () => Array(n).fill(1));
+
+  // iterate through the grid starting from (1, 1)
+  for (let i = 1; i < m; i++) {
+    for (let j = 1; j < n; j++) {
+      // to reach (i-1, j) and (i, j-1) because the robot can only move down or right
+      dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+    }
+  }
+
+  // the value at the bottom-right corner of the grid is the number of unique paths
+  return dp[m - 1][n - 1];
+};