A*算法实现九宫重排

最新推荐文章于 2024-03-28 09:17:43 发布
最新推荐文章于 2024-03-28 09:17:43 发布
阅读量4.6k 收藏 80
点赞数 12
分类专栏： 人工智能课
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43501512/article/details/111143964
版权

这里写自定义目录标题

基础知识介绍

  1. 问题描述

九宫重排问题即八数码问题，是在一个3*3的方格盘上放置1-8八个数字和一个宫格，开始的数字状态随机给出，通过控制空格的上下左右移动实现数字形成有序的或指定的顺序。
在这里插入图片描述

  1. A*算法

A算法与A算法的区别在于A算法使用了启发式搜索而不是盲目搜索，盲目搜索包括广度优先搜索、深度优先搜索等。

  1. 启发式搜索

给出了评价函数的定义： f(n) = g(n) + h(n)
其中，n为待评价的节点；g(n)为从初始节点s到节点n的最佳路径耗散值的估计值；h(n)为从节点n到目标节点t的最佳路径耗散值的估计值，称为启发函数；f(n)为从初始节点s经过节点n到达目标节点的最佳路径耗散值的估计值，成为评价函数，我们每次从叶节点选出f(n)最小的节点扩展。如果启发函数满足 h(n) <= h*(n), 则可以证明当问题有解时，A算法一定可以得到一个耗散值最小的结果。
取g(n)为层数，h(n)为不在位的数字的数量
在这里插入图片描述

代码说明

  1. 设置一个变量OPEN用于存放那些搜索图上的叶节点，也就是已经被生成出来，但是还没被扩展的节点；变量CLOSE用于存放图中的非叶节点，也就是不但被生成出来，还已经被扩展的节点。
  2. OPEN中的节点按照 f 值从小到大排列。每次从OPEN表中取出第一个元素 n 进行扩展，如果 n 是目标节点，则算法找到一个解，算法结束，否则扩展 n
  3. 对于 n 的子节点 m ，如果 m 既不在OPEN也不在CLOSE， 则将 m 加入OPEN； 如果 m 在CLOSE， 说明从初始节点到 m 有两条路径， 如果新路径耗散值大，什么都不做；如果较小，则将 m （新找到的）从CLOSE中取出放入OPEN中（删除原来在CLOSE的，将新找到的放入OPEN）
  4. 重复 1 ，知道找到一个解结束；或者OPEN为空算法以失败结束，说明无解

代码内容

C++.代码实现

#include <iostream>
using namespace std;

#define MAXLISTSIZE 10000
#define MAXSTEPSIZE 100

/*
定义八数码节点结构体
status存储节点的状态（即八数码的排列），G存储走的是第几步，H存储不在位的将牌数，F存储总耗散值，Zero存储‘0’将牌所在位置，
step存储该节点是上一节点通过怎样的移动得到的（1左2右3上4下）
*/
struct ENode
{
    int status[9];
    int G;
    int H;
    int F;
    int Zero;
    int step;
    ENode *Parent;
};

//最终状态
int FinalStatus[9] = { 1, 2, 3, 8, 0, 4, 7, 6, 5 };

//定义OPEN表和CLOSE表,open和close是表中最后一个内容的下一位序号
ENode OPEN[MAXLISTSIZE];
ENode CLOSE[MAXLISTSIZE];
int open = 0;
int close = 0;

ENode *Node;

/*
计算不在位的将牌数H
返回 H
*/
int CountH(int *status)
{
    int H = 0;
    int i;
    for (i = 0; i <= 8; i++)
    {
        if (FinalStatus[i] != status[i])
        {
            H++;
        }
    }
    return H;
}

