八皇后问题 回溯法 C++ 含迭代器

#ifndef POSITION

#define POSITION

class Position

{

    protected:

        int row,column;

    public:

        Position();

        Position (int row, int column);

        int getRow() const;

        int getColumn() const;

int getnum_of_queen() const;

void setPosition(int newRow,int newColumn);

}; // class Position

#endif

#ifndef BACKTRACK

#define BACKTRACK

#include "Application.h";

#include "Position.h";

class BackTrack  

{

    public:

        BackTrack (const Application& app);

        bool tryToSolve (Position pos);

    protected:

        Application app;

}; // class BackTrack

#endif

#ifndef APPLICATION

#define APPLICATION

#include <iostream>

#include "Position.h"

using namespace std;

class Application

{

    friend ostream& operator<<(ostream& stream, Application& app);

    public:

        // Postcondition: the initial state for this Application has been

        //                generated -- from input or assignments -- and

        //                the start position has been returned.

        Position generateInitialState();

        // Postcondition: true has been returned if pos can be on the path

        //                to a goal.  Otherwise, false has been returned.

        bool valid (const Position& pos);

        // Precondition: pos represents a valid position.

        // Postcondition: pos has been recorded as a valid position.

        void record (const Position& pos);

        // Postcondition: true has been returned if pos is the final

        //                position for this application.  Otherwise, false

        //                has been returned.

        bool done () const;

        // Postcondition: pos has been marked as not being on the path to

        //                a goal.

        void undo (const Position& pos);      

    class Iterator

    {

protected:

            void* fieldPtr;

        public:

            // Postcondition: this Iterator has been initialized to

            //                iterate from pos.

            Iterator (const Position& pos);

            // Postcondition: the next position for this Iterator has

            //                been returned.

            Position operator++ (int);

            // Postcondition: this Iterator cannot iterate any further.

            bool atEnd();

    }; // class Iterator

}; // class Application

#endif

///主要部分

#include "Application.h"

#include "Position.h"

#include <iostream>

#include <string>

#include <Math.h>

const short QUEEN= 9;

const short ROWS = 8;

const short COLUMNS = 8;

const short TRIED = 2;

short ChessBoard[8][8];

short NUM_OF_QUEEN=0;

//int newRow=0;

Position start;

using namespace std;

struct itrFields

{

int row,column,direction_x,direction_y;

};//itrFields

Position Application::generateInitialState()

{

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

{

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

{

ChessBoard[i][j]=0;

cout<<ChessBoard[i][j]

    <<" ";

if(j==7) cout<<endl;

}

}//初始化棋盘并输出整个棋盘

    const string START_PROMPT =

        "Please enter the start row and start column: ";

    int row,column;

cout<<"请输入第一个皇后的位置(纵坐标1~8，横坐标1~8)：";

cin>>row>>column;

    start.setPosition (row-1, column-1);

cout<<endl<<endl;

    return start;//获取并返回第一个皇后的位置

} // method generateInitialState

bool Application::valid (const Position& pos)

{

bool flag=true;

if(pos.getRow()+1>8||pos.getRow()+1<1||pos.getColumn()+1>8||

pos.getColumn()+1<1)

flag=false;

if(flag)

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

{

if(i==pos.getColumn()) continue;

if(ChessBoard[pos.getRow()][i]==9)  {flag=false;break;}

}//检查横行是否有皇后

if(flag)

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

{

if(j==pos.getRow()) continue;

if(ChessBoard[j][pos.getColumn()]==9) {flag=false;break;}

}//检查竖行是否有皇后

if(flag)

for(int r=0;r<8;r++)

{

for(int c=0;c<8;c++)

{

if(r==pos.getRow()&&c==pos.getColumn()) continue;

if(abs(r-pos.getRow())==abs(c-pos.getColumn()))

{

if(ChessBoard[r][c]==9) {flag=false;break;}

}

}

if(!flag) break;

}//检查左斜，右斜有没有皇后

// if(flag) newRow++;

return flag;

}

//标记皇后

void Application::record(const Position& pos)

