Update README.md

Author: JawadSher

20 - Hashmap Data Structure Problems/03 - N - Queens/README.md

@@ -7,97 +7,51 @@
 ![image](https://github.com/user-attachments/assets/e8761c6f-261e-4dcd-b8d3-5ead85274f52)
 
 ## Problem Explanation
+#### **Problem Statement**
+The **N-Queens problem** is about placing `N` queens on an `N x N` chessboard such that:
+- No two queens threaten each other.
+- Queens threaten in the same row, same column, or along both diagonals.
 
-The **N-Queens Problem** is a famous backtracking problem where the goal is to place \(n\) queens on an \(n \times n\) chessboard so that:
-1. No two queens threaten each other.
-   - A queen threatens another queen if they are in the same **row**, **column**, or **diagonal**.
-2. You need to find all possible valid arrangements of \(n\) queens and return them in a specific format:
-   - Each solution is represented as a list of strings where:
-     - A `Q` represents a queen.
-     - A `.` represents an empty space.
-
-#### **Example**
-For \(n = 4\), there are two valid solutions:
-```plaintext
-Solution 1:
-[
- "Q...",
- "...Q",
- ".Q..",
- "..Q."
-]
-
-Solution 2:
-[
- "..Q.",
- "Q...",
- "...Q",
- ".Q.."
-]
-```
-
-#### **Approach**
-To solve this problem, we can use **backtracking**. Backtracking systematically explores all possibilities to build solutions, backtracking (undoing) when a solution violates the constraints. Here's how we can approach this problem step-by-step:
-
-
-
-**1. Represent the Chessboard**
-- Use a **2D array** (`board`) of size \(n \times n\), where:
-  - `1` indicates a queen is placed.
-  - `0` indicates an empty spot.
-- Initially, the board is filled with `0`.
-
-
-
-**2. Solve Column-by-Column**
-- Start from the **first column** and attempt to place a queen in any valid row.
-- Move to the **next column** only if the queen placement in the current column is valid.
-
-
+We need to find all valid configurations for placing these queens and return them in a specific format:
+- Each solution is represented by a list of strings, where each string represents a row.
+- For example, if `N = 4`, one solution looks like:
+  ```
+  .Q..
+  ...Q
+  Q...
+  ..Q.
+  ```
 
-**3. Safety Check**
-- For every cell `(row, col)` where we attempt to place a queen, we need to ensure:
-  1. **No queen in the same row** to the left of the current column.
-  2. **No queen in the upper-left diagonal**.
-  3. **No queen in the lower-left diagonal**.
 
 
+#### **Understanding the Approach**
 
-**4. Backtrack if a Solution Fails**
-- If no valid row exists for the current column, backtrack:
-  - Remove the last queen placed (reset `board[row][col]` to `0`).
-  - Try the next row in the previous column.
+To solve this problem, we use **backtracking**, a recursive approach that explores all possible placements of queens column by column. Here’s a breakdown:
 
+1. **Constraints**:
+   - Each column must have exactly one queen.
+   - A queen's position in the current column must not conflict with queens in the previous columns.
 
+2. **Tracking Validity**:
+   - To check if placing a queen at `(row, col)` is valid:
+     - **Row**: Check if any queen already occupies this row.
+     - **Primary diagonal**: No queen should occupy `(row - col)`.
+     - **Secondary diagonal**: No queen should occupy `(row + col)`.
 
-**5. Store Valid Solutions**
-- If queens are successfully placed in all \(n\) columns, convert the `board` to the required string format and save it.
+   These checks are implemented efficiently using hash sets.
 
+3. **Recursive Process**:
+   - Start placing queens from column `0`.
+   - For the current column:
+     - Try placing a queen in every row.
+     - If valid, mark the row and diagonals as occupied.
+     - Recursively move to the next column.
+   - If all queens are placed (base case), add the current configuration to the solution.
+   - Backtrack by removing the queen and marking the row and diagonals as free.
 
+4. **Output Format**:
+   - Store solutions as a vector of strings.
 
-#### **Example Walkthrough**
-Let’s consider \(n = 4\).
-
-1. **Start with Column 0**:
-   - Try placing a queen at `(0, 0)` (row 0, column 0). It's valid.
-   - Move to **column 1**.
-
-2. **Column 1**:
-   - Try `(0, 1)` → Invalid (same row as `(0, 0)`).
-   - Try `(1, 1)` → Valid. Place the queen and move to **column 2**.
-
-3. **Column 2**:
-   - Try `(0, 2)` → Invalid (same row as `(0, 0)`).
-   - Try `(1, 2)` → Invalid (same row as `(1, 1)`).
-   - Try `(2, 2)` → Valid. Place the queen and move to **column 3**.
-
-4. **Column 3**:
-   - Try `(0, 3)` → Invalid.
-   - Try `(1, 3)` → Invalid.
-   - Try `(2, 3)` → Invalid.
-   - Try `(3, 3)` → Valid. This completes one solution!
-
-Backtrack and explore other possibilities until all valid solutions are found.
 
 ## Problem Solution
 ```cpp
@@ -156,152 +110,125 @@ class Solution {
 
 ## Problem Solution Explanation
 
-#### **1. Helper Function: `addSolution`**
+#### **Helper Function: `addSolution`**
 ```cpp
-void addSolution(vector<vector<string>>& ans, vector<vector<int>>& board, int n) {
+void addSolution(vector<vector<string>>& ans, vector<int>& board, int n){
     vector<string> temp;
-    for (int i = 0; i < n; i++) {
-        string row = "";
-        for (int j = 0; j < n; j++) {
-            if (board[i][j] == 1)
-                row += "Q";
-            else
-                row += ".";
-        }
-        temp.push_back(row);
+    for(int i = 0; i < n; i++){
+        string row(n, '.'); // Create a string of size 'n', initialized with '.'
+        row[board[i]] = 'Q'; // Place a queen at the column index stored in board[i]
+        temp.push_back(row); // Add this row to the solution
     }
-    ans.push_back(temp);
+    ans.push_back(temp); // Add this configuration to the final answers
 }
 ```
-- Converts the `board` into the required string representation and adds it to the `ans` vector.
+- This function converts the internal `board` representation (queen positions per column) into the required string format.
+- **Example**: If `board = [1, 3, 0, 2]` for `N = 4`, this means:
+  - Column `0` → Row `1` has a queen → Row: `.Q..`
+  - Column `1` → Row `3` has a queen → Row: `...Q`
+  - Column `2` → Row `0` has a queen → Row: `Q...`
+  - Column `3` → Row `2` has a queen → Row: `..Q.`
 
-#### **2. Helper Function: `isSafe`**
-```cpp
-bool isSafe(int row, int col, vector<vector<int>>& board, int n) {
-    int x = row;
-    int y = col;
-
-    // Check left side of the row
-    while (y >= 0) {
-        if (board[x][y] == 1) return false;
-        y--;
-    }
 
-    // Check upper-left diagonal
-    x = row;
-    y = col;
-    while (x >= 0 && y >= 0) {
-        if (board[x][y] == 1) return false;
-        x--;
-        y--;
-    }
 
-    // Check lower-left diagonal
-    x = row;
-    y = col;
-    while (x < n && y >= 0) {
-        if (board[x][y] == 1) return false;
-        x++;
-        y--;
-    }
-
-    return true; 
-}
-```
-- Validates whether a queen can be safely placed at `(row, col)`:
-  1. Checks all positions in the **left row**.
-  2. Checks all positions in the **upper-left diagonal**.
-  3. Checks all positions in the **lower-left diagonal**.
-
-#### **3. Recursive Function: `solve`**
+#### **Recursive Function: `solve`**
 ```cpp
-void solve(int col, vector<vector<string>>& ans, vector<vector<int>>& board, int n) {
-    if (col == n) {
-        addSolution(ans, board, n);
+void solve(int col, vector<vector<string>>& ans, vector<int>& board, unordered_set<int>& rows, unordered_set<int>& primaryDiag, unordered_set<int>& secondaryDiag, int n){
+    if(col == n){
+        addSolution(ans, board, n); // If all columns are processed, store the current board configuration
         return;
     }
-
-    for (int row = 0; row < n; row++) {
-        if (isSafe(row, col, board, n)) {
-            board[row][col] = 1;
-            solve(col + 1, ans, board, n);
-            board[row][col] = 0; 
+    for(int row = 0; row < n; row++){ // Try placing a queen in each row of the current column
+        int diag1 = row - col; // Primary diagonal value
+        int diag2 = row + col; // Secondary diagonal value
+        
+        // Check if placing a queen is valid
+        if(rows.find(row) == rows.end() && primaryDiag.find(diag1) == primaryDiag.end() && secondaryDiag.find(diag2) == secondaryDiag.end()){
+            board[col] = row; // Place the queen in the current column
+            rows.insert(row); // Mark this row as occupied
+            primaryDiag.insert(diag1); // Mark the primary diagonal as occupied
+            secondaryDiag.insert(diag2); // Mark the secondary diagonal as occupied
+            
+            solve(col + 1, ans, board, rows, primaryDiag, secondaryDiag, n); // Recurse to the next column
+
+            // Backtrack: Remove the queen and mark the row/diagonals as free
+            board[col] = -1;
+            rows.erase(row);
+            primaryDiag.erase(diag1);
+            secondaryDiag.erase(diag2);
         }
     }
 }
 ```
-- If \( \text{col} = n \), all queens are placed, so call `addSolution`.
-- For each row in the current column:
-  1. Check if it's safe to place a queen.
-  2. If valid, place the queen, move to the next column, and backtrack if needed.
+- **Base Case**: When `col == n`, all queens are placed, and the current configuration is stored using `addSolution`.
+- **Recursive Case**: For each column, try placing a queen in every row and check if the position is valid.
+- **Backtracking**: Ensures that the algorithm explores all possibilities by undoing changes made for a failed path.
+
 
-#### **4. Main Function**
+
+#### **Main Function: `solveNQueens`**
 ```cpp
 vector<vector<string>> solveNQueens(int n) {
-    vector<vector<int>> board(n, vector<int>(n, 0)); 
-    vector<vector<string>> ans; 
-    solve(0, ans, board, n);
-    return ans;
+    vector<int> board(n, -1); // Tracks queen positions for each column (initially no queens placed)
+    vector<vector<string>> ans; // Stores all valid solutions
+    unordered_set<int> rows; // Tracks rows that are already occupied
+    unordered_set<int> primaryDiag; // Tracks primary diagonals that are occupied
+    unordered_set<int> secondaryDiag; // Tracks secondary diagonals that are occupied
+
+    solve(0, ans, board, rows, primaryDiag, secondaryDiag, n); // Start solving from the first column
+    return ans; // Return the list of all solutions
 }
 ```
-- Initializes the board and calls `solve` starting from column 0.
+- Initializes all data structures and starts the recursive backtracking process.
 
 
 
 ### **Step 3: Example Walkthrough**
-Input: \( n = 4 \)
-
-1. The algorithm explores all possibilities, starting with:
-   ```
-   Q...
-   ...Q
-   .Q..
-   ..Q.
-   ```
-
-2. After finding a solution, it backtracks to explore:
-   ```
-   ..Q.
-   Q...
-   ...Q
-   .Q..
-   ```
-
-Output:
-```cpp
-[
-  ["Q...", "...Q", ".Q..", "..Q."],
-  ["..Q.", "Q...", "...Q", ".Q.."]
-]
-```
 
+#### **Example: N = 4**
+1. Start from column `0`:
+   - Place queen in `(0, 0)`. Mark row `0` and diagonals `(0 - 0)` and `(0 + 0)` as occupied.
 
+2. Move to column `1`:
+   - Row `0` is blocked. Try row `1` → Conflicts diagonally.
+   - Try row `2` → Valid. Place queen in `(2, 1)`.
 
-### **Step 4: Time and Space Complexity**
+3. Move to column `2`:
+   - Row `0` is blocked. Row `1` conflicts diagonally.
+   - Try row `3` → Valid. Place queen in `(3, 2)`.
 
-#### **Time Complexity**
-- **Backtracking** explores all possible queen placements:
-  - The total number of recursive calls is roughly \( O(n!) \) since we attempt to place queens column by column.
-- Checking safety involves \( O(n) \) operations for each queen.
+4. Move to column `3`:
+   - Place queen in `(1, 3)`.
+   - **Valid Configuration Found**:
+     ```
+     .Q..
+     ...Q
+     Q...
+     ..Q.
+     ```
 
-Overall time complexity: \( O(n! \times n) \).
-
-#### **Space Complexity**
-- The `board` requires \( O(n^2) \) space.
-- The recursion stack can grow to \( O(n) \).
-
-Total space complexity: \( O(n^2) \).
 
 
+### **Step 4: Time and Space Complexity**
 
-### **Step 5: Recommendations**
-1. **Practice Backtracking**:
-   - Try simpler problems like generating all subsets or permutations to strengthen your recursion and backtracking skills.
+#### **Time Complexity**
+- There are `N!` permutations for placing queens.
+- Validity checks for rows and diagonals take O(1).
+- Total time complexity: **O(N!)**
 
-2. **Optimize Safety Check**:
-   - Instead of rechecking the board for threats, consider using hash sets for rows and diagonals to reduce the safety check to \( O(1) \).
+#### **Space Complexity**
+- Space for:
+  - `board` array: O(N)
+  - `rows`, `primaryDiag`, `secondaryDiag` sets: O(N)
+  - Recursive stack: O(N)
+- Total space complexity: **O(N)**
 
-3. **Visualize Solutions**:
-   - Draw the chessboard for smaller \( n \) values to understand how the queens are placed.
 
 
+### **Step 5: Recommendations for Students**
+1. **Visualize the Problem**: Draw the chessboard and manually place queens to understand constraints.
+2. **Practice Similar Problems**: Try variations like "Sudoku Solver" and "Knight's Tour."
+3. **Understand Diagonal Indexing**:
+   - `Primary Diagonal`: `row - col`
+   - `Secondary Diagonal`: `row + col`
+4. **Optimize with Bitmasking**: For larger `N`, bitmasking can reduce space usage for row and diagonal tracking.