/*
判断新生成的节点是否已经存在于OPEN表或CLOSE表中
返回 表征是否存在于OPEN或CLOSE的值，值为0 均不在，值>0 只在OPEN表，值<0 只在CLOSE表，|值|-1表示所在列表中的位置
*/
int Exist(ENode *N)
{
    int i, j;
    int H = 0;                      //计算不在位的将牌数，如果为0，则证明给函数的节点在表中已存在
    int status[9];

    Node = new ENode;
    Node = N;

    for (i = 0; i <= 8; i++)
    {
        status[i] = Node->status[i];
    }

    for (i = 0; i <= open - 1; i++)     //判断是否在OPEN表
    {
        for (j = 0; j <= 8; j++)
        {
            if (status[j] != OPEN[i].status[j])
            {
                H++;
            }
        }

        if (H == 0)                 //H=0证明在表中找到该节点
        {
            return i + 1;           //如果在OPEN表中，返回i（节点在OPEN的位置）+ 1（在OPEN找到该节点）
        }
        H = 0;                      //扫描完一个节点后重置H
    }

    for (i = 0; i <= close - 1; i++)     //判断是否在CLOSE表
    {
        for (j = 0; j <= 8; j++)
        {
            if (status[j] != CLOSE[i].status[j])
            {
                H++;
            }
        }

        if (H == 0)                 //H=0证明在表中找到该节点
        {
            return (-i) - 1;        //如果在CLOSE表中，返回-i（i为节点在CLOSE的位置）- 1（在CLOSE找到该节点）
        }
        H = 0;                      //扫描完一个节点后重置H
    }

    return 0;
}

/*
初始化节点
返回 初始化后的节点Node
*/
ENode *ENodeInit(int *status, int zero, int g, ENode *parent, int step)
{
    int i;
    Node = new ENode;
    for (i = 0; i <= 8; i++)
    {
        Node->status[i] = status[i];
    }
    Node->Zero = zero;
    Node->G = g;
    Node->H = CountH(Node->status);
    Node->F = Node->G + Node->H;
    Node->Parent = parent;
    Node->step = step;
    return Node;
}

/*
左移后的变化
返回 左移后的状态
*/
int *Left(int *s, int z)
{
    int temp, i;
    static int status[9];
    for (i = 0; i <= 8; i++)
    {
        status[i] = s[i];
    }
    temp = status[z - 1];
    status[z - 1] = 0;
    status[z] = temp;
    return status;
}

/*
右移后的变化
返回 右移后的状态
*/
int *Right(int *s, int z)
{
    int temp, i;
    static int status[9];
    for (i = 0; i <= 8; i++)
    {
        status[i] = s[i];
    }
    temp = status[z + 1];
    status[z + 1] = 0;
    status[z] = temp;
    return status;
}

/*
上移后的变化
返回 上移后的状态
*/
int *Up(int *s, int z)
{
    int temp, i;
    static int status[9];
    for (i = 0; i <= 8; i++)
    {
        status[i] = s[i];
    }
    temp = status[z - 3];
    status[z - 3] = 0;
    status[z] = temp;
    return status;
}

/*
下移后的变化
返回 下移后的状态
*/
int *Down(int *s, int z)
{
    int temp, i;
    static int status[9];
    for (i = 0; i <= 8; i++)
    {
        status[i] = s[i];
    }
    temp = status[z + 3];
    status[z + 3] = 0;
    status[z] = temp;
    return status;
}

/*
判断子节点是否在OPEN或CLOSE中，并进行对应的操作
返回值 NULL
*/
void ExistAndOperate(ENode *N)
{
    int i;
    int inList;                 //定义表示新生成节点是否在OPEN表或CLOSE表中, 值为0 均不在，值>0 只在OPEN表，值<0 只在CLOSE表

    Node = new ENode;
    Node = N;

    if (Node->G == 1)           //如果是第一步的节点，直接加入OPEN中，返回
    {
        OPEN[open] = *Node;
        open++;
        return;
    }

    inList = Exist(Node);       //判断新节点是否在OPEN或CLOSE中

    if (inList == 0)            //如果均不在两个表中，将节点加入OPEN表中
    {
        OPEN[open] = *Node;      //将拓展出的新结点加入到OPEN表中
        open++;
    }

    else if (inList > 0)             //如果在OPEN中，说明从初始节点到该节点找到了两条路径，保留耗散值短的那条路径
    {
        if (OPEN[inList - 1].F > Node->F)    //如果表内节点F值大于新节点F值，用新节点代替表内节点
        {
            OPEN[inList - 1] = *Node;
        }
    }

    else if (inList < 0)             //如果在CLOSE中，说明初始节点到该节点有两条路径，如果新找到的路径耗散值大，什么都不做，如果较小，将其从CLOSE中取出放入OPEN中    
    {
        inList = -inList;
        if (CLOSE[inList - 1].F > Node->F)       //如果较小
        {
            OPEN[open] = *Node;       //将其取出放入OPEN
            open++;
        }
        for (i = inList - 1; i <= close - 1; i++)     //将其在CLOSE中释放
        {
            CLOSE[i] = CLOSE[i + 1];
        }
        close--;
    }
}

