精华内容
下载资源
问答
  • 八数码问题实验报告

    2013-06-18 18:20:42
    八数码问题,课程设计实验报告
  • 已结贴√问题点数:20回复次数:8 八数码问题题目:http://acm.hdu.杭电和北大上有同样的题目,但是杭电的数据比较强,北大的数据弱,我在做杭电的题:1.用朴素的BFS(TLE)2.使用预处理,先遍历18W+种情况,然后直接...

    已结贴√

    问题点数:20 回复次数:8

    ca56232b3bbedf9a539d07f37fffb99a.gif

    3144d8b7615c79d9f638db40d5689d26.gif

    a218af6549b45ee526caf607ebff1358.gif

    0f8df0e29816ae721419de940fb833d1.gif

    八数码问题

    题目:http://acm.hdu.

    杭电和北大上有同样的题目,但是杭电的数据比较强,北大的数据弱,我在做杭电的题:

    1.用朴素的BFS(TLE)

    2.使用预处理,先遍历18W+种情况,然后直接打印路径 如果该start在visit里没有被记录,那么就提示误解    (WA) :打印出来的路径不对,不知道是什么原因?

    做北大的题:

    1.用朴素的BFS(RE) 虽然没有TLE,但是评测系统提示数组越界

    RQNOJ:

    1.用朴素的BFS(AC) 数据很弱吧

    朴素BFS:

    #include

    #include

    #include

    int dx[4]={-1,0,1,0};

    int dy[4]={0,1,0,-1};

    char queue[400000][10];

    int s[400000];

    char visit[400000];

    int farther[400000];

    char r[400000];

    int fac[9]={1,1,2,6,24,120,720,5040,40320};

    void print(int x,int end)

    {

    if(x==end)

    return ;

    print(farther[x],end);

    printf("%c",r[x]);

    }

    int judge(int x,int y)

    {

    if(x>=0&&x<3&&y>=0&&y<3)

    return 1;

    return 0;

    }

    int cantor(char s[])

    {

    int i,j,t,sum=0;

    for(i=0;i<9;i++)

    {

    t=0;

    for (j=i+1;j<9;j++)

    if(s[j]-'0'

    t++;

    sum=sum+t*fac[9-i-1];

    }

    return sum;

    }

    void bfs(char start[],char end[])

    {

    int head=0,tail=1;

    int i,j,k,x,y,xx,yy,m,step,f;

    char temp;

    char temp1[10],temp2[3][3];

    char temp3[10];

    memset(queue,0,sizeof(queue));

    memset(visit,0,sizeof(visit));

    memset(r,0,sizeof(r));

    memset(farther,0,sizeof(farther));

    memset(s,0,sizeof(visit));

    strcpy(queue[0],start);

    while(head

    {

    strcpy(temp1,queue[head]);

    m=0;

    for(i=0;i<3;i++)

    for(j=0;j<3;j++)

    {

    temp2[i][j]=temp1[m++];

    if(temp2[i][j]=='0')

    x=i,y=j;

    }

    step=s[head];

    if(strcmp(temp1,end)==0)

    {

    print(cantor(end),cantor(start));

    //printf(" %d\n",step);

    printf("\n");

    return ;

    }

    head++;

    for(i=0;i<4;i++)

    {

    xx=x+dx[i];

    yy=y+dy[i];

    m=0;

    for(k=0;k<3;k++)

    for(j=0;j<3;j++)

    temp2[k][j]=temp1[m++];

    if(judge(xx,yy)==1)

    {

    temp=temp2[xx][yy];

    temp2[xx][yy]=temp2[x][y];

    temp2[x][y]=temp;

    m=0;

    for(k=0;k<3;k++)

    for(j=0;j<3;j++)

    temp3[m++]=temp2[k][j];

    f=cantor(temp3);

    if(visit[f]==1)

    continue;

    visit[f]=1;

    farther[f]=cantor(temp1);

    if(i==0)

    r[f]='u';

    else if(i==1)

    r[f]='r';

    else if(i==2)

    r[f]='d';

    else

    r[f]='l';

    strcpy(queue[tail],temp3);

    s[tail]=step+1;

    tail++;

    continue;

    }

    }

    }

    printf("unsolvable\n");

    }

    int main()

    {

    int i,m;

    char temp[1000];

    char start[10],end[10];

    while(gets(temp))

    {

    for(i=0,m=0;i

    if((temp[i]>='0'&&temp[i]<='9')||temp[i]=='x')

    {

    if(temp[i]!='x')

    start[m++]=temp[i];

    else

    start[m++]='0';

    }

    strcpy(end,"123456780");

    bfs(start,end);

    }

    //system("pause");

    return 0;

    }

    预处理BFS:

    #include

    #include

    #include

    int dx[4]={-1,0,1,0};

    int dy[4]={0,1,0,-1};

    char queue[400000][10];

    char visit[400000];

    int farther[400000];

    char r[400000];

    int fac[9]={1,1,2,6,24,120,720,5040,40320};

    void print(int x,int end)

    {

    if(x==end)

    return ;

    print(farther[x],end);

    printf("%c",r[x]);

    }

    int judge(int x,int y)

    {

    if(x>=0&&x<3&&y>=0&&y<3)

    return 1;

    return 0;

    }

    int cantor(char s[])

    {

    int i,j,t,sum=0;

    for(i=0;i<9;i++)

    {

    t=0;

    for (j=i+1;j<9;j++)

    if(s[j]-'0'

    t++;

    sum=sum+t*fac[9-i-1];

    }

    return sum;

    }

    void bfs()

    {

    int head=0,tail=1;

    int i,j,k,x,y,xx,yy,m,f;

    char temp;

    char temp1[10],temp2[3][3];

    char temp3[10];

    memset(queue,0,sizeof(queue));

    memset(visit,0,sizeof(visit));

    memset(r,0,sizeof(r));

    memset(farther,0,sizeof(farther));

    strcpy(queue[0],"123456780");

    while(head

    {

    strcpy(temp1,queue[head]);

    m=0;

    for(i=0;i<3;i++)

    for(j=0;j<3;j++)

    {

    temp2[i][j]=temp1[m++];

    if(temp2[i][j]=='0')

    x=i,y=j;

    }

    head++;

    /*for(i=0;i<3;i++)

    {

    printf("\n");

    for(j=0;j<3;j++)

    printf("%c",temp2[i][j]);

    }

    printf("\n");*/

    for(i=0;i<4;i++)

    {

    xx=x+dx[i];

    yy=y+dy[i];

    m=0;

    for(k=0;k<3;k++)

    for(j=0;j<3;j++)

    temp2[k][j]=temp1[m++];

    if(judge(xx,yy)==1)

    {

    temp=temp2[xx][yy];

    temp2[xx][yy]=temp2[x][y];

    temp2[x][y]=temp;

    m=0;

    memset(temp3,0,sizeof(temp3));

    for(k=0;k<3;k++)

    for(j=0;j<3;j++)

    temp3[m++]=temp2[k][j];

    f=cantor(temp3);

    if(visit[f]==1)

    continue;

    visit[f]=1;

    farther[f]=cantor(temp1);

    if(i==0)

    r[f]='u';

    else if(i==1)

    r[f]='r';

    else if(i==2)

    r[f]='d';

    else

    r[f]='l';

    strcpy(queue[tail],temp3);

    tail++;

    continue;

    }

    }

    }

    //printf("-1\n");

    }

    int main()

    {

    int i,m;

    char temp[50];

    char start[10],end[10];

    bfs();

    strcpy(end,"123456780");

    while(gets(temp))

    {

    for(i=0,m=0;i

    if((temp[i]>='0'&&temp[i]<='9')||temp[i]=='x')

    {

    if(temp[i]!='x')

    start[m++]=temp[i];

    else

    start[m++]='0';

    }

    if(visit[cantor(start)]==1)

    {

    print(cantor(start),cantor(end));

    printf("\n");

    }

    else

    printf("unsolvable\n");

    }

    //system("pause");

    return 0;

    }

    展开全文
  • 本资源包括宽度优先搜索算法解决八数码问题实验报告以及用python实现的源代码,有较详细的原理和设计思路,代码有详细的注释,适合初学者学习。
  • 北航三系,人工智能,A星算法,8数码难题,含C源代码
  • C语言解八数码问题人工智能实验报告《人工智能》上机实验基于人工智能的状态空间搜索策略研究——八数码问题求解(一)实验软件TC2.0 或 VC6.0 编程语言或其它编程语言(二)实验目的1. 熟悉人工智能系统中的问题求解...

    C语言解八数码问题人工智能实验报告

    《人工智能》上机实验

    基于人工智能的状态空间搜索策略研究

    ——八数码问题求解

    (一)实验软件

    TC2.0 或 VC6.0 编程语言或其它编程语言

    (二)实验目的

    1. 熟悉人工智能系统中的问题求解过程;

    2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用;

    3. 熟悉对八数码问题的建模、求解及编程语言的应用。

    (三)需要的预备知识

    1. 熟悉TC2.0 或 VC6.0 编程语言或者其它编程语言;

    2. 熟悉状态空间的宽度优先搜索、深度优先搜索和启发式搜索算法;

    3. 熟悉计算机语言对常用数据结构如链表、队列等的描述应用;

    4. 熟悉计算机常用人机接口设计。

    (四)实验数据及步骤

    1. 实验内容

    八数码问题:在3×3的方格棋盘上,摆放着1到8这八个数码,有1个方格是空的,其初始状态如图1所示,要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。

    2541233784186765(a) 初始状态 (b) 目标状态

    图1 八数码问题示意图

    请任选一种盲目搜索算法(深度优先搜索或宽度优先搜索)或 任选一种启发式搜索方法(A 算法或 A* 算法)编程求解八数码问题(初始状态任选),并对实验结果进行分析,得出合理的结论。

    2. 实验步骤

    (1)分析算法基本原理和基本流程;

    程序采用宽度优先搜索算法,基本流程如下:

    (2)确定对问题描述的基本数据结构,如 Open 表和 Closed 表等;

    OPENCLOSEDS?A,B,CSB,C,D,E,FS,AC,D,E,F,GS,A,BD,E,F,G,HS,A,B,CE,F,G,H,I,JS,A,B,C,DF,G,H,I,J K,LS,A,B,C,D,EG,H,I,J K,L,M,NS,A,B,C,D,E,FH,I,J K,L,M,N,O,PS,A,B,C,D,E,F,G

    (3)编写算符运算、目标比较等函数;

    (4)编写输入、输出接口;

    (5)全部模块联调;

    (6)撰写实验报告。

    (五)实验报告要求

    所撰写的实验报告必须包含以下内容:

    1. 算法基本原理和流程框图;

    2. 基本数据结构分析和实现;

    3. 编写程序的各个子模块,按模块编写文档,含每个模块的建立时间、功能、输入输出参数意义和与其它模块联系等;

    4. 程序运行结果,含使用的搜索算法及搜索路径等;

    5. 实验结果分析;

    6. 结论;

    7. 提供全部源程序及软件的可执行程序。

    附:实验报告格式

    一、实验问题

    二、实验目的

    三、实验原理

    四、程序框图

    五、实验结果及分析

    六、结论

    七、源程序及注释

    #include

    #include

    int n,m;

    typedef struct Node

    {

    char matrix[10];/*存储矩阵*/

    char operate;/*存储不可以进行的操作,L代表不能左移R代表不能右移U代表不能上移D代表不能下移*/

    char extend;/*是否可以扩展,Y代表可以,N代表不可以*/

    int father;/*指向产生自身的父结点*/

    }Node;

    char start[10]={"};/*此处没有必要初始化*/

    char end[10]={"1238 4765"};/*此处没有必要初始化*/

    Node base[4000];

    int result[100];/*存放结果的base数组下标号,逆序存放*/

    int match()/*判断是否为目标*/

    {

    int i;

    for(i=0;i<9;i++)

    {

    if(base[n-1].matrix[i]!=end[i])

    {

    return 0;

    }

    }

    return 1;

    }

    void show()/*显示矩阵的内容*/

    {

    int i=1;

    while(m>=0)

    {

    int mm=result[m];

    //clrscr();

    printf("\n\n\n 状态方格\t\t步骤 %d",i);

    printf("\n\n\n\n\n\t\t\t%c\t%c\t%c\n",base[mm].matrix[0],base[mm].matrix[1],base[mm].matrix[2]);

    printf("\n\n\t\t\t%c\t%c\t%c\n",base[mm].matrix[3],base[mm].matrix[4]

    展开全文
  • 一、实验内容和要求八数码问题:在 3 ×3的方格棋盘上,摆放着 1到8这八个数码,有 1个方格是空的,其初始状态如图 1所示,要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到...

    一、实验内容和要求

    八数码问题:在 3 ×3的方格棋盘上,摆放着 1到8这八个数码,有 1个方格是

    空的,其初始状态如图 1所示,要求对空格执行空格左移、空格右移、空格上移

    和空格下移这四个操作使得棋盘从初始状态到目标状态。

    例如:

    2 8 3 1 2 3

    1 6 4 8 4

    7 0 5 7 6 5

    (a) 初始状态 (b) 目标状态

    图 1 八数码问题示意图

    请任选一种盲目搜索算法 (广度优先搜索或深度优先搜索) 或任选一种启发

    式搜索方法(全局择优搜索,加权状态图搜索, A 算法或 A * 算法)编程求解八

    数码问题( 初始状态任选 )。选择一个初始状态,画出搜索树,填写相应的 OPEN

    表和 CLOSED表,给出解路径,对实验结果进行分析总结,得出结论。

    二、实验目的

    1. 熟悉人工智能系统中的问题求解过程;

    2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用;

    3. 熟悉对八数码问题的建模、求解及编程语言的应用。

    三、实验算法

    A* 算法是一种常用的启发式搜索算法。

    在 A* 算法中,一个结点位置的好坏用估价函数来对它进行评估。 A* 算法的估价

    函数可表示为:

    f'(n) = g'(n) + h'(n)

    这里,f'(n) 是估价函数, g'(n) 是起点到终点的最短路径值 (也称为最小耗费或

    最小代价),h'(n) 是 n 到目标的最短路经的启发值。由于这个 f'(n) 其实是无法

    预先知道的,所以实际上使用的是下面的估价函数:

    f(n) = g(n) + h(n)

    其中 g(n) 是从初始结点到节点 n 的实际代价, h(n) 是从结点 n 到目标结点的最

    佳路径的估计代价。在这里主要是 h(n) 体现了搜索的启发信息,因为 g(n) 是已

    知的。用 f(n) 作为 f'(n) 的近似,也就是用 g(n) 代替 g'(n) ,h(n) 代替 h'(n) 。

    这样必须满足两个条件: (1)g(n)>=g'(n) (大多数情况下都是满足的,可以不

    用考虑),且 f 必须保持单调递增。 (2)h 必须小于等于实际的从当前节点到达

    目标节点的最小耗费 h(n)<=h'(n) 。第二点特别的重要。可以证明应用这样的估

    价函数是可以找到最短路径的。

    3.A* 算法的步骤

    A* 算法基本上与广度优先算法相同, 但是在扩展出一个结点后, 要计算它的估价

    函数,并根据估价函数对待扩展的结点排序, 从而保证每次扩展的结点都是估价

    函数最小的结点。

    A* 算法的步骤如下:

    1)建立一个队列,计算初始结点的估价函数 f ,并将初始结点入队,设置队列

    头和尾指针。

    2 )取出队列头(队列头指针所指)的结点,如果该结点是目标结点,则输出路

    径,程序结束。否则对结点进行扩展。

    3 )检查扩展出的新结点是否与队列中的结点重复,若与不能再扩展的结点重复

    (位于队列头指针之前),则将它抛弃;若新结点与待扩展的结点重复(位于队

    列头指针之后),则比较两个结点的估价函数中 g 的大小,保留较小 g 值的结点。

    跳至第五步。

    4 )如果扩展出的新结点与队列中的结点不重复,则按照它的估价函数 f

    展开全文
  • 八数码实验报告

    2016-06-02 18:27:07
    八数码实验报告
  • 八数码问题:在3×3的方格棋盘上,摆放着1到8这八个数码,有1个方格是空的,其初始状态如图1所示,要求对空格执行空格左移、空格右移、空格上移和空格下移这四个操作使得棋盘从初始状态到目标状态。分别用广度优先和...
  • 人工智能实验,包括八数码问题八皇后问题和tsp问题。。。。。。
  • 基于人工智能的状态空间搜索策略研究 八数码问题求解 一实验软件 或 编程语言或其它编程语言 二实验目的 1. 熟悉人工智能系统中的问题求解过程 2. 熟悉状态空间的盲目搜索和启发式搜索算法的应用 3. 熟悉对八数码...
  • AI 八数码A_star算法问题-实验报告

    千次阅读 2020-04-24 12:44:21
    八数码问题的A星搜索算法实现         要求:设计估价函数,并采用c或python编程实现,以八数码为例演示A星算法的搜索过程,争取做到直观、清晰地演示算法,代码要适当加...

    一 题目要求:

            八数码问题的A星搜索算法实现
            要求:设计估价函数,并采用c或python编程实现,以八数码为例演示A星算法的搜索过程,争取做到直观、清晰地演示算法,代码要适当加注释。
            八数码难题:在3×3方格棋盘上,分别放置了标有数字1,2,3,4,5,6,7,8的八张牌,初始状态S0可自己随机设定,使用的操作有:空格上移,空格左移,空格右移,空格下移。试采用A*算法编一程序实现这一搜索过程.

    二 构造状态空间:

            这个题目的状态空间描述为一组整数对(r,s,t,u,v,w,x,y,z)。
            每个字母分别对应八数码的每个位置,如下表所示。

    r s t
    u v w
    x y z

    表1-八数码状态空间对应关系

    三 对题目的理解:

            这个题目也应该采用树形结构来解,我觉得难点有二:

    1. 如何建立每个节点的数据结构;
    2. 因为是A*算法,所以公式f=g+h启发信息,如何在编程中体现。
      这里我是用Python写的算法,结点的数据结构如下:
    class Point:
        def __init__(self, r, s, t, u, v, w, x, y, z):
            self.r = r
            self.s = s
            self.t = t
            self.u = u
            self.v = v
            self.w = w
            self.x = x
            self.y = y
            self.z = z
            self.g = 0
            self.f = 0  # f = g+h
            self.father = None
            self.node = [r, s, t, u, v, w, x, y, z]	
    

    首先定义了八数码问题的9个位置的值。比较重要的是Point结点的father属性,指明了子节点与父节点的关系,保证了树形结构的准确性。然后定义了g属性,来保存节点的深度,f属性为g+h的和,这样就保证了启发信息。

    1. 后来遇到个Python特有的bug,就是def了一个函数,然后传参,就算我用=号复制了一个list,原来的参数也会被改变,因为他们的指针都是一样的。解决方法是用copy.copy(list),这样复制就不是同一个指针了。

    四 算法代码:

    见报告最后。

    五 代码解释:

    1. 首先定义了open表、closed表,声明了Point类,定义了初始节点init(2, 0, 3, 1, 8, 4, 7, 6, 5)和目的节点(1, 2, 3, 8, 4, 5, 0, 7, 6)。
    2. 在开始进行A_star(A*)算法之前,先定义几个函数:
      1) getKey:找出Point节点中0(即空格)的位置索引;
      2) up:空格上移函数。把某节点的空格和上方位置的值交换(考虑了溢出问题,即第一行不能up);
      3) down:空格下移函数。同上;
      4) left:空格左移函数。同上;
      5) right:空格右移函数。同上;
      6) h:启发函数。将某个节点与目的节点比较,返回位置不同的数目;
      7) equal:判断两个节点是否相同;
      8) open_sort:把open表里面的节点,按照属性f的值,排序;
      9) in_list:判断节点是否在open表或者closed表已经存在。
    3. 开始编写A*算法:
      1) 首先,先把初始节点init放入到OPEN表中,然后遍历OPEN表;
      2) 如果OPEN中取出的节点是目的节点goal,那么结束遍历;否则把这个节点从OPEN表取出,放入CLOUSED表;
      3) 然后根据此节点,来得到它的子节点,通过上、下、左、右四个方向来获取四个新节点,然后对四个节点遍历;
      4) 把该节点的f属性、father属性、g属性指定好。判断该new节点是否已经出现在open表中,如果已经出现了而且它的f属性值更好,说明它更优,那么把之前的移除,把这个插入。Open表同理。如果该new节点在open表和closed表都没有,那么把它直接插入到open表。最后根据f属性的值,对open表的节点排序
      4 最后打印一下路径,就可显示出解。

    六 算法输出分析:

    如图1是以初始节点init(2, 0, 3, 1, 8, 4, 7, 6, 5)和目的节点(1, 2, 3, 8, 4, 5, 0, 7, 6)运行的程序输出。根据OPEN表画出树形图如图2。

    在这里插入图片描述

    图1-程序输出
    在这里插入图片描述
    图2-分析过程

    附:Python算法

    import copy
    import operator
    
    OPEN = []  # open表
    CLOSED = []  # closed表
    
    
    class Point:
        def __init__(self, r, s, t, u, v, w, x, y, z):
            self.r = r
            self.s = s
            self.t = t
            self.u = u
            self.v = v
            self.w = w
            self.x = x
            self.y = y
            self.z = z
            self.g = 0
            self.f = 0  # f = g+h
            self.father = None
            self.node = [r, s, t, u, v, w, x, y, z]
    
    
    init = Point(2, 0, 3, 1, 8, 4, 7, 6, 5)  # 初始节点
    goal = Point(1, 2, 3, 8, 0, 4, 7, 6, 5)  # 目标
    
    
    # 返回空位的index值
    def getKey(s):
        return s.node.index(0)
    
    
    def up(s, key):
        if key - 3 >= 0:
            arr = copy.copy(s.node)
            arr[key], arr[key - 3] = arr[key - 3], arr[key]
            return Point(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8])
        else:
            return None
    
    
    def down(s, key):
        if key + 3 <= 8:
            arr = copy.copy(s.node)
            arr[key], arr[key + 3] = arr[key + 3], arr[key]
            return Point(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8])
        else:
            return None
    
    
    def left(s, key):
        if key != 0 and key != 3 and key != 6:
            arr = copy.copy(s.node)
            arr[key], arr[key - 1] = arr[key - 1], arr[key]
            return Point(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8])
        else:
            return None
    
    
    def right(s, key):
        if key != 2 and key != 5 and key != 8:
            arr = copy.copy(s.node)
            arr[key], arr[key + 1] = arr[key + 1], arr[key]
            return Point(arr[0], arr[1], arr[2], arr[3], arr[4], arr[5], arr[6], arr[7], arr[8])
        else:
            return None
    
    
    # 启发函数
    def h(s, p=goal):
        flag = 0
        for i in range(0, 9):
            if s.node[i] != p.node[i]:
                flag += 1
        return flag
    
    
    def equal(a, b):
        if a.node == b.node:
            return True
    
    
    # 将open_list以f值进行排序
    def open_sort(l):
        the_key = operator.attrgetter('f')  # 指定属性排序的key
        l.sort(key=the_key)
    
    
    # 扩展节点时在open表和closed表中找原来是否存在相同属性的节点
    def in_list(new, l):
        for item in l:
            if new.node == item.node:
                return True, item
        return False, None
    
    
    def A_star(s):
        global OPEN, CLOSED
        OPEN = [s]
        CLOSED = []
    
        while OPEN:  # open表非空
            get = OPEN[0]  # 取出open表第一个元素get
            if get.node == goal.node:  # 判断是否为目标节点
                return get
            OPEN.remove(get)  # 将get从open表移出
            CLOSED.append(get)  # 将get加入closed表
            # 以下得到一个get的新子节点new并考虑是否放入OPEN
            key = getKey(get)
            for i in range(0, 4):  # 四个方向
                if i == 0:
                    new = up(get, key)
                elif i == 1:
                    new = down(get, key)
                elif i == 2:
                    new = left(get, key)
                elif i == 3:
                    new = right(get, key)
    
                if new == None:  # 状态非法或new折返了
                    pass
                # 如果要拓展的节点满足以上情况,将它的父亲设为当前节点,计算f,并对open_list排序
                else:
                    new.father = get
                    new.g = get.g + 1  # 与起点的距离
                    new.f = get.g + h(new)  # f = g + h
    
                    # 如果new在open表中(只关注m,c,b的值)
                    if in_list(new, OPEN)[0]:
                        old = in_list(new, OPEN)[1]
                        if new.f < old.f:  # new的f<open表相同状态的f
                            OPEN.remove(old)
                            OPEN.append(new)
                            open_sort(OPEN)
                        else:
                            pass
                    # 继续,如果new在closed表中
                    elif in_list(new, CLOSED)[0]:
                        old = in_list(new, CLOSED)[1]
                        if new.f < old.f:
                            # 将old从closed删除,并重新加入open
                            CLOSED.remove(old)
                            OPEN.append(new)
                            open_sort(OPEN)
    
                        else:
                            pass
                    else:
                        OPEN.append(new)
                        open_sort(OPEN)
            print('OPEN:')
            for o in OPEN:
                print(o.node,o.f,o.g)
    
    
    # 递归打印路径
    def printPath(f):
        if f is None:
            return
        printPath(f.father)
        print(f.node)
    
    
    if __name__ == '__main__':
        final = A_star(init)
        if final:
            print('有解,解为:')
            printPath(final)
        else:
            print('无解!')
    
    
    展开全文
  • 有C语言编写的八数码问题的源程序,可以运行,采用的是A*算法,可直接运行。
  • 八数码问题是人工智能经典难题之一。问题是在3×3 方格盘上,放有八个数码,剩下一个为空,每一空格其上下左右的数码可移至空格。问题给定初始位置和目标位置,要求通过一系列的数码移动,将初始位置转化为目标位置...
  • 八数码问题c语言a星算法详细实验报告含代码解析 (13页) 本资源提供全文预览,点击全文预览即可全文预览,如果喜欢文档就下载吧,查找使用更方便哦!14.9 积分一、实验内容和要求 八数码问题:在3×3的方格棋盘上,...
  • 实验一 启发式搜索算法 姓名尹鹏飞 学号 S201407031 日期2014/10/22 一实验目的 熟练掌握启发式搜索 A 算法及其可采纳性 二实验内容 使用启发式搜索算法求解 8 数码问题 编制程序实现求解 8 数码问题 A 算法采用估价...
  • 八数码,人工智能,实验报告,附c语言源代码,好资源啊。
  • 以重排九宫问题/八数码问题为例,以启发式搜索方法求解给定初始状态和目标状态的最优搜索路径
  • 精品文档 精品文档 PAGE PAGE #欢迎下载 精品文档 精品文档 PAGE PAGE #欢迎下载 精品文档 精品文档 1 1欢迎下载 昆明理工大学信息工程与自动化学院学生实验报告 201 201 学年第一学期 课程名称 开课实验室 年 月曰 ...
  • 八数码实验报告(转)

    2008-03-24 09:19:00
    八数码实验报告转自http://tb.blog.csdn.net/TrackBack.aspx?PostId=599897.aspx主要有以下几点不错:(1)用整数表示数码盘的状态,特别是单独用个位表示空格位置。但是仅限于8数码盘
  • 八数码的C语言实现是人工智能的大作业,希望能给大家带来方便!

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 1,143
精华内容 457
关键字:

八数码问题实验报告