AI_八数码

#include<stdio.h>
typedef struct  
{
    int parent;
    int index;    
    int Grid[9];
    int H;//启发函数值
}State;
State S,T;//起始态，目标态
State OPEN[2000];//队列-----考察已考察过的状态
State CLOSE[2000];//--------存储待考察的状态
int OPhead=0,OPtail=0,openlen=2000;
int CLhead=0,CLtail=0,closelen=2000;

void readdata();
void init();
int search();
int Evaluate(State s);
void addtoopen(State v);//将节点v加入队列
State takeoutofopen();//从OPEN表中取队头数据
void addtoclose(State v);
State Swap(State v,int Epindex,int Nindex);

int main()
{   
   readdata();
   int flag=search();
   if(flag==1)//找到了,输出CLOSE表中的考察过的状态
       for(int i=CLhead;i<CLtail;i++)
       {  
           printf("第%d个状态 ",i);
           for(int j=0;j<9;j++)
               printf(" %d",CLOSE[i].Grid[j]);
           printf("\n");
       }
   return 0;
}

int search()
{
    State u,v;    
    while(OPhead != OPtail)
    {
       int Epindex,Nindex;
       u = takeoutofopen();//从队列头取数据 
       for(int i=0;i<9;i++)
            v.Grid[i]=u.Grid[i];//子节点v复制父节点u的状态
       for(int k=0;k<9;k++)
          if(u.Grid[k]==0)
             Epindex=k;  //记录父节点u空格位所在的位置
       v.parent =u.index ;
       v.index =u.index+1;  


       //四个方向搜索----暂时不考虑去除父节点的
       //空格向上移
       Nindex=(Epindex/3-1)*3+Epindex%3;//计算待移动的数据所在的位置
       if(Epindex/3-1>=0)
       {   
           v=Swap(v,Epindex,Nindex);
           v.H=Evaluate(v);
           if(v.H==0) return 1;
           addtoopen(v);//将当前状态节点加入到OPEN表
       }
       //空格向下移
       Nindex=(Epindex/3+1)*3+Epindex%3;
       if(Epindex/3+1<3)
       {    
           v=Swap(v,Epindex,Nindex);
           v.H=Evaluate(v);
           if(v.H==0) return 1;
           addtoopen(v);
       }
       //空格向左移
       Nindex=Epindex/3*3+(Epindex%3-1);
       if(Epindex%3-1>=0)
       {
           v=Swap(v,Epindex,Nindex);
           v.H=Evaluate(v);
           if(v.H==0) return 1;
           addtoopen(v);
       }
       //空格向右移
       Nindex=Epindex/3*3+(Epindex%3+1);
       if(Epindex%3+1<3)
       {
           v=Swap(v,Epindex,Nindex);
           v.H=Evaluate(v);
           if(v.H==0) return 1;
           addtoopen(v);
       }
       //按启发函数值对OPEN表中的元素进行排序----降序
       for(int ii=OPhead;ii<OPtail;ii++)
       {
           int kk=ii;
           for(int jj=ii;jj<OPtail;jj++)
               if(OPEN[jj].H>OPEN[kk].H) 
                  kk=jj;               
           State temp=OPEN[ii];
           OPEN[ii]=OPEN[kk];
           OPEN[kk]=temp;
       }      
       //将u加入CLOSE表
      addtoclose(v);
    }
    return 0;
}

State Swap(State v,int Epindex,int Nindex)
{
    int temp=v.Grid[Epindex];
    v.Grid[Epindex]=v.Grid[Nindex];
    v.Grid[Nindex]=temp;
    return v;
}
State takeoutofopen()//从队列头取节点数据
{
    State v;
    v=OPEN[OPhead++];
    OPhead=OPhead%openlen;
    return v;
}
void addtoopen(State v)
{
    OPEN[OPtail++]=v;    
    OPtail = OPtail%openlen;
    //走过的点状态记为1
}
void addtoclose(State v)
{
    CLOSE[CLtail++]=v;    
    CLtail = CLtail%closelen;
    //走过的点状态记为1
}
int Evaluate(State s)//启发式函数
{
   int count=0;//数列逆序值
   for(int i=0;i<9;i++)
   {   
       for(int j=0;j<i;j++)
           if(s.Grid[j]>s.Grid[i])
               count++;
   }
   return count;//返回逆序值
}
void readdata()
{
    //起始态输入
    S.index=0;
    S.parent=-1;
    S.Grid[0]=2;
    S.Grid[1]=8;
    S.Grid[2]=3;
    S.Grid[3]=1;
    S.Grid[4]=6;
    S.Grid[5]=4;
    S.Grid[6]=7;
    S.Grid[7]=0;//
    S.Grid[8]=5;

    //for(int i=0;i<9;i++)
        //scanf(" %d",&S.Grid[i]);//&???
    S.H=Evaluate(S); 
    //目标态输入
    ////////////////     
    addtoopen(S);
}