A*算法解决八数码问题（C++版本）

八数码问题定义：

八数码问题也称为九宫问题。在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。

A*算法的通用伪代码 ：

A*算法解决八数码问题的关键之处：

关键之处：

要维护两个结构：

open表，存放将要拓展的节点。

close表，存放已经拓展过的节点。

每次从open表中选择F值(f = g + h)最小的点进行拓展，对于拓展出的新节点要，如果已经访问过且此时F值比以前访问时更优时，要更新close表，并将此节点重新插入到open表中。

实现源代码：

#include <iostream>
#include <fstream>
#include <vector>
#include <cmath>
#include <list>
//#include "process.cpp";
#define SIZE 3//棋盘的大小 size*size

using namespace std;

/**
*定义方案节点
*/
typedef struct Node
{
vector<int> board;
int rc;
int h;
int g;
int parent;//在close中指示父亲节点的下表

}pNode;

int x_axis[] = {-1,  0, 0, 1};
int y_axis[] = { 0, -1, 1, 0};

/**
*输出方案
*/
void print(vector<int> board, int rc)
{
cout<<"当前方案为："<<endl;
for(int i = 0; i < rc; ++i)
{
for(int j = 0; j < rc; ++j)
{
cout<<board[i*rc+j]<<' ';
}
cout<<endl;
}
//cout<<"当前方案的F值为："<<endl;
//cout<<board[board.size()-1]<<endl;

return ;
}

/**
*将遍历到的当前节点输出到文本文件中
*/
void out_data(pNode &node)
{
int s = node.rc;
ofstream outdata("rt.txt",ios::app);

outdata<<"第"<<node.parent<<"层数据"<<endl;
for(int i = 0; i < s; i++) {
for(int j = 0; j < s; j++) {
outdata<<node.board[i*s+j]<<" ";
}
outdata<<endl;
}
outdata<<"h值："<<node.h<<endl;

outdata.flush();
outdata.close();
return ;
}
/*
*判断棋盘是否有序
*
*@param vector<int> board
*@return bool是否有序
*/
bool is_ordered(vector<int> board)
{
for(int i = 0; i < board.size(); ++i)
{
if(board[i] != i)
{
return false;
}
}
return true;
}

/**
*定义heuristic函数 探索函数
*
*@param vector<int> board , int rc 表示解决方案是rc*rc的 r&c
*@return int value of heuristic
*/
int heuristics(vector<int> board,int rc)
{
//表示元素的正确位置
int gx = 0;
int gy = 0;

//表示Manhattan block distance
int distance = 0;

for(int i = 0; i < rc*rc; ++i)
{
int nx = i / rc;
int ny = i % rc;

gx = board[i] / rc;
gy = board[i] % rc;

distance += abs(nx - gx) + abs(ny-gy);
}
return distance;
}

/**
*same_plan()判断两个vector<int> 是否相等
*即判断两个方案是否相等
*
*@param vector<int> board1, vector<int> board2
*@return bool
*/
bool same_plan(vector<int> board1, vector<int> board2)
{
//首先判断数组的长度是否相等
if(board1.size() != board2.size())
{
return false;
}

//判断每一个元素是否对应相等
for(int i = 0; i < board1.size(); ++i)
{
if(board1[i] != board2[i])
{
return false;
}
}
//所有元素都比较完毕以后
return true;
}

/**
*In_open()函数，判断一个节点是否在open表中
*
*@param pNode, list<pNode> open
*@return bool true--在ope表中， false--不再open表中
*/
bool in_open(pNode plan, list<pNode> &open)
{
//遍历整个open表，使用迭代器
for(list<pNode>::iterator it = open.begin(); it != open.end(); it++)
{
if(same_plan(plan.board, (*it).board))
{
return true;
}
}
return false;
}

/**
*in_close()函数，判断一个节点是否在close表中
*
*@param pNode, vector<pNode> close
*@return bool true 在close表中 false不再表中
*/
bool in_close(pNode plan, vector<pNode> &close)
{
//遍历每一个节点
for(int i = 0; i < close.size(); i++)
{
if(same_plan(plan.board, close[i].board))
{
return true;
}
}
//都遍历完毕以后依然没有找到
return false;
}

/**
*insert_close()函数 将正在访问的节点添加到close表中
*
*@param pNode, vector<pNode &close
*@return int position ,节点在close表中的索引
*/
int insert_close(pNode plan, vector<pNode>& close)
{
close.push_back(plan);

return close.size()-1;
}

