SOLN: LRU cache and others (#193)

Author: retiman

src/array/group-anagrams.ts

@@ -15,8 +15,8 @@ export { groupAnagrams };
 //
 // COMPLEXITY:
 //
-// Runs in O(n * m * log(m)) time, where n is the number of strings and m is the length of the longest string.  This
-// is because we have to sort each string's characters in O(m * log(m)), and there are n strings.
+// Runs in O(n * m * log m) time, where n is the number of strings and m is the length of the longest string.  This
+// is because we have to sort each string's characters in O(m * log m), and there are n strings.
 function groupAnagrams(texts: string[]): string[][] {
   type Canonical = string;
   type Anagram = string;

src/array/merge-sorted-array.ts

@@ -14,6 +14,8 @@ export { merge };
 
 // SOLUTION:
 //
+// TLDR: Work backwards.  Send the largest elements from the smaller array to the end of the bigger array.
+//
 // This would be VERY easy, if you could use extra memory.  To merge without using extra memory, we do need to merge
 // into the bigger array, nums1.
 //

src/array/top-k-frequent-elements.ts

@@ -25,13 +25,12 @@ function topKFrequent(xs: number[], k: number) {
     map.set(x, frequency + 1);
   }
 
-  // Sort the map keys by their frequency.
-  //
-  // Note that map.get(a)! - map.get(b)! would sort by increasing frequency; we want decreasing frequency because we
-  // want the top k elements.
-  const keys = Array.from(map.keys());
-  const sorted = keys.sort((a, b) => map.get(b)! - map.get(a)!);
+  // Now get all unique elements from the list.
+  const uniques = [...map.keys()];
+
+  // Sort the unique values by their frequency.  Since we want the most frequent elements, we sort in decreasing order.
+  uniques.sort((a, b) => map.get(b)! - map.get(a)!);
 
   // Return the first k elements.
-  return sorted.slice(0, k);
+  return uniques.slice(0, k);
 }

src/binary-search/k-th-smallest-element-in-a-sorted-matrix.ts

@@ -0,0 +1,99 @@
+// DIFFICULTY: MEDIUM
+//
+// Given an n x n matrix where each of the rows and columns is sorted in ascending order, return the kth smallest
+// element in the matrix.
+//
+// Note that it is the kth smallest element in the sorted order, not the kth distinct element.
+//
+// You must find a solution with a memory complexity better than O(n^2).
+//
+// See {@link https://leetcode.com/problems/kth-smallest-element-in-a-sorted-matrix/}
+export { kthSmallest };
+
+// SOLUTION:
+//
+// We can't flatten the list because that would take O(n^2) memory.
+//
+// Use binary search to narrow down where the kth smallest element is.  Here, the left value is the smallest element,
+// and the right value is the largest element.
+//
+// We can use the mid element to tell us how close or far we are from the kth smallest element.  The matrix is sorted,
+// so for any mid === matrix[i][j] we can figure out how many elements are less than or equal to mid.
+//
+// COMPLEXITY:
+//
+// We are using binary search on a range between the smallest and largest elements in the matrix, call it k.  We will
+// do O(log k) iterations, but in each iteration, we do have to count how many elements are less than or equal to the
+// mid target.
+//
+// The countLessThanOrEqualTo() function takes at most n steps (where n is the number of rows/columns in the matrix).
+// Since this is done at every single iteration, the total time is O(n log k).
+//
+// Space complexity is O(1).
+function kthSmallest(matrix: number[][], k: number): number {
+  // Use insertion sort binary search to find exactly where the kth smallest element is; don't use the standard binary
+  // search algorithm because we're not looking for an exact value.
+  let left = matrix[0][0];
+  let right = matrix[matrix.length - 1][matrix.length - 1];
+  while (left < right) {
+    const mid = Math.floor((left + right) / 2);
+    const count = countLessThanOrEqualTo(matrix, mid);
+
+    if (count < k) {
+      left = mid + 1;
+    } else {
+      right = mid;
+    }
+  }
+
+  return left;
+}
+
+function countLessThanOrEqualTo(matrix: number[][], target: number) {
+  // We can leverage the properties of the matrix to count how many elements are less than or equal to the target.
+  // Use a modified two pointer technique to count up elements.
+  let count = 0;
+
+  // Start at the bottom left corner of the matrix:
+  //
+  // - - - -
+  // - - - -
+  // - - - -
+  // x - - -
+  //
+  // If the value is less than or equal to the target, then all elements from all previous rows are also less than our
+  // target (since the matrix is sorted).  To count up that specific column, add (row + 1) to the count (the rows are
+  // 0 indexed, but the count is not, so we add 1).
+  let row = matrix.length - 1;
+  let column = 0;
+  while (row >= 0 && column < matrix.length) {
+    // Add up all the elements in the column.  That is:
+    //
+    // x - - -
+    // x - - -
+    // x - - -
+    // x - - -
+    //
+    // All x's get added to the count, which means all elements in the column get added to the count.  Because the
+    // matrix is sorted, all elements in the above column MUST be less than or equal to the target.
+    //
+    // Stop when we reach column === matrix.length - 1.
+    if (matrix[row][column] <= target) {
+      count += row + 1;
+      column++;
+    }
+    // If the element is greater than the target, we can move up a row and try again:
+    //
+    // x - - -
+    // x - - -
+    // x - - -
+    // - - - -
+    //
+    // Stop when we reach row === 0.
+    else {
+      row--;
+    }
+  }
+
+  return count;
+}

src/linked-list/lru-cache.ts

@@ -22,17 +22,20 @@ export { LRUCache };
 // This class definition is provided by LeetCode and must be implemented by you.  An LRU cache can be implemented
 // using a hashmap and a linked list.
 class LRUCache {
-  private head?: Node;
-
-  private last?: Node;
-
   private map: Map<number, Node>;
-
   private capacity: number;
+  private head: Node;
+  private tail: Node;
 
   constructor(capacity: number) {
     this.map = new Map();
     this.capacity = capacity;
+
+    // These are sentinel nodes that will never be directly accessed, but help us avoid certain undefined checks.
+    this.head = new Node(-1, -1);
+    this.tail = new Node(-1, -1);
+    this.head.next = this.tail;
+    this.tail.previous = this.head;
   }
 
   get(key: number): number {
@@ -44,105 +47,61 @@ class LRUCache {
     // storing the key on the node, we can just delete the last element from the list and then check for an undefined
     // value here in case we deleted the key from being at capacity.
     const node = this.map.get(key)!;
-
-    // If the node is already at the front of the list, just remove it and return the value.
-    if (node.key === this.head?.key) {
-      return node.value;
-    }
-
-    // Detach the node from its position in the list, and connect the previous and next nodes to each other instead.
-    this.unlink(node);
-
-    // Move the node to the front of the list.
-    this.unshift(node);
-
+    this.moveToHead(node);
     return node.value;
   }
 
   put(key: number, value: number): void {
     // If we already have this value in the map, just update it and don't bother mucking with the capacity.
     if (this.map.has(key)) {
       const node = this.map.get(key)!;
+      this.moveToHead(node);
       node.value = value;
-
-      // Call get to update timestamp on the node, but throw away the result.
-      const _ = this.get(key);
       return;
     }
 
-    // If there's no capacity, we don't have to do anything.
-    if (this.capacity <= 0) {
-      return;
-    }
-
-    // If we are at capacity, we will first have to evict an entry from the cache by finding the last accessed element
-    // from our list.
-    if (this.map.size === this.capacity) {
-      this.pop();
-    }
-
     const node = new Node(key, value);
     this.map.set(key, node);
-
-    // I am assuming that a put will also update the last accessed timestamp of the node, so move it to the front of
-    // the list.
-    this.unshift(node);
-  }
-
-  // Remove a node that is NOT the head node.
-  private unlink(node: Node) {
-    // If this was the last node, update the last pointer.
-    if (node.key === this.last?.key) {
-      this.last = node.previous!;
-      this.last.next = undefined;
-      return;
-    }
-
-    // Otherwise, this is not the last node and not the head node, so stitch the previous and next nodes together.
-    const left = node.previous!;
-    const right = node.next;
-    left.next = right;
-    if (right !== undefined) {
-      right.previous = left;
+    this.addToHead(node);
+
+    // If we've exceed capacity, we have to remove the least used element, aka the tail.  At this point, there is
+    // guaranteed to be at least one other element in the list because we just added one.  Also, unless the capacity
+    // is 0, we will always at least have another.
+    //
+    // So we can safely access this.tail.previous!
+    if (this.map.size > this.capacity) {
+      const tail = this.tail.previous!;
+      this.removeNode(tail);
+      this.map.delete(tail.key);
     }
   }
 
-  // Unshift a node that is NOT the head node.
-  private unshift(node: Node) {
-    node.previous = undefined;
+  private addToHead(node: Node): void {
+    const a = this.head;
+    const b = node;
+    const c = this.head.next;
 
-    if (this.head === undefined) {
-      this.head = node;
-    } else {
-      this.head.previous = node;
-      node.next = this.head;
-      this.head = node;
-    }
+    // Updates the pointers for the node itself.
+    b.next = c;
+    b.previous = a;
 
-    if (this.last === undefined) {
-      this.last = node;
-    }
+    // Inserts the node at the front of the list.
+    a.next = b;
+    c!.previous = b;
   }
 
-  // Unlink the last node (also possibly the head node) and remove it from the map.
-  private pop() {
-    const node = this.last;
-
-    if (node === undefined) {
-      return;
-    }
-
-    this.map.delete(node.key);
+  private moveToHead(node: Node): void {
+    this.removeNode(node);
+    this.addToHead(node);
+  }
 
-    // If this was the head node, just set both nodes to undefined and be done with it.
-    if (node.key === this.head?.key) {
-      this.head = undefined;
-      this.last = undefined;
-      return;
-    }
+  private removeNode(node: Node): void {
+    const b = node;
+    const a = b.previous!;
+    const c = b.next!;
 
-    // Otherwise, unlink the last node.
-    this.unlink(node);
+    a.next = c;
+    c.previous = a;
   }
 }