Optimized NQueens implementation using hashing

Author: Bhanubasyan

src/main/java/com/thealgorithms/backtracking/NQueens.java

@@ -2,6 +2,8 @@
 
 import java.util.ArrayList;
 import java.util.List;
+import java.util.HashSet;
+import java.util.Set;
 
 /**
  * Problem statement: Given a N x N chess board. Return all arrangements in
@@ -32,7 +34,22 @@
  * queen is not placed safely. If there is no such way then return an empty list
  * as solution
  */
+
+/*
+ * Time Complexity: O(N!)
+ * space Complexity: O(N)
+ */
 public final class NQueens {
+
+    // Store occupied rows for constant time safety check
+    private static final Set<Integer> occupiedRows = new HashSet<>();
+
+    // Store occupied main diagonals (row - column)
+    private static final Set<Integer> occupiedDiagonals = new HashSet<>();
+
+    // Store occupied anti-diagonals (row + columns)
+    private static final Set<Integer> occupiedAntiDiagonals = new HashSet<>();
+
     private NQueens() {
     }
 
@@ -43,10 +60,11 @@ public static List<List<String>> getNQueensArrangements(int queens) {
     }
 
     public static void placeQueens(final int queens) {
-        List<List<String>> arrangements = new ArrayList<List<String>>();
+        List<List<String>> arrangements = new ArrayList<>();
         getSolution(queens, arrangements, new int[queens], 0);
         if (arrangements.isEmpty()) {
-            System.out.println("There is no way to place " + queens + " queens on board of size " + queens + "x" + queens);
+            System.out.println(
+                    "There is no way to place " + queens + " queens on board of size " + queens + "x" + queens);
         } else {
             System.out.println("Arrangement for placing " + queens + " queens");
         }
@@ -59,15 +77,15 @@ public static void placeQueens(final int queens) {
     /**
      * This is backtracking function which tries to place queen recursively
      *
-     * @param boardSize: size of chess board
-     * @param solutions: this holds all possible arrangements
-     * @param columns: columns[i] = rowId where queen is placed in ith column.
+     * @param boardSize:   size of chess board
+     * @param solutions:   this holds all possible arrangements
+     * @param columns:     columns[i] = rowId where queen is placed in ith column.
      * @param columnIndex: This is the column in which queen is being placed
      */
     private static void getSolution(int boardSize, List<List<String>> solutions, int[] columns, int columnIndex) {
         if (columnIndex == boardSize) {
             // this means that all queens have been placed
-            List<String> sol = new ArrayList<String>();
+            List<String> sol = new ArrayList<>();
             for (int i = 0; i < boardSize; i++) {
                 StringBuilder sb = new StringBuilder();
                 for (int j = 0; j < boardSize; j++) {
@@ -82,30 +100,28 @@ private static void getSolution(int boardSize, List<List<String>> solutions, int
         // This loop tries to place queen in a row one by one
         for (int rowIndex = 0; rowIndex < boardSize; rowIndex++) {
             columns[columnIndex] = rowIndex;
-            if (isPlacedCorrectly(columns, rowIndex, columnIndex)) {
-                // If queen is placed successfully at rowIndex in column=columnIndex then try
-                // placing queen in next column
-                getSolution(boardSize, solutions, columns, columnIndex + 1);
-            }
-        }
-    }
 
-    /**
-     * This function checks if queen can be placed at row = rowIndex in column =
-     * columnIndex safely
-     *
-     * @param columns: columns[i] = rowId where queen is placed in ith column.
-     * @param rowIndex: row in which queen has to be placed
-     * @param columnIndex: column in which queen is being placed
-     * @return true: if queen can be placed safely false: otherwise
-     */
-    private static boolean isPlacedCorrectly(int[] columns, int rowIndex, int columnIndex) {
-        for (int i = 0; i < columnIndex; i++) {
-            int diff = Math.abs(columns[i] - rowIndex);
-            if (diff == 0 || columnIndex - i == diff) {
-                return false;
+            // Skip current position if row or diagonal is already occupied
+            if (occupiedRows.contains(rowIndex)
+                    || occupiedDiagonals.contains(rowIndex - columnIndex)
+                    || occupiedAntiDiagonals.contains(rowIndex + columnIndex)) {
+                continue;
             }
+
+            // Mark current row and diagonal as occupied
+            occupiedRows.add(rowIndex);
+            occupiedDiagonals.add(rowIndex - columnIndex);
+            occupiedAntiDiagonals.add(rowIndex + columnIndex);
+
+            // Move to the next column after placing current queen
+            getSolution(boardSize, solutions, columns, columnIndex + 1);
+
+            // Backtrack by removing current queen
+
+            occupiedRows.remove(rowIndex);
+            occupiedDiagonals.remove(rowIndex - columnIndex);
+            occupiedAntiDiagonals.remove(rowIndex + columnIndex);
         }
-        return true;
     }
+
 }