Add solution #3342

Author: JoshCrozier

README.md

@@ -1,4 +1,4 @@
-# 1,705 LeetCode solutions in JavaScript
+# 1,706 LeetCode solutions in JavaScript
 
 [https://leetcodejavascript.com](https://leetcodejavascript.com)
 
@@ -1699,6 +1699,7 @@
 3223|[Minimum Length of String After Operations](./solutions/3223-minimum-length-of-string-after-operations.js)|Medium|
 3272|[Find the Count of Good Integers](./solutions/3272-find-the-count-of-good-integers.js)|Hard|
 3306|[Count of Substrings Containing Every Vowel and K Consonants II](./solutions/3306-count-of-substrings-containing-every-vowel-and-k-consonants-ii.js)|Medium|
+3342|[Find Minimum Time to Reach Last Room II](./solutions/3342-find-minimum-time-to-reach-last-room-ii.js)|Medium|
 3356|[Zero Array Transformation II](./solutions/3356-zero-array-transformation-ii.js)|Medium|
 3375|[Minimum Operations to Make Array Values Equal to K](./solutions/3375-minimum-operations-to-make-array-values-equal-to-k.js)|Easy|
 3392|[Count Subarrays of Length Three With a Condition](./solutions/3392-count-subarrays-of-length-three-with-a-condition.js)|Easy|

solutions/3342-find-minimum-time-to-reach-last-room-ii.js

@@ -0,0 +1,57 @@
+/**
+ * 3342. Find Minimum Time to Reach Last Room II
+ * https://leetcode.com/problems/find-minimum-time-to-reach-last-room-ii/
+ * Difficulty: Medium
+ *
+ * There is a dungeon with n x m rooms arranged as a grid.
+ *
+ * You are given a 2D array moveTime of size n x m, where moveTime[i][j] represents the minimum
+ * time in seconds when you can start moving to that room. You start from the room (0, 0) at
+ * time t = 0 and can move to an adjacent room. Moving between adjacent rooms takes one
+ * second for one move and two seconds for the next, alternating between the two.
+ *
+ * Return the minimum time to reach the room (n - 1, m - 1).
+ *
+ * Two rooms are adjacent if they share a common wall, either horizontally or vertically.
+ */
+
+/**
+ * @param {number[][]} moveTime
+ * @return {number}
+ */
+var minTimeToReach = function(moveTime) {
+  const rows = moveTime.length;
+  const cols = moveTime[0].length;
+  const distances = Array.from({ length: rows }, () => new Array(cols).fill(Infinity));
+  const pq = new PriorityQueue((a, b) => a[0] - b[0]);
+  pq.enqueue([0, 0, 0, 0]);
+  const directions = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+
+  distances[0][0] = 0;
+
+  while (!pq.isEmpty()) {
+    const [time, row, col, moveCount] = pq.dequeue();
+
+    if (row === rows - 1 && col === cols - 1) return time;
+
+    if (time > distances[row][col]) continue;
+
+    for (const [dr, dc] of directions) {
+      const newRow = row + dr;
+      const newCol = col + dc;
+
+      if (newRow < 0 || newRow >= rows || newCol < 0 || newCol >= cols) continue;
+
+      const moveCost = moveCount % 2 === 0 ? 1 : 2;
+      const startTime = Math.max(time, moveTime[newRow][newCol]);
+      const newTime = startTime + moveCost;
+
+      if (newTime < distances[newRow][newCol]) {
+        distances[newRow][newCol] = newTime;
+        pq.enqueue([newTime, newRow, newCol, moveCount + 1]);
+      }
+    }
+  }
+
+  return distances[rows - 1][cols - 1];
+};