N-Queens | & N-Queens II

The n-queens puzzle is the problem of placing n queens on an n×n chessboard such that no two queens attack each other.

Given an integer n, return all distinct solutions to the n-queens puzzle.

Each solution contains a distinct board configuration of the n-queens' placement, where 'Q' and '.' both indicate a queen and an empty space respectively.

Example

There exist two distinct solutions to the 4-queens puzzle:

[
  // Solution 1
  [".Q..",
   "...Q",
   "Q...",
   "..Q."
  ],
  // Solution 2
  ["..Q.",
   "Q...",
   "...Q",
   ".Q.."
  ]
]

 class Solution {
     public List<List<String>> solveNQueens(int n) {
         List<List<String>> allList = new ArrayList<>();
         if (n <= ) return allList;
         Integer[] row = new Integer[n];
         List<List<Integer>> integerList = new ArrayList<>();
         queen(, n, row, new ArrayList<>());

         char[] arr = new char[n];
         Arrays.fill(arr, '.');
         for (List<Integer> list : integerList) {
             List<String> temp = new ArrayList<String>();
             for (int i = ; i < list.size(); i++) {
                 arr[list.get(i)] = 'Q';
                 temp.add(new String(arr));
                 arr[list.get(i)] = '.';
             }
             allList.add(new ArrayList<String>(temp));
         }
         return allList;

     }

     public void queen(int n, int count, Integer[] row, List<List<Integer>> list) {
         if (n == count) {
             list.add(new ArrayList<Integer>(Arrays.asList(row)));
             return;
         }

         for (int i = ; i < count; i++) {
             row[n] = i;
             if (isSatisfied(n, row)) {
                 queen(n + , count, row, list);
             }
         }
     }

     public boolean isSatisfied(int n, Integer[] row) {
         for (int i = ; i < n; i++) {
             if (row[i] == row[n]) return false;
             if (Math.abs(row[n] - row[i]) == n - i) return false;
         }
         return true;
     }
 }

N-Queens II

Follow up for N-Queens problem.

Now, instead outputting board configurations, return the total number of distinct solutions.

Example

For n=4, there are 2 distinct solutions.

 class Solution {
     public int totalNQueens(int n) {
         int[] row = new int[n];
         int[] current = new int[];
         queen(, n, row, current);
         return current[];
     }

     public void queen(int n, int count, int[] row, int[] current) {
         if (n == count) {
             current[]++;
             return;
         }
         for (int i = ; i < count; i++) {
             row[n] = i;
             if (isSatisfied(n, row)) {
                 queen(n + , count, row, current);
             }
         }
     }

     public boolean isSatisfied(int n, int[] row) {
         for (int i = ; i < n; i++) {
             if (row[i] == row[n]) return false;
             if (Math.abs(row[n] - row[i]) == n - i) return false;
         }
         return true;
     }
 }