chore: add LeetCode daily solution

Author: TechnoBlogger14o3

Medium/2025-11-02-2257-Count-Unguarded-Cells-in-the-Grid/explanation.md

@@ -0,0 +1,37 @@
+# Count Unguarded Cells in the Grid (Medium)
+
+**Problem ID:** 2257  
+**Date:** 2025-11-02  
+**Link:** https://leetcode.com/problems/count-unguarded-cells-in-the-grid/
+
+## Approach
+
+To solve the problem of counting unguarded cells in a grid, we can adopt the following approach:
+
+### Main Idea:
+The primary goal is to determine which cells in the grid are guarded by at least one guard and then count the remaining unguarded cells. A guard can see in four cardinal directions (up, down, left, right) until blocked by a wall or another guard. 
+
+### Approach:
+1. **Grid Representation**: 
+   - We will use a 2D grid to represent the cells, but given the constraints, we can optimize by using a set to track the positions of guards and walls.
+
+2. **Marking Guarded Cells**:
+   - For each guard, we will check in all four directions (up, down, left, right) to mark the cells that can be seen by the guard:
+     - Start from the guard's position and move in the direction until we hit a wall or another guard.
+     - For each cell that is not a wall or guard, mark it as guarded (using a set to avoid duplicates).
+
+3. **Counting Unguarded Cells**:
+   - After marking all guarded cells, we can calculate the total number of unguarded cells by:
+     - Starting with the total number of cells in the grid (`m * n`).
+     - Subtracting the number of cells that are either guarded or occupied by guards or walls.
+
+### Data Structures:
+- **Set**: To keep track of the positions of guarded cells. This allows O(1) average time complexity for insertions and checks.
+- **List or Array**: To store the positions of guards and walls for easy iteration.
+
+### Complexity:
+- **Time Complexity**: O(m * n) in the worst case, as we may need to check each cell in the grid. However, since the total number of guards and walls is limited to `5 * 10^4`, the actual operations performed will be significantly less than this in practice.
+- **Space Complexity**: O(m * n) in the worst case for the set storing guarded cells, but it will be limited by the number of guards and walls in practical scenarios.
+
+### Summary:
+By efficiently marking the cells that are guarded based on the positions of guards and walls, we can quickly compute the number of unguarded cells in the grid. This approach leverages sets for efficient membership checking and ensures we respect the constraints of the problem.

Medium/2025-11-02-2257-Count-Unguarded-Cells-in-the-Grid/solution.java

@@ -0,0 +1,40 @@
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public int countUnguarded(int m, int n, int[][] guards, int[][] walls) {
+        Set<String> guarded = new HashSet<>();
+        Set<String> wallsSet = new HashSet<>();
+
+        for (int[] wall : walls) {
+            wallsSet.add(wall[0] + "," + wall[1]);
+        }
+
+        for (int[] guard : guards) {
+            int r = guard[0], c = guard[1];
+            guarded.add(r + "," + c);
+            // Check north
+            for (int i = r - 1; i >= 0 && !wallsSet.contains((i) + "," + c); i--) {
+                guarded.add(i + "," + c);
+            }
+            // Check south
+            for (int i = r + 1; i < m && !wallsSet.contains((i) + "," + c); i++) {
+                guarded.add(i + "," + c);
+            }
+            // Check west
+            for (int i = c - 1; i >= 0 && !wallsSet.contains(r + "," + (i)); i--) {
+                guarded.add(r + "," + i);
+            }
+            // Check east
+            for (int i = c + 1; i < n && !wallsSet.contains(r + "," + (i)); i++) {
+                guarded.add(r + "," + i);
+            }
+        }
+
+        int totalCells = m * n;
+        int guardedCells = guarded.size();
+        int occupiedCells = walls.length + guards.length;
+
+        return totalCells - guardedCells - occupiedCells;
+    }
+}

Medium/2025-11-02-2257-Count-Unguarded-Cells-in-the-Grid/solution.js

@@ -0,0 +1,36 @@
+var countUnguarded = function(m, n, guards, walls) {
+    const grid = Array.from({ length: m }, () => Array(n).fill(0));
+    
+    for (const [r, c] of guards) {
+        grid[r][c] = 1; // Mark guards
+    }
+    
+    for (const [r, c] of walls) {
+        grid[r][c] = 2; // Mark walls
+    }
+    
+    const directions = [[0, 1], [1, 0], [0, -1], [-1, 0]];
+    
+    for (const [r, c] of guards) {
+        for (const [dr, dc] of directions) {
+            let nr = r + dr;
+            let nc = c + dc;
+            while (nr >= 0 && nr < m && nc >= 0 && nc < n && grid[nr][nc] === 0) {
+                grid[nr][nc] = 3; // Mark guarded cells
+                nr += dr;
+                nc += dc;
+            }
+        }
+    }
+    
+    let unguardedCount = 0;
+    for (let i = 0; i < m; i++) {
+        for (let j = 0; j < n; j++) {
+            if (grid[i][j] === 0) {
+                unguardedCount++;
+            }
+        }
+    }
+    
+    return unguardedCount;
+};

Medium/2025-11-02-2257-Count-Unguarded-Cells-in-the-Grid/solution.py

@@ -0,0 +1,23 @@
+class Solution:
+    def countUnguarded(self, m: int, n: int, guards: List[List[int]], walls: List[List[int]]) -> int:
+        grid = [[0] * n for _ in range(m)]
+        
+        for r, c in guards:
+            grid[r][c] = 1  # Mark guard positions
+        for r, c in walls:
+            grid[r][c] = 2  # Mark wall positions
+        
+        directions = [(0, 1), (1, 0), (0, -1), (-1, 0)]
+        
+        for r in range(m):
+            for c in range(n):
+                if grid[r][c] == 1:  # If there's a guard
+                    for dr, dc in directions:
+                        nr, nc = r, c
+                        while 0 <= nr < m and 0 <= nc < n and grid[nr][nc] == 0:
+                            grid[nr][nc] = 3  # Mark as guarded
+                            nr += dr
+                            nc += dc
+        
+        unguarded_count = sum(row.count(0) for row in grid)
+        return unguarded_count

README.md

@@ -266,3 +266,4 @@ Through completing the Blind 75 and NeetCode 150, you will have mastered:
 - 2025-10-30 — [Minimum Number of Increments on Subarrays to Form a Target Array](https://leetcode.com/problems/minimum-number-of-increments-on-subarrays-to-form-a-target-array/) (Hard) → `Hard/2025-10-30-1526-Minimum-Number-of-Increments-on-Subarrays-to-Form-a-Target-Array`
 - 2025-10-31 — [The Two Sneaky Numbers of Digitville](https://leetcode.com/problems/the-two-sneaky-numbers-of-digitville/) (Easy) → `Easy/2025-10-31-3289-The-Two-Sneaky-Numbers-of-Digitville`
 - 2025-11-01 — [Delete Nodes From Linked List Present in Array](https://leetcode.com/problems/delete-nodes-from-linked-list-present-in-array/) (Medium) → `Medium/2025-11-01-3217-Delete-Nodes-From-Linked-List-Present-in-Array`
+- 2025-11-02 — [Count Unguarded Cells in the Grid](https://leetcode.com/problems/count-unguarded-cells-in-the-grid/) (Medium) → `Medium/2025-11-02-2257-Count-Unguarded-Cells-in-the-Grid`