H - Eight

#include<iostream>
#include<cstring>
#include<cstdio>
#include<algorithm>
#include<unordered_map>//用于哈希操作
#include<queue>

#define x first
#define y second

#define outt  cout<<t<<endl;
#define debug cout<<"这里没问题！"<<endl;
#define outkk  cout<<"kk "<<kk<<endl;

using namespace std;

typedef pair<char,string>PII;

//apre记录从起来出来的路径和转化方式
unordered_map<string,PII>apre,bpre;

//da 表示从起点出来的字符串到起点的距离 db表示从终点出来的距离终点的距离
unordered_map<string,int>da,db;

string kk="nul";

const int N=5;

//两个队列，分别用于存放从起点走出来的字符串和从终点走出来的字符串
queue<string>qa,qb;

char g[N][N];

/*--------------------------------------------------------------------------------------------------------------------*/
void set(string state)//这个函数是将我们当前的字符串转换为字符数组以便于我们进行变化操作
{
    for(int i=0;i<3;i++)g[0][i]=state[i];
    for(int i=3,j=0;i<6;i++,j++)g[1][j]=state[i];
    for(int i=6,j=0;i<9;i++,j++)g[2][j]=state[i];

}

string get()//这个是将我们变化后的数组转回字符串进行后续操作
{
    string res;

    for(int i=0;i<3;i++)
      for(int j=0;j<3;j++)
      res+=g[i][j];

    return res;
}

string change1(string state)//第一种变化方式 u
{
    set(state);//先把字符串转化为数组便于操作

    int xx,yx;//用于记录当前x的位置

    for(int i=0;i<3;i++)
      for(int j=0;j<3;j++)
       if(g[i][j]=='x'&&i==0)
       {
       return "x";//如果在边界上，说明不能走，返回 x 表示不能走
       }
       else if(g[i][j]=='x'&&i!=0)
       {
           xx=i;//如果可以走得话，记录一下下标，然后操作
           yx=j;
       }

    swap(g[xx][yx],g[xx-1][yx]);

    return get();//返回操作后的字符串
}
string change2(string state)//第二种变化方式 d
{
    set(state);//先把字符串转化为数组便于操作

    int xx,yx;//用于记录当前x的位置

    for(int i=0;i<3;i++)
      for(int j=0;j<3;j++)
       if(g[i][j]=='x'&&i==2)
       {
       return "x";//如果在边界上，说明不能走，返回 x 表示不能走
       }
       else if(g[i][j]=='x'&&i!=2)
       {
           xx=i;//如果可以走得话，记录一下下标，然后操作
           yx=j;
       }


    swap(g[xx][yx],g[xx+1][yx]);

    return get();//返回操作后的字符串
}
string change3(string state)//第三种变化方式 l
{
    set(state);//先把字符串转化为数组便于操作

    int xx,yx;//用于记录当前x的位置

    for(int i=0;i<3;i++)
      for(int j=0;j<3;j++)
       if(g[i][j]=='x'&&j==0)
       {
       return "x";//如果在边界上，说明不能走，返回 x 表示不能走
       }
       else if(g[i][j]=='x'&&j!=0)
       {
           xx=i;//如果可以走得话，记录一下下标，然后操作
           yx=j;
       }


    swap(g[xx][yx],g[xx][yx-1]);

    return get();//返回操作后的字符串
}

string change4(string state)//第四种变化方式 r
{
    set(state);//先把字符串转化为数组便于操作

    int xx,yx;//用于记录当前x的位置

    for(int i=0;i<3;i++)
      for(int j=0;j<3;j++)
       if(g[i][j]=='x'&&j==2)
       {
       return "x";//如果在边界上，说明不能走，返回 x 表示不能走
       }
       else if(g[i][j]=='x'&&j!=2)
       {
           xx=i;//如果可以走得话，记录一下下标，然后操作
           yx=j;
       }


    swap(g[xx][yx],g[xx][yx+1]);

    return get();//返回操作后的字符串
}
/*--------------------------------------------------------------------------------------------------------------------*/

//上面全是操作函数，大家可以稍微看一下
int num=0;

