八数码与A*算法

最新推荐文章于 2023-12-04 21:53:45 发布

Star_.

最新推荐文章于 2023-12-04 21:53:45 发布

阅读量451

点赞数

分类专栏： ACM

本文链接：https://blog.csdn.net/qq_52237775/article/details/119530934

版权

ACM 专栏收录该内容

19 篇文章 0 订阅

订阅专栏

八数码

状态搜索问题

八数码问题也称为九宫问题。在3×3的棋盘，摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。要求解决的问题是：给出一个初始状态和一个目标状态，找出一种从初始转变成目标状态的移动棋子步数最少的移动步骤。

我们从空格处移动，也就是初始状态A,可以按上下左右顺序移动，之后再将这四个改变的棋盘再拓展，直到目标状态F。在此中间，我们还要判断这个状态是否与之前的状态重复，一是减少时间复杂度，二是使我们的代码更加完善。
这里要用到康托展开来快速判重。
康托展开
我们按某种规则将一个数的全排列排序，然后依次写上序号
比如三的全排列（按照字典序）
123 —1
132 —2
213 —3
231 —4
312 —5
321 —6
从上面可以看出 312是第5位

在八码数里，我们就可以利用康托展开来判重

拓展知识：
康托逆展开
输入一个数n，返回第n大的排列

下面是独立完成的八数码代码
（以后写程序会加上注释，不然回头自己看时候自己都不知道什么意思）

#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <map>
#include <algorithm>
#include <queue>
#include <stack>
#include <cmath>
using namespace std;
typedef long long  ll;
#define pi acos(-1.0)
#define INF 0x7fffffff
#define mem(x) memset(x,INF,sizeof(x))
#define rep(m,n,h) for(int m=n;m<=h;m++)
#define fo(m,n,h) for(int m=n;m<h;m++)
#define cls(x) memset(x,0,sizeof(x))
#define IOS  std::ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
const int N =362880;//9的阶乘
int dir[4][2]={{-1,0},{0,-1},{1,0},{0,1}};//按上下左右的方向
int visited[N+50]={0};//每个状态的记录，查看是否用过
int factorial[]={1,1,2,6,24,120,720,5040,40320,362880};//从0到9的阶乘，在康托展开时要用到
struct node{
int state[9];
int dis;
};//记录一个状态和到初始状态的步数
bool Cantor(int *str,int n){//康托展开判重
    int result=0;
    for(int i=0;i<n;i++){
        int counted=0;
        for(int j=i+1;j<n;j++){
            if(str[i]>str[j]){
                counted++;
            }
        }
        result+=counted*factorial[n-i-1];
    }
    if(!visited[result]){
        visited[result]=1;
        return 1;
    }
    return 0;
}
int start[9],goal[9];
int BFS(){
    node head;
    head.dis=0;
    memcpy(head.state,start,sizeof(head.state));//复制初始状态的值
    Cantor(head.state,9);//判重，将初始状态的visited[]赋值为1
    queue<node> q;
    q.push(head);
    while(!q.empty()){
        head=q.front();
        if(memcmp(head.state,goal,sizeof(goal))==0)//判断是否与目标状态一致
            return head.dis;
        q.pop();
       int k;
       for(k=0;k<9;k++)//找到该状态0所处的位置
            if(head.state[k]==0)
            break;
       int x=k%3;//所在的行
       int y=k/3;//所在的列
       for(int i=0;i<4;i++){
           int newx=x+dir[i][0];
           int newy=y+dir[i][1];
           int newk=newx+3*newy;//转一维坐标
        if(newx>=0&&newx<3&&newy>=0&&newy<3){//未出界
            node newhead;
            memcpy(&newhead,&head,sizeof(struct node));//复制这个新的状态
            swap(newhead.state[k],newhead.state[newk]);
            newhead.dis++;
            if(Cantor(newhead.state,9))//康托展开来判重
                q.push(newhead);
        }
       }
    }
    return -1;
}
int main()
{
    //freopen("C:\\Users\\lenovo\\Desktop\\in.txt","r",stdin);
    IOS
    for(int i=0;i<9;i++)
        cin>>start[i];
    for(int i=0;i<9;i++)
        cin>>goal[i];
    int num=BFS();
    if(num!=-1)
        cout<<num<<endl;
    else
        cout<<"Impossible"<<endl;
    return 0;
}