Add questions

Author: Sanajit Jana

Hard/0042-trapping-rain-water.java

@@ -0,0 +1,125 @@
+# [Valid Sudoku](https://leetcode.com/problems/valid-sudoku/)
+
+## Question Description
+Determine if a 9 x 9 Sudoku board is valid. Only the filled cells need to be validated according to these rules:
+1. Each row must contain the digits 1-9 without repetition.
+2. Each column must contain the digits 1-9 without repetition.
+3. Each of the nine 3 x 3 sub-boxes must contain the digits 1-9 without repetition.
+
+Note: A Sudoku board (partially filled) could be valid but is not necessarily solvable.
+
+---
+
+## Constraints
+- `board.length == 9`
+- `board[i].length == 9`
+- `board[i][j]` is a digit `'1'-'9'` or `'.'`
+- The board may be partially filled
+
+---
+
+## Approach
+Use HashSet to track digits in each row, column, and 3x3 sub-box.
+
+**Why this approach works:**
+- HashSet provides O(1) average time complexity for lookup and insertion operations
+- We need to ensure no duplicate digits appear in rows, columns, or 3x3 boxes
+- By using separate HashSets for each validation, we can efficiently track seen digits
+
+**Alternative approaches considered:**
+- Could use arrays instead of HashSets for digit tracking, but HashSets are more readable and handle the logic more elegantly
+- Could use bitwise operations for memory optimization, but HashSet approach is clearer and sufficient for this problem
+
+---
+
+## Dry Run
+Example Input:
+```
+board = [
+  ["5","3",".",".","7",".",".",".","."],
+  ["6",".",".","1","9","5",".",".","."],
+  [".","9","8",".",".",".",".","6","."],
+  ["8",".",".",".","6",".",".",".","3"],
+  ["4",".",".","8",".","3",".",".","1"],
+  ["7",".",".",".","2",".",".",".","6"],
+  [".","6",".",".",".",".","2","8","."],
+  [".",".",".","4","1","9",".",".","5"],
+  [".",".",".",".","8",".",".","7","9"]
+]
+```
+
+Step-by-step execution:
+- Step 1: Validate all rows - check each row has unique digits (skip '.')
+- Step 2: Validate all columns - check each column has unique digits (skip '.')
+- Step 3: Validate all 3x3 sub-boxes - check each 3x3 block has unique digits (skip '.')
+
+Final Answer = `true` (this is a valid Sudoku board)
+
+---
+
+## Solution
+```java
+import java.util.HashSet;
+import java.util.Set;
+
+class Solution {
+    public boolean isValidSudoku(char[][] board) {
+
+        int m = board.length;
+        int n = board[0].length;
+
+        // Check rows
+        for (int i = 0; i < m; i++) {
+            Set<Character> set = new HashSet<>();
+            for (int j = 0; j < n; j++) {
+                char ch = board[i][j];
+                if (ch != '.') {
+                    if (set.contains(ch))
+                        return false;
+                    else
+                        set.add(ch);
+                }
+            }
+        }
+
+        // Check cols
+        for (int i = 0; i < m; i++) {
+            Set<Character> set = new HashSet<>();
+            for (int k = 0; k < m; k++) {
+                char ch = board[k][i];
+                if (ch != '.') {
+                    if (set.contains(ch))
+                        return false;
+                    else
+                        set.add(ch);
+                }
+            }
+        }
+
+        // Check 3x3 sub-boxes
+        for (int blockRow = 0; blockRow < 3; blockRow++) {
+            for (int blockCol = 0; blockCol < 3; blockCol++) {
+                Set<Character> set = new HashSet<>();
+                for (int i = 0; i < 3; i++) {
+                    for (int j = 0; j < 3; j++) {
+                        char ch = board[blockRow * 3 + i][blockCol * 3 + j];
+                        if (ch != '.') {
+                            if (set.contains(ch))
+                                return false;
+                            set.add(ch);
+                        }
+                    }
+                }
+            }
+        }
+
+        return true;
+    }
+}
+```
+
+---
+
+## Time and Space Complexity
+- **Time Complexity:** O(1) - We scan each cell at most 3 times (row, column, box validation), board size is fixed at 9x9
+- **Space Complexity:** O(1) - Extra space comes from HashSets used in validation, but board size is fixed so memory usage is constant

Medium/0036-valid-sudoku.java

@@ -0,0 +1,103 @@
+# [Set Matrix Zeroes](https://leetcode.com/problems/set-matrix-zeroes/)
+
+## Question Description
+Given an m x n integer matrix matrix, if an element is 0, set its entire row and column to 0's.
+
+You must do it in place.
+
+---
+
+## Constraints
+- `m == matrix.length`
+- `n == matrix[0].length`
+- `1 <= m, n <= 200`
+- `-2^31 <= matrix[i][j] <= 2^31 - 1`
+
+---
+
+## Approach
+Use the first row and first column as markers to record which rows/columns should be zeroed. Track separately if the first row or first column need to be zeroed to avoid losing marker info. In the second pass, set entire rows/columns to zero based on these markers.
+
+**Why this approach works:**
+- Uses O(1) extra space by utilizing the matrix itself as storage
+- First pass marks which rows and columns need to be zeroed
+- Second pass actually sets the zeros
+- Handles edge cases for first row and first column separately
+
+**Alternative approaches considered:**
+- Could use separate arrays to track rows and columns, but that would use O(m+n) space
+- Could use a set to store positions, but that would also use extra space
+
+---
+
+## Dry Run
+Example Input: `matrix = [[1,1,1],[1,0,1],[1,1,1]]`
+
+Step-by-step execution:
+- Step 1: Find 0 at position [1][1], mark row 1 and column 1
+- Step 2: Set matrix[0][1] = 0 and matrix[1][0] = 0 as markers
+- Step 3: Set entire column 1 to 0 (except already processed cells)
+- Step 4: Set entire row 1 to 0 (except already processed cells)
+- Step 5: Handle first row and first column if needed
+
+Final Answer = `[[1,0,1],[0,0,0],[1,0,1]]`
+
+---
+
+## Solution
+```java
+class Solution {
+    public void setZeroes(int[][] matrix) {
+        int m = matrix.length;
+        int n = matrix[0].length;
+
+        boolean r0F = false;
+        boolean c0F = false;
+
+        for (int i = 0; i < m; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == 0 && matrix[i][j] == 0) r0F = true;
+                if (j == 0 && matrix[i][j] == 0) c0F = true;
+                if (matrix[i][j] == 0) {
+                    matrix[0][j] = 0;
+                    matrix[i][0] = 0;
+                }
+            }
+        }
+
+        for (int i = 1; i < n; i++) {
+            if (matrix[0][i] == 0) {
+                for (int j = 0; j < m; j++) {
+                    matrix[j][i] = 0;
+                }
+            }
+        }
+
+        for (int i = 1; i < m; i++) {
+            if (matrix[i][0] == 0) {
+                for (int j = 0; j < n; j++) {
+                    matrix[i][j] = 0;
+                }
+            }
+        }
+
+        if (r0F) {
+            for (int i = 0; i < n; i++) {
+                matrix[0][i] = 0;
+            }
+        }
+
+        if (c0F) {
+            for (int i = 0; i < m; i++) {
+                matrix[i][0] = 0;
+            }
+        }
+    }
+}
+```
+
+---
+
+## Time and Space Complexity
+- **Time Complexity:** O(m * n) - each cell is visited a constant number of times
+- **Space Complexity:** O(1) - in-place, only a few extra variables