LeetCode problem Flood Fill and Rotting Oranges

Author: laxmanrathod69

15_Flood_Fill_Rotting_Oranges_Graph/floodFillDFS.js

@@ -0,0 +1,37 @@
+// LeetCode: 733. Flood Fill
+const floodFill = (image, sr, sc, color) => {
+  const rows = image.length;
+  const cols = image[0].length;
+  const originalColor = image[sr][sc];
+  if (originalColor === color) {
+    return image;
+  }
+  const dfs = (row, col) => {
+    if (
+      row < 0 ||
+      row >= rows ||
+      col < 0 ||
+      col >= cols ||
+      image[row][col] !== originalColor
+    ) {
+      return;
+    }
+    image[row][col] = color;
+
+    dfs(row + 1, col); // Down
+    dfs(row - 1, col); // Up
+    dfs(row, col + 1); // Right
+    dfs(row, col - 1); // Left
+  };
+  dfs(sr, sc);
+  return image;
+};
+const image = [
+  [1, 1, 1],
+  [1, 1, 0],
+  [1, 0, 1],
+];
+const sr = 1,
+  sc = 1,
+  color = 2;
+console.log(floodFill(image, sr, sc, color)); // Output: [[2, 2, 2], [2, 2, 0], [2, 0, 1]]

15_Flood_Fill_Rotting_Oranges_Graph/rottingOranges.js

@@ -0,0 +1,62 @@
+// LeetCode: 994. Rotting Oranges
+const orangesRotting = (grid) => {
+  const rows = grid.length;
+  const cols = grid[0].length;
+  const directions = [
+    [1, 0], // Down
+    [-1, 0], // Up
+    [0, 1], // Right
+    [0, -1], // Left
+  ];
+
+  let queue = []; // To store the rotten oranges with their timestamps
+  let freshCount = 0;
+
+  // Initialize the queue with all rotten oranges and count fresh oranges
+  for (let r = 0; r < rows; r++) {
+    for (let c = 0; c < cols; c++) {
+      if (grid[r][c] === 2) {
+        queue.push([r, c, 0]); // [row, col, minutes]
+      } else if (grid[r][c] === 1) {
+        freshCount++;
+      }
+    }
+  }
+
+  let minutes = 0;
+
+  // Perform BFS
+  while (queue.length > 0) {
+    const [row, col, time] = queue.shift();
+    minutes = time;
+
+    // Check all 4-directionally adjacent cells
+    for (const [dr, dc] of directions) {
+      const newRow = row + dr;
+      const newCol = col + dc;
+
+      // If the adjacent cell is a fresh orange, rot it
+      if (
+        newRow >= 0 &&
+        newRow < rows &&
+        newCol >= 0 &&
+        newCol < cols &&
+        grid[newRow][newCol] === 1
+      ) {
+        grid[newRow][newCol] = 2; // Mark it as rotten
+        freshCount--; // Decrease fresh orange count
+        queue.push([newRow, newCol, time + 1]); // Add it to the queue with the new timestamp
+      }
+    }
+  }
+
+  // If there are still fresh oranges left, return -1
+  return freshCount === 0 ? minutes : -1;
+};
+
+const grid1 = [
+  [2, 1, 1],
+  [1, 1, 0],
+  [0, 1, 1],
+];
+console.log(orangesRotting(grid1)); // Output: 4