A*算法解决八数码问题

#include <iostream>
#include <cstring>
#include <vector>
#include <cmath>
#include <conio.h>
#include <cstdlib>
#include <algorithm>
#include <windows.h>
using namespace std;

#define DIRECTION int

const char TEST_END = '0';
const int BOARDSIZE = 3;
const int TABLESIZE = 370000;
const int DIRECTION_SIZE = 4;
const int INIT_POS_IN_HASH = -1;
const int INIT_PARENT = -1;
const int INIT_START = -1;
const int INIT_G = 1;
const int G_GROW = 1;
const char BLANK = 'X';

enum VISITESTATE{ NOTFOUND, INOPEN, INCLOSE };
const int hashArr[9] = { 7, 17, 47, 117, 217, 977, 1299, 5971, 7779 };
const int dir_x[DIRECTION_SIZE] = { -1, 1, 0, 0 };
const int dir_y[DIRECTION_SIZE] = { 0, 0, -1, 1 }; //Up Down Left Right

struct position{

position(){}
position( int xx, int yy ):x( xx ), y( yy ){}

int x;
int y;

};

position finalPosition[BOARDSIZE * BOARDSIZE];

struct ChessBoard{

ChessBoard(){

visitState = NOTFOUND;
posInHashTable = INIT_POS_IN_HASH;

}

ChessBoard& operator = ( const ChessBoard& cb ){

for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){
this->ChessState[i][j] = cb.ChessState[i][j];
}
}

this->blankX = cb.blankX;
this->blankY = cb.blankY;
this->g = cb.g;
this->h = cb.h;
this->direction = cb.direction;
this->parent = cb.parent;
this->posInHashTable = cb.posInHashTable;

return *this;

}

friend bool operator < ( const ChessBoard& a, const ChessBoard& b ){
return ( a.g + a.h ) > ( b.g + b.h );
}

char ChessState[BOARDSIZE][BOARDSIZE];

VISITESTATE visitState;
int blankX;
int blankY;
int g;
int h;
int direction;
int posInHashTable;
int parent;

};

ChessBoard hashTable[TABLESIZE];

class AStarAlg{

public:

AStarAlg(){

finalState.ChessState = {
{ '1', '2', '3' },
{ '4', '5', '6' },
{ '7', '8', BLANK }
};

initChessBoard();

}

void initChessBoard();
void AStar();
void printPath( ChessBoard );
void showChessBoard( const ChessBoard& ) const;

const ChessBoard& getChessBoard( int index ){ return hashTable[index]; };
const ChessBoard& getInitalChessBoard(){ return initState; };

private:

bool isSolvable( const ChessBoard& );
bool getNextChessBoard( ChessBoard& nextState, const ChessBoard& parentState, const DIRECTION& );
int hashCal( ChessBoard& );
void setInOpen( ChessBoard& );
void updateOpen( const ChessBoard& );
bool isInOpen( const ChessBoard& ) const;
void setInClose( ChessBoard& );
bool isNotFound( const ChessBoard& ) const;
bool isInClose( const ChessBoard& ) const;
void calHeuristic( ChessBoard& );
void calG( ChessBoard& );
void calFun( ChessBoard& );
bool isEqual( const ChessBoard&, const ChessBoard& );

vector< ChessBoard >openTable;

ChessBoard initState;
ChessBoard finalState;

};

bool AStarAlg::isSolvable( const ChessBoard& cb ){

char* tempArr = new char[BOARDSIZE * BOARDSIZE + 1];
const int length = BOARDSIZE * BOARDSIZE;
int count = 0;
int countNum = 0;

for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){

if( initState.ChessState[i][j] == BLANK )
tempArr[count] = '9';
else
tempArr[count] = initState.ChessState[i][j];

count++;

}
}

for( int i = 0; i < length; ++i ){

const int base = tempArr[i] - '0';

for( int j = 0; j < i; ++j ){

const int cmp = tempArr[j] - '0';

if( cmp > base )
countNum++;

}
}

delete tempArr;

if( countNum % 2 != 0 )
return false;

return true;
}