{

ChessBoard[pos.getRow()][pos.getColumn()]=QUEEN;

NUM_OF_QUEEN++;

}

// 判断八个皇后是否已经都摆上

bool Application::done () const

{

// cout<<NUM_OF_QUEEN;

return NUM_OF_QUEEN==8;

}

void Application::undo(const Position& pos)

{

if(ChessBoard[pos.getRow()][pos.getColumn()]==9) 

    NUM_OF_QUEEN--;

ChessBoard[pos.getRow()][pos.getColumn()]=0;

}

ostream& operator<<(ostream& stream, Application& app)

{

cout<<endl;

for(int row=0;row<ROWS;row++)

{

for(int column=0;column<COLUMNS;column++)

cout<<ChessBoard[row][column]<<" ";

cout<<endl;

}//outfor

return stream;

}//operation <<

Application::Iterator::Iterator(const Position& pos)

{

itrFields* itrPtr=new itrFields;

itrPtr->row=pos.getRow();

itrPtr->column=pos.getColumn();

itrPtr->direction_x=pos.getRow();

itrPtr->direction_y=0;

fieldPtr=itrPtr;

}//constructor

Position Application::Iterator::operator ++(int)

{

itrFields* itrPtr=(itrFields*)fieldPtr;

int nextRow = itrPtr -> row,

        nextColumn = itrPtr -> column;

switch(itrPtr->direction_x)

{

case 0:nextRow=0;break;

case 1:nextRow=1;break;

case 2:nextRow=2;break;

case 3:nextRow=3;break;

case 4:nextRow=4;break;

case 5:nextRow=5;break;

case 6:nextRow=6;break;

case 7:nextRow=7;break;

}

    switch(itrPtr -> direction_y++)

{

case 0:nextColumn=0;break;

case 1:nextColumn=1;break;

case 2:nextColumn=2;break;

case 3:nextColumn=3;break;

case 4:nextColumn=4;break;

case 5:nextColumn=5;break;

case 6:nextColumn=6;break;

case 7:nextColumn=7;break;

}

//cout<<nextRow<<nextColumn<<" ";

Position next(nextRow+1,nextColumn);

return next;

}//operator++

bool Application::Iterator::atEnd()

{

if(((itrFields*)fieldPtr)->direction_x>7||

((itrFields*)fieldPtr)->direction_y>7)

     return true;

return false;

}

#include "Position.h"

Position::Position()

{

    row = 0;

    column = 0;

} // default constructor

Position::Position (int row, int column)

{

    this -> row = row;

    this -> column = column;

} // constructor

void Position::setPosition(int newRow,int newColumn)

{

this->row=newRow;

this->column=newColumn;

}

int Position::getRow() const

{

    return row;

} // method getRow()

int Position::getColumn() const

{

    return column;

} // method getColumn()

#include <iostream>

#include <string>

#include "BackTrack.h"

#include "Application.h"

#include "Position.h"

 

using namespace std;

int main()

{

    Application app;

BackTrack b(app);

cout<<"初始化棋盘：\n";

Position start=app.generateInitialState();

if(!app.valid(start))

cout<<"您的输入有误！"<<endl;

else

{

app.record(start);

if(app.done() || b.tryToSolve(start))

cout<<"八个皇后已经正确摆放！"<<endl<<app;

else

{

cout<<app<<endl;

app.undo(start);

cout<<"八个皇后没有正确摆放！"<<endl;

}

}

cout<<endl<<endl;

system("pause");

return 0;

}

#include "BackTrack.h"

BackTrack::BackTrack (const Application& app)

{

    this -> app = app;

} // constructor

bool BackTrack::tryToSolve (Position pos)

{

    bool success = false;

    Application::Iterator itr (pos);

    while (!success && !itr.atEnd())

    {

        pos = itr++;

        if (app.valid (pos))

        {

            app.record (pos);

            if (app.done ())

                success = true;

            else

            {

                success = tryToSolve (pos);

//if(!success) cout<<1;

if (!success)

{   

app.undo(pos); 

}

            } // not done

        }

    } // while

    return success;

} // method tryToSolve