先不考虑加减操作,看通过另外的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,代表魔棒经历过)
固有这样的处理
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;
}