void AStarAlg::setInOpen( ChessBoard& cb ){

cb.visitState = INOPEN;
hashTable[cb.posInHashTable].visitState = INOPEN;

openTable.push_back( cb );
push_heap( openTable.begin(), openTable.end() );

}

void AStarAlg::printPath( ChessBoard cb ){

if( cb.parent == INIT_PARENT ){

cout<<"Finsh."<<endl;
return;

}

vector< ChessBoard >path;

while( true ){

path.push_back( cb );
if( cb.parent == INIT_PARENT )
break;
cb = hashTable[cb.parent];

}

for( int i = path.size() - 1; i >= 0; --i ){
showChessBoard( path[i] );
}
}

void AStarAlg::updateOpen( const ChessBoard& cb ){

for( int i = 0; i < openTable.size(); ++i ){
if( isEqual( openTable[i], cb ) ){

openTable[i] = cb;
break;

}
}

make_heap( openTable.begin(), openTable.end() );

}

void AStarAlg::setInClose( ChessBoard& cb ){

hashTable[cb.posInHashTable].visitState = INCLOSE;
cb.visitState = INCLOSE;

}

bool AStarAlg::isInClose( const ChessBoard& cb ) const{
return ( hashTable[cb.posInHashTable].visitState == INCLOSE ) ? true : false;
}

bool AStarAlg::isInOpen( const ChessBoard& cb ) const{
return ( hashTable[cb.posInHashTable].visitState == INOPEN ) ? true : false;
}

bool AStarAlg::isNotFound( const ChessBoard& cb ) const{
return ( hashTable[cb.posInHashTable].visitState == NOTFOUND ) ? true : false;
}

void AStarAlg::calHeuristic( ChessBoard& cb ){

int h = 0;

for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){

int val = cb.ChessState[i][j] - '0';
int x = finalPosition[val - 1].x;
int y = finalPosition[val - 1].y;
h += abs( i - x ) + abs( j - y );

}
}

cb.h = h;

}

void AStarAlg::calG( ChessBoard& cb ){

if( cb.parent == INIT_PARENT )
cb.g = INIT_G;
else
cb.g = hashTable[cb.parent].g + G_GROW;

}

void AStarAlg::calFun( ChessBoard& cb ){

calHeuristic( cb );
calG( cb );

}

void AStarAlg::initChessBoard(){

string str;

cout << "Enter inital State : ";
getline( cin, str );

int count = 0;

for( int i = 0; i < str.length(); ++i ){
if( str[i] != ' ' ){

initState.ChessState[count / BOARDSIZE][count % BOARDSIZE] = str[i];

if( str[i] == 'x' ){

initState.ChessState[count / BOARDSIZE][count % BOARDSIZE] = BLANK;
initState.blankX = count / BOARDSIZE;
initState.blankY = count % BOARDSIZE;

}

++count;

}
}

initState.direction = INIT_START;
initState.parent = INIT_PARENT;
calFun( initState );
int pos = hashCal( initState );
openTable.push_back( initState );
make_heap( openTable.begin(), openTable.end() );

}

bool AStarAlg::isEqual( const ChessBoard& cbA, const ChessBoard& cbB ){

for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){
if( cbA.ChessState[i][j] != cbB.ChessState[i][j] )
return false;
}
}

return true;

}

int AStarAlg::hashCal( ChessBoard& cb ){

/* function： calculate the position of the state of chessboard in hashTable
if the state has been existing ( INOPEN , INCLOSE ) then return its position is hashTble
else set the state in hashTable and then return its position
PS: must after all operation ( my drawback ) */

int pos = 0;

for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){

int val = cb.ChessState[i][j] - '0';
pos += val * hashArr[ BOARDSIZE * i + j ];

}
}

pos = pos % TABLESIZE;

while( hashTable[pos].visitState != NOTFOUND ){

if( isEqual( hashTable[pos], cb ) ){

cb.posInHashTable = pos;

return pos;

}

pos = ( pos + 1 ) % TABLESIZE;

}

cb.posInHashTable = pos;
hashTable[pos] = cb;

return pos;

}

