MATLAB—A*解决八数码问题

最新推荐文章于 2021-03-17 15:37:20 发布
最新推荐文章于 2021-03-17 15:37:20 发布
阅读量6.5k 收藏 47
点赞数 16
分类专栏： 人工智能 文章标签： MATLAB
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LY_624/article/details/72651409
版权

一、实验目的

1、 熟悉和掌握启发式搜索的定义、估价函数和算法过程。
2、 利用A*算法求解N数码难题，理解求解流程和搜索顺序。
 

二、实验内容

以八数码为例实现A或A*算法 。

1、分析算法中的OPEN表和CLOSE表的生成过程。

2、分析估价函数对搜索算法的影响。

3、分析启发式搜索算法的特点。

三、程序实现

up8.m

function B=up8(a)  %0向上移动
[x,y]=find(a==0);
if x==1            %如果0在矩阵的最上一层，则B=-1
    B=-1;         
    return 
end
B=a;               %否则交换两个位置的值
B(x,y)=a(x-1,y);
B(x-1,y)=0;
return

down8.m 

function B=down8(a)   %0向下移动
[x,y]=find(a==0);
if x==3               %如果0在矩阵的最下一层，则B=-1
    B=-1;    
    return 
end
B=a;                   %否则交换两个位置的值
B(x,y)=a(x+1,y);
B(x+1,y)=0;
return

left8.m 

function B=left8(a)     %0向左移动
[x,y]=find(a==0);
if y==1                 %如果0在矩阵的最左一层，则B=-1
    B=-1;
    return 
end
B=a;                    %否则交换两个位置的值
B(x,y)=a(x,y-1);
B(x,y-1)=0;
return

right8.m 
function B=right8(a)         %0向右移动
[x,y]=find(a==0);
if y==3                      %如果0在矩阵的最右一层，则B=-1
    B=-1;
    return 
end
B=a;                         %否则交换两个位置的值
B(x,y)=a(x,y+1);
B(x,y+1)=0;
return

h1.m 

function val=h1(A,T) 
[i,j]=find(A==0);
B=A-T;
index=find(B~=0);     %找出A中不在位的个数，即B中非0的个数
[k,l]=find(T==0);
if i==k&&j==l        %除去目标矩阵中为0的位置，因为0不在位不计入
    val=length(index);
    return;
end
val=length(index)-1;

chushi8.m 

function OPEN8=chushi8(A,T)
    OPEN8=cell(1);
    OPEN8{1,1}.g=0;
    OPEN8{1,1}.h=h1(A,T);
    OPEN8{1,1}.f=OPEN8{1,1}.g+OPEN8{1,1}.h;
    OPEN8{1,1}.S=A;  %当前节点的状态
    OPEN8{1,1}.fa=[]; %父节点的状态，这样的保留可以从找到的目标状态追踪到初始状态

tuozhan8.m

