西普实验吧CTF-聪明的打字员

题目描述：

阿兰是某机密部门的打字员，她现在接到一个任务：需要在一天之内输入几百个长度固定为6的密码。当然，她希望输入的过程中敲击键盘的总次数越少越好。 
不幸的是，出于保密的需要，该部门用于输入密码的键盘是特殊设计的，键盘上没有数字键，而只有以下六个键：Swap0, Swap1, Up, Down, Left, Right，为了说明这6个键的作用，我们先定义录入区的6个位置的编号，从左至右依次为1，2，3，4，5，6。下面列出每个键的作用： 
Swap0：按Swap0，光标位置不变，将光标所在位置的数字与录入区的1号位置的数字（左起第一个数字）交换。如果光标已经处在录入区的1号位置，则按Swap0键之后，录入区的数字不变； 
Swap1：按Swap1，光标位置不变，将光标所在位置的数字与录入区的6号位置的数字（左起第六个数字）交换。如果光标已经处在录入区的6号位置，则按Swap1键之后，录入区的数字不变； 
Up：按Up，光标位置不变，将光标所在位置的数字加1（除非该数字是9）。例如，如果光标所在位置的数字为2，按Up之后，该处的数字变为3；如果该处数字为9，则按Up之后，数字不变，光标位置也不变； 
Down：按Down，光标位置不变，将光标所在位置的数字减1（除非该数字是0），如果该处数字为0，则按Down之后，数字不变，光标位置也不变； 
Left：按Left，光标左移一个位置，如果光标已经在录入区的1号位置（左起第一个位置）上，则光标不动； 
Right：按Right，光标右移一个位置，如果光标已经在录入区的6号位置（左起第六个位置）上，则光标不动。 
为了使这样的键盘发挥作用，每次录入密码之前，录入区总会随机出现一个长度为6的初始密码，而且光标固定出现在1号位置上。当巧妙地使用上述六个特殊键之后，可以得到目标密码，这时光标允许停在任何一个位置。 
现在，编写一个程序，初始密码为123456， 目标密码为654321，求出录入需要的最少的击键次数。
key格式：CTF{}

参考网上的大神的代码：

#include<iostream>
#include<queue>
#include<cmath>
using namespace std;
const int MAX = 99999999;
struct NODE{
	int num[6];
	int state;
	int step;
	int pos;
};
bool 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,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,1   
};  
int s[6],d[6];
char ch1[7],ch2[7]; 
int perm[730][8];
bool visit[6][6][6][6][6][6][6][10];
int index=0;
void ChangeState(NODE& a){
	visit[a.num[0]][a.num[1]][a.num[2]][a.num[3]][a.num[4]][a.num[5]][a.pos][a.state]=true;
}
bool Check(NODE& a){
	return visit[a.num[0]][a.num[1]][a.num[2]][a.num[3]][a.num[4]][a.num[5]][a.pos][a.state];
}
void Swap(int& a,int& b){
	int temp=a; 
	a=b;
	b=temp;
}
void bfs(){
	NODE e;
	queue<NODE> q;
	int i;
	for(i=0;i<6;i++)
		e.num[i]=i;
	e.pos=e.step=e.state=0;
	q.push(e);
	while(!q.empty()){
		e=q.front();
		q.pop();
		for(i=0;i<6;i++){
			perm[index][i]=e.num[i];
		}
		perm[index][6]=e.state;
		perm[index][7]=e.step;
		index++;
		if(e.pos>0){
			NODE node=e;
			node.step+=1;
			Swap(node.num[0],node.num[node.pos]);
			if(Check(node)==false){
				q.push(node);
				ChangeState(node);
			}
		}
		if(e.pos<5){
			NODE node=e;
			node.step++;
			node.pos++;
			if(node.state<9)
				node.state++;
			if(Check(node)==false){
				q.push(node);
				ChangeState(node);
			}
			node=e;
			node.step++;
			Swap(node.num[node.pos],node.num[5]);
			if(node.state<5) node.state+=5;
			if(Check(node)==false){
				q.push(node);
				ChangeState(node);
			}
		}
	}
}
int main(){
	memset(visit,0,sizeof(visit));
	bfs();
	while(cin>>ch1>>ch2){
		int i,j;
		int ans=MAX;
		for(i=0;i<6;i++){
			s[i]=ch1[i]-'0';
			d[i]=ch2[i]-'0';
		}
		for(i=0;i<index;i++){
			int step=perm[i][7];
			bool flag=true;
			for(j=0;j<6;j++){
				if(state[perm[i][6]][j]==false && s[perm[i][j]]!=d[j]){
					flag=false;
					break;
				}
				step+=abs(s[perm[i][j]]-d[j]);
			}
			if(flag==true && step<ans) ans=step;
		}
		cout<<ans<<endl;
	}
	return 0;
}

得出最少要11次，提交CTF{11}，通过！