Question

WRITE A JAVA PROGRAM using STACKS and backtracing to solves the N Queens Problem . The program takes the user's input integer for N and prints out all the solutions for N . The N Queen is the problem of placing N chess queens on an N×N chessboard so that no two queens attack each other. For example, the following is the output for 4 entered for userinput.

Output for 4 Queens :

1-
 *  *  Q  * 
 Q  *  *  * 
 *  *  *  Q 
 *  Q  *  * 

2-
 *  Q  *  * 
 *  *  *  Q 
 Q  *  *  * 
 *  *  Q  * 

Answer 1

2 public class Queens Problem { Nm tono int[] queenPositions; boolean solutionPossible = false; <terminated> Queens Problem (Java Application) C:\Program Fil No Solutions are possible for 2 X 2 No Solutions are possible for 3 X 3 * Q * * * * * O * * * // constructor public QueensProblem(int noof Queens) { queenPositions = new int[no0fQueens]; * * * * * * * * * 120 * * * 13 * * * o 14 15 17 180 Check if a queen can be placed in row r and column c. When we call this * function, the queen Positions array would have been filled for (row -1) * rows already * return true if placement is possible else false */ public boolean canPlaceQueen(int row, int col) { for (int a = 0; a < row; a++) { if (queenPositions[a] == col II (a - row) == (queenPositions[a] - col) II (a - row) == (col - queen Positions[a])) { return false; 25 26 return true; 27 29 300 // print results in matrix format public void printoutputQueens (int[] x) { 31 33 35 // x[i] = y, means in the ith Row, queen need to be placed in yth column int noOfQuens = x.length; for (int row = 0; row < no0fQuens; row++) { for (int col = 0; col < noOfQuens; col++) { if (x[row] == col) { System.out.print(" "); } else { System.out.print("* "); 38

public class QueensProblem {

        int[] queenPositions;
        boolean solutionPossible = false;

        // constructor
        public QueensProblem(int noOfQueens) {
                queenPositions = new int[noOfQueens];
        }

        /**
         * Check if a queen can be placed in row r and column c. When we call this
         * function, the queenPositions array would have been filled for (row -1)
         * rows already
         * return true if placement is possible else false
         */
        public boolean canPlaceQueen(int row, int col) {
                for (int a = 0; a < row; a++) {
                        if (queenPositions[a] == col
                                        || (a - row) == (queenPositions[a] - col)
                                        || (a - row) == (col - queenPositions[a])) {
                                return false;
                        }
                }
                return true;
        }

        // print results in matrix format
        public void printOutputQueens(int[] x) {
                
                // x[i] = y, means in the ith Row, queen need to be placed in yth column
                int noOfQuens = x.length;
                for (int row = 0; row < noOfQuens; row++) {
                        for (int col = 0; col < noOfQuens; col++) {
                                if (x[row] == col) {
                                        System.out.print("Q ");
                                } else {
                                        System.out.print("* ");
                                }
                        }
                        System.out.println();
                }
                System.out.println();
        }

        /**
         * We are using backtracking here. First we will place one queen at a
         * row, then we will recurse for other rows and check to make sure that
         * the queens don't conflict each other. If they do so, we stop and
         * start again
         * 
         */
        public void placeQueensUtil(int rowNo, int noOfQueens) {
                for (int queenNo = 0; queenNo < noOfQueens; queenNo++) {
                        if (canPlaceQueen(rowNo, queenNo)) {
                                queenPositions[rowNo] = queenNo;
                                if (rowNo == noOfQueens - 1) {
                                        // if queen has been placed at last row
                                        solutionPossible = true; // solution for this problem is possible
                                        printOutputQueens(queenPositions);
                                } else {
                                        // recurse for other rows now.
                                        placeQueensUtil(rowNo + 1, noOfQueens);
                                }
                        }
                }
        }

        // this method places the queens at specified positions
        public void placeQueens() {
                
                // for checking if any solution exists 
                solutionPossible = false;
                
                placeQueensUtil(0, queenPositions.length);
                
                if(!solutionPossible) {
                        System.out.println("No Solutions are possible for " + queenPositions.length + " X " + queenPositions.length);
                }
        }

        public static void main(String args[]) {
                QueensProblem queensProblem = new QueensProblem(2);
                queensProblem.placeQueens();

                queensProblem = new QueensProblem(3);
                queensProblem.placeQueens();
                
                queensProblem = new QueensProblem(4);
                queensProblem.placeQueens();

        }
}