function [OPEN8,g,tail]=tuozhan8(g,c,tail,T,OPEN8,CLOSED8)
    flag=0;                     %设置是否可扩展的标志位
    flag2=0;
    if up8(OPEN8{1,1}.S)~=-1    %判断是否可以向某个方向移动
        for i=1:c-1             %判断是否在CLOSED8表中，如果在，则不能进行扩展
            if up8(OPEN8{1,1}.S)==CLOSED8{1,i}.S
                flag=1;
                break;
            end
        end 
        
        for j=1:tail             %判断是否在OPEN8表中，如果在，则不能进行扩展
            if up8(OPEN8{1,1}.S)==OPEN8{1,j}.S
                flag2=1;
                break;
            end
        end 
        
        if flag~=1&&flag2~=1
            tail=tail+1;
            OPEN8{1,tail}.g=g;
            B=up8(OPEN8{1,1}.S);
            OPEN8{1,tail}.h=h1(B,T);
            OPEN8{1,tail}.f=OPEN8{1,tail}.g+OPEN8{1,tail}.h;
            OPEN8{1,tail}.S=B;  %当前节点的状态 
            OPEN8{1,tail}.fa=OPEN8{1,1}.S; %父节点的状态，这样的保留可以从找到的目标状态追踪到初始状态
        end
    end 
    
    if down8(OPEN8{1,1}.S)~=-1
        for i=1:c-1
            if down8(OPEN8{1,1}.S)==CLOSED8{1,i}.S
                flag=2;
                break;
            end
        end 
        
        for j=1:tail             %判断是否在OPEN8表中，如果在，则不能进行扩展
            if down8(OPEN8{1,1}.S)==OPEN8{1,j}.S
                flag2=2;
                break;
            end
        end 
        
        if flag~=2&&flag2~=2
        tail=tail+1;
        OPEN8{1,tail}.g=g;
        B=down8(OPEN8{1,1}.S);
        OPEN8{1,tail}.h=h1(B,T);
        OPEN8{1,tail}.f=OPEN8{1,tail}.g+OPEN8{1,tail}.h;
        OPEN8{1,tail}.S=B;  %当前节点的状态
        OPEN8{1,tail}.fa=OPEN8{1,1}.S; %父节点的状态，这样的保留可以从找到的目标状态追踪到初始状态
        end
    end
    
    if left8(OPEN8{1,1}.S)~=-1
        for i=1:c-1
            if left8(OPEN8{1,1}.S)==CLOSED8{1,i}.S
                flag=4;
                break;
            end
        end 
        
        for j=1:tail             %判断是否在OPEN8表中，如果在，则不能进行扩展
            if left8(OPEN8{1,1}.S)==OPEN8{1,j}.S
                flag2=4;
                break;
            end
        end 
        
        if flag~=4&&flag2~=4
        tail=tail+1;
        OPEN8{1,tail}.g=g;
        B=left8(OPEN8{1,1}.S);
        OPEN8{1,tail}.h=h1(B,T);
        OPEN8{1,tail}.f=OPEN8{1,tail}.g+OPEN8{1,tail}.h;
        OPEN8{1,tail}.S=B;  %当前节点的状态
        OPEN8{1,tail}.fa=OPEN8{1,1}.S; %父节点的状态，这样的保留可以从找到的目标状态追踪到初始状态
        end
    end
    
    if right8(OPEN8{1,1}.S)~=-1
        for i=1:c-1
            if right8(OPEN8{1,1}.S)==CLOSED8{1,i}.S
                flag=3;
                break;
            end
        end 
        
        for j=1:tail             %判断是否在OPEN8表中，如果在，则不能进行扩展
            if right8(OPEN8{1,1}.S)==OPEN8{1,j}.S
                flag2=3;
                break;
            end
        end 
        
        if flag~=3&&flag2~=3
        tail=tail+1;
        OPEN8{1,tail}.g=g;
        B=right8(OPEN8{1,1}.S);
        OPEN8{1,tail}.h=h1(B,T);
        OPEN8{1,tail}.f=OPEN8{1,tail}.g+OPEN8{1,tail}.h;
        OPEN8{1,tail}.S=B;  %当前节点的状态
        OPEN8{1,tail}.fa=OPEN8{1,1}.S; %父节点的状态，这样的保留可以从找到的目标状态追踪到初始状态
        end
    end

yunxing.m 

%A=[2 8 3;1 6 4;7 0 5]
%T=[1 2 3;8 0 4;7 6 5]

%A=[7 5 3;1 6 4;2 8 0]
%T=[1 2 3;8 0 4;7 6 5]

%A=[1 2 3;7 8 4;0 6 5]
%T=[1 2 3;8 0 4;7 6 5]

%A=[2 3 0;1 5 6;8 4 7]
%T=[1 2 3;4 5 6;7 8 0]     %运行时要修改h1函数中的if语句，因为0的位置不计入不在位个数
function [CLOSED8]= yunxing(A,T)
    OPEN8=chushi8(A,T);        %初始化OPEN8表，即将待扩展的第一个节点放入
    c=1;                       %CLOSED8表中的指针
    g=1;
    tail=1;
    CLOSED8=cell(1);
    k=1;                       %设置扩展了多少个的标志
