[Sicily 1150 1151 1515 魔板] BFS+判重（康托展开）

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.