八数码问题-A*算法

//我也不知道算不算是A*算法，所以暂且叫近似A*算法，

 

// astar.cpp : 定义控制台应用程序的入口点。
//
#include "stdafx.h"
#include <iostream>
#include <string>
#include <vector>
#include <queue>
#include <stack>

using namespace std;

#define DOTNUM 3
#define HASHSIZE 10
#define STATENUM 500

enum direction{U,D,L,R};//移动方向

typedef struct stateNode  //状态结构
{
 int state[DOTNUM][DOTNUM];//用二维数组记录布局情况
 // string str;//用一个字符串记录当前布局状态
 int notInTargetPlace[HASHSIZE];//不在目标位置的结点
 // int curDiffNum;//当前布局状态下，与目标位置不同的数字结点个数,不算空格
 int blankPlace;//空格的位置，即数字0的位置
 struct stateNode* preSN;//指向前一个状态
 // int preDot;//记录上一次与空格交换的数字位置
}stateNode;
vector<stateNode*> pastState;//已尝试的状态
queue<stateNode*> tryState;//将要尝试的状态
int judgeReversedOrderNum(stateNode const& curState)  //判断逆序数
{
 int i,j,sum=0;
 for(i=0;i<DOTNUM*DOTNUM;++i)
  for(j=i+1;j<DOTNUM*DOTNUM;++j)
  {
   if(curState.state[j/DOTNUM][j%DOTNUM]<curState.state[i/DOTNUM][i%DOTNUM])sum++;
  }
  return sum;
}
int calNotInTargetPlace(stateNode& curState,const stateNode& targetState,int modFlag=0)  //计算当前状态下与目标状态位置不同的数字结点的个数，不算空格（即0）在内
{
 int i,sum=0;
 if(modFlag==1)for(int i=0;i<HASHSIZE;i++)curState.notInTargetPlace[i]=0;
 for(i=0;i<DOTNUM*DOTNUM;i++)
 {
  if((curState.state[i/DOTNUM][i%DOTNUM]!=targetState.state[i/DOTNUM][i%DOTNUM])&&(curState.state[i/DOTNUM][i%DOTNUM]!=0))
  {
   if(modFlag==1)curState.notInTargetPlace[curState.state[i/DOTNUM][i%DOTNUM]]=1;//若不在目标位置上，则在notInTargetPlace数组中此数字结点对应位置

   置1，这样方便查找
    sum++;
  }
 }
 //if(modFlag==1)curState.curDiffNum=sum;
 return sum;
}
void judgeIfJoinQueue(stateNode ** attempt,stateNode& sn,int i,int j,direction dr)
{
 if(sn.notInTargetPlace[sn.state[i][j]]==1)//如果空白结点的上方结点不在目标位置
 {
  *attempt=(stateNode*)malloc(sizeof(stateNode));
  **attempt=sn;
  int bp=sn.blankPlace; 

  int temp=(**attempt).state[i][j];//临时制作一个空白结点与欲交换结点交换后的状态
  (**attempt).state[i][j]=(**attempt).state[bp/DOTNUM][bp%DOTNUM];
  (**attempt).state[bp/DOTNUM][bp%DOTNUM]=temp;
  vector<stateNode*>::iterator iter;
  for(iter=pastState.begin();iter!=pastState.end();iter++)//临时状态是否与已尝试过的状态都不同
  {

   if(calNotInTargetPlace(**attempt,**iter)==0)break;
  }
  if(iter==pastState.end())//未尝试过的状态入tryState队列
  {
   if(dr==U)(**attempt).blankPlace-=DOTNUM;
   else if(dr==D)(**attempt).blankPlace+=DOTNUM;
   else if(dr==L)(**attempt).blankPlace-=1;
   else if(dr==R)(**attempt).blankPlace+=1;
   // attempt.preDot=
   (**attempt).preSN=&sn;//指向前一个状态
   tryState.push(*attempt);//入tryState队列
  }
 }
}