/*
寻找最佳路径函数
返回 最后的节点Node
*/
ENode *Search()
{
    int *status;
    int i, j;

    ENode *Temp;

    while (1)                   //一直循环知道找到解结束
    {
        Temp = new ENode;
       
        for (i = open - 1; i > 0; i--)    //用冒泡排序给OPEN表里面的节点按耗散值进行排序
        {
            for (j = 0; j < i; j++)
            {
                if (OPEN[j].F > OPEN[j + 1].F)
                {
                    *Temp = OPEN[j + 1];
                    OPEN[j + 1] = OPEN[j];
                    OPEN[j] = *Temp;
                }
            }
        }

        Node = new ENode;
        *Node = OPEN[0];                 //从OPEN表中取出第一个元素（F值最小）进行扩展

        if (!CountH(Node->status))      //判断该节点是否是目标节点，若是，则不在位的将牌数为0，算法结束
        {
            break;
        }

        Temp = Node;
        CLOSE[close] = *Node;            //将扩展过的节点放入CLOSE    
        close++;
        for (i = 0; i <= open - 1; i++) //将扩展的节点从OPEN中释放
        {
            OPEN[i] = OPEN[i + 1];
        }
        open--;

        if ((Temp->Zero) % 3 >= 1)        //如果能左移，则进行左移创造新结点    
        {
            Node = new ENode;                                           //创造新结点
            status = Left(Temp->status, Temp->Zero);                   //得到新的状态
            Node = ENodeInit(status, Temp->Zero - 1, (Temp->G) + 1, Temp, 1);    //初始化新结点
            ExistAndOperate(Node);      //判断子节点是否在OPEN或CLOSE中，并进行对应的操作
        }

        if ((Temp->Zero) % 3 <= 1)        //如果能右移，则进行右移创造新结点    
        {
            Node = new ENode;                                           //创造新结点
            status = Right(Temp->status, Temp->Zero);                   //得到新的状态
            Node = ENodeInit(status, Temp->Zero + 1, (Temp->G) + 1, Temp, 2);    //初始化新结点
            ExistAndOperate(Node);      //判断子节点是否在OPEN或CLOSE中，并进行对应的操作
        }

        if (Temp->Zero >= 3)            //如果能上移，则进行上移创造新结点    
        {
            Node = new ENode;                                           //创造新结点
            status = Up(Temp->status, Temp->Zero);                   //得到新的状态
            Node = ENodeInit(status, Temp->Zero - 3, (Temp->G) + 1, Temp, 3);    //初始化新结点
            ExistAndOperate(Node);      //判断子节点是否在OPEN或CLOSE中，并进行对应的操作
        }

        if (Temp->Zero <= 5)            //如果能下移，则进行下移创造新结点    
        {
            Node = new ENode;                                           //创造新结点
            status = Down(Temp->status, Temp->Zero);                   //得到新的状态
            Node = ENodeInit(status, Temp->Zero + 3, (Temp->G) + 1, Temp, 4);    //初始化新结点
            ExistAndOperate(Node);      //判断子节点是否在OPEN或CLOSE中，并进行对应的操作
        }

        if (open == 0)                  //如果open=0， 证明算法失败， 没有解
            return NULL;
    }
    return Node;
}

/*
展示具体步骤
返回 NULL
*/
void ShowStep(ENode *Node)
{
    int STEP[MAXSTEPSIZE];
    int STATUS[MAXSTEPSIZE][9];
    int step = 0;
    int i, j;
    int totalStep = Node->G;
    while (Node)
    {
        STEP[step] = Node->step;
        for (i = 0; i <= 8; i++)
        {
            STATUS[step][i] = Node->status[i];
        }
        step++;
        Node = Node->Parent;
    }
    cout << "----------------------" << endl;
    cout << totalStep << endl;
    cout << "----------------------" << endl;
    for (i = step - 1; i >= 0; i--)
    {
        if (STEP[i] == 1)
            cout << "left";
        else if (STEP[i] == 2)
            cout << "right";
        else if (STEP[i] == 3)
            cout << "up";
        else if (STEP[i] == 4)
            cout << "down";
        else if (STEP[i] == 0)
            cout << "START";
        cout << " ";
    }
    cout << endl << "----------------------" << endl;
    for (i = step - 1; i >= 0; i--)
    {
        for (j = 0; j <= 8; j++)
        {
            cout << STATUS[i][j];
            if (j == 2 || j == 5 || j == 8)
                cout << endl;
            else
                cout << " ";
        }
        cout << "----------------------" << endl;
    }
}