int extrend(queue<string>&q,int tt)//扩展一下队内元素较少的那一个，能有效减少我们的算法实际运行效率
{
    for(int i=0;i<q.size();i++)
    {
        string t=q.front();//取出对头扩展

        q.pop();//出队

        string state4[5];//记录一下我们不同操作对应的结果状态

        int is[5]={};//用于操作是否合法（比如，我们如果在最右边那么我们就不能和右边的交换）

        if(change1(t)!="x")//如果说能走，那就赋值
        state4[1]=change1(t);
        else
        is[1]=1;//如果不能走就标记一下
        if(change2(t)!="x")
        state4[2]=change2(t);
        else
        is[2]=1;
        if(change3(t)!="x")
        state4[3]=change3(t);
        else
        is[3]=1;
        if(change4(t)!="x")
        state4[4]=change4(t);
        else
        is[4]=1;

        if(!tt)//判断一下当前扩展的是队列a还是队列b

        {
          for(int i=1;i<=4;i++)
          if(!da[state4[i]]&&!is[i])
          {
              da[state4[i]]=da[t]+1;

                if(i==1)
                 apre[state4[i]]={'u',t};//存一下当前用了哪一个操作，还有当前是从哪一个字符串转移过来的
               else if(i==2)
                 apre[state4[i]]={'d',t};
               else if(i==3)
                 apre[state4[i]]={'l',t};
               else
                 apre[state4[i]]={'r',t};
             //如果当前的字符串在对方中已经被找到过了，那说明二者之间已经有了一个联系，那就可以结束寻找了
             if(db[state4[i]]!=0)//如果对方已经搜到了
             {
                 kk=state4[i];
                 return db[state4[i]];
             }

              q.push(state4[i]);//放入队列进行扩展
          }

        }
        else//判断一下当前扩展的是队列a还是队列b
        {
          for(int i=1;i<=4;i++)
          if(!db[state4[i]]&&!is[i])
          {
              db[state4[i]]=db[t]+1;

                if(i==1)
                 bpre[state4[i]]={'u',t};//存一下当前用了哪一个操作，还有当前是从哪一个字符串转移过来的 
               else if(i==2)
                 bpre[state4[i]]={'d',t};
               else if(i==3)
                 bpre[state4[i]]={'l',t};
               else
                 bpre[state4[i]]={'r',t};
             //如果当前的字符串在对方中已经被找到过了，那说明二者之间已经有了一个联系，那就可以结束寻找了
             if(da[state4[i]]!=0)
             {
                 kk=state4[i];//先记录一下中间连接串是哪一个，方便后续找出路径   (需要说明)
                 return da[state4[i]];
             }

              q.push(state4[i]);//放入队列进行扩展
           }
        }

    }

    return -1;//如果本次扩展没有找到连接前后的字符串，那就返回-1表示还需要继续找
}

int bfs(string A,string B)
{
    qa.push(A);//先将起点放入我们从起点开始扩展的队列，作为起点

    da[A]=0;//让起点距离起点的距离设置为0

    qb.push(B);//先将终点放入我们从终点开始扩展的队列，作为终点

    db[B]=0;//让终点距离终点的距离设置为0

    while(qa.size()&&qb.size())//当二者队列里面同时含有元素的时候，才满足继续扩展的条件  (需要说明)
    {
  //神奇的特判操作，由于这题目的特殊性质，双方有可能搜了很久还是没搜到交集，那么就其实说明无解了  (需要说明)
        if(num>=10000)return -1;


        int t,tt;//tt用于判断我们当前是该扩展 a 还是扩展 b
        if(qa.size()<=qb.size())
        {
            tt=0;
             t=extrend(qa,tt);

             num+=qa.size();
        }

        else
        {
            tt=1;
            t=extrend(qb,tt);
            num+=qb.size();
        }

        if(t!=-1)
        return t;
    }

    return -1;//如果到最后都没有找到的话，那也说明无解了
}

int main()
{
    string A,B;

    for(int i=1;i<=9;i++)
    {
        B+=char(i+'0');//生成一下我们的终点
        char x;

        scanf(" %c",&x);

        A+=x;//生成起点
    }
    B[8]='x';//生成终点

      int ans=bfs(A,B);//然后直接进行搜索


     string res1,res2;

     if(ans==-1)//如果返回的是-1 那说明无解
     printf("unsolvable");
     else//如果有解
     {
      string tt=kk; //首先我们要找到连接二者的中介，也就是我们记录下来的中介
      while(tt!=A)//找出我们从起点到中间点所经历的操作
      {
          res1+=apre[tt].x;
          tt=apre[tt].y;
      }
      //由于我们所得到的顺序是从中间到起点的，那么我们需要的是从起点到中间的，直接倒一边就好了
      //注意这里只是顺序反了一下，操作是没问题的，因为我们实际上就是从起点到终点的
      //只不过我们取出来的时候是反向取的，和下面的操作有一些差别
      reverse(res1.begin(),res1.end());
      tt=kk;
      /*这一步操作需要特殊说明，由于我们实际上，也就是代码上实现的是从终点到中间点的，但是我们需要的是
      从中间点到终点的，它的转换其实不是一个简单的倒回去操作就可以实现的，比如，我们在前面解释过的例子
      我们需要把每个操作都反一下，才是回来的操作，也就是从中间点到终点的操作(前面已经解释)
      */
      while(tt!=B)
      {
          char aa=bpre[tt].x;

          if(aa=='u'||aa=='d')
          aa='u'+'d'-aa;//回去的时候要转化
          else
          aa='l'+'r'-aa;//回去的时候要转化
          res2+=aa;
          tt=bpre[tt].y;
      }
   //为什么后半段不需要转化呢？前面已经解释过了就不再赘述

      cout<<res1<<res2;//最后输出两段合起来的就好了
     }

/*---------------------------------------------------------------------------------------------------------------------*/
    //  string zheng="ullddrurdllurrdlurd";

    // for(int i=0;i<zheng.size();i++)
    // {
    //     if(zheng[i]=='u')
    //     {
    //         set(A);

    //         A=change1(A);
    //     }
    //     else if(zheng[i]=='d')
    //     {
    //          set(A);
    //         A=change2(A);
    //     }
    //     else if(zheng[i]=='l')
    //     {
    //          set(A);
    //         A=change3(A);
    //     }
    //     else
    //     {
    //          set(A);
    //         A=change4(A);
    //     }
    // }

    // cout<<kk<<endl;
    // cout<<A<<endl;
    // 1237486x5

    // uldldrrulldrrulu ruulddlurdrulul
/*----------------------------------------------------------------------------------------------------------------------*/
//这上面是debug用的代码，为了验证一下程序的正确性，还有找一下问题的产生点
    return 0;
}