int _tmain(int argc, _TCHAR* argv[])
{
 while(1)
 {
  int i=0,input,blankplace;

  printf("请输入起始状态，%d * %d =%d 个数字，空格隔开，从上到下，左到右，0表示空白格子\n",DOTNUM,DOTNUM,DOTNUM*DOTNUM); 
  stateNode *start=(stateNode*)malloc(sizeof(stateNode));
  stack<stateNode*> ssn;
  //start->state[0][0]=2;start->state[0][1]=8;start->state[0][2]=3;
  //start->state[1][0]=1;start->state[1][1]=6;start->state[1][2]=4;
  //start->state[2][0]=7;start->state[2][1]=0;start->state[2][2]=5;
  //start->blankPlace=7;

  while(i<DOTNUM*DOTNUM)
  {
   scanf("%d",&input);
   start->state[i/DOTNUM][i%DOTNUM]=input;
   if(input==0)start->blankPlace=i;
   ++i;
  }
  start->preSN=NULL;//前一个状态

  printf("\n你输入的起始状态如下");
  for(i=0;i<DOTNUM*DOTNUM;++i)
  {
   if(i%DOTNUM==0)cout<<endl;
   if(start->state[i/DOTNUM][i%DOTNUM]==0)cout<<" ";
   else cout<<start->state[i/DOTNUM][i%DOTNUM];
   cout<<" ";
  }
  cout<<endl;

  printf("请输入目标状态，%d * %d =%d 个数字，空格隔开，从上到下，左到右，0表示空白格子\n",DOTNUM,DOTNUM,DOTNUM*DOTNUM);
  stateNode* target=(stateNode*)malloc(sizeof(stateNode));
  i=0;
  /*
  target->state[0][0]=1;target->state[0][1]=2;target->state[0][2]=3;
  target->state[1][0]=8;target->state[1][1]=0;target->state[1][2]=4;
  target->state[2][0]=7;target->state[2][1]=6;target->state[2][2]=5;
  */
  while(i<DOTNUM*DOTNUM)
  {
   scanf("%d",&input);
   target->state[i/DOTNUM][i%DOTNUM]=input;
   ++i;
  }
  printf("\n你输入的目标状态如下");
  for(i=0;i<DOTNUM*DOTNUM;++i)
  {
   if(i%DOTNUM==0)cout<<endl;
   if(target->state[i/DOTNUM][i%DOTNUM]==0)cout<<" ";
   else cout<<target->state[i/DOTNUM][i%DOTNUM];
   cout<<" ";
  }
  cout<<endl;

  int testInput[HASHSIZE]={0};   
  for(int m=0;m<DOTNUM;m++)
   for(int n=0;n<DOTNUM;n++)  
   {
    testInput[start->state[m][n]]++;
    testInput[target->state[m][n]]++;
   }
   for(int k=0;k<DOTNUM*DOTNUM;++k)if(testInput[k]!=2)//简单判断输入是否有错
   {
    printf("input error");
    return;
   }

 

   //if(judgeReversedOrderNum(*start)&0x1!=judgeReversedOrderNum(*target)&0x1)//判断是否有解
   //{
   // cout<<"起始状态无法到达目标状态!";
   // goto nd;
   //}  

   tryState.push(start);

   stateNode* sn;
   while(!tryState.empty())
   {
    sn=tryState.front();  
    tryState.pop();
    if(calNotInTargetPlace(*sn,*target,1)==0)break;//计算当前状态与目标状态的差距  
    pastState.push_back(sn);//已尝试的状态进入pastState数组 
    int bp=sn->blankPlace; 
    stateNode *attempt;
    int uf=0,df=0,lf=0,rf=0;
    bool ifNodeEnterTryState=0;
    if(bp/DOTNUM-1>=0)      //如果空白结点的上方结点存在  
    {
     uf=sn->notInTargetPlace[sn->state[bp/DOTNUM-1][bp%DOTNUM]]; 
     if(uf==1)//如果空白结点的上方结点不在目标位置
      ifNodeEnterTryState=judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM-1,bp%DOTNUM,U); 
    }
    if(bp/DOTNUM+1<DOTNUM)  //如果空白结点的下方结点存在
    {
     df=sn->notInTargetPlace[sn->state[bp/DOTNUM+1][bp%DOTNUM]];
     if(df==1)//如果空白结点的下方结点不在目标位置
      ifNodeEnterTryState=judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM+1,bp%DOTNUM,D);
    }
    if(bp%DOTNUM-1>=0)      //如果空白结点的左边结点存在
    {
     lf=sn->notInTargetPlace[sn->state[bp/DOTNUM][bp%DOTNUM-1]];
     if(lf==1)//如果空白结点的左边结点不在目标位置
      ifNodeEnterTryState=judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM,bp%DOTNUM-1,L);
    }
    if(bp%DOTNUM+1<DOTNUM)  //如果空白结点的右边结点存在
    {
     rf=sn->notInTargetPlace[sn->state[bp/DOTNUM][bp%DOTNUM+1]];
     if(rf==1)//如果空白结点的右边结点不在目标位置
      ifNodeEnterTryState=judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM,bp%DOTNUM+1,R); 
    }
    if(ifNodeEnterTryState==false)
    {
     if(bp/DOTNUM-1>=0)judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM-1,bp%DOTNUM,U);      
     if(bp/DOTNUM+1<DOTNUM) judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM+1,bp%DOTNUM,D);
     if(bp%DOTNUM-1>=0)judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM,bp%DOTNUM-1,L);
     if(bp%DOTNUM+1<DOTNUM)judgeIfJoinQueue(&attempt,*pastState.back(),bp/DOTNUM,bp%DOTNUM+1,R);
    }
   }
   pastState.push_back(sn);//已尝试的状态进入pastState数组 

   if(tryState.empty()&&(calNotInTargetPlace(*sn,*target,1)!=0))
   {
    cout<<"失败！"<<endl;
    goto nd;//return -1;
   }

   stateNode *s=pastState.back();

   printf("\n移动步骤如下\n");

   while(s!=NULL){ssn.push(s);s=s->preSN;}
   int k=1;
   while(!ssn.empty())
   {
    cout<<"步骤"<<k++<<endl;
    s=ssn.top();ssn.pop();
    for(i=0;i<DOTNUM*DOTNUM;++i)
    {
     if(i%DOTNUM==0)cout<<endl;
     if(s->state[i/DOTNUM][i%DOTNUM]==0)cout<<" ";
     else cout<<s->state[i/DOTNUM][i%DOTNUM];
     cout<<" ";
    }
    cout<<endl<<endl;
    //s=s->preSN;

   }
nd:
   cout<<"over\n";
   // while(1);
 }
 return 0;
}