八数码总结
题意：
八数码问题也称为九宫问题。编号为1~8的8个正方形滑块被摆成3行3列，棋盘上还有一个空格，每次可以把与空格相邻的滑块移到空格中，而它原来的位置就成了新的空格。给定初始局面和目标局面，计算出最少的移动步数。
参考来源：八数码的八境界
方法1：
暴搜+queue，如果空格用’0’表示的话可以直接将状态压缩成一个9位整数，也可以用字符串表示状态，用结构体表示状态+步数+空格的位置。
代码：
/* 264137058 815736402 */
#include<iostream>
#include<map>
#include<cstring>
#include<queue>
#include<cstdio>
using namespace std;
map<string, int>vis;
int m, n;
struct state{string str; int pos; int dist;};
state s;
string goal;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int bfs()
{
queue<state>q;
q.push(s);
vis[s.str] = 1;
while(!q.empty()){
state t = q.front();q.pop();
if(t.str.compare(goal) == 0) return t.dist;
int p= t.pos;
int x= p / 3, y = p % 3;
for(int i = 0; i < 4; i++){
int newx = x + dx[i];
int newy = y + dy[i];
int newpos = newx * 3 + newy;
string a = t.str;
if(newx >= 0 && newx < 3 && newy >= 0 && newy < 3){
swap(a[p], a[newpos]);
if(vis[a]) continue;
vis[a] = 1;
q.push((state){a, newpos, t.dist + 1});
}
}
}
return -1;
}
int main (void)
{
string st;
int pos;
cin>>st;
cin>>goal;
for(int i = 0; i < 9; i++){
if(st[i] == '0') pos = i;
}
s = (state){st, pos, 0};
int res = bfs();
if(res == -1) cout<<"No solution"<<endl;
else cout<<res<<endl;
}
方法2：
模拟队列+康拓展开/哈希/STL set判重，学习紫书上的代码~
注意其中康拓展开
代码：
康拓展开
#include<iostream> #include<cstring> #include<set> #include<cstdio> using namespace std; typedef int state[9];//表示state 代表 int[9] const int maxn = 1e7 + 5; state st[maxn], sta, goal; int dist[maxn]; int dx[4] = {-1, 1, 0, 0}; int dy[4] = {0, 0, -1, 1}; /* 2 6 4 1 3 7 0 5 8 8 1 5 7 3 6 4 0 2 */ /******把0~8的全排列和0~362879的整数一一对应起来****/ int vis[400000], fact[10]; void init() { memset(vis, 0, sizeof(vis)); fact[0] = 1; for(int i = 1; i < 9; i++) fact[i] = fact[i - 1] * i; } int Insert(int s) { int code = 0; for(int i = 0; i < 9; i++){ int cnt = 0; for(int j = i + 1; j < 9; j++) if(st[s][j] < st[s][i]) cnt++; code += fact[8 - i] * cnt; } if(vis[code]) return 0; return vis[code] = 1; } int bfs() { init(); int fro = 0, rear = 1; dist[fro] = 0; Insert(fro); while(fro < rear){ state& s = st[fro]; if (memcmp(goal, s, sizeof(s)) == 0) return dist[fro]; int pos; for(pos = 0; pos < 9; pos++) if(!s[pos]) break; int x = pos / 3, y = pos % 3; for (int i = 0; i < 4; i++){ int newx = x + dx[i]; int newy = y + dy[i]; int newpos = newx * 3 + newy; if (newx >= 0 && newx < 3 && newy >= 0 && newy < 3){ state& t = st[rear]; memcpy(&t, &s, sizeof(s)); t[newpos] = 0; t[pos] = s[newpos]; dist[rear] = dist[fro] + 1; if(Insert(rear)) rear++; } } fro++; } return -1; } int main (void) { for(int i = 0; i < 9; i++) cin>>st[0][i]; for(int i = 0; i < 9; i++) cin>>goal[i]; int res = bfs(); if(res != -1) cout<<res<<endl; else cout<<"No solution"<<endl; return 0; } 哈希：
const int hashsize = 1000003;//大质数
int head[hashsize], next[hashsize];
void init()
{
memset(head, 0, sizeof(head));
}
int Hash(int s)
{
int tmp = 0;
for(int i = 0; i < 9; i++)
tmp = tmp * 10 + st[s][i];
return tmp % hashsize;
}
int Insert(int s)
{
int h = Hash(s);
int u = head[h];
while(u){
if(memcpy(st[u], st[s], sizeof(st[s])) == 0) return 0;
u = next[u];
}
next[s] = head[h];
head[h] = s;
return 1;
}set判重：
set<int>vis;
void init()
{
vis.clear();
}
int Insert(int s)
{
int v = 0;
for(int i = 0; i < 9; i++) v = v* 10 + st[s][i];
if(vis.count(v)) return 0;
vis.insert(v);
return 1;
}方法3：
模拟队列+双向bfs~~这里判重随便选一个就好啦~~节约一半的时间和一半的空间，真心快多了~
代码：
#include<iostream>
#include<queue>
#include<cstring>
using namespace std;
typedef int state[9];
const int maxn = 1e7 + 5;
state st[maxn];
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int fact[maxn], vis[maxn], dist[3][maxn];
/* 2 6 4 1 3 7 0 5 8 8 1 5 7 3 6 4 0 2 */
void init()
{
memset(vis, 0, sizeof(vis));
fact[0] = 1;
for(int i = 1; i < 9; i++)
fact[i] = fact[i - 1] * i;
}
int canto(state s)
{
int code = 0;
for(int i = 0; i < 9; i++){
int cnt = 0;
for(int j = i + 1; j < 9; j++){
if(s[j] < s[i]) cnt++;
}
code += fact[8 - i] * cnt;
}
return code;
}
int bfs()
{
init();
int cs = canto(st[0]);
int ct = canto(st[1]);
dist[1][cs] = 0;
dist[2][ct] = 0;
vis[cs] = 1;
vis[ct] = 2;
int fro = 0, rear = 2;
while(fro < rear){
state& s = st[fro];
cs = canto(s);
int pos;
for(pos = 0; pos < 9; pos++) if(!s[pos]) break;
int x = pos / 3, y = pos % 3;
for (int i = 0; i < 4; i++){
int newx = x + dx[i];
int newy = y + dy[i];
int newpos = newx * 3 + newy;
if (newx >= 0 && newx < 3 && newy >= 0 && newy < 3){
state& t = st[rear];
memcpy(&t, &s, sizeof(s));
t[pos] = s[newpos];
t[newpos] = s[pos];
ct = canto(t);
if(!vis[ct]){
vis[ct] = vis[cs];
dist[vis[cs]][ct] = dist[vis[cs]][cs] + 1;
rear++;
}else if(vis[ct] != vis[cs]){
return dist[vis[ct]][ct] + dist[vis[cs]][cs] + 1;
}
}
}
fro++;
}
return -1;
}
int main (void)
{
for(int i = 0; i < 9; i++) cin>>st[0][i];
for(int i = 0; i < 9; i++) cin>>st[1][i];
int res = bfs();
if(res != -1) cout<<res<<endl;
else cout<<"No solution"<<endl;
return 0;
}
方法4：
A* + 优先级队列（小顶堆）+ 曼哈顿距离
A*搜索算法
当任何第二次走到一个点的时候，判断最小步骤是否小于记录的内容，如果是，则更新掉原最小步数，关于记录最小步数，如果使用曼哈顿距离作为 h(n) ，则不必记录，这时的A*满足：每个点第一次被选出搜索队列时的状态为到达此点的最优解,而且每个点只会进入队列一次。所以只需要设定一个vis的数组就够了。
代码：
#include<iostream>
#include<cstring>
#include<cmath>
#include<queue>
/* 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 0 7 8 2 6 4 1 3 7 0 5 8 8 1 5 7 3 6 4 0 2 */
using namespace std;
struct state
{
int a[9];
int pos;
int f,g;
int can;
bool operator < ( const state s2)const {
return f > s2.f;
}
};
const int maxn = 1e7 + 5;
state sta, goal;
int dx[4] = {-1, 1, 0, 0};
int dy[4] = {0, 0, -1, 1};
int fact[maxn], vis[maxn];
void init()
{
fact[0] = 1;
for(int i = 1; i < 9; i++)
fact[i] = fact[i - 1] * i;
}
int canto(state s)
{
int code = 0;
for(int i = 0; i < 9; i++){
int cnt = 0;
for(int j = i + 1; j < 9; j++){
if(s.a[j] < s.a[i]) cnt++;
}
code += fact[8 - i] * cnt;
}
return code;
}
int geth(state be)
{
int res = 0;
for(int i = 0; i < 9; i++){
int tmp = goal.a[i];
for(int j = 0; j < 9; j++){
if(be.a[j] == tmp)
res += abs(i/3 - j/3) + abs(i % 3 - j % 3);
break;
}
}
return res;
}
int astar()
{
priority_queue<state> q;
q.push(sta);
vis[sta.can] = 1;
while(!q.empty()){
state s = q.top();
q.pop();
if(s.can == goal.can) return s.g;
int x = s.pos / 3, y = s.pos % 3;
for(int i = 0; i < 4; i++){
int newx = x + dx[i];
int newy = y + dy[i];
int newpos = newx * 3 + newy;
if (newx >= 0 && newx < 3 && newy >= 0 && newy < 3){
state t = s;
t.a[t.pos] = s.a[newpos];
t.a[newpos] = s.a[t.pos];
t.pos = newpos;
t.can = canto(t);
if(vis[t.can]) continue;
t.g = s.g + 1;
t.f= geth(t) + t.g;
q.push(t);
vis[t.can] = 1;
}
}
}
return -1;
}
void print (state t)
{
for(int i = 0; i < 9; i++)
cout<<t.a[i]<<' ';
cout<<endl;
cout<<"pos"<<t.pos<<endl;
cout<<"can"<<t.can<<endl;
cout<<"f"<<t.f<<endl;
}
int main (void)
{
init();
for(int i = 0; i < 9; i++){
cin>>sta.a[i];
if(sta.a[i] == 0){
sta.pos = i;
}
}
sta.g = 0;
sta.can = canto(sta);
//print(sta);
for(int i = 0; i < 9; i++) cin>>goal.a[i];
goal.can = canto(goal);
//print(goal);
int res = astar();
if(res != -1) cout<<res<<endl;
else cout<<"No solution"<<endl;
return 0;
}
方法5：
IDA* + 曼哈顿距离
IDA*即迭代加深的A*搜索，实现代码是最简练的，无须状态判重，无需估价排序。那么就用不到哈希表，堆上也不必应用，空间需求变的超级少。效率上，应用了曼哈顿距离。同时可以根据深度和h值，在找最优解的时候，对超过目前最优解的地方进行剪枝，这可以导致搜索深度的急剧减少，所以，这是一个致命的剪枝！因此，IDA*大部分时候比A*还要快，可以说是A*的一个优化版本！
代码：
#include<iostream>
#include<queue>
#include<cstring>
#include<cmath>
using namespace std;
const int maxn = 1e7 + 5;
int maxdepth;
int dx[4] = {1, 0 , 0, -1};
int dy[4] = {0, 1, -1, 0};
/* 1 2 3 4 5 6 7 8 0 1 2 3 4 5 6 0 7 8 2 6 4 1 3 7 0 5 8 8 1 5 7 3 6 4 0 2 */
struct state
{
int a[9];
int pos;
};
state st[maxn];
state goal, sta;
int geth(state be)
{
int res = 0;
for(int i = 0; i < 9; i++){
int tmp = goal.a[i];
if(tmp == 0) continue;
for(int j = 0; j < 9; j++){
if(be.a[j] == tmp){
res += abs(i/3 - j/3) + abs(i % 3 - j % 3);
break;
}
}
}
return res;
}
void print(state s)
{
for(int i = 0; i < 9; i++)
cout<<s.a[i]<<' ';
cout<<endl;
}
int dfs(state s, int h, int depth, int prei)
{
if(h == 0) return 1;
// print(s);
if(depth + h > maxdepth) return 0;
int x = s.pos / 3, y = s.pos % 3;
for (int i = 0; i < 4; i++){
if(prei + i == 3) continue;
int newx = x + dx[i];
int newy = y + dy[i];
int newpos = newx * 3 + newy;
if (newx >= 0 && newx < 3 && newy >= 0 && newy < 3){
state t = s;
t.a[s.pos] = s.a[newpos];
t.a[newpos] = s.a[s.pos];
t.pos = newpos;
if(dfs(t, geth(t), depth + 1, i)) return 1;
}
}
return 0;
}
int idastar()
{
int h = geth(sta);
maxdepth = h;
while(!dfs(sta, h, 0, -1) && maxdepth < 100) {
maxdepth++;
}
return maxdepth;
}
int main (void)
{
for(int i = 0; i < 9; i++){
cin>>sta.a[i];
if(sta.a[i] == 0){
sta.pos = i;
}
}
for(int i = 0; i < 9; i++){
cin>>goal.a[i];
}
int res = idastar();
if(res < 100) cout<<res<<endl;
else cout<<"No solution"<<endl;
return 0;
}
方法6：
有关逆序数
空格在同一行上进行移动，1~8的排列逆序数不变，空格在同一列上进行移动，1~8的排列逆序数发生变化的对数为偶数。所以初始状态的逆序数与目标态同奇偶则有解，反之无解；
这一优化可以用在上面的所有方法中，也是一个很重要的剪枝。
代码：
int Reverse(state s)
{
int cnt = 0;
for(int i = 0; i < 9; i++){
int tmp = s.a[i];
if(tmp == 0) continue;
for(int j = i +1; j < 9; j++){
if(s.a[j] && s.a[i] > s.a[j]) cnt++;
}
}
return cnt % 2;
}真的是细节决定一切。。。竟然写了一天。。。一半时间还都用来调试。。。写的时候就应该心思细腻，检查的时候模拟一遍过程，任何细节都不能放过！