蓝桥杯 九宫重排

问题描述
　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。

我们把第一个图的局面记为：12345678.
　　把第二个图的局面记为：123.46758
　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。
　　本题目的任务是已知九宫的初态和终态，求最少经过多少步的移动可以到达。如果无论多少步都无法到达，则输出-1。
输入格式
　　输入第一行包含九宫的初态，第二行包含九宫的终态。
输出格式
　　输出最少的步数，如果不存在方案，则输出-1。
样例输入
12345678.
123.46758
样例输出
3
样例输入
13524678.
46758123.
样例输出
22

这道题很明显是一道广度优先搜索的题目，要注意的是，在移动的过程中，可能会遇到重复绕圈的情况，所以要记录下每一种移动的情况，使得每一次移动完可以检查是否重复，可以用哈希表来记录每一种情况。

代码如下：

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#define HASH_SIZE 362881

typedef int map[9];
typedef struct
{
	map arr[362881];
	int front;
	int rear;
	int size;
} Queue;

map current, target;//current为开始的图形，target为目标的图形
map table[362881];//哈希表
int step[100000] = {0};//记录步数
int dx[4] = {0, 0, -1, 1};//x方向移动
int dy[4] = {-1, 1, 0, 0};//y方向移动

int isEmpty(Queue* Q)
{
	if (Q->front == Q->rear)
		return 1;
	
	return 0;
}

Queue* createQueue()
{
	Queue* Q = malloc(sizeof(Queue));
	Q->front = Q->rear = 0;
	Q->size = 362881;
	
	return Q;
}

void push(Queue* Q, map element)
{
	if (Q->rear + 1 != Q->front)
	{
		memcpy(Q->arr[Q->rear ++], element, sizeof(map));
		Q->rear %= Q->size;
	}
}

void pop(Queue* Q, map element)
{
	if (!isEmpty(Q))
	{
		memcpy(element, Q->arr[Q->front ++], sizeof(map));
		Q->front %= Q->size;
	}
}

void destory(Queue* Q)
{
	free(Q);
}

void hash_init()
{
	memset(table, -1, sizeof(table));
}

long hash(map m)
{
	long long v = 0;
	int i;

	for (i = 0; i <= 9; i++)
		v = v * 10 + m[i];//这里的映射方法为把图形转成一个9位数
	
	return v % HASH_SIZE;
}

int hash_insert(map m)
{
	int pos = hash(m);

	while (table[pos][0] != -1)
	{
		if (memcmp(table[pos], m, sizeof(map)) == 0)//判断是否重复
			return 0; 

		pos ++;//线性探测法
		pos %= HASH_SIZE;
	}
	
	memcpy(table[pos], m, sizeof(map));//记录

	return 1;
}

int bfs()
{
	Queue* Q = createQueue();
	map cur;
	int move = 0, pos = 0;
	int move_x, move_y, x, y;
	int i, index;
	map mtmp;

	hash_init();
	hash_insert(current);//先把开始的图形插入hash表
	push(Q, current);//把开始的图形入队

	while (!isEmpty(Q))
	{
		pop(Q, cur);//出队

		if (memcmp(cur, target, sizeof(map)) == 0)//判断当前出队的图形是否为目标图形，如果为真则返回step中记录最少步数的位置。
		{
			index = step[Q->front - 1];//最先到达目标图形的方案的移动步数最小，Q->front - 1为当前出队元素在队列中的位置，之所以不是Q->front，是因为在pop后front会+1
			destory(Q);//销毁队列，释放内存
			return index ;
		}

		for (i = 0; i < 9; i++)//找到0所在的位置
			if (cur[i] == 0)
				pos = i;
	
		x = pos % 3;
		y = pos / 3;

		for (i = 0; i < 4; i++)
		{
			move_x = x + dx[i];//x方向移动
			move_y = y + dy[i];//y方向移动

			move = move_y * 3 + move_x;//因为存储图形的时候我们是用一维数组储存，所以要把二维坐标转成一维坐标
			memcpy(mtmp, cur, sizeof(map));//拷贝一份图形，避免后面移动破坏原来出队的图形

			if (move_x >= 0 && move_x < 3 && move_y >= 0 && move_y < 3)
			{
				//元素交换，就是进行移动
				mtmp[move] = cur[pos];
				mtmp[pos] = cur[move];

				step[Q->rear] = step[Q->front - 1] + 1;//记录步数，当前出队的元素在队列中的位置为Q->front - 1,该记录方案自己模拟一下即可理解，这里不做解释

				if (hash_insert(mtmp))//如果进行该移动后的图形没有和之前已被记录图形重复，就把该图形入队，否则重新移动
					push(Q, mtmp);
			}
		}
	}

	destory(Q);
	return -1;
}
			
int main()
{
	char cstr[50], tstr[50];
	map m;
	int i;
	int res;

	scanf("%s", cstr);
	scanf("%s", tstr);

	for (i = 0; i < strlen(cstr); i++)//把字符串转为整形数组，其中用0代表'.'
	{
		if (cstr[i] == '.')
			current[i] = 0;
		else
			current[i] = cstr[i] - '0';

		if (tstr[i] == '.')
			target[i] = 0;
		else
			target[i] = tstr[i] - '0';
	}
		
	res = bfs();
	if (res == -1)
		printf("-1\n");
	else
		printf("%d\n", step[res]);

	return 0;
}