版权声明:本文为博主原创文章,未经博主允许不得转载。 https://blog.csdn.net/Qin7_Victory/article/details/79963413
The 15-puzzle has been around for over 100 years; even if you don't know it by that name, you've seen it. It is constructed with 15 sliding tiles, each with a number from 1 to 15 on it, and all packed into a 4 by 4 frame with one tile missing. Let's call the missing tile 'x'; the object of the puzzle is to arrange the tiles so that they are ordered as:
where the only legal operation is to exchange 'x' with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle:
The letters in the previous row indicate which neighbor of the 'x' tile is swapped with the 'x' tile at each step; legal values are 'r','l','u' and 'd', for right, left, up, and down, respectively.
Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and
frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing 'x' tile, of course).
In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three
arrangement.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 x
where the only legal operation is to exchange 'x' with one of the tiles with which it shares an edge. As an example, the following sequence of moves solves a slightly scrambled puzzle:
1 2 3 4 1 2 3 4 1 2 3 4 1 2 3 4 5 6 7 8 5 6 7 8 5 6 7 8 5 6 7 8 9 x 10 12 9 10 x 12 9 10 11 12 9 10 11 12 13 14 11 15 13 14 11 15 13 14 x 15 13 14 15 x r-> d-> r->
The letters in the previous row indicate which neighbor of the 'x' tile is swapped with the 'x' tile at each step; legal values are 'r','l','u' and 'd', for right, left, up, and down, respectively.
Not all puzzles can be solved; in 1870, a man named Sam Loyd was famous for distributing an unsolvable version of the puzzle, and
frustrating many people. In fact, all you have to do to make a regular puzzle into an unsolvable one is to swap two tiles (not counting the missing 'x' tile, of course).
In this problem, you will write a program for solving the less well-known 8-puzzle, composed of tiles on a three by three
arrangement.
Input You will receive, several descriptions of configuration of the 8 puzzle. One description is just a list of the tiles in their initial positions, with the rows listed from top to bottom, and the tiles listed from left to right within a row, where the tiles are represented by numbers 1 to 8, plus 'x'. For example, this puzzle
1 2 3
x 4 6
7 5 8
is described by this list:
1 2 3 x 4 6 7 5 8
Output You will print to standard output either the word ``unsolvable'', if the puzzle has no solution, or a string consisting entirely of the letters 'r', 'l', 'u' and 'd' that describes a series of moves that produce a solution. The string should include no spaces and start at the beginning of the line. Do not print a blank line between cases.
Sample Input
2 3 4 1 5 x 7 6 8Sample Output
ullddrurdllurdruldr
整理了好长时间,终于解决了。 刚开始一直纠结康拓展开式,后来通过资料查找,进一步的了解。
康拓展开式
//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!;
int cator(int t[]) //康拓展开式
{
int sum = 0;
for(int i = 0; i < 9; i++)
{
int num = 0;
for(int j = i+1; j < 9; j++)
if(t[i] > t[j])
num++;
sum += num*fac[8-i]; //((n-1)-i)
}
return sum;
}
逆运算
int n; //表示有几位数
int book[110];
int fac[] = {1,1,2,6,24,120,720,5040,40320,362880}; //第 i!的数值
// k = an*(n-1)! + an-1*(n-2) + ... + a2*1! + a1*0!;
void reverse_cator(int k,char s[])
{
memset(book,0,sizeof(0));
int j;
for(int i = 0;i < n; i++)
{
int t = k/fac[n-i-1]; //表示的是 an;
for(j = 1; j <= n; j++)
if(!vis[j])
{
if(t == 0)
break;
--t;
}
s[i] = j+'0';
vis[j] = 1;
k = k%fac[n-1-i]; //继续往下找
}
}
刚开始做的是POJ 1077这道题,这道题是单租数据输入,可以从起始位置找终点位置,A了。
后来发现HDU 1043,本来想着可以秀一把了,可谁知竟然相同的代码,竟然来了个Compilation Error。
很绝望,后来得知1043这题是多组数据输入,然后就换种思路,开始从最终位置出发,找到所有的点,并保存其路径。在这里,应注意运用数组实现邻接表。
//逆向搜索,从终点往前搜索
#include<stdio.h>
#include<queue>
#include<string.h>
#include<iostream>
#include<algorithm>
using namespace std;
int a[]={-1,1,0,0};
int b[]={0,0,-1,1};
char str[]={"durl"}; //由于从终点往前找,故方向相反
int fac[]={1,1,2,6,24,120,720,5040,40320,362880};
int book[370000];
struct note //存储路径
{
int head; //表示的是
char st; //存储方向
}f[370000];
struct node
{
int x0;
int num; //s[]在全排列中从大到小第几位
int s[10]; // 存储数康拓展开式 所求的数值
};
//判断这个数在其各个数字全排列中从小到大排第几位
// X = an*(n-1)! + an-1*(n-2)! + ... + a2*1! + a1*0!;
int cator(int t[]) //康拓展开式
{
int sum = 0;
for(int i = 0; i < 9; i++)
{
int num = 0;
for(int j = i+1; j < 9; j++)
if(t[i] > t[j])
num++;
sum += num*fac[8-i]; //((n-1)-i)
}
return sum;
}
void bfs()
{
memset(book,0,sizeof(book));
queue<node>Q;
node now,tmp;
for(int i = 0; i < 8; i++)
now.s[i] = i+1;
now.s[8] = 0;
now.x0 = 8;
now.num = 0;
f[0].head = 0;
Q.push(now);
while(!Q.empty())
{
now = Q.front();
Q.pop();
int x = now.x0/3;
int y = now.x0%3;
for(int i = 0;i < 4; i++)
{
int tx = x + a[i];
int ty = y + b[i];
if(tx < 0 || ty < 0 || tx > 2 || ty > 2 )
continue;
tmp = now;
tmp.x0 = tx*3 + ty;
swap(tmp.s[tmp.x0],tmp.s[now.x0]);
tmp.num = cator(tmp.s);
if(!book[tmp.num])
{
book[tmp.num] = 1;
f[tmp.num].head = now.num; //此时的数连接着上一个状态 now.head
f[tmp.num].st = str[i];
Q.push(tmp);
}
}
}
return ;
}
int main()
{
char c;
int t[10];
bfs();
while(cin >> c) //cin不吸收空格回车等字符
{
if(c == 'x')
t[0] = 0;
else
t[0] = c-'0';
for(int i = 1; i < 9; i++)
{
cin >> c;
if(c == 'x')
t[i] = 0;
else
t[i] = c-'0';
}
int n = cator(t);
//printf("%d\n",n);
if(book[n])
{
while(n)
{
printf("%c",f[n].st);
n = f[n].head; //下一个状态
}
printf("\n");
}
else
printf("unsolvable\n");
}
return 0;
}
在这里,要注意的是
1 我们是从后往前找的,所有方向应该正好相反(上下左右的坐标, 保存的字符应该是下上右左)
2 数据有多重答案,所有不要一直纠结自已的运行结果和测试数据不一样啊。
在这里,把字符'x'变成0或者9都可以
重在尝试哦,说不定自己就对了呢