Question

t is N queens problem please complete it

//***************************************************************

// D.S. Malik

//

// This class specifies the functions to solve the n-queens

// puzzle.

//***************************************************************

class nQueensPuzzle

{

public:

nQueensPuzzle(int queens = 8);

//constructor

//Postcondition: noOfSolutions = 0; noOfQueens = queens;

// queensInRow is a pointer to the array

// that store the n-tuple.

// If no value is specified for the parameter queens,

// the default value, which is 8, is assigned to it.

bool canPlaceQueen(int k, int i);

//Function to determine whether a queen can be placed

//in row k and column i.

//Postcondition: returns true if a queen can be placed in

// row k and column i; otherwise it returns false

void queensConfiguration(int k);

//Function to determine all solutions to the n-queens

//puzzle using backtracking.

//The function is called with the value 0.

//Postcondition: All n-tuples representing solutions of

// n-queens puzzle are generated and printed.

void printConfiguration();

//Function to output an n-tuple containing a solution

//to the n-queens puzzle.

int solutionsCount();

//Function to return the total number of solutions.

//Postcondition: The value of noOfSolution is returned.

private:

int noOfSolutions;

int noOfQueens;

int *queensInRow;

};

#include <iostream>

#include <cmath>

#include "nQueenPuzzle.h"

using namespace std;

nQueensPuzzle::nQueensPuzzle()

{

noOfQueens = 8;

queensInColumn = new int[8];

noOfSolutions = 0;

}

nQueensPuzzle::nQueensPuzzle(int queens)

{

noOfQueens = queens;

queensInColumn = new int[noOfQueens];

noOfSolutions = 0;

}

bool nQueensPuzzle::canPlaceQueen(int k, int i)

{

for(int j = 0; j < k; j++)

if((queensInColumn[j] == i)

|| (abs(queensInColumn[j] - i) == abs(j-k)))

return false;

return true;

}

void nQueensPuzzle::queensConfiguration(int k)//, int queens)

{

for(int i = 0; i < noOfQueens; i++)

{

if(canPlaceQueen(k, i))

{

queensInColumn[k] = i;

if(k == noOfQueens - 1)

printConfiguration();

else

queensConfiguration(k + 1);

}

}

}

void nQueensPuzzle::printConfiguration()

{

noOfSolutions++;

cout<<"(";

for(int i = 0; i < noOfQueens - 1; i++)

cout<<queensInColumn[i]<<", ";

cout<<queensInColumn[noOfQueens - 1]<<")"<<endl;

}

int nQueensPuzzle::solutionsCount()

{

return noOfSolutions;

}

Answer 1

Working code implemented in C++ and appropriate comments provided for better understanding.

Here I am attaching code for all files:

main.cpp:

#include <iostream>
#include <fstream>
#include "nQueenPuzzle.h"

int main() {

   int max = 10;
   std::ofstream output;
   output.open("output.txt");

   for (int i = 0; i < max; i++) {
       nQueensPuzzle queens(i + 1);

       output << "\t\tBOARD " << i + 1 << "x" << i + 1 << "\n\n";

       queens.queensConfiguration(0, output);

       std::cout << "A " << i + 1 << "x" << i + 1 << " board has ";
       std::cout << queens.solutionsCount();
       std::cout << " solutions.\n";

       output << "\nA " << i + 1 << "x" << i + 1 << " board has ";
       output << queens.solutionsCount();
       output << " solutions.\n\n";
   }

   std::cout << "Output has been saved to output.txt because large numbers output too many lines.\n";

   output.close();

   return 0;
}

nQueenPuzzle.cpp:

#include <iostream>
#include <fstream>
#include <cmath>
#include "nQueenPuzzle.h"

nQueensPuzzle::nQueensPuzzle(int queens) {
   noOfQueens = queens;
   queensInRow = new int[noOfQueens];
   noOfSolutions = 0;
}

bool nQueensPuzzle::canPlaceQueen(int k, int i) {
   for (int j = 0; j < k; j++) {
       if ((queensInRow[j] == i) || (abs(queensInRow[j] - i) == abs(j-k))) {
           return false;
       }
   }
   return true;
}

void nQueensPuzzle::queensConfiguration(int k, std::ofstream &output) {
   for (int i = 0; i < noOfQueens; i++) {
       if (canPlaceQueen(k, i)) {
           queensInRow[k] = i;
           if (k == noOfQueens - 1) {
               printConfiguration(output);
           } else {
               queensConfiguration(k + 1, output);
           }
       }
   }
}

void nQueensPuzzle::printConfiguration(std::ofstream &output) {
   noOfSolutions++;
   output << "(";
   for (int i = 0; i < noOfQueens - 1; i++) {
       output << queensInRow[i] << ", ";
   }

   output << queensInRow[noOfQueens - 1] << ")\n";
}

int nQueensPuzzle::solutionsCount() {
   return noOfSolutions;
}
nQueensPuzzle.h:

#include <fstream>

class nQueensPuzzle {
public:
   nQueensPuzzle(int queens = 8);
   bool canPlaceQueen(int k, int i);
   void queensConfiguration(int k, std::ofstream &output);
   void printConfiguration(std::ofstream &output);
   int solutionsCount();
private:
   int noOfSolutions;
   int noOfQueens;
   int *queensInRow;
};

Sample Output Screenshots: