more leetcode

Author: o D

data-structure-and-algorithm/typescript/leetcode/package.json

@@ -22,5 +22,8 @@
     "gts": "^3.1.1",
     "typescript": "~4.7.0",
     "@types/node": "^14.11.2"
+  },
+  "engines": {
+    "node": ">=18.12.1"
   }
-}
+}

data-structure-and-algorithm/typescript/leetcode/src/booking-concert-tickets-in-groups.ts

@@ -0,0 +1,104 @@
+/*
+2286. Booking Concert Tickets in Groups
+
+A concert hall has n rows numbered from 0 to n - 1, each with m seats, numbered from 0 to m - 1. You need to design a ticketing system that can allocate seats in the following cases:
+
+If a group of k spectators can sit together in a row.
+If every member of a group of k spectators can get a seat. They may or may not sit together.
+Note that the spectators are very picky. Hence:
+
+They will book seats only if each member of their group can get a seat with row number less than or equal to maxRow. maxRow can vary from group to group.
+In case there are multiple rows to choose from, the row with the smallest number is chosen. If there are multiple seats to choose in the same row, the seat with the smallest number is chosen.
+Implement the BookMyShow class:
+
+BookMyShow(int n, int m) Initializes the object with n as number of rows and m as number of seats per row.
+int[] gather(int k, int maxRow) Returns an array of length 2 denoting the row and seat number (respectively) of the first seat being allocated to the k members of the group, who must sit together. In other words, it returns the smallest possible r and c such that all [c, c + k - 1] seats are valid and empty in row r, and r <= maxRow. Returns [] in case it is not possible to allocate seats to the group.
+boolean scatter(int k, int maxRow) Returns true if all k members of the group can be allocated seats in rows 0 to maxRow, who may or may not sit together. If the seats can be allocated, it allocates k seats to the group with the smallest row numbers, and the smallest possible seat numbers in each row. Otherwise, returns false.
+
+
+Example 1:
+
+Input
+["BookMyShow", "gather", "gather", "scatter", "scatter"]
+[[2, 5], [4, 0], [2, 0], [5, 1], [5, 1]]
+Output
+[null, [0, 0], [], true, false]
+
+Explanation
+BookMyShow bms = new BookMyShow(2, 5); // There are 2 rows with 5 seats each
+bms.gather(4, 0); // return [0, 0]
+                  // The group books seats [0, 3] of row 0.
+bms.gather(2, 0); // return []
+                  // There is only 1 seat left in row 0,
+                  // so it is not possible to book 2 consecutive seats.
+bms.scatter(5, 1); // return True
+                   // The group books seat 4 of row 0 and seats [0, 3] of row 1.
+bms.scatter(5, 1); // return False
+                   // There is only one seat left in the hall.
+
+
+Constraints:
+
+1 <= n <= 5 * 104
+1 <= m, k <= 109
+0 <= maxRow <= n - 1
+At most 5 * 104 calls in total will be made to gather and scatter.
+*/
+
+import {BinaryIndexTree} from './data-structure/BinaryIndexTree';
+import {SegmentTree} from './data-structure/SegmentTree';
+
+class BookMyShow {
+  rows: number;
+  seats: number;
+  segTree: SegmentTree;
+  biTree: BinaryIndexTree;
+
+  constructor(rows: number, seats: number) {
+    this.rows = rows;
+    this.seats = seats;
+    this.segTree = new SegmentTree(Array(rows).fill(0));
+    this.biTree = new BinaryIndexTree(Array(rows).fill(seats));
+  }
+
+  gather(cnt: number, maxRow: number): [number, number] | [] {
+    const idx = this.segTree.indexOf(0, this.seats - cnt);
+    if (idx === -1 || idx > maxRow) {
+      return [];
+    }
+    const min = this.segTree.min(idx, idx + 1);
+    this.segTree.update(idx, min + cnt);
+    this.biTree.updateDelta(idx, -cnt);
+    return [idx, min];
+  }
+
+  scatter(cnt: number, maxRow: number): boolean {
+    const total = this.biTree.getSum(maxRow);
+    if (total < cnt) {
+      return false;
+    }
+    while (cnt > 0) {
+      const idx = this.segTree.indexOf(0, this.seats - 1);
+      if (idx === -1 || idx > maxRow) {
+        break;
+      }
+      const min = this.segTree.min(idx, idx + 1);
+      const use = Math.min(cnt, this.seats - min);
+      cnt -= use;
+      this.segTree.update(idx, min + use);
+      this.biTree.updateDelta(idx, -use);
+    }
+    return true;
+  }
+}
+
+const bms = new BookMyShow(2, 5); // There are 2 rows with 5 seats each
+console.log(bms.gather(4, 0)); // return [0, 0]
+// The group books seats [0, 3] of row 0.
+console.log(bms.gather(2, 0)); // return []
+// There is only 1 seat left in row 0,
+// so it is not possible to book 2 consecutive seats.
+console.log(bms.scatter(5, 1)); // return True
+// The group books seat 4 of row 0 and seats [0, 3] of row 1.
+console.log(bms.scatter(5, 1)); // return False
+// There is only one seat left in the hall.