/*
主函数
返回 0
*/
int main()
{
    int fstatus[9];
    int i;
    ENode *FNode;
    ENode *EndNode;

    for (i = 0; i <= 8; i++)                    //输入初始状态
    {
        cin >> fstatus[i];
    }

    for (i = 0; i <= 8; i++)                    //判断0节点位置
    {
        if (fstatus[i] == 0)
            break;
    }

    FNode = ENodeInit(fstatus, i, 0, NULL, 0);  //获得初始节点

    OPEN[open] = *FNode;                         //将初始节点放入OPEN中
    open++;
    EndNode = Search();                         //寻找最佳路径

    if (!EndNode)
        cout << "无解" << endl;
    else
        ShowStep(EndNode);                      //展示步骤

    return 0;
}

效果截图

在这里插入图片描述
第一行是输入内容是目前的棋盘状态，每一个数字之间用空格隔开，棋盘上的空格用0表示
第二行是输出内容，是走的最少的步数
第三行是输出的操作，start后是显示的是上下左右的集中操作
剩余展示的每走一步之后的状态

转载借鉴声明

本文借鉴https://www.codenong.com/cs105897291/，代码摘自上篇内容，为了有更好的理解，所以写此篇内容，如有侵权，联系删除，感谢上述博主的分享。

丑女无敌2333
关注
  • 12
    点赞
  • 踩
  • 80
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
启发式算法解决八数码（九宫）问题
Embattle的博客
04-22 1万+
人工智能课程实验  背景知识：估价函数在对问题的状态空间进行搜索时，为提高搜索效率需要和被解问题的解有关的大量控制性知识作为搜索的辅助性策略。这些控制信息反映在估价函数中。估价函数的任务就是估计待搜索节点的重要程度，给这些节点排定次序。估价函数可以是任意一种函数，如有的定义它是节点x处于最佳路径的概率上，或是x节点和目标节点之间的距离等等。在此，我们把估价函数f(n)定义为从初始节点经过n节点到达...
A*算法求解重排九宫问题
03-12
用A*算法求解重排九宫问题，将九宫格以3*3矩阵形式设计为动态对象数组类的对象，形式比较新颖。希望对大家了解A*算法，重排九宫，以及c++的动态对象数组类有所帮助。文档包含一个动态对象数组类头文件和一个源文件。
A*算法实现八数码问题
05-24
自己写的用c++实现的简易八数码问题，搜索算法采用A*算法，搜索代价使用哈密顿路（可以自己更改，），资源是工程文件。在vs2008下运行通过，里面代码都进行了注释。
九宫重排介绍
Songxianshengbei的博客
03-28 344
九宫重排是一种经典的数字游戏和算法问题，具有悠久的历史和文化背景。九宫重排游戏的规则非常简单，玩家需要通过滑动数字块来将棋盘上的数字重新排列成预定的顺序或目标状态。九宫重排问题不仅仅是一种有趣的数字游戏，还具有广泛的应用场景和实际意义。随着时代的发展，人们开始尝试将纵横图中的数字进行重新排列，以探索其中的变化规律和有趣性质。随着计算机技术的不断发展和进步，我们可以期待九宫重排问题在未来会有更多的应用场景和更高效的解决方法。同时，也可以将九宫重排问题与其他领域的问题相结合，探索出更多有趣和有价值的研究方向。
搜索算法解决九宫重排问题
12-02
不同搜索算法解决九宫重排问题，JAVA语言实现广度优先，全局择优算法解九宫重排问题，输出路径。。。。。。
九宫重排（广度优先搜索）
二哈
03-09 5897
1. 问题描述： 问题描述 　　如下面第一个图的九宫格中，放着 1~8 的数字卡片，还有一个格子空着。与空格子相邻的格子中的卡片可以移动到空格中。经过若干次移动，可以形成第二个图所示的局面。 　　我们把第一个图的局面记为：12345678. 　　把第二个图的局面记为：123.46758 　　显然是按从上到下，从左到右的顺序记录数字，空格记为句点。 　　本题目的任务是已知九宫的初态和终态，求最...
A*算法求解八数码难题（python实现）
qq_54893805的博客
10-21 1万+
本文用python实现A*算法解决了八数码问题，有被八数码问题困扰的uu们，抓紧时间，进入正文，一定会对你有所帮助！以上就是今天要讲的内容，本文介绍了如何使用python实现A*算法，解决八数码难题，希望能够对uu们有所帮助，如果有uu们有不懂的问题或者有更好的创意和建议，可以在评论区留下宝贵意见，随时欢迎私信博主，给博主点个关注，留个赞，博主不胜感激。
用探索启发A*算法解决八数码问题
weixin_35756130的博客
12-17 195
探索启发A*算法是一种用于解决八数码问题的搜索算法。 这种算法将搜索空间分成若干个节点，每个节点表示一种可能的状态。搜索从初始状态开始，通过不断拓展相邻的节点来找到最终状态。 A算法在搜索过程中使用了启发函数来估算当前节点到最终状态的距离，并将这个距离与已经走过的距离相加，得到当前节点的代价。然后，A算法会根据代价最小的原则来选择下一步要拓展哪个节点。 在解决八数码问题时，我们可以将每个数字看作一...
基于pythonA*算法两种搜索算法求解八数码问题
01-22 3168
基于pythonA*算法两种搜索算法求解八数码问题
启发式搜索解决八数码问题
如何心安理得的在老板眼皮下摸鱼
05-24 6262
1.问题描述 在一个3*3的方棋盘上放置着1,2,3,4,5,6,7,8八个数码,每个数码占一格,且有一个空格。这些数码可以在棋盘上移动，其移动规则是：与空格相邻的数码方格可以移入空格。现在的问题是：对于指定的初始棋局和目标棋局，给出数码的移动序列。该问题称八数码难题或者重排九宫问题。 2.问题分析 八数码问题是个典型的状态图搜索问题。搜索方式有两种基本的方式，即树式搜索和线式搜索。搜索策略大体有盲目搜索和启发式搜索两大类。盲目搜索就是无“向导”的搜索，启发式搜索就是有“向导”的搜索。 启发式.
重排九宫（广度优先）
12-16
重排九宫的广度优先算法 有代价函数实现局部优先 用哈希表来看是否已经在open表中
带启发函数的经典八数码问题源程序
01-09
经典八数码问题源程序，是采用启发函数的，启发函数为节点与目标节点的差异。
用Java实现九宫重排问题
最新发布
03-28
A*算法在解决九宫重排问题时非常有效，因为它可以快速找到从初始状态到目标状态的最佳路径。 广度优先搜索（BFS）算法：BFS是一种遍历或搜索树或图的算法，它从一个节点开始，探索所有相邻的节点，然后再探索下一层...
A*算法之八数码问题 python解法
热门推荐
Weary_PJ的博客
11-02 2万+
A*算法之八数码问题 python解法 文章目录A*算法之八数码问题 python解法问题描述A*算法与八数码问题状态空间的定义各种操作的定义启发式函数的定义 人工智能课程中学习了A*算法,在耗费几小时完成了八数码问题和野人传教士问题之后,决定写此文章来记录一下,避免忘记 问题描述 在3×3的棋盘上，摆有八个棋子，每个棋子上标有1至8的某一数字。棋盘中留有一个空格，空格用0来表示。空格周围的棋子可以移到空格中。要求解的问题是：给出一种初始布局（初始状态）和目标布局（为了使题目简单,设目标状态为12380
A* 算法解决八数码问题 matlab
张旺华的博客
05-17 2万+
A* 算法使用matlab 解决 八数码问题 张旺华 这个算法值得注意和思考的问题就是 评估函数 ，评估函数直接影响到你的A*算法的效率，刚开始我选取的h（n）为p（n）------（每一个将牌与其目标位置之间的距离总和）运行时间较为慢需要6秒左右，后面加上S（n） ------ （每一个将牌估分值总和加上中心位置估分值）耗时只要1.5秒。
八数码问题
weixin_33875839的博客
05-12 349
 摘要：近日来，人工智能成为科技领域搜索热词，无论是从人机大战的新闻来看，还是从新提出的深度学习理论来分析，我们可以可以清晰的预见，人工智能即将腾飞。  人工智能，顾名思义，就是模拟人类思考模式的超级算法系统，学习能力和推理能力是其核心内容。举个简单的例子，“机器学习（MachineLearning）”就是人工智能领域里很有前途的课题，其主要内容是利用大数据训练程序，让它们找到一些可遵循的规律，并...
