八数码第一境界——暴力反向BFS+存状态

这题首先会遇到一个问题：BFS无法实施

为什么会无法实施？

正常情况，x从队列中取出，8、6入队

8从队列中取出，x和8交换，7、5入队

这个时候下一个要出队列的是6，但是你x在8原来的位置，怎么实施交换？

所以队列中应该入的是状态，可能很抽象，但是下面的图不抽象。

我们还是看6要出队列的时候的情况，就是第三行第一个。我们发现他可以出队列了。出队列，向左移动的一个情况以及向右移动的一个情况被添加到队列底端。

如何存这个队列？

采用结构体。

 struct node
 {
     string str;
     vector<int>res;
     int index;
 };
 mapint> mp;
 vector<int>res;

str一维数组，把二维数组降了一维。

vector用来存你历次的移动方向。

index用来存当前str中的x在哪个位置。

map用来判断当前这种状态我们是否已经走过了。

具体BFS的方法？

 while(!q.empty())
     {
         g=q.front();q.pop();
         if(g.str==ss)
         {
             res=g.res;
             return true;
         }
         h=g;
         if((h.index+1)%3!=0)
         {
             c=h.str[h.index];h.str[h.index]=h.str[h.index+1];h.str[h.index+1]=c;
             h.index++;
             h.res.push_back(4);
             if(mp[h.str]==0)
             {
                 mp[h.str]=true;
                 q.push(h);
             }
         }

第三行，出队列。

接下来的if判断，用来判断是否当前这个状态和我们要求的一样，如果是，那代表已经找到了，返回true。

h=g，把当前队首元素给h，因为当前的队首元素后面还要用，这里仅仅是代表了他右移的可能性。

接下来if判断，如果他不是最后一列，我们进入这个if，而且不用想在不是最后一列的情况下我们是可以右移的。

和右边的数交换。

x所在string中的位置增加一位。

4存入操作，4代表的是右移。

如果这种状态的键取出来的值是0，那就代表这种状态以前没走过，可以入队列，并且把这个状态设置为已走过。

完毕。

接下来几个方向也是几乎一样的操作。

全部代码

 char s[101];
 struct node
 {
     string str;
     vector<int>res;
     int index;
 };
 mapint> mp;
 vector<int>res;

 bool bfs(string ss)
 {
     char c;
     queue q;
     while(!q.empty())q.pop();
     node g,h;
     g.str="12345678x";g.res.clear();g.index=8;
     q.push(g);
     while(!q.empty())
     {
         g=q.front();q.pop();
         if(g.str==ss)
         {
             res=g.res;
             return true;
         }
         h=g;
         if((h.index+1)%3!=0)
         {
             c=h.str[h.index];h.str[h.index]=h.str[h.index+1];h.str[h.index+1]=c;
             h.index++;
             h.res.push_back(4);
             if(mp[h.str]==0)
             {
                 mp[h.str]=true;
                 q.push(h);
             }
         }
         h=g;
         if(h.index%3!=0)
         {
             c=h.str[h.index];h.str[h.index]=h.str[h.index-1];h.str[h.index-1]=c;
             h.index--;
             h.res.push_back(3);
             if(!mp[h.str])
             {
                 mp[h.str]=true;
                 q.push(h);
             }
         }
         h=g;
         if(h.index<6)
         {
             c=h.str[h.index];h.str[h.index]=h.str[h.index+3];h.str[h.index+3]=c;
             h.index+=3;
             h.res.push_back(2);
             if(!mp[h.str])
             {
                 mp[h.str]=true;
                 q.push(h);
             }
         }
         h=g;
         if(h.index>2)
         {
             c=h.str[h.index];h.str[h.index]=h.str[h.index-3];h.str[h.index-3]=c;
             h.index-=3;
             h.res.push_back(1);
             if(!mp[h.str])
             {
                 mp[h.str]=true;
                 q.push(h);
             }
         }
     }
     return false;
 }
 int main()
 {
     int i,j,k,kk,t,x,y,z;
     while(scanf("%s",s)!=EOF)
     {
         mp.clear();
         for(i=1;i<9;i++)
             scanf("%s",s+i);
         string ss(s);
         if(bfs(ss))
             for(i=res.size()-1;i>=0;i--)
             {
                 if(res[i]==1)printf("d");
                 if(res[i]==2)printf("u");
                 if(res[i]==3)printf("r");
                 if(res[i]==4)printf("l");
             }
         else
             printf("unsolvable");
         printf("\n");
     }
     return 0;
 }