Question

================Data Structures C++===============

– Implement the Eight Queens Problem

This is an object oriented program. This is #1 on page 187 of your book with ONE difference, I’m requiring you add a client program to test your code (a main). If you have the old book the question says “Complete the Queen and Board class for the Eight Queens problem.”

On page 179 of your book is a function placeQueens that solves the Eight Queens problem.

On page 180 of your book are some suggestions to implementing two ADTs to solve the problem in C++. I want you to follow their suggestions to implement the solution.

1. First create a Board class data type. This class data type should represent the chess board (you can use any implementation you want, a two dimensional array (however this may waste space but not if you’re displaying in my opinion), a vector (it could represent only the board places occupied by queens), an array of vectors etc – there is more than one right way!). The board should keep track of the Queens currently placed on it and contain operations/methods (such as placeQueens and displayBoard) to solve the problem and display a solution. You can add other methods as you need them. Note the board will need to contain a Queen (or perhaps an array or vector of queens) – I haven’t done this problem yet but I immediately thought composition might be needed.
2. Next create a Queen data type. A queen instance should be able to keep track of its current position (row and column) and be able to move to the next row. Again you can add other methods as you see fit.
3. Add a client program to test your code:
   • This program should place the first queen anywhere on the board and then call placeQueens to see if a solution can be reached. If the solution can be reached the program should display the board with the queens properly placed.
   • The header fi le for the class Board from the book example
     /** @file Board.h */
     #ifndef _BOARD
     #define _BOARD
     #include "Queen.h"
     #include <vector>
     #include <cassert>#include <iostream>
     using namespace std;
     static const int BOARD_SIZE = 8;
     class Board
     {
     private :
     vector<Queen*> queens; // Array of pointers to queens on the board
     /** Sees whether a queen exists in position (inRow, inCol). */
     bool isQueen( int inRow, int inCol) const;
     /** Attempts to place queens on board, starting with the designated queen. */
     const placeQueens(Queen* queenPtr);
     /** Removes the last queen from the board, but does not deallocate it. */
     void removeQueen();
     /** Places a queen on the board. */
     void setQueen( const Queen* queenPtr);
     public:
     /** Supplies the Queen class with a pointer to the board. */
     Board();
     /** Clears the board and removes pointer from queens. */
     ~Board();
     /** Clears board. */
     void clear();
     /** Displays board. */
     void display() const;
     /** Initiates the Eight Queens problem. */
     void doEightQueens();
     /** @return The number of queens on the board. */
     int getNumQueens() const;
     /** @return A pointer to the queen at the designated index. */
     const Queen* getQueen( int index) const;
     }; // end Board
     #endif
     LISTING 5-2 The class Queen
     class Board; // Forward declaration of Board class
     /** The Queen class. */
     class Queen
     {
     public:
     /** Places a queen in upper-left corner of board. */
     Queen();/** Places a queen in supplied location. */
     Queen( int inRow, int inCol);
     /** @return Column number. */
     int getCol() const;
     /** @return Row number. */
     int getRow() const;
     /** Moves queen to next row. */
     void nextRow();
     /** Sees whether the queen is under attack by another queen.
     @return True if another queen is in the same row or the same
     diagonal; otherwise, returns false. */
     bool isUnderAttack() const;
     /** Saves a pointer to the board for all queens. */
     static void setBoard( const Board* bPtr);
     private:
     int row; // Row (or prospective row) of queen if it is on the board
     int col; // Column (or prospective column) of queen if it is on
     // the board
     // All queens share the same board
     static const Board* boardPtr;
     }; // end Queen
     An implementation of placeQueens follows:
     bool Board::placeQueens(Queen* queenPtr)
     {
     // Base case: Try to place a queen in a nonexistent column.
     if (queenPtr->getCol() >= BOARD_SIZE)
     {
     delete queenPtr;
     return true;
     } // end if
     bool isQueenPlaced = false;
     while (!isQueenPlaced && queenPtr->getRow() < BOARD_SIZE)
     {
     // If the queen can be attacked, try moving it
     // to the next row in the current column
     if (queenPtr->isUnderAttack())
     queenPtr->nextRow();
     else
     {
     // Put this queen on the board and try putting a
     // new queen in the first row of the next column
     setQueen(queenPtr);
     Queen* newQueenPtr = new Queen(0, queenPtr->getCol() + 1);
     isQueenPlaced = placeQueens(newQueenPtr);// If it wasn't possible to put the new queen in the next column,
     // backtrack by deleting the new queen and moving the last
     // queen placed down one row
     if (!isQueenPlaced)
     {
     delete newQueenPtr;
     removeQueen();
     queenPtr->nextRow();
     } // end if
     } // end if
     } // end while
     return isQueenPlaced;
     } // end placeQueens

Answer 1

Please let me know if you have any doubts or you want me to modify the answer. And if you find this answer useful then don't forget to rate my answer as thumps up. Thank you! :)

//main.cpp
#include <iostream>
#include <vector>
#include "Queen.h"
#include "Board.h"
#include "Queen.cpp"
#include "Board.cpp"
using namespace std;
#include <iostream>