bool AStarAlg::getNextChessBoard( ChessBoard& tempNextState,
const ChessBoard& parentState,
const DIRECTION& dir ){
//Get temp next chess board blank_x and blank_y
int tempNextBlankX = parentState.blankX + dir_x[dir];
int tempNextBlankY = parentState.blankY + dir_y[dir];

if( tempNextBlankX < 0 || tempNextBlankX > BOARDSIZE - 1
|| tempNextBlankY < 0 || tempNextBlankY > BOARDSIZE - 1 )
return false;

tempNextState.blankX = tempNextBlankX;
tempNextState.blankY = tempNextBlankY;
tempNextState.direction = dir;

//Get temp next chess board state
for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){
tempNextState.ChessState[i][j] = parentState.ChessState[i][j];
}
}

char change = tempNextState.ChessState[tempNextState.blankX][tempNextState.blankY];
tempNextState.ChessState[parentState.blankX][parentState.blankY] = change;
tempNextState.ChessState[tempNextState.blankX][tempNextState.blankY] = BLANK;

//Get temp next chess board parent position
tempNextState.parent = parentState.posInHashTable;

//Get temp next chess board g and h, its parent state has got
calFun( tempNextState );

//Hash Cal
hashCal( tempNextState );

return true;

}

void AStarAlg::AStar(){

char c;

while( !openTable.empty() ){

pop_heap( openTable.begin(), openTable.end() );
ChessBoard parent = openTable.back();

if( !isSolvable( parent ) ){

cout<<"unsolvable"<<endl;

return;

}

openTable.erase( openTable.end() - 1 );
setInClose( parent );

if( isEqual( parent, finalState ) ){

printPath( parent );

return;

}

for( int i = 0; i < DIRECTION_SIZE; ++i ){

ChessBoard tempNextState;

if( !getNextChessBoard( tempNextState, parent, i ) )
continue;

if( isNotFound( tempNextState ) ){

setInOpen( tempNextState );

continue;

}

if( isInOpen( tempNextState ) ){

int f = tempNextState.g + tempNextState.h;

if( f < hashTable[tempNextState.posInHashTable].g + hashTable[tempNextState.posInHashTable].h ){

hashTable[tempNextState.posInHashTable] = tempNextState;
updateOpen( tempNextState );

continue;
}
}

if( isInClose( tempNextState ) ){

int f = tempNextState.g + tempNextState.h;

if( f < hashTable[tempNextState.posInHashTable].g + hashTable[tempNextState.posInHashTable].h ){

hashTable[tempNextState.posInHashTable] = tempNextState;
setInOpen( tempNextState );

continue;
}
}
}
}

cout << "unsolveable" << endl;

}

void AStarAlg::showChessBoard( const ChessBoard& cb ) const{

cout << endl;
cout << "<<<<<<<<<<<<<<<<<<<<<< Pandora >>>>>>>>>>>>>>>>>>>>>" << endl;
cout << "ChessBoard State : " << endl;

for( int i = 0; i < BOARDSIZE; ++i ){

for( int j = 0; j < BOARDSIZE; ++j )
cout<<cb.ChessState[i][j]<<" ";

cout<<endl;

}

cout << "Blank_X : " << cb.blankX << " " << "Blank_Y : " << cb.blankY << endl;
cout << "Position is HashTable : " << cb.posInHashTable << endl;
cout << "Parent : " << cb.parent << endl;
cout << "G : " << cb.g << " " << "H : " << cb.h << " " << "F : " << cb.h + cb.g << endl;

switch( cb.visitState ){

case NOTFOUND:{

cout << "Now my state : Not be found." << endl;
break;

}
case INOPEN:{

cout << "Now my state : In open table." << endl;
break;

}
case INCLOSE:{

cout << "Now my state : In close" << endl;
break;

}
default:{

cout << "Error state!" << endl;
break;

}
}

cout << "<<<<<<<<<<<<<<<<<<<<<< Pandora >>>>>>>>>>>>>>>>>>>>>" << '\n\n';
}

void preWork(){

int count = 0;

for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){

position temp;
temp.x = i;
temp.y = j;
finalPosition[count] = temp;
count++;

}
}
}

int main(){

AStarAlg a;

preWork();
a.AStar();

return 0;

}