2014 UESTC Training for Search Algorithm J

先不考虑加减操作，看通过另外的4个操作能对原序列发生什么改变，且要注意加减操作只能在魔棒经过的地方才能够执行，所以要有一个状态变量，标记一下这个状态中对应位是否被遍历过，如果1才能够加减，否则不可加减
固有这样的处理
int State[10][6]=
{
    1,0,0,0,0,0,
    1,1,0,0,0,0,
    1,1,1,0,0,0,
    1,1,1,1,0,0,
    1,1,1,1,1,0,
    1,1,1,1,1,1,//5
    1,0,0,0,0,1,
    1,1,0,0,0,1,
    1,1,1,0,0,1,
    1,1,1,1,0,1
};
可以考虑利用BFS预处理，对于每一个起始的位置，可以BFS预处理出经过魔棒变换后
这些位置的元素到了哪里。
另外需要注意的一点就是只有魔棒所在的位置可以进行加减
一开始魔棒在最左端那么魔棒可能遍历到的位置是1,12,123,1234,12345,123456直接右移魔棒，同事可以先和最后一位交换
访问的状态就增加了16，,16，,1236,12346.共10种状态
所以有状态记录vis[6][6][6][6][6][6][6][6][10];
倒数第二个代表魔棒的位置，最后一个可以定义为状态中包含了什么，利用 0,1表示这个位置是否已经经过魔棒处理（主要是为了只有魔棒遍历过的位置才可以加减）
这样BFS节点中就需要dist，数组，状态值（映射到函数中查找遍历状态），pos(魔棒的位置)
把队列中每个节点的六位数字的数组，dist，state存到res[][]二维数组中。
经过这样的预处理后可以再主函数查找对应元素的步数
对于每一个目标数字遍历所有res数组，如果6位数的每一位和目标数字的目标位不同，那么就需要尝试加减（但是需要注意条件，这个state状态对应位必须为1，代表魔棒经历过）

最后求加和的总步数就可以了

#include <map>
#include <set>
#include <list>
#include <cmath>
#include<cctype>
#include <ctime>
#include <deque>
#include <stack>
#include <queue>
#include <cstdio>
#include <string>
#include <vector>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#define LL long long
#define PI 3.1415926535897932626
using namespace std;
int gcd(int a, int b)
{
	return a % b == 0 ? b : gcd(b, a % b);
}
int State[10][6]=
{
    1,0,0,0,0,0,
    1,1,0,0,0,0,
    1,1,1,0,0,0,
    1,1,1,1,0,0,
    1,1,1,1,1,0,
    1,1,1,1,1,1,//5
    1,0,0,0,0,1,
    1,1,0,0,0,1,
    1,1,1,0,0,1,
    1,1,1,1,0,1
};
struct node
{
    int a[6];
    int dist,pos,state;
}q[50005];
int res[50005][8];
bool vis[6][6][6][6][6][6][6][10];
char s1[10],s2[10];
int ori[6],dest[6];
int cas;
void show(node s)
{
    for (int i=0;i<6;i++)
        printf("%d ",s.a[i]);
    putchar('\n');
    printf("%d %d %d\n",s.dist,s.pos,s.state);
}
void bfs()
{
    memset(vis,false,sizeof(vis));
    int front=0,rear=1;
    cas=0;
    for (int i=0;i<6;i++)
        q[0].a[i]=i;
    q[0].dist=q[0].pos=q[0].state=0;
    vis[0][1][2][3][4][5][0][0]=true;
    while (front<rear)
    {
        node u=q[front];
        for (int i=0;i<6;i++)
          res[cas][i]=u.a[i];
          res[cas][6]=u.state;
          res[cas][7]=u.dist;
          cas++;
          node s=u;
          if (u.pos>0)//跟首位交换数字
          {
              swap(u.a[0],u.a[u.pos]);
                if (!vis[u.a[0]][u.a[1]][u.a[2]][u.a[3]][u.a[4]][u.a[5]][u.pos][u.state])
                {
                    vis[u.a[0]][u.a[1]][u.a[2]][u.a[3]][u.a[4]][u.a[5]][u.pos][u.state]=true;
                    u.dist++;
                    q[rear++]=u;
                }
          }
          u=s;
          if (u.pos<5)
          {
              u.pos++;
              //移动光标
              if (u.pos>u.state || (u.state>5 && u.pos>u.state-6))
                {
                    if (u.state==9) u.state=5;
                    else u.state++;
                }
              if (!vis[u.a[0]][u.a[1]][u.a[2]][u.a[3]][u.a[4]][u.a[5]][u.pos][u.state])
                {
                    vis[u.a[0]][u.a[1]][u.a[2]][u.a[3]][u.a[4]][u.a[5]][u.pos][u.state]=true;
                    u.dist++;
                    q[rear++]=u;
                }
            //复原
            u=s;
            swap(u.a[5],u.a[u.pos]);//交换
            if (u.state<5)
            {
                u.state+=6;
                if (u.state>9) u.state=5;
            }
            if (!vis[u.a[0]][u.a[1]][u.a[2]][u.a[3]][u.a[4]][u.a[5]][u.pos][u.state])
                {
                    vis[u.a[0]][u.a[1]][u.a[2]][u.a[3]][u.a[4]][u.a[5]][u.pos][u.state]=1;
                    u.dist++;
                    q[rear++]=u;
                }
          }
          front++;
    }
}
int main()
{
    bfs();
   // printf("%d\n",cas);
    //freopen("sample.txt","r",stdin);
    //for (int i=0;i<10;i++) show(q[i]);
    while (scanf("%s%s",s1,s2)!=EOF)
    {
        for (int i=0;i<6;i++)
        {
            ori[i]=s1[i]-'0';
            dest[i]=s2[i]-'0';
        }
        int ANS=1e7;
       /* for (int i=0;i<6;i++)
        {
            printf("%d ",ori[i]);
        }
        for (int i=0;i<6;i++)
        {
            printf("%d ",dest[i]);
        } */
        for (int i=0;i<cas;i++)
        {
            int s=res[i][7];int j;
            for ( j=0;j<6;j++)
            {
                if (ori[res[i][j]]!=dest[j] && State[res[i][6]][j]==0) break;
                s+=abs(ori[res[i][j]]-dest[j]);
            }
            if (j==6 && s<ANS) ANS=s;
        }
        printf("%d\n",ANS);
    }
    return 0;
}