Add solution #2503

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,035 LeetCode solutions in JavaScript
+# 1,036 LeetCode solutions in JavaScript
 
 [https://leetcode.com/](https://leetcode.com/)
 
@@ -964,6 +964,7 @@
 2482|[Difference Between Ones and Zeros in Row and Column](./solutions/2482-difference-between-ones-and-zeros-in-row-and-column.js)|Medium|
 2490|[Circular Sentence](./solutions/2490-circular-sentence.js)|Easy|
 2493|[Divide Nodes Into the Maximum Number of Groups](./solutions/2493-divide-nodes-into-the-maximum-number-of-groups.js)|Hard|
+2503|[Maximum Number of Points From Grid Queries](./solutions/2503-maximum-number-of-points-from-grid-queries.js)|Hard|
 2523|[Closest Prime Numbers in Range](./solutions/2523-closest-prime-numbers-in-range.js)|Medium|
 2529|[Maximum Count of Positive Integer and Negative Integer](./solutions/2529-maximum-count-of-positive-integer-and-negative-integer.js)|Easy|
 2535|[Difference Between Element Sum and Digit Sum of an Array](./solutions/2535-difference-between-element-sum-and-digit-sum-of-an-array.js)|Easy|

solutions/2503-maximum-number-of-points-from-grid-queries.js

@@ -0,0 +1,68 @@
+/**
+ * 2503. Maximum Number of Points From Grid Queries
+ * https://leetcode.com/problems/maximum-number-of-points-from-grid-queries/
+ * Difficulty: Hard
+ *
+ * You are given an m x n integer matrix grid and an array queries of size k.
+ *
+ * Find an array answer of size k such that for each integer queries[i] you start in the top left
+ * cell of the matrix and repeat the following process:
+ * - If queries[i] is strictly greater than the value of the current cell that you are in, then
+ *   you get one point if it is your first time visiting this cell, and you can move to any adjacent
+ *   cell in all 4 directions: up, down, left, and right.
+ * - Otherwise, you do not get any points, and you end this process.
+ *
+ * After the process, answer[i] is the maximum number of points you can get. Note that for each
+ * query you are allowed to visit the same cell multiple times.
+ *
+ * Return the resulting array answer.
+ */
+
+/**
+ * @param {number[][]} grid
+ * @param {number[]} queries
+ * @return {number[]}
+ */
+var maxPoints = function(grid, queries) {
+  const rows = grid.length;
+  const cols = grid[0].length;
+  const result = new Array(queries.length);
+  const sortedQueries = queries
+    .map((value, index) => ({ value, index }))
+    .sort((a, b) => a.value - b.value);
+  const directions = [[1, 0], [0, 1], [-1, 0], [0, -1]];
+  const queue = new MinPriorityQueue(([row, col]) => grid[row][col]);
+  const visited = new Set();
+
+  queue.enqueue([0, 0]);
+  visited.add('0,0');
+
+  let queryIndex = 0;
+  let points = 0;
+  while (queue.size()) {
+    const [row, col] = queue.dequeue();
+    const currentValue = grid[row][col];
+    while (queryIndex < sortedQueries.length && currentValue >= sortedQueries[queryIndex].value) {
+      result[sortedQueries[queryIndex].index] = points;
+      queryIndex++;
+    }
+    if (queryIndex === sortedQueries.length) break;
+    points++;
+    for (const [rowOffset, colOffset] of directions) {
+      const nextRow = row + rowOffset;
+      const nextCol = col + colOffset;
+      const positionKey = `${nextRow},${nextCol}`;
+      if (nextRow >= 0 && nextRow < rows && nextCol >= 0 && nextCol < cols
+          && !visited.has(positionKey)) {
+        visited.add(positionKey);
+        queue.enqueue([nextRow, nextCol]);
+      }
+    }
+  }
+  while (queryIndex < sortedQueries.length) {
+    result[sortedQueries[queryIndex].index] = points;
+    queryIndex++;
+  }
+
+  return result;
+};