data-structure-and-algorithm/typescript/leetcode/src/consecutive-numbers-sum.ts

@@ -0,0 +1,40 @@
+/*
+829. Consecutive Numbers Sum
+
+Given an integer n, return the number of ways you can write n as the sum of consecutive positive integers.
+
+
+
+Example 1:
+
+Input: n = 5
+Output: 2
+Explanation: 5 = 2 + 3
+Example 2:
+
+Input: n = 9
+Output: 3
+Explanation: 9 = 4 + 5 = 2 + 3 + 4
+Example 3:
+
+Input: n = 15
+Output: 4
+Explanation: 15 = 8 + 7 = 4 + 5 + 6 = 1 + 2 + 3 + 4 + 5
+
+
+Constraints:
+
+1 <= n <= 109
+*/
+
+function consecutiveNumbersSum(target: number): number {
+  let result = 0;
+  let sum = 0;
+  for (let i = 1; sum < target; ++i) {
+    sum += i;
+    if ((target - sum) % i === 0) {
+      ++result;
+    }
+  }
+  return result;
+}

data-structure-and-algorithm/typescript/leetcode/src/data-structure/BinaryIndexTree.ts

@@ -11,19 +11,23 @@ export class BinaryIndexTree {
 
   update(i: number, data: number): void {
     const diff = data - this.numList[i + 1];
+    this.updateDelta(i, diff);
+  }
+
+  updateDelta(i: number, delta: number): void {
     for (let j = i + 1; j < this.bitList.length; j += this.leastBit(j)) {
-      this.bitList[j] += diff;
+      this.bitList[j] += delta;
     }
-    this.numList[i + 1] = data;
+    this.numList[i + 1] = delta + this.numList[i + 1];
   }
 
   sumRange(i: number, j: number): number {
-    return this.getSum(j + 1) - this.getSum(i);
+    return this.getSum(j) - this.getSum(i - 1);
   }
 
   getSum(i: number): number {
     let result = 0;
-    for (let j = i; j > 0; j -= this.leastBit(j)) {
+    for (let j = i + 1; j > 0; j -= this.leastBit(j)) {
       result += this.bitList[j];
     }
     return result;

data-structure-and-algorithm/typescript/leetcode/src/data-structure/SegmentTree.ts

@@ -0,0 +1,116 @@
+export class SegmentTree {
+  minList: number[];
+  maxList: number[];
+  size: number;
+  height: number;
+  constructor(numList: number[]) {
+    const {length} = numList;
+    this.height = 2 ** Math.ceil(Math.log2(length));
+    this.size = 2 * this.height;
+    this.minList = Array(this.size).fill(Infinity);
+    this.maxList = Array(this.size).fill(-Infinity);
+    for (let i = 0; i < length; i++) {
+      this.minList[this.height + i] = numList[i];
+      this.maxList[this.height + i] = numList[i];
+    }
+    for (let i = this.height - 1; i >= 1; --i) {
+      this.propagate(i);
+    }
+  }
+
+  update(idx: number, value: number): void {
+    this.minList[this.height + idx] = value;
+    this.maxList[this.height + idx] = value;
+    for (let i = this.parent(this.height + idx); i >= 1; i = this.parent(i)) {
+      this.propagate(i);
+    }
+  }
+
+  propagate(i: number): void {
+    this.minList[i] = Math.min(
+      this.minList[this.left(i)],
+      this.minList[this.right(i)]
+    );
+    this.maxList[i] = Math.max(
+      this.maxList[this.left(i)],
+      this.maxList[this.right(i)]
+    );
+  }
+
+  min(i: number, j: number): number {
+    let min = Infinity;
+    for (
+      let [x, y] = [i + this.height, j + this.height];
+      x < y;
+      x = this.parent(x), y = this.parent(y)
+    ) {
+      if (x & 1) {
+        min = Math.min(min, this.minList[x++]);
+      }
+      if (y & 1) {
+        min = Math.min(min, this.minList[--y]);
+      }
+    }
+    return min;
+  }
+
+  max(i: number, j: number): number {
+    let max = -Infinity;
+    for (
+      let [x, y] = [i + this.height, j + this.height];
+      x < y;
+      x = this.parent(x), y = this.parent(y)
+    ) {
+      if (x & 1) {
+        max = Math.max(max, this.maxList[x++]);
+      }
+      if (y & 1) {
+        max = Math.max(max, this.maxList[--y]);
+      }
+    }
+    return max;
+  }
+
+  indexOf(i: number, value: number): number {
+    if (i >= this.height) {
+      return -1;
+    }
+
+    for (let node = this.height + i; ; ) {
+      if (this.minList[node] <= value) {
+        if (node >= this.height) {
+          return node - this.height;
+        }
+        node = this.left(node);
+      } else {
+        ++node;
+        if ((node & (node - 1)) === 0) {
+          return -1;
+        }
+        if (node % 2 === 0) {
+          node = this.parent(node);
+        }
+      }
+    }
+  }
+
+  parent(i: number): number {
+    return i >> 1;
+  }
+
+  left(i: number): number {
+    return 2 * i;
+  }
+
+  right(i: number): number {
+    return 2 * i + 1;
+  }
+
+  minTree(): number[] {
+    return this.minList;
+  }
+
+  maxTree(): number[] {
+    return this.maxList;
+  }
+}

data-structure-and-algorithm/typescript/leetcode/src/evaluate-division.ts

@@ -0,0 +1,94 @@
+/*
+ 399. Evaluate Division
+
+You are given an array of variable pairs equations and an array of real numbers values, where equations[i] = [Ai, Bi] and values[i] represent the equation Ai / Bi = values[i]. Each Ai or Bi is a string that represents a single variable.
+
+You are also given some queries, where queries[j] = [Cj, Dj] represents the jth query where you must find the answer for Cj / Dj = ?.
+
+Return the answers to all queries. If a single answer cannot be determined, return -1.0.
+
+Note: The input is always valid. You may assume that evaluating the queries will not result in division by zero and that there is no contradiction.
+
+
+
+Example 1:
+
+Input: equations = [["a","b"],["b","c"]], values = [2.0,3.0], queries = [["a","c"],["b","a"],["a","e"],["a","a"],["x","x"]]
+Output: [6.00000,0.50000,-1.00000,1.00000,-1.00000]
+Explanation:
+Given: a / b = 2.0, b / c = 3.0
+queries are: a / c = ?, b / a = ?, a / e = ?, a / a = ?, x / x = ?
+return: [6.0, 0.5, -1.0, 1.0, -1.0 ]
+Example 2:
+
+Input: equations = [["a","b"],["b","c"],["bc","cd"]], values = [1.5,2.5,5.0], queries = [["a","c"],["c","b"],["bc","cd"],["cd","bc"]]
+Output: [3.75000,0.40000,5.00000,0.20000]
+Example 3:
+
+Input: equations = [["a","b"]], values = [0.5], queries = [["a","b"],["b","a"],["a","c"],["x","y"]]
+Output: [0.50000,2.00000,-1.00000,-1.00000]
+
+
+Constraints:
+
+1 <= equations.length <= 20
+equations[i].length == 2
+1 <= Ai.length, Bi.length <= 5
+values.length == equations.length
+0.0 < values[i] <= 20.0
+1 <= queries.length <= 20
+queries[i].length == 2
+1 <= Cj.length, Dj.length <= 5
+Ai, Bi, Cj, Dj consist of lower case English letters and digits.
+ */
+
+import {Queue} from './data-structure/Queue';
+
+function calcEquation(
+  equations: string[][],
+  values: number[],
+  queries: string[][]
+): number[] {
+  const map = new Map<string, [string, number][]>();
+  for (let i = 0; i < equations.length; i++) {
+    const [src, dst] = equations[i];
+    if (!map.has(src)) {
+      map.set(src, []);
+    }
+    if (!map.has(dst)) {
+      map.set(dst, []);
+    }
+    map.get(src)!.push([dst, values[i]]);
+    map.get(dst)!.push([src, 1 / values[i]]);
+  }
+
+  const resultList: number[] = [];
+
+  for (const [src, dst] of queries) {
+    const queue = new Queue<[string, number]>();
+    const visited = new Set<string>();
+    let result = -1;
+    queue.push([src, 1]);
+    visited.add(src);
+    if (map.has(dst)) {
+      while (!queue.isEmpty()) {
+        const [node, value] = queue.pop();
+        if (node === dst) {
+          result = value;
+          break;
+        }
+        if (!map.has(node)) {
+          break;
+        }
+        for (const [nextNode, nextValue] of map.get(node)!) {
+          if (!visited.has(nextNode)) {
+            visited.add(nextNode);
+            queue.push([nextNode, value * nextValue]);
+          }
+        }
+      }
+    }
+    resultList.push(result);
+  }
+  return resultList;
+}