while 1    
    if h1(OPEN8{1,1}.S,T)==0&&k<=1000  %当找到最终的目标时则输出，并跳出while循环
        disp(OPEN8{1,1}.S);
        break;
    end
    if k>=1000                   %如果扩展了的节点个数大于某个数则跳出并显示
        disp(k);
        break;
    end
    [OPEN8,g,tail]=tuozhan8(g,c,tail,T,OPEN8,CLOSED8);  %对OPEN8表中的第一个点扩展
    CLOSED8{1,c}=OPEN8{1,1};         %将已扩展的节点放入CLOSED8表中
    c=c+1;
    
    b=10000;
    index=1;
    for i=2:tail                     %找出OPEN8表中f值最小的元素
        if OPEN8{1,i}.f<=b         
            b=OPEN8{1,i}.f;
            g=OPEN8{1,i}.g;
            index=i;
        end
    end
    
    g=g+1;
    OPEN8{1,1}=OPEN8{1,index};       %将OPEN8表中的最小f的元素给OPEN8{1,1}
    OPEN8{1,index}=OPEN8{1,tail};    %将OPEN表尾元素赋给最小f值的位置
    tail=tail-1;
    k=k+1;
 end

%输出矩阵
d=length(CLOSED8);   
i=g-1;               %i表示输出的个数
t=CLOSED8{1,d};      %t为CLOSED表里最后一个元素
while i>0
    disp(t.S);       %输出此节点
    t=t.fa;          %令其等于其父节点
    if isempty(t)    %判断其父节点是否为空，为空则结束
        break;
    end
    
    for j=1:length(CLOSED8)   %判断其父节点在CLOSED表中的位置
        if CLOSED8{1,j}.S==t
            t=CLOSED8{1,j};   %如果有的话，将其位置赋给t
            break;
        end 
    end
    
    i=i-1;
end

四、运行结果


五、实验分析

首先从上向下扩展节点

结果从下向上输出，依次查找其父节点。

