◇广度优先搜索◇Eight - 八数码问题
◆题外话◆
说实话，作者对这道题深有感触……TLE了6次——编码、hash、set都试了，最后发现是代码写的丑 ~~o(>_<)o ~~
—— 在此献上 Blog 一篇
◆题目◆
Description
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:
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 a description of a configuration of the 8 puzzle. The 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.
Sample Input
2 3 4 1 5 x 7 6 8
Sample Output
ullddrurdllurdruldr
◆题目解析◆
看到题 —— 一个 3*3 的矩阵 —— 搜索！然后又看到网上说 八数码问题 的解决方式很多，所以不暇思索选择了 广度优先搜索。
写了一半，突然发现 —— 八数码怎么判重？于是在网上一搜，oh……
（1） 变量声明
由于题目要求输出路径，用 STL 的 queue<> 就不太方便，所以直接用手写队列 que，以结构体 Queue 作为变量类型 —— 包含：①八数码的位置按题目描述转换为一个链状数组后相连而成的 int 变量 num （在用 编码 的方法时，num为一维 int 数组）；②达到这一状态的上一步所在 que 中的下标 father；③从上一步移动到这个状态所移动的方向 F（从0~3依次是 上左下右）；④当前空位所在 num 中的位置（从高位到低位）where 。
接下来是几个需要用到的常量数组——
①方向控制 int 数组 F ，由于是以一维形式存储的 3*3 的矩阵，一维数组中的第 i 个元素对应的上左下右的元素分别是 i-3,i-1,i+1,i+3 ，但是向上要满足 i>3，向下要满足 i≤6 ，向左要满足（[x]表示x向下取整） [(i-2)/3]=[(i-1)/3]，向右要满足 [i/3]==[(i-1)/3] 。这样就构成了移动所必须满足的条件。
②输出方案 char 数组 Char 分别对应 上左下右 Char[4]={'u','l','d','r'}。
③取整型数中某一位的数字要用到的 long long 数组 ten_n ，ten_n_i=10^i 。
（2） 交换整型数中指定2个位置上的数字
八数码矩阵转换为整型数时必然是9位（把空位变为0），写一个函数 change(n,a,b) 用于将一个9位的整型数 n 的第 a 位与第 b 位交换（从高位开始为第一位），即是如下函数：
const long long ten_n[]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000,10000000000};
long long change(int n,int a,int b) //记得是long long !
{
long long A=n%ten_n[9-a+1]/ten_n[9-a],B=n%ten_n[9-b+1]/ten_n[9-b],Ret; //取出第a、b位上的数
Ret=n-A*ten_n[9-a]-B*ten_n[9-b]; //将n的第a、b位去除
Ret=Ret+B*ten_n[9-a]+A*ten_n[9-b]; //将 A、B 换位重新放入 n
return Ret;
}（3）广度优先搜索
将起点的 father、F 初始化为 -1 ，套一下模板：
while(l<r) //l 队头所在位置， r队尾所在位置
{
Queue Front=que[l];
for(int i=0;i<4;i++)
{
Queue Push=Front;
Push.F=i;Push.where=Front.where+F[i];Push.father=l;
if(Push.where<=0 || Push.where>9 || (i%2 && (Push.where-1)/3!=(Front.where-1)/3)) continue;
Push.num=(int)change((long long)Push.num,Front.where,Push.where);
/*判重*/
que[r++]=Push;
if(Push.num==123456780)
{
int G=r-1;
vector<int> vec; //逆序存储答案
while(true) //找“爸爸”
{
vec.push_back(que[G].F);
G=que[G].father;
if(G==-1) break;
}
for(int j=vec.size()-2;j>=0;j--)
printf("%c",Char[vec[j]]);
puts("");
return 0;
}
}
l++;
}（4）判重
① STL set<> （如果有 O2 优化的话也能 AC）
这是最简单但是速度最慢的方法（网上也是这么说的，的确是三个方法唯一一个 TLE 的）。也就是利用 STL set<> 的 .count(x) ——可以查找在该容器中是否存在 x（时间复杂度近似于 log n）。如果没有查找到就用 .insert(x) 将该元素存入 set ，作标记。
② hash
其实就是把原数字模一个 Mod(Mod越大越好，但是不要超内存)得到 y，然后存入一个 vector vec[y]，由于不同的数字模 Mod 可能相同，因此每次需要查找 vec[y] 中是否存在 x ，这样的优化就是将所有出现过的数字以模 Mod 得到的数分为不同集合，从而减少查找规模。
③逆序对编码
这个时候结构体中的 num 用数组就比较好了。由于每一个数字的逆序对的位置不相同，可以用此特点编码，最大会出现 9!=362880 ，因此数组只需要362880这么大就可以了。
◆代码片◆
第一次尝试用 set<> - TLE:
/*Lucky_Glass*/
#include<cstdio>
#include<algorithm>
#include<set>
#include<vector>
using namespace std;
const long long ten_n[]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000,10000000000};
const int F[4]={-3,-1,3,1};
const char Char[4]={'u','l','d','r'};
struct Queue
{
int num,father,F,where;
}que[700000];
set<int> flag;
long long change(int n,int a,int b)
{
long long A=n%ten_n[9-a+1]/ten_n[9-a],B=n%ten_n[9-b+1]/ten_n[9-b],Ret;
Ret=n-A*ten_n[9-a]-B*ten_n[9-b];
Ret=Ret+B*ten_n[9-a]+A*ten_n[9-b];
return Ret;
}
int main()
{
int l=0,r=0;
Queue begin;
begin.num=0;begin.father=begin.F=-1;
for(int i=1,num;i<=9;i++)
{
char c='\0';
while(!('0'<=c && c<='9') && c!='x') c=getchar();
if(c=='x') begin.num*=10,begin.where=i;
else begin.num=begin.num*10+c-'0';
}
que[r++]=begin;
while(l<r)
{
Queue Front=que[l];
for(int i=0;i<4;i++)
{
Queue Push=Front;
Push.F=i;Push.where=Front.where+F[i];Push.father=l;
if(Push.where<=0 || Push.where>9 || (i%2 && (Push.where-1)/3!=(Front.where-1)/3)) continue;
Push.num=(int)change((long long)Push.num,Front.where,Push.where);
if(flag.count(Push.num)) continue;
flag.insert(Push.num);
que[r++]=Push;
if(Push.num==123456780)
{
int G=r-1;
vector<int> vec;
while(true)
{
vec.push_back(que[G].F);
G=que[G].father;
if(G==-1) break;
}
for(int j=vec.size()-2;j>=0;j--)
printf("%c",Char[vec[j]]);
puts("");
return 0;
}
}
l++;
}
puts("unsolvable");
return 0;
}第二次试了一试 hash - AC:
/*Lucky_Glass*/
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
const long long ten_n[]={1,10,100,1000,10000,100000,1000000,10000000,100000000,1000000000,10000000000};
const int MOD=1000003;
const int F[4]={-3,-1,3,1};
const char Char[4]={'u','l','d','r'};
struct Queue
{
int num,father,F,where;
}que[700000];
vector<int> flag[MOD];
bool found(int n)
{
int Size=flag[n%MOD].size();
for(int i=0;i<Size;i++)
if(flag[n%MOD][i]==n)
return true;
return false;
}
long long change(int n,int a,int b)
{
long long A=n%ten_n[9-a+1]/ten_n[9-a],B=n%ten_n[9-b+1]/ten_n[9-b],Ret;
Ret=n-A*ten_n[9-a]-B*ten_n[9-b];
Ret=Ret+B*ten_n[9-a]+A*ten_n[9-b];
return Ret;
}
int main()
{
int l=0,r=0;
Queue begin;
begin.num=0;begin.father=begin.F=-1;
for(int i=1,num;i<=9;i++)
{
char c='\0';
while(!('0'<=c && c<='9') && c!='x') c=getchar();
if(c=='x') begin.num*=10,begin.where=i;
else begin.num=begin.num*10+c-'0';
}
que[r++]=begin;
while(l<r)
{
Queue Front=que[l];
for(int i=0;i<4;i++)
{
Queue Push=Front;
Push.F=i;Push.where=Front.where+F[i];Push.father=l;
if(Push.where<=0 || Push.where>9 || (i%2 && (Push.where-1)/3!=(Front.where-1)/3)) continue;
Push.num=(int)change(Push.num,Push.where,Front.where);
if(found(Push.num)) continue;
flag[Push.num%MOD].push_back(Push.num);
que[r++]=Push;
if(Push.num==123456780)
{
int G=r-1;
vector<int> vec;
while(true)
{
vec.push_back(que[G].F);
G=que[G].father;
if(G==-1) break;
}
for(int j=vec.size()-2;j>=0;j--)
printf("%c",Char[vec[j]]);
puts("");
return 0;
}
}
l++;
}
printf("unsolvable\n");
return 0;
}这个是AC的 编码 ：
/*Lucky_Glass*/
#include<cstdio>
#include<algorithm>
#include<vector>
using namespace std;
const int H[15]={1,1,2,6,24,120,720,5040,40320,362880,3628800};
const int F[4]={-3,-1,3,1};
const char Char[4]={'u','l','d','r'};
struct Queue
{
int num[15],father,F,where;
}que[600000];
bool vis[362885];
bool End(int n[])
{
for(int i=0;i<8;i++)
if(n[i]!=i+1)
return false;
return true;
}
bool found(int n[])
{
int Sum=0;
for(int i=0;i<9;i++)
for(int j=i+1;j<9;j++)
if(n[j]<n[i])
Sum+=H[8-i];
if(vis[Sum]) return true;
vis[Sum]=true;
return false;
}
int main()
{
int l=0,r=0;
Queue begin;
begin.father=begin.F=-1;
for(int i=0,num;i<9;i++)
{
char c='\0';
while(!('0'<=c && c<='9') && c!='x') c=getchar();
if(c=='x') begin.num[i]=0,begin.where=i;
else begin.num[i]=c-'0';
}
que[r++]=begin;
while(l<r)
{
Queue Front=que[l];
for(int i=0;i<4;i++)
{
Queue Push=Front;
Push.F=i;Push.where=Front.where+F[i];Push.father=l;
if(Push.where<0 || Push.where>=9 || (i%2 && Push.where/3!=Front.where/3)) continue;
swap(Push.num[Push.where],Push.num[Front.where]);
if(found(Push.num)) continue;
que[r++]=Push;
if(End(Push.num))
{
int G=r-1;
vector<int> vec;
while(true)
{
vec.push_back(que[G].F);
G=que[G].father;
if(G==-1) break;
}
for(int j=vec.size()-2;j>=0;j--)
printf("%c",Char[vec[j]]);
puts("");
return 0;
}
}
l++;
}
printf("unsolvable\n");
return 0;
}The End
Thanks for reading!
-Lucky_Glass
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
