POJ1077——Eight

3 * 3的矩阵的八数码问题。比较简单

因为输入的只是1-8，所以可以将x当作9.

解决问题的关键是将数字序列根据康托展开转换成一个数，每一个数对应一个序列，所以可以用来判断这个序列是否查找过。

用深搜搜索，总共9！种，还可以接受。

下面是代码：

#include <iostream>
#include <queue>
using namespace std;

const int SIZE = 362880;                              //数组最大值
int fac[] = {1,1,2,6,24,120,720,5040,40320,362880};   //0 - 9的阶乘

int xy[4][2] = {-1,0,1,0,0,-1,0,1};       //四个方向搜索
int parent[SIZE];                         //查找路径需要的父节点的数组
char visited[SIZE];                       //判断是否查找过
char move[SIZE];                          //记录某个序列向哪个方向移动

struct node                               //节点，包括了序列，空格的位置x，以及序列根据康托展开转成的数
{
	char str[9];
	char x;
	int kangtuo;
};

int kangtuo(char *s, int n)               //康托展开把一个序列转成一个数
{
	int i, j, temp, num;
	num = 0;
	for(i = 0; i < n - 1; i++)
	{
		temp = 0;
		for(j = i + 1; j < n; j++)
		{
			if(s[j] < s[i])
				temp++;
		}
		num += fac[s[i] - 1] * temp;
	}
	return num;
}

int hash(char *cur)
{
	return kangtuo(cur, 9);
}

void bfs(node &start)    //深搜
{
	int x, y, k, a, b;
	int u, v;

	for(k = 0; k < SIZE; ++k)   //初始化visited
		visited[k] = 0;

	u = start.kangtuo;          //第一个序列的康托数

	parent[u] = -1;             //父节点为-1
	visited[u] = 1;             //标记为查找过
	queue<node> que;
	que.push(start);            //入队

	node temp, te;
	while(!que.empty())
	{
		te = que.front();
		que.pop();
		u = te.kangtuo;
		k = te.x;               //根据x的下标，找到x的坐标
		x = k / 3;
		y = k % 3;

		for(int i = 0; i < 4; i++)    //四个方向进行交换
		{
			a = x + xy[i][0];
			b = y + xy[i][1];
			if(0 <= a && a <= 2 && 0 <= b && b <= 2)   //符合条件的交换位置，计算康托数，判断是否查找过，
			{
				temp = te;
				temp.x = a * 3 + b;
				swap(temp.str[k], temp.str[temp.x]);
				temp.kangtuo = hash(temp.str);
				v = temp.kangtuo;
				if(visited[v] != 1)
				{
					move[v] = i;
					visited[v] = 1;
					parent[v] = u;
					if(v == 0)         //判断是否查找完成，是则返回，不是添加如队
						return;
					que.push(temp);
				}
			}
		}
	}
}

void print_path()       //根据parent数组和move数组找出路径
{
	int n, u;
	char path[1000];
	n = 1;
	path[0] = move[0];
	u = parent[0];
	while(parent[u] != -1)
	{
		path[n] = move[u];
		++n;
		u = parent[u];
	}

	for(int i = n - 1; i >= 0; --i)
	{
		if(path[i] == 0)
			cout << "u";
		else if(path[i] == 1)
			cout << "d";
		else if(path[i] == 2)
			cout << "l";
		else
			cout << "r";
	}
}

int main()
{
	node start;
	char c;
	for(int i = 0; i < 9; i++)
	{
		cin >> c;
		if(c == 'x')
		{
			start.str[i] = 9;
			start.x = i;
		}
		else
			start.str[i] = c - '0';
	}
	start.kangtuo = hash(start.str);
	bfs(start);

	if(visited[0] == 1)
	{
		print_path();
		cout << endl;
	}
	else
		cout << "unsolvable" << endl;

	return 0;
}