Li_yy123
关注
专栏目录
八数码问题matlab实现,A* 算法解决八数码问题 matlab
weixin_29894169的博客
03-17 3647
1、问题描述1．1什么是八数码问题八数码游戏包括一个33的棋盘，棋盘上摆放着8个数字的棋子，留下一个空位。与空位相邻的棋子能够滑动到空位中。游戏的目的是要达到一个特定的目标状态。标注的形式化以下： 初始状态 75 3java1 64c++2 80算法目标状态 1 23编程80 4...
基于MATLAB的八数码难题（含详细注释）
K60OLED的博客
04-10 1207
八数码难题 function []= bashumananti(A,T) c=1; %closed表中的指针 k=1; %扩展的次数 op=1; %open表中的指针 g=1; %表示第几次扩展...
人工智能八数码问题过程表示求解matlab代码
03-21
蔡振兴版人工智能中过程表示法求解八数码问题的matlab代码，GUI展示，可以自定义输入输出。
MATLAB实现8数码问题
12-13
本代码由ＭＡＴＬＡＢ实现，用于解决８数码问题的求解
MATLAB八数码问题
06-01
人工智能—MATLAB实现A*算法解决八数码问题。
A* 算法解决八数码问题 matlab
热门推荐
张旺华的博客
05-17 2万+
A* 算法使用matlab 解决 八数码问题 张旺华 这个算法值得注意和思考的问题就是 评估函数 ，评估函数直接影响到你的A*算法的效率，刚开始我选取的h（n）为p（n）------（每一个将牌与其目标位置之间的距离总和）运行时间较为慢需要6秒左右，后面加上S（n） ------ （每一个将牌估分值总和加上中心位置估分值）耗时只要1.5秒。
八数码问题的MATLAB实现（启发式）
06-08
启发式搜索，可通过修改代价函数来构建A*等不同的算法；包含基本功能
八数码问题matlab实现,用A*算法解决八数码问题 MATLAB
weixin_39789206的博客
03-17 268
代码：bashuma.mfunction []=bashumaglobal e; %open表计数global i; %close表计数global m; %循环次数计数a=0;b=0;n=0;i=0;e=1;m=0;%初始化dis=[1 2 3;8 0 4;7 6 5]; %目标节点f.prev=zeros(3);f.con=[7 5 3;1 6 4;2 8 0]; %初始节点f.num...
matlab利用深度和广度搜索解决八数码问题
08-13
代码内容为自己根据学校的课程要求进行书写，可以直接执行，可能不太符合各位大佬的要求，但是新手，我会继续努力去改进的。
八数码问题（8皇后问题）的A*算法求解（Python实现）
06-03
**八数码问题（8皇后问题）** 八数码问题，又称为8皇后问题，是一个经典的回溯法和搜索算法的应用实例。在这个问题中，目标是在一个8×8的棋盘上放置八个皇后，使得任何两个皇后都无法在同一行、同一列或同一对角线...
A*算法实现8数码问题
06-07
原创，能够实现简单的移动，超过5000次拓展则退出，可修改
A星算法八数码问题
11-01
人工智能课程作业 采用A星算法解决八数码问题 采用曼哈顿距离 A星算法 matlab 程序 性能可靠
自动进行八数码问题的最优求解，可以显示步数和过程中的数组状态，matlab源码
03-16
【达摩老生出品，必属精品，亲测校正，质量保证】 资源名：自动进行八数码问题的最优求解，可以显示步数和过程中的数组状态，matlab源码 资源类型：matlab项目全套源码 源码说明： 全部项目源码都是经过测试校正后百分百成功运行的，如果您下载后不能运行可联系我进行指导或者更换。 适合人群：新手及有一定经验的开发人员
八数码问题A*算法代码
04-06
A*算法解决八数码问题，包含了两种估价函数1.不在位的数字到该位置的曼哈顿距离；2.初始格局与目标格局位置不符的数码数目
八数码问题 基于A算法得matlab版本.zip
03-12
在MATLAB实现中，八数码问题的A*算法可能包括以下几个关键部分： 1. **状态表示**：每个状态由一个8位的数字矩阵表示，其中0代表空白格子，其他数字代表拼图中的数字。例如，[[1, 2, 3], [4, 0, 5], [6, 7, 8]]表示...
Matlab利用宽度和深度优先搜索解决八数码问题
qq_43470610的博客
08-13 4409
代码结构广度（宽度）优先搜索原理介绍算法理论流程图本次代码的算法步骤设计思路direction（移动方向判定）move(移动目标数据)主执行部分使用模块及变量程序具体流程深度优先搜索原理介绍理论流程图算法思路设计思路direction和move函数和广度搜索一致主执行部分程序设计流程图使用模块及变量 广度（宽度）优先搜索 例子为： 原理介绍 在宽度优先搜索算法中，树上节点的扩展是沿着节点深度的“断层”进行的，也就是说，节点的扩展是按照它们接近起始节点的程度依次进行的。 宽度优先搜索法在对深度为n+1的任一
用A*算法解决八数码问题 MATLAB
不想宅的冷同学
04-18 1万+
代码： bashuma.m function []=bashuma global e; %open表计数 global i; %close表计数 global m; %循环次数计数 a=0;b=0;n=0;i=0; e=1;m=0; %初始化 dis=[1 2 3;8 0 4;7 6 5]; %目标节点 f.prev=zeros(3); f.con=[7 5 3;1
matlab八数码问题
最新发布
06-12
Matlab八数码（或称Sudoku）问题是一个经典的逻辑谜题，它在数学和计算机编程中常被用作教学和娱乐项目。八数码游戏的目标是在一个9x9的网格中填入1到9的数字，每个数字在每一行、每一列以及每一个3x3的小宫格（称为"区"）内都只能出现一次。这个过程需要使用算法进行求解，因为不是所有的数字排列都是合法的。 在Matlab中，你可以利用其强大的数值计算和图形处理能力来解决八数码问题。以下是一些可能的步骤： 1. **数据结构**：通常会创建一个二维数组表示棋盘，用0表示空格。 2. **输入验证**：检查用户输入或初始状态是否满足游戏规则。 3. **启发式搜索**：常见的方法有回溯法（Backtracking），从空白格子开始，尝试填入数字，如果发现违反规则则回溯并尝试下一个数字。 4. **算法优化**：为了提高效率，可以使用一些优化技巧，如约束传播（Constraint Propagation）、部分填充（Partial Solution）、 Dancing Links 算法等。 5. **图形界面**：创建GUI展示当前状态和解决方案的过程。 6. **解决策略**：除了基本的回溯法，还可以使用人工智能技术，如遗传算法、模拟退火等高级搜索算法。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值