sicily 1150&1151 魔板[Special judge]

Description

魔板由8个大小相同方块组成，分别用涂上不同颜色，用1到8的数字表示。

其初始状态是

1 2 3 4

8 7 6 5

对魔板可进行三种基本操作：

A操作（上下行互换）：

8 7 6 5

1 2 3 4

B操作（每次以行循环右移一个）：

4 1 2 3

5 8 7 6

C操作（中间四小块顺时针转一格）：

1 7 2 4

8 6 3 5

用上述三种基本操作，可将任一种状态装换成另一种状态。

Input

输入包括多个要求解的魔板，每个魔板用三行描述。

第一行步数N，表示最多容许的步数。

第二、第三行表示目标状态，按照魔板的形状，颜色用1到8的表示。

当N等于-1的时候，表示输入结束。

Output

对于每一个要求解的魔板，输出一行。

首先是一个整数M，表示你找到解答所需要的步数。接着若干个空格之后，从第一步开始按顺序给出M步操作（每一步是A、B或C），相邻两个操作之间没有任何空格。

注意：如果不能达到，则M输出-1即可。

Sample Input

 Copy sample input to clipboard

45 8 7 64 1 2 338 7 6 51 2 3 4-1

Sample Output

2 AB1 A评分：M超过N或者给出的操作不正确均不能得分。

我的解法：

#include <iostream>
#include <vector>
#include <string>


using namespace std;


int fact[8]={1,1,2,6,24,120,720,5040};  //定义1到7的阶乘


struct board
{
int num;         //记录步数
string id;       //记录顺序
bool visit;      //记录是否已存在
}step[40321];     //把每种排序用康托展开编码并存在board数组中        


int encode(int n)      //康托展开式编码
{
int temp[8];
for(int k=7;k>=0;k--)
{
temp[k]=n%10;
n=n/10;
}
int output=0;
for(int i=0;i<8;i++)
{
int tempcount = 0;
for(int j=i+1;j<8;j++)
if(temp[i]>temp[j])
tempcount++;
output+=tempcount*fact[7-i];
}
return output;
}


int operatingA(int n)          
{
return n/10000+n%10000*10000;
}


int operatingB(int n)
{
int temp = 0;  
    temp += n%1000/10;  
    temp += n%10000/1000*100;  
    temp += n%10*1000;  
    temp += n%1000000/100000*10000;  
    temp += n/1000000*100000;  
    temp += n%100000/10000*10000000;
return temp;
}


int operatingC(int n)
{
int temp = 0;  
    temp += n%10;  
    temp += n%1000000/100000*10;  
    temp += n%100/10*100;  
    temp += n%100000/1000*1000;  
    temp += n%10000000/1000000*100000;  
    temp += n%1000/100*1000000;  
    temp += n/10000000*10000000;  
    return temp;  
}


void clear(board step[])    //将board型数组清零
{
for(int i=0;i<40321;i++)
{
step[i].id =" ";
step[i].num =0;
step[i].visit =false;
}
}




int main()
{
int source = 12348765;
int gen,a,aen,b,ben,c,cen,maxstep,ss;
while(cin>>maxstep)
{
if(maxstep==-1)
return 0;
int ini=source;
int g=0;
int goal[8];
clear(step);
for(int i=0;i<8;i++)    //读取目标board数据     
{
cin>>goal[i];
g=g*10+goal[i];
}
gen=encode(g);          
vector<int> q;          //用深度遍历算法BFS，向量q用来记录遍历状态
q.push_back(ini);      
ss=encode(ini);
step[ss].visit=true;
bool ans=true;
while(q[0] !=g)
{
if(step[encode(q[0])].num>maxstep)  
{
cout<<"-1"<<endl;
ans = false;
break;
}
a=operatingA(q[0]);
aen=encode(a);
b=operatingB(q[0]);
ben=encode(b);
c=operatingC(q[0]);
cen=encode(c);
ss=encode(q[0]);


if(!step[aen].visit)
{
q.push_back(a);
step[aen].num=step[ss].num+1;
step[aen].id=step[ss].id+"A";
step[aen].visit=true;
}
if(!step[ben].visit)
{
q.push_back(b);
step[ben].num=step[ss].num+1;
step[ben].id=step[ss].id+"B";
step[ben].visit=true;
}
if(!step[cen].visit)
{
q.push_back(c);
step[cen].num=step[ss].num+1;
step[cen].id=step[ss].id+"C";
step[cen].visit=true;
}
q.erase(q.begin());
}
if(ans)
cout<<step[gen].num<<"   "<<step[gen].id<<endl;
}
return 0;
}