八数码宽度优先搜索

/*程序利用C++程序设计语言，在VC6.0下采用宽度优先的搜索方式，

成功的解决了八数码问题。程序中把OPEN表和CLOSED表用队列的方式存储，

大大地提高了效率，开始的时候要输入目标状态和起始状态，由于在宽度优先搜索的情况下，搜索过程中所走过的状态是不确定且很庞大的，所以程序

最后输出宽度优先情况下最少步数的搜索过程以及程序运行所需要的时间*/

#include "iostream"

#include "stdio.h"

#include "stdlib.h"

#include "time.h"

#include "string.h"

#include

#include

using namespace std;

constint N = 3;//3*3图

enum Direction{None,Up,Down,Left,Right};//方向

staticint n=0;

staticint c=0;

struct Map//图

{

int cell[N][N];//数码数组

Direction BelockDirec;//所屏蔽方向

struct Map * Parent;//父节点

};

//打印图

voidPrintMap(struct Map *map)

{

cout<<"*************************************************"<

for(int i=0;i

{

for(int j=0;j

{

cout<cell[i][j]<<" ";

}

cout<

}

cout<<"*************************************************"<

}

//移动图

struct Map * MoveMap(struct Map * map,DirectionDirect,boolCreateNewMap)

{

struct Map * NewMap;

//获取空闲格位置inti,j;

for(i = 0; i < N; i++)

{ boolHasGetBlankCell = false; for(j = 0; j < N; j++)

{

if(map->cell[i][j] == 0)

{ HasGetBlankCell = true; break;

}

}

if(HasGetBlankCell) break;

}

//移动数字

intt_i = i,t_j = j; boolAbleMove = true; switch(Direct)

{

case Down:

t_i++;

if(t_i>= N)

AbleMove=false;

break;

case Up:

t_i--;

if(t_i< 0)

AbleMove=false;

break;

case Left:

t_j--;

if(t_j< 0)

AbleMove=false;

break;

case Right:

t_j++;

if(t_j>= N)

AbleMove=false;

break;

};

if(!AbleMove)//不可以移动则返回原节点

{

return map;

}

if(CreateNewMap)

{

NewMap = new Map();

for(int x = 0; x < N; x++)

for(int y = 0; y < N; y++)

NewMap->cell[x][y] = map->cell[x][y];

}

else

NewMap = map;

NewMap->cell[i][j] = NewMap->cell[t_i][t_j];

NewMap->cell[t_i][t_j] = 0;

returnNewMap;

}

boolIsSuccess(struct Map * map,struct Map * Target)

{

boolIsSuc = true;

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

{

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

{

if(map->cell[i][j] != Target->cell[i][j])

{

IsSuc = false;

break;

}

}

if(!IsSuc)

break;

}

returnIsSuc;

}

struct Map * BNF_Search(struct Map * begin,struct Map * Target) {

struct Map * p1, *p2, *p=NULL;

boolIsSucc = false;

queue Queue;

if(IsSuccess(begin,Target))

return begin;

Queue.push(begin);

do

{

p1 = Queue.front();

Queue.pop();

for (int i = 1; i <= 4; i++)

{

Direction Direct=(Direction)i;

if(Direct == p1->BelockDirec)//跳过屏蔽方向continue;

p2 = MoveMap(p1,Direct,true);

if(p2 != p1) //数码是否可以移动

{

p2->Parent = p1;

switch(Direct)//设置屏蔽方向,防止往回推

{

case Up:

p2->BelockDirec = Down;

break;

case Down:

p2->BelockDirec = Up;

break;

case Left:

p2->BelockDirec = Right;

break;

case Right:

p2->BelockDirec = Left;

break;

}

if (IsSuccess(p2,Target))

{

p = p2;

return p;

}

Queue.push(p2);

n++;

}

}

}

while(!Queue.empty() || p == NULL);

return p;

}

intJou(struct Map *map) //将八数码转换成一个数列，并计算其逆序数{

int a=0;

char b[9];

for(int i=0;i

{

for(int j=0;j

b[i*3+j]=map->cell[i][j];

}

for(int k=0;k<9;k++)

{

for(int h=0;h

{

if((b[h]

a++;

}

}

return a%2;

}

int main()

{

int a1,a2;

inti,j,m,n;

int target[9];

int flag;

Map Target;

Map *begin,*T;

begin=new Map;

cout<<"请输入八数码的目标状态(用0代替空格):"<

//输入目标状态

for (i=0;i<9;i++) //此for循环用来把输入的数存入到target数组中{

flag=0;

cin>>target[i];

for(j=0;j

if(target[i]==target[j])

flag=1;

if (target[i]<0||target[i]>8||flag==1) //判断输入是否正确

{

i--;

cout<<"输入错误，请关闭重新运行!\n";

}

}

int k=0;

for (m=0;m<3;m++) //把数组target中的数传给图Target {

for (n=0;n<3;n++)

{

Target.cell[m][n]=target[k];

k++;

}

}

//输入起始状态

cout<<"请输入八数码的起始状态(用0代替空格):"<

for (i=0;i<9;i++)

{

flag=0;

cin>>target[i];

for(j=0;j

if(target[i]==target[j]) //判断输入的数是否正确

flag=1;

if (target[i]<0||target[i]>8||flag==1)

{

i--;

cout<<"输入错误，请关闭重新运行!\n";

}

}

k=0;

for (m=0;m<3;m++)

{

for (n=0;n<3;n++)

{

begin->cell[m][n]=target[k];

k++;

}

}

begin->Parent = NULL;

begin->BelockDirec = None;

cout<<"目标图:"<

PrintMap(&Target);

cout<<"起始图:"<

PrintMap(begin);

a1=Jou(&Target);

a2=Jou(begin);

if(a1!=a2)

{

cout<<"无解"<

exit(0); //无解的话就退出，重新运行

}

else

{

double start=clock();

cout<<"有解"<

//图搜索

T=BNF_Search(begin,&Target);

//打印

if(T != NULL)

{

//把路径倒序

Map *p=T;

stack

while(p->Parent != NULL)

{

Stack1.push(p);

p = p->Parent;

}

cout<<"宽度优先最少步数的搜索过程为:"<

while(!Stack1.empty())

{

PrintMap(Stack1.top());

c++;

Stack1.pop();

}

cout<<"\n完成!"<

cout<<"找到目标状态所需要的最少步数为:"<

double end=clock();

cout<<"程序运行的时间为:"<

}

}

return 0;

}