int main() {
    Board board;
    for (int row = 0; row < 8; row++) {
        Queen queen(row, 0);
        queen.setBoard(&board);
        board.doEightQueens(queen);
        board.display();
        board.clear();
        cout << endl;
    }
    system("PAUSE");
    return 0;
}

-----------------------------------------------------------------------------------------------------------
//Queen.cpp
#include "Queen.h"
#include "Board.h"
#include <iostream>
using namespace std;

const Board* Queen::boardPtr;

Queen::Queen() : row(0), col(0) {
}

Queen::Queen(int inRow, int inCol) : row(inRow), col(inCol) {

}

Queen::~Queen() {

}

int Queen::getCol() const {
    return col;
}

int Queen::getRow() const {
    return row;
}
void Queen::nextRow() {
    ++row;
}

bool Queen::isUnderAttack() const {
    for (int i = 0; i < boardPtr->getNumQueens(); i++) {
        const Queen* q = boardPtr->getQueen(i);
        if (q->getCol() == col || q->getRow() == row || q->getRow()-q->getCol() == row-col || q->getRow()+q->getCol() == row+col)
            return true;
    }
    return false;
}

void Queen::setBoard(const Board* bPtr) {
    boardPtr = bPtr;
}

-----------------------------------------------------------------------------------------------------------
//Queen.h
#ifndef QUEEN_H
#define QUEEN_H

class Board; class Queen {
public:
    Queen();
    ~Queen();
    Queen(int inRow, int inCol);
    int getCol() const;
    int getRow() const;
    void nextRow();
    static void setBoard(const Board* bPtr);
    bool isUnderAttack() const;
private:
    int row;
    int col;
    static const Board* boardPtr;

};
#endif
-----------------------------------------------------------------------------------------------------------
//Board.cpp
#include <iostream>
#include <vector>
#include "Board.h"
using namespace std;

Board::Board() {
    Queen::setBoard(this);
}

Board::~Board() {
    clear();
}

bool Board::placeQueens(Queen* queenPtr) {
    if (queenPtr->getCol() >= BOARD_SIZE) {
        delete queenPtr;
        return true;
    }

    bool isQueenPlaced = false;

    while (!isQueenPlaced && queenPtr->getRow()<BOARD_SIZE) {

        if (queenPtr->isUnderAttack()) {
            queenPtr->nextRow();
        }
        else {
            setQueen(queenPtr);
            Queen* newQueenPtr = new Queen(0, queenPtr->getCol() + 1);
            isQueenPlaced = placeQueens(newQueenPtr);
            if (!isQueenPlaced) {
                delete newQueenPtr;
                removeQueen();
                queenPtr->nextRow();
            }
        }
    }
    return isQueenPlaced;
}

void Board::doEightQueens(Queen q) {
    placeQueens(new Queen(q.getRow(),q.getCol()));
}

void Board::clear() {
    for (int i = getNumQueens(); i > getNumQueens() ;++i) {
        delete (queens[i]);
    }
    queens.clear();
}

void Board::removeQueen() {
    if (queens.size() != 0)
        queens.pop_back();
}

bool Board::isQueen(int row, int col) const {
    bool isOnBoard = false;
    for (int i = 0; i < (int)queens.size(); i++) {
        if (queens[i]->getRow() == row && queens[i]->getCol() == col) {
            isOnBoard = true;
        }
    }
    return isOnBoard;
}
void Board::setQueen(Queen* queenPtr) {
    queens.push_back(queenPtr);
}

void Board::display() const {
    cout << " ";
    for (int rowNum = 0; rowNum < BOARD_SIZE; rowNum++)
        cout << rowNum << " ";
    cout << endl;
    for (int row = 0; row < BOARD_SIZE; row++) {
        cout << row << " ";
        for (int col = 0; col < BOARD_SIZE; col++) {
            if (isQueen(row, col)) {
                cout << "Q ";
            }
            else cout << "+ ";
        } cout << endl;
    }

}

int Board::getNumQueens() const {
    return queens.size();
}

const Queen* Board::getQueen(int index) const {
    return queens[index];
}

-----------------------------------------------------------------------------------------------------------

//Board.h
#ifndef _BOARD
#define _BOARD
#include "Queen.h"
#include <vector>
#include <cassert>
#include <iostream>
using namespace std;

static const int BOARD_SIZE = 8;
class Board {
private:
    vector<Queen*> queens;
    bool isQueen(int inRow, int inCol) const ;
    bool placeQueens(Queen* queenPtr);
    void removeQueen();
    void setQueen( Queen* queenPtr);

public:
    Board();
    ~Board();
    void clear();
    void display() const;
    void doEightQueens(Queen q);
    int getNumQueens() const;
    const Queen* getQueen(int index) const;
};
#endif

/CLionProjects/Eight m] - main.cpp main.cpp *증 *-Δ cMakel.ists.txt main.cppQueenepp Queen.h.cpp Board.h Project ▼ /Users/swapnil/CLionProjects/EightQueensProblem/cmake-build-debug/EightQueensProblem 0 1234567 0 12 3 456 7 0 123 4567 0 1234567 0 1 234567 O Event Log Terminal ㅿCMake 9: Messages Process finished with exit code O 4: Run -6. T000 85:1 LF UTF-8# 4 spaces Context: EightQueensProblem [D