/**
*insert_open()函数 将新生成的plan添加到fringe上去
*
*@param pNode plan, list<pNode> fringe
*@return  fringe
*/
bool insert_open(pNode plan, list<pNode>& open)
{
//先取得当前方案的f-value值 = h + g;
int f = plan.h + plan.g;
//int h = plan.h;

//遍历fringe,查看此方案是否已在队列中
for(list<pNode>::iterator it = open.begin(); it != open.end(); it++)
{
//if(h < ((*it).f + (*it).g))
if(f < ((*it).h+(*it).g))
{
//cout<<"进行插入"<<endl;
open.insert(it, plan);

return true;
}
}
//当走到这时，说明这个plan的fvalue是最大的
open.push_back(plan);

return true;
}

/**
*generate函数：生成新的解决方案
*
*@param vector<int> board, list<board> l, int rc边的长度;
*/
void generate(list<pNode>& open, vector<pNode> &close)
{
//取得h值最小的元素
pNode plan = open.front();

//将取得的节点从open包中删除
open.pop_front();

//将当前方案添加到close表中
int pos = insert_close(plan, close);
//数据是3*3的
int rc = plan.rc;

//寻找0的位置
int px;
int py;

for(int i = 0; i < rc*rc; ++i)
{
if(plan.board[i] == 0)
{
px = i / rc;
py = i % rc;
}
}
//想四个方向拓展，首先得判断能否拓展
for(int i = 0; i < 4; i++)
{
if(px+x_axis[i] >= 0 && px+x_axis[i] < rc &&
py+y_axis[i] >= 0 && py+y_axis[i] < rc)
{
//生成一个新的节点
pNode new_plan = plan;
new_plan.board[px*rc+py] =
new_plan.board[(px+x_axis[i])*rc+(py+y_axis[i])];
new_plan.board[(px+x_axis[i])*rc+(py+y_axis[i])] = 0;

new_plan.h = heuristics(new_plan.board, new_plan.rc);
new_plan.g = plan.g+1;//g表示层数
new_plan.parent = pos;//记录新生成节点的父节点

if(in_open(new_plan, open))//如果新生成的节点在open表中
{
for(list<pNode>::iterator it = open.begin(); it != open.end(); it++)
{
if(same_plan(new_plan.board, (*it).board))
{
if((new_plan.h+new_plan.g) > ((*it).h+(*it).g))
{
//open.erase(it);
break;
}
else
{
//删除
open.erase(it);
break;
}
}
//找该节点应该插入的位置
bool inserted = false;
if(!inserted && (new_plan.h+new_plan.g) < ((*it).h+(*it).g))
{
inserted = true;
open.insert(it, new_plan);
}
}
}
else if(in_close(new_plan, close))
{
for(int i = 0; i < close.size(); i++)
{
if(same_plan(new_plan.board, close[i].board) &&
((new_plan.h+new_plan.g)<(close[i].h+close[i].g)))
{
close[i].h = new_plan.h;
close[i].g = new_plan.g;
//将这个重新赋值的节点插入到open表中
insert_open(new_plan, open);
break;
}
}
}
else
{
insert_open(new_plan, open);
}
}
}
return ;
}

/**
*void get_path()函数，根据当前符合目标状态的节点在close表中回溯，
* 从而获得从起点到达目标终点的路径
*
*@param pNode, vector<pNode> close
*@return null
*/
void get_path(pNode plan, vector<pNode> &close, int plen)
{
if(plan.parent == -1)
{
print(plan.board, plan.rc);

cout<<"路径长度为："<<plen++<<endl;
return;//递归出口，表示回溯到起点
}
//输出当前节点
print(plan.board, plan.rc);

return get_path(close[plan.parent], close, ++plen);
}

int main(int argc, char *argv[])
{
//构造输入
pNode plan;

//生成初始状态
ifstream data_in("input.txt");
char digit;

while(data_in.get(digit))
{
if(digit >= '0' && digit <= '9')
{
int num = digit - '0';
//cout<<digit;
plan.board.push_back(num);
}
}

plan.rc = 3;
plan.g = 1;
plan.parent = -1; //标识起点

plan.h = heuristics(plan.board, plan.rc);

//生成open表，并将起点添加到表中
list<pNode> open;
open.push_back(plan);

//生成close表
vector<pNode> close;

while(!open.empty())
{
//print(open.front().board, 3);
out_data(open.front());
//判断当前节点是否满足目标状态
if(is_ordered(open.front().board))
{
cout<<"************************"<<endl;
cout<<"*******查找完成*********"<<endl;
cout<<"************************"<<endl;
get_path(open.front(), close, 0);
break;
}
//产生新的方案
generate(open, close);
}
//cout<<close.size()<<endl;
return 0;
}

测试用例

[1 6 4 8 7 0 3 2 5]的输入可以得到21步的最优解。