八数码问题a*算法c语言,八数码问题-启发式搜索(A*算法)
weixin_39861920的博客
05-24 1342
八数码问题也称为九宫问题。在3×3的棋盘上摆有八个棋子，每个棋子上标有1至8的某一数字，不同棋子上标的数字不相同。棋盘上还有一个空格，与空格相邻的棋子可以移到空格中。给出一个初始状态和一个目标状态，求出从初始状态转变成目标状态的移动棋子步数的最少值。 一般的目标状态是指下面这样的排列方式。 我们先讲解下面这几个子问题，从而一步一步解决它。1.康托展开和逆康托展开假设有A,B,C,D四个字母的一个排...
八数码问题的A*算法求解
跨链技术践行者
05-16 1万+
A*算法是启发式搜素算法中较为出名和高效的算法之一，其关键是对于启发式函数的实际，启发式函数h(x)需要尽可能的接近实际的h(x)∗h(x)∗。下面是人工智能八数码问题使用A*算法求解的源码放在博客上记录一下。程序使用放错位置的棋子的个数作为启发式函数。 #include <iostream> #include <vector> #include <queue&g...
C++实现A*算法实现九宫重排
05-15
九宫重排问题是一种经典的搜索问题，可以使用A*算法来解决。下面是使用C++实现A*算法解决九宫重排问题的代码示例： ```c++ #include <iostream> #include <queue> #include <vector> #include <map> using namespace std; const int N = 3; // 九宫格大小 const int MAX_STATE = 1e5; // 最大状态数 struct State { int a[N][N]; // 九宫格 int x, y; // 空格位置 int f, g, h; // f = g + h int id; // 状态编号 bool operator < (const State& rhs) const { return f > rhs.f; // 优先队列按 f 值从小到大排序 } }; int dx[4] = {-1, 0, 1, 0}; // 方向数组 int dy[4] = {0, 1, 0, -1}; int start[N][N] = { // 初始状态 {2, 8, 3}, {1, 6, 4}, {7, 0, 5} }; int goal[N][N] = { // 目标状态 {1, 2, 3}, {8, 0, 4}, {7, 6, 5} }; int get_h(const int a[][N]) { // 估价函数 int res = 0; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (a[i][j] == 0) continue; int x = (a[i][j] - 1) / N; int y = (a[i][j] - 1) % N; res += abs(x - i) + abs(y - j); } } return res; } int state_id; // 状态编号 map<int, int> vis; // 判重数组 State S[MAX_STATE]; // 状态数组 int get_id(const int a[][N]) { // 获取状态编号 int res = 0, p = 1; for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { res += a[i][j] * p; p *= 10; } } return res; } void print(const State& s) { // 打印状态 for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { cout << s.a[i][j] << " "; } cout << endl; } } bool is_goal(const State& s) { // 判断是否为目标状态 for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { if (s.a[i][j] != goal[i][j]) return false; } } return true; } void A_star() { // A*算法 priority_queue<State> q; state_id = 0; vis.clear(); State start_state; start_state.x = 1, start_state.y = 2; // 空格位置 for (int i = 0; i < N; i++) { for (int j = 0; j < N; j++) { start_state.a[i][j] = start[i][j]; } } start_state.g = 0; start_state.h = get_h(start_state.a); start_state.f = start_state.g + start_state.h; start_state.id = state_id++; S[start_state.id] = start_state; q.push(start_state); vis[get_id(start_state.a)] = start_state.id; while (!q.empty()) { State t = q.top(); q.pop(); if (is_goal(t)) { cout << "找到目标状态" << endl; print(t); return; } for (int k = 0; k < 4; k++) { int nx = t.x + dx[k], ny = t.y + dy[k]; if (nx < 0 || nx >= N || ny < 0 || ny >= N) continue; State s = t; s.x = nx, s.y = ny; swap(s.a[t.x][t.y], s.a[nx][ny]); s.h = get_h(s.a); s.g = t.g + 1; s.f = s.g + s.h; int id = get_id(s.a); if (vis.count(id) == 0) { s.id = state_id++; S[s.id] = s; q.push(s); vis[id] = s.id; } else { int pre_id = vis[id]; if (S[pre_id].f > s.f) { S[pre_id] = s; vis[id] = s.id; q.push(s); } } } } } int main() { A_star(); return 0; } ``` A*算法的核心是估价函数，本例中使用的是曼哈顿距离，即当前状态与目标状态每个数码所在位置的曼哈顿距离之和。在代码实现中，使用了优先队列来维护搜索过程中的状态集合，采用了判重和状态编号的方法来优化算法效率。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值