1150、1151、1515都是魔板的题目，只是数据规模以及一些操作不同，1515的步数上限N最大会达到100。所以，我选择直接解决1515魔板C。这样就相当于同时解决了1150、1151、1515
（1）魔板状态以及对应操作序列的存储
定义一个struct结构体，该结构体有两个成员，第一个是2行4列的数组m，存放魔板的状态，第二个是string类型的operation，存放达到这个状态对应的操作序列。
struct Status
{
int m[2][4];
string operation;
};
（2）实现三种基本操作
实现函数Status change_m(Status a, int op)
该函数两个参数，一个是Status类型的a，一个是int类型的op，op=1、2、3，分别表示执行A、B、C操作，该函数的功能是对a执行一个op操作，然后返回执行完该操作的Status类型。
要注意的是，要对应改变魔板状态，也就是对a.m[ ][ ]赋值，并且a.operation = operation+“A”(或“B”或“C”)，然后返回a就可以了。
（3）实现返回值为布尔类型的函数来判断魔板状态是否等于目标状态
bool match(int ma[2][4], int mb[2][4])
该函数的一个参数是当前魔板状态，另一个参数是目标魔板状态。只要分别判断数组里对应位置的数是否都相等就可以了。
（4）BFS
要对三叉树进行BFS，第一个可行解即是最优解。
BFS基本思想：
这时候，BFS的队列里存的类型是我之前定义的Status，一开始把初始状态push进去，然后只要队列不为空，就取出队首元素，对队首元素进行A、B、C三种操作的扩展，把扩展完的三种Status加入到队列中去，然后pop队首元素。一直循环直到队列为空。
对于这道题的BFS，还要增加以下两个判断：
一是每次取队首元素的时候要判断队首元素的操作序列长度，如果大于步数上限，就打印出-1，返回。
二是每次还要判断队首元素的魔板状态是否等于目标状态，如果等于则打印出对应操作序列长度，以及操作序列，然后返回。
（5）判重
不同的操作序列可能会产生相同的魔板状态，例如AB和BA对应的魔板状态是一样的，当这种情况出现时，我们就不应该再对这两种相同的魔板状态进行扩展。
所以，BFS每经过一个节点，就要把对应的魔板状态放入已搜索列表中，如果当前节点在已搜索列表中存在，则不再扩展该节点。在这里，扩展的意思是在当前操作上加一步操作（A、B或C），一个节点扩展为三个。
这个魔板有8个元素，所以一共有8！=40320个节点。
（6）康托展开
康托展开是一个全排列到一个自然数的一一映射，常用于构建哈希表时的空间压缩。
我们首先定义一个数组
初始化visited里每个元素为0。
利用康托展开，我们就可以直接得到当前魔板状态对应的自然数，然后把visited[当前对应的自然数]=1，表示已经搜索过该状态。
（7）康托展开的基本思想
康托展开其实就是对全排列进行编号。求对于当前这个排列，有多少个排列的数值比它小，对应的自然数就是多少。
例如对于1324，第一位是1，小于1的数为0，对应0 * 3！= 0
第二位是3，小于3的数有1和2，但是1已经在第一位出现了，所以1 * 2！= 2
第三位是2，小于2的数有1，但是 1已经在前面出现过，所以0 * 1！= 0
0 + 2 + 0 = 2
所以小于1324的有两个，康托展开后，1324对应的自然数为2
理解了思想就可以写代码实现康托展开了。
（8）阶乘
康托展开里涉及到阶乘，所以要实现求阶乘的函数。
代码实现：
#include<iostream>
#include<string>
#include<cstdio>
#include<queue>
#include<algorithm>
using namespace std;
int target_m[2][4];//目标魔板状态
int start_m[2][4] = {1, 2, 3, 4, 5, 6, 7, 8};//开始魔板状态
int visited[41000];//8!=40320，所以节点的状态一共有40320种
struct Status
{
int m[2][4];
string operation;
};
Status initial;
int factorial(int number)//求阶乘
{
int fac = 1;
while(number > 0)
{
fac = fac * number;
number--;
}
return fac;
}
int Cantor(Status& current)//康托展开
{
int cantor = 0;
int vis[9] = {0, 0, 0, 0, 0, 0, 0, 0, 0};
for(int i = 0; i < 2; i++)
{
for(int j = 0; j < 4; j++)
{
vis[current.m[i][j]] = 1;
int less = current.m[i][j] - 1;//小于当前这个数的数有less个
int l = less;
for(int k = 1; k <= l; k++)
{
if(vis[k])//虽然小于当前这个数，但是已经在前面出现过了
less = less - 1;
}
cantor = cantor + less * factorial(8 - 4 * i - j - 1);
}
}
return cantor;
}
Status change_m(Status a, int op)//在这里Status a不可以按引用传递，因为bfs要对同一个状态执行A、B、C操作，所以不可以在执行A操作的时候就把它改了。
{//返回的是增加一个操作的status
if(op == 1)//左右两列互换
{
int tmp1 = a.m[0][0];
a.m[0][0] = a.m[0][2];
int tmp2 = a.m[0][1];
a.m[0][1] = a.m[0][3];
int tmp3 = a.m[1][0];
a.m[1][0] = a.m[1][2];
int tmp4 = a.m[1][1];
a.m[1][1] = a.m[1][3];
a.m[0][2] = tmp1;
a.m[0][3] = tmp2;
a.m[1][2] = tmp3;
a.m[1][3] = tmp4;
a.operation = a.operation + "A";
}
else if(op == 2)//每次以行循环左移一个
{
int tmp1 = a.m[0][0];
int tmp2 = a.m[1][0];
for(int i = 0; i < 2; i++)
{
for(int j = 0; j < 3; j++)
{
a.m[i][j] = a.m[i][j + 1];
}
}
a.m[0][3] = tmp1;
a.m[1][3] = tmp2;
a.operation = a.operation + "B";
}
else//中间四小块逆时针转一格
{
int tmp1 = a.m[0][1];
a.m[0][1] = a.m[0][2];
a.m[0][2] = a.m[1][2];
a.m[1][2] = a.m[1][1];
a.m[1][1] = tmp1;
a.operation = a.operation + "C";
}
return a;
}
bool match(int ma[2][4], int mb[2][4])
{
for(int i = 0; i < 2; i++)
{
for(int j = 0; j < 4; j++)
{
if(ma[i][j] != mb[i][j])
return false;
}
}
return true;
}
void bfs(int n)
{
queue<Status> q;
q.push(initial);
while(!q.empty())
{
//取队首元素
Status top = q.front();
if(top.operation.length() > n)
{
cout << "-1" << endl;
return;
}
if(match(top.m, target_m))
{
cout << top.operation.length() << " " << top.operation << endl;
return;
}
if(!visited[Cantor(top)])//如果当前节点没有被visited过，则扩展该节点
{
for(int i = 1; i <= 3; i++)
{
Status cur = change_m(top, i);
q.push(cur);
}
visited[Cantor(top)] = 1;
}
q.pop();
}
}
int main()
{
int n;
//初始化魔板
for(int i = 0; i < 2; i++)
{
for(int j = 0; j < 4; j++)
initial.m[i][j] = start_m[i][j];
}
initial.operation = "";
while(cin >> n && n != -1)//n表示最多容许步数
{
fill(visited, visited + 41000, 0);//初始化visited
for(int i = 0; i < 2; i++)//输入目标魔板
for(int j = 0; j < 4; j++)
cin >> target_m[i][j];
bfs(n);
}
return 0;
}
Finally, good luck to you.
