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;
}
//Manhattan distance (state : AC)
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 ){ // caution : == =
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(){
cout<<"Enter inital State : ";
string str;
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() );
}
//is equal with each other ( state : AC )
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;
}
// 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 AStarAlg::hashCal( ChessBoard& cb ){
int pos = 0;
for( int i = 0; i < BOARDSIZE; ++i ){
for( int j = 0; j < BOARDSIZE; ++j ){
//'x'
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;
}
//Just get next chess board state from its parent state ( state : AC )
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 );
// showChessBoard( parent );
//c = getch();
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;
}
//Show information of chess board ( State : AC )
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 >>>>>>>>>>>>>>>>>>>>>"<<endl;
cout<<endl;
}
//Get the fianl chess board state ( State : AC )
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(){
preWork();
AStarAlg a;
a.AStar();
return 0;
}