精华内容
下载资源
问答
  • 利用遗传算法求解迷宫问题,描述什么是遗传算法算法细节,应用到迷宫求解问题中。同时包括对退火算法的描述并结合实际问题求解。
  • 迷宫生成算法

    2013-10-17 08:25:00
    我们现在说Recursive backtracking: 迷宫的初始状态是墙壁都存在。选择一个开始区域。 随机得选择一个没有访问过的邻接...大家都知道,至于迷宫的求解问题,可以穷举法进行求解。那么什么是穷举法了,就是...

    我们现在说Recursive backtracking:

    1. 迷宫的初始状态是墙壁都存在。选择一个开始区域。
    2. 随机得选择一个没有访问过的邻接区域,并打通与它之间的墙壁。此邻接区域称为当前区域。
    3. 如果所有周围的区域都是访问过的,则退回上一个区域进行挖据墙壁,一直重复。
    4. 当开始的区域被退回的时候,算法结束。 

    大家都知道,至于迷宫的求解问题,可以用穷举法进行求解。那么什么是穷举法了,就是将每一种可能的情况都穷举完。而具体到迷宫的求解问题上,由于在求解过程中可能会遇到某一路径不可行的情况,此时我们就必须按原路返回,这时自然也就会想到栈的应用了,因为栈的一个很重要的特性就是”先进后出”,可以用来记录每次所探索的路径,方便在原路返回的过程中,得到上一步所走路径,再按此方法,退回到可以走得通的位置上,继续探索下去,直到到达终点或者最终无法到达,正常退出程序为止。

    下面我们现在首先定义一下有关迷宫求解过程中运用到的相关定义与技巧吧!

    1.我们规定每次探索的方向是把当前位置的相邻的东边位置作为第一个探索位置,若不通,则再逆时间方向探索之。具体地说就是右——上——左—— 下的方向进行探索。当然这个方向大家可以随意确定,只是确定后探索方向后,我们在下面编写确定下一位置的函数过程中得根据这个方向进行编码!当然迷宫的位置我们可以定义一个结构体表示,如:

    1:  typedef struct Postion
    2:  {
    3:      int x;
    4:      int y;
    5:  }Postion;

    那么确定下一探索位置的函数我们可以这么编写:

    01:  struct Postion nextPos(struct Postion pos,int dir)
    02:  {
    03:      //contrarotate(¨逆?时±针?旋y转a)?
    04:      switch(dir)
    05:      {
    06:          case 1:pos.y+=1;break;
    07:          case 2:pos.x-=1;break;
    08:          case 3:pos.y-=1;break;
    09:          case 4:pos.x+=1;break;
    10:          default:break;
    11:      }
    12:      return pos;
    13:  }

    2.我们定义一个顺序栈来存储探索过的路径,以便返回时得到上一次走过的位置。而栈元素主要记录了当前位置、步数以及下一探索方向,即:

    1:  typedef struct mazenode
    2:  {
    3:      struct Postion pos;//current location
    4:      int curstep;//current step number
    5:      int dir;//current direction
    6:  }mazenode;

    接下来就是定义栈的各种典型操作呢,有初始化、进栈、出栈、是否为空判断等操作。(此步骤较简单,在此先不贴出代码了~)

    3.最后让我们来理清一下迷宫求解过程的关键思想吧!

    do

    {

    if(当前的路径可以通过)

    {

             留下足迹;

              将当前位置保存并入栈

              if(判断当前路径是否为最终路径)

               {

                            退栈,并修改迷宫的数据,记录所走的路线

                            并返回 1;

                }

                当前步数增一;

                获取下一位置;

    }

    else//当前位置走不通

    {

                 if(当前栈不为空)

                 {

                             退栈;

                             while(当前位置的所走方向为4并且当

                                         当前栈不为空)

                             {

                                        记录当前位置不为走不通;

                                         退栈处理;

                                         当前步数减一; 

                              }

                               if(当前的位置所走方向小于4)

                               {

                                           将当前位置的方向增一;

                                            将当前位置重新进栈;

                                             获取下一将要通过的位置;

                                }

                  }

    }

    }

    while(当前的栈不为空)

    (注:当前的逻辑写得比较简单,各位看客们呆会看具体的源码哈!)

            接下来我先贴一下有关栈的相关操作函数吧,主要包括典型的进栈

    、出栈、判断栈是否为空等操作。

    01:  void initStack(struct Sqstack *s)
    02:  {
    03:      s->base=(struct mazenode **)malloc(STACK_INIT_SIZE*sizeof(struct mazenode *));
    04:      if(!s->base)
    05:      {
    06:          printf("allocation fails!");
    07:          exit(-1);
    08:      }
    09:      s->top=s->base;
    10:      s->stacksize=STACK_INIT_SIZE;
    11:  }
    12:  
    13:  void Push(struct Sqstack *s,struct mazenode * e)
    14:  {
    15:      if((s->top-s->base)>=STACK_INIT_SIZE)
    16:      {
    17:          s->base=(struct mazenode **)realloc(s->base,(STACK_INIT_SIZE+STACKINCREASE)*sizeof(struct mazenode *));
    18:          if(!s->base)
    19:          {
    20:              printf("allocation fails!");
    21:              exit(-1);
    22:          }
    23:          s->top=s->base+STACK_INIT_SIZE;
    24:          s->stacksize=STACK_INIT_SIZE+STACKINCREASE;
    25:      }
    26:      *s->top++=e;
    27:  }
    28:  
    29:  void Pop(struct Sqstack *s,struct mazenode **e)
    30:  {
    31:      if(s->base==s->top)
    32:      {
    33:          printf("the stack is empty!");
    34:          exit(0);
    35:      }
    36:      *e=*(--s->top);
    37:  }
    38:  
    39:  int getTop(struct Sqstack *s,struct mazenode ** e)
    40:  {
    41:      if(s->base==s->top)
    42:      {
    43:          printf("the stack is empty!");
    44:          return 0;
    45:      }
    46:      else
    47:      {
    48:          *e=*(s->top-1);
    49:          return 1;
    50:      }
    51:  }
    52:  
    53:  int emptyStack(struct Sqstack *s)
    54:  {
    55:      if(s->base==s->top)
    56:      {
    57:          return 1;//stack is empty!
    58:      }
    59:      else
    60:      {
    61:          return 0;//stack is not empty!
    62:      }
    63:  }

              接下来是有关迷宫求解的“业务”规则代码吧!

    01:  int Pass(struct Postion pos,int array[MAZESIZE][MAZESIZE])
    02:  {
    03:      if(array[pos.x][pos.y]!=0&&array[pos.x][pos.y]!=-1)
    04:      {
    05:          return 1;//indicate the way can pass
    06:      }
    07:      else
    08:      {
    09:          return 0;//indicate the way can not pass
    10:      }
    11:  }
    12:  
    13:  struct Postion nextPos(struct Postion pos,int dir)
    14:  {
    15:      //contrarotate(¨逆?时±针?旋y转a)?
    16:      switch(dir)
    17:      {
    18:          case 1:pos.y+=1;break;
    19:          case 2:pos.x-=1;break;
    20:          case 3:pos.y-=1;break;
    21:          case 4:pos.x+=1;break;
    22:          default:break;
    23:      }
    24:      return pos;
    25:  }
    26:  
    27:  
    28:  void markFoot(int arr[MAZESIZE][MAZESIZE],struct Postion pos)
    29:  {
    30:      arr[pos.x][pos.y]=0;//have pass by the way
    31:  }
    32:  
    33:  void markblock(int arr[MAZESIZE][MAZESIZE],struct Postion pos)
    34:  {
    35:      arr[pos.x][pos.y]=-1;//do not pass by the postion
    36:  }

             然后是迷宫求解可走线路的核心算法:

    01:  int processMaze(int arr[MAZESIZE][MAZESIZE],struct Postion start,struct Postion end)
    02:  {
    03:      struct Sqstack s;
    04:      struct mazenode *p=(struct mazenode*)malloc(sizeof(struct mazenode));
    05:      struct mazenode *nodelist=(struct mazenode *)malloc(100*sizeof(struct mazenode));//put down the way of sucess!
    06:      int curstep=1,flag=0;
    07:      struct Postion curpos=start,temp;
    08:      initStack(&s);
    09:      do
    10:      {
    11:          if(Pass(curpos,arr))
    12:          {
    13:              markFoot(arr,curpos);
    14:              //struct mazenode node;
    15:              nodelist[flag].pos=curpos;
    16:              nodelist[flag].curstep=curstep;
    17:              nodelist[flag].dir=1;//towards east
    18:              Push(&s,nodelist+flag);
    19:              flag++;
    20:              if(curpos.x==end.x&&curpos.y==end.y)
    21:              {
    22:                  while(!emptyStack(&s))
    23:                  {
    24:                      Pop(&s,&p);
    25:                      arr[p->pos.x][p->pos.y]=p->curstep;
    26:                  }
    27:                  return 1;
    28:              }
    29:              curstep++;
    30:              curpos=nextPos(curpos,1);//towards east
    31:          }
    32:          else
    33:          {
    34:              if(!emptyStack(&s))
    35:              {
    36:                  Pop(&s,&p);
    37:                  while(p->dir==4&&!emptyStack(&s))
    38:                  {
    39:                      markblock(arr,p->pos);//mark that the way is not passed
    40:                      Pop(&s,&p);
    41:                      curstep--;
    42:                  }
    43:                  if(p->dir<4)
    44:                  {
    45:                      p->dir++;
    46:                      Push(&s,p);
    47:                      temp=p->pos;
    48:                      curpos=nextPos(temp,p->dir);
    49:                  }
    50:              }
    51:          }
    52:      }
    53:      while(!emptyStack(&s));
    54:      return 0;//failure
    55:  }

             最后我们来实现下代码的可行性测试函数吧(说白了就是main函数啦)

    01:  int _tmain(int argc, _TCHAR* argv[])
    02:  {    
    03:      int maze[8][8]={{0,0,0,0,0,0,0,0},{0,0,1,0,0,1,0,0},{0,1,1,0,0,0,1,0},
    04:      {0,1,0,0,0,0,0,0},{0,1,1,1,0,0,1,0},{0,0,0,1,0,0,1,0},
    05:      {0,0,0,1,1,1,1,0},{0,0,0,0,0,0,0,0}},i,j,flag;
    06:      struct Postion start,end;
    07:      start.x=1;start.y=2;
    08:      end.x=4;end.y=6;
    09:      printf("primative maze:\n");
    10:      for(i=0;i<MAZESIZE;i++)
    11:      {
    12:          for(j=0;j<MAZESIZE;j++)
    13:          {
    14:              printf("%2d",maze[i][j]);
    15:          }
    16:          printf("\n");
    17:      }
    18:      flag=processMaze(maze,start,end);
    19:      if(flag==1)
    20:      {
    21:          printf("maze processing success!\n");
    22:          printf("processed maze:\n");
    23:          for(i=0;i<MAZESIZE;i++)
    24:          {
    25:              for(j=0;j<MAZESIZE;j++)
    26:              {
    27:                  printf("%2d",maze[i][j]);
    28:              }
    29:              printf("\n");
    30:          }
    31:      }
    32:      else
    33:      {
    34:          printf("maze processing fail!\n");
    35:      }
    36:      return 0;
    37:  }

             好了,最后让我们看看最终方案的运行情况吧!

    11

            有必要解释下,我们使用0和1分别代表可以不能通过和能够通过,千万不要和当前的步数混淆哈!

     

    转:http://www.cnblogs.com/JackyTecblog/archive/2011/02/20/1958880.html

    转载于:https://www.cnblogs.com/WayneZeng/p/3373296.html

    展开全文
  • 求解迷宫算法

    2008-04-08 19:29:00
    兄弟姐妹大哥大姐小弟小妹们你们知道用什么算法比较适合走迷宫吗?请指教..谢谢了

    兄弟姐妹大哥大姐小弟小妹们

    你们知道用什么算法比较适合走迷宫吗?

    请指教..

    谢谢了

    展开全文
  • 实现迷宫的设置布局,选择方向,判断什么是绝境,什么是墙
  • 文章目录前言一、什么是(DFS)深度优先算法?深度优先算法实现步骤1.引入库2.初始化参数3.Turtle画方格函数4.开始生成数组并调用Turtle画图二、什么是(BFS)广度优先算法?广度优先算法实现步骤1.引入库2.初始化...


    前言

    最近学习了随机生成迷宫的算法, 分享学习经验以及碰到的问题点。目前学习两个算法 生成随机地图, 深度优先算法和广度优先算法来生成迷宫。比较下他们的不同点。

    在程序中,我们用数组M表示所有的单元格子的属性,并用turtle 库来画图。用红色单元格来表示当前遍历到单元格。

    一、什么是(DFS)深度优先算法?

    简单来说它是一头扎到底的玩法。我们选择一条支路,尽可能不断地深入,如果遇到死路就往回退,回退过程中如果遇到没探索过的支路,就进入该支路继续深入。如此循环反复直到把所有的单元格都遍历了。

    深度优先算法实现步骤

    1.引入库

    代码如下:

    import random
    import numpy as np
    from turtle import *
    import time
    

    2.初始化参数

    代码如下:

    #初始化参数
    num_rows = 20 # 生成迷宫的行数
    num_cols = 20 # 生成迷宫的列数
    
    M = np.zeros((num_rows, num_cols, 5), dtype=np.uint8)
    # 阵列M将保存每个单元的阵列信息。
    # 前四个坐标告诉墙壁在那些边上是否存在
    # 和第五个指示在搜索中是否已访问该单元格。
    # M【上,右,下,左,是否被访问】
    
    # 我们先把第一个单元格最和后一个墙打开。
    M[0, 0, 0] = 1
    M[num_rows-1, num_cols-1, 2] = 1
    
    #如下是turtle模块的初始化
    tracer(0)# 最快生成图
    ht()# 隐藏画笔
    pensize(1)#画笔大小设为1
    

    3.Turtle画方格函数

    代码如下:

    def pengoto(x, y):
        up()
        goto(x, y)
        down()
    
    
    def drawing(r, c, M):
        x = 20*c-200
        y = 200-20*r
        pengoto(x, y)
        for i in range(4):
            if M[i] == 1:
                pencolor('blue')
                fd(1)
                pencolor('white')
                fd(19)
                right(90)
            else:
                pencolor('blue')
                fd(20)
                right(90)
    

    4.开始生成数组并调用Turtle画图

    # 设置开始的行和列
    r = 0
    c = 0
    history = [(r, c)]  # 这个是历史访问的单元格列表。
    n = 0  # 砸墙的数量。
    # 从初始单元个一路开墙并进入下一个单元格,如果无路可走则返回。
    # 我们使用while循环来执行此操作,重复该循环直到n=所有的单元格数-1.说明所有的单元格都是通的了。
    while history:
        M[r, c, 4] = 1  #将此位置指定为已访问
        
        #检查相邻单元格是否可移动去,注意上下左右的边界。 
        check = []
        if c > 0 and M[r, c-1, 4] == 0:
            check.append('L')
        if r > 0 and M[r-1, c, 4] == 0:
            check.append('U')
        if c < num_cols-1 and M[r, c+1, 4] == 0:
            check.append('R')
        if r < num_rows-1 and M[r+1, c, 4] == 0:
            check.append('D')
    
        if len(check): #如果有单元可以去
            history.append([r, c])
            n += 1
            move = random.choice(check)#随机打开一堵墙
            # 注意数组[上, 右,下,左,1]
            if move == 'L':  
                M[r, c, 3] = 1
                c = c-1
                M[r, c, 1] = 1
            if move == 'U':
                M[r, c, 0] = 1
                r = r-1
                M[r, c, 2] = 1
            if move == 'R':
                M[r, c, 1] = 1
                c = c+1
                M[r, c, 3] = 1
            if move == 'D':
                M[r, c, 2] = 1
                r = r+1
                M[r, c, 0] = 1
        else:  #如果发现没有下个单元格可以去,我们要回溯。
            r, c = history.pop()
        # 红色显示当前单元格子
        clear()#清理下,不然内存会被占用
        fillcolor("red")
        begin_fill()
        drawing(r, c, M[r, c])
        end_fill()
        # 调用turtle画图显示当前整个地图状态。
        for i in range(num_rows): 
            for j in range(num_cols):
                drawing(i, j, M[i, j])
                update()#更新下,不然turtle会卡死
        time.sleep(0.5)
        if n == num_cols*num_rows-1:  # 当砸墙的数量等于单元格子的数量-1时结束循环。
            break
    
    done()
    

    二、什么是(BFS)广度优先算法?

    广度优先搜索是按层来处理顶点,距离开始点最近的那些顶点首先被访问,而最远的那些顶点则最后被访问,这个和树的层序变量很像,BFS的代码使用了一个队列。Prim

    广度优先算法实现步骤

    1.引入库

    代码如下:

    import random
    import numpy as np
    from turtle import *
    import timet
    

    2.初始化参数

    代码如下:

    #初始化参数
    num_rows = 20 # 生成迷宫的行数
    num_cols = 20 # 生成迷宫的列数
    
    M = np.zeros((num_rows, num_cols, 5), dtype=np.uint8)
    # 阵列M将保存每个单元的阵列信息。
    # 前四个坐标告诉墙壁在那些边上是否存在
    # 和第五个指示在搜索中是否已访问该单元格。
    # M【上,右,下,左,是否被访问】
    
    # 我们先把第一个单元格最和后一个墙打开。
    M[0, 0, 0] = 1
    M[num_rows-1, num_cols-1, 2] = 1
    
    #如下是turtle模块的初始化
    tracer(0)# 最快生成图
    ht()# 隐藏画笔
    pensize(1)#画笔大小设为1
    

    3.Turtle画方格函数

    代码如下:

    def pengoto(x, y):
        up()
        goto(x, y)
        down()
    
    
    def drawing(r, c, M):
        x = 20*c-200
        y = 200-20*r
        pengoto(x, y)
        for i in range(4):
            if M[i] == 1:
                pencolor('blue')
                fd(1)
                pencolor('white')
                fd(19)
                right(90)
            else:
                pencolor('blue')
                fd(20)
                right(90)
    

    4.开始生成数组并调用Turtle画图

    # 设置开始的行和列
    r = 0
    c = 0
    history = [(r, c)]  # 这个是历史访问的单元格列表。
    n = 0  # 砸墙的数量。
    while history:
        # 随机选择一个可以敲墙的单元格
        r, c = random.choice(history)
        M[r, c, 4] = 1  # 把单元设成以访问
        history.remove((r, c))
        check = []
    #如果随机选择的单元格具有多个边
    #将其连接到现有的迷宫,
        if c > 0:
            if M[r, c-1, 4] == 1:
                check.append('L')
            elif M[r, c-1, 4] == 0:
                history.append((r, c-1))
                M[r, c-1, 4] = 2
        if r > 0:
            if M[r-1, c, 4] == 1:
                check.append('U')
            elif M[r-1, c, 4] == 0:
                history.append((r-1, c))
                M[r-1, c, 4] = 2
        if c < num_cols-1:
            if M[r, c+1, 4] == 1:
                check.append('R')
            elif M[r, c+1, 4] == 0:
                history.append((r, c+1))
                M[r, c+1, 4] = 2
        if r < num_rows-1:
            if M[r+1, c, 4] == 1:
                check.append('D')
            elif M[r+1, c, 4] == 0:
                history.append((r+1, c))
                M[r+1, c, 4] = 2
    # 随机前往一个边界墙.
        if len(check):
        	n+=1
            move = random.choice(check)
            if move == 'L':  # [上,右,下,左,1]
                M[r, c, 3] = 1
                c = c-1
                M[r, c, 1] = 1
            if move == 'U':
                M[r, c, 0] = 1
                r = r-1
                M[r, c, 2] = 1
            if move == 'R':
                M[r, c, 1] = 1
                c = c+1
                M[r, c, 3] = 1
            if move == 'D':
                M[r, c, 2] = 1
                r = r+1
                M[r, c, 0] = 1
    
        # 红色方格显示当前单元格子位置
        clear()#清理下,不然内存会一直被占用。
        fillcolor("red")
        begin_fill()
        drawing(r, c, M[r, c])
        end_fill()
        # 调用turtle画图显示当前整个地图状态。
        for i in range(num_rows): 
            for j in range(num_cols):
                drawing(i, j, M[i, j])
                update()#需要跟新下,不然会卡死
        time.sleep(0.5)
        if n == num_cols*num_rows-1:  # 当砸墙的数量等于单元格子的数量-1时结束循环。
            break
    
    done()
    

    总结

    1、深度优先算法:是对每一个可能的分支路径深入到不能再深入为止,深度优先法生成的迷宫扭曲,有着一条明显的主路。
    2、广度优先算法:系统地展开并检查图中的所有节点,直到遍历完成。

    程序生产的图片如下:
    在这里插入图片描述
    视频如下:

    深度优先算法和广度优先算法的生成迷宫

    展开全文
  • 问题:一个二维数组来存储迷宫,数组中的每个元素的值只取0或1,其中0表示此路可通,1表示此路不通。对于上例的迷宫可存储如图。 假定迷宫入口坐标为(1,1) 输出为路径 实现代码如下 /* 迷宫问题 作者:Lumao...

    迷宫问题


    问题:用一个二维数组来存储迷宫,数组中的每个元素的值只取0或1,其中0表示此路可通,1表示此路不通。对于上例的迷宫可存储如图。
    在这里插入图片描述
    假定迷宫入口坐标为(1,1)
    输出为路径
    实现代码如下

    /*
       迷宫问题
       作者:Lumao
       版本:2021/3/28 0.0版
       方法:C++ 队列 数组 结构体 递归 深度优先
       目标:找到地图中的所有走法并输出
       要点:记录路径 恢复现场 深搜
       小结:拎出一个位置来分析,往哪走,出去了做什么,要回来怎么做
    */
    #include<iostream>
    #include<stack>
    #include<queue>
    using namespace std;
    #define m  6//地图长
    #define n  8//地图宽
    int Count = 0;//记录不同走法数量
    struct step//坐标类型
    {
    	int x;
    	int y;
    	bool operator!=(step&q) //用于后面退回时的函数back_one_step
    	{
    		return (x != q.x || y != q.y) ? true : false;
    	}
    };
    struct step Move[8] {//step 类型数组Move代表8个前进方向
    	{0,1},
    	{1,1},
    	{1,0},
    	{1,-1},
    	{0,-1},
    	{-1,-1},
    	{-1,0},
    	{-1,1}
    };
    int TheMap[][n+2] = {//初始地图,1表示此路不通,0表示可以通过,外面加一层1为围墙
    	{1,1,1,1,1,1,1,1,1,1},
    	{1,0,1,1,1,0,1,1,1,1 },
    	{1,1,0,1,0,1,0,1,0,1 },
    	{1,0,1,0,0,1,1,1,1,1 },
    	{1,0,1,1,1,0,0,1,1,1 },
    	{1,1,0,0,1,1,0,0,0,1},
    	{1,0,1,1,0,0,1,1,0,1 },
    	{1,1,1,1,1,1,1,1,1,1}
    };
    
    queue<step>s;//用于记录路径的队列
    int Maze[m + 2][n + 2];//当前地图
    
    void initialize(int Maze[m+2][n+2])//初始化地图
    {
    	for (int i = 0; i < m + 2; i++)
    		for (int j = 0; j < n + 2; j++)
    			Maze[i][j] = TheMap[i][j];
    	while (!s.empty())
    		s.pop();//清空记录的路径
    }
    void Restore(int Maze[m + 2][n + 2],int x,int y,int loop)//恢复地图
    {
    	int loop_now=loop;//只要把当前loop及loop之前方向数据恢复即可
    	int j, k;
    	for (; loop_now >= 0; loop_now--)
    	{
    		j = x + Move[loop_now].x;
    		k = y + Move[loop_now].y;
    		Maze[j][k] = TheMap[j][k];
    	}
    }
    void back_one_step(step last)//从记录路径的队列中去掉最近一次记录的那一步
    {
    	while (s.front() != last)
    	{
    		s.push(s.front());
    		s.pop();
    	}
    	s.pop();//去掉last坐标
    }
    void PrintPath()//打印路径
    {
    	step path;
    	queue<step>temp;
    	cout << "Path No."<<++Count<<" :" << endl;
    	while (!s.empty())
    	{
    		path = s.front();
    		temp.push(path);
    		cout << "(" << path.x << "," << path.y << ")" << endl;
    		s.pop();
    	}//将队列中的路径输出并pop
    
    	while (!temp.empty())//恢复队列中存储的路径,因为要继续探索其他路径
    	{
    		path = temp.front();
    		s.push(path);
    		temp.pop();
    	}
    }
    int MazePath(int x, int y)//走迷宫函数
    {
    	step temp;
    	int j, k;
    	int loop;//循环8个方向
    	Maze[x][y] = -1;//标志位置已经到达过
    	for (loop = 0; loop < 8; loop++)//探索当前位置的八个相邻位置
    	{
    		j = x + Move[loop].x;//采用move作为数组名与保留字冲突了,改为Move
    		k = y + Move[loop].y;
    		if ((j == m)&&(k == n))//找到出口
    		{
    			step out = { m,n };//记录出口到路径中
    			s.push(out);
    			PrintPath();//输出路径
    			cout << endl;
    			Restore(Maze,x,y,loop);//恢复迷宫
    
    			//退一步
    			back_one_step(out);
    
    			//return 1;//表示成功找到路径
    			continue;//继续循环
    		}
    		if (Maze[j][k] == 0)//新位置是否可到达
    		{
    			temp.x = j;
    			temp.y = k;
    			s.push(temp);//保存该点坐标
    			MazePath(j, k);//深度优先算法,从当前点重新开始出发
    
    			//如果要找出所有出路,则需要一个恢复现场的标记
    			//结束MazePath(j,k)内的循环遍历后,恢复进入前的环境
    			//在递归中去除Maze(j,k)的-1标记即可。
    			Maze[j][k] = 0;
    			back_one_step(temp);//从路径队列中去掉刚刚记录的那一步
    		}
    	}
    	return 0;
    }
    
    int main()
    {
    	initialize(Maze);//初始化地图
    	MazePath(1, 1);//以(1,1)为入口,若没有输出则说明该地图没有路径
    	system("pause");
    	return 0;
    }
    

    若认为该代码可以有可以更优化的地方,望不吝指教

    展开全文
  • 首先详细介绍了什么是遗传算法,然后通过遗传算法的思想实例解析使用遗传算法解决迷宫问题,需要的朋友可以参考下
  • 10分分钟钟教教你你用用python动动画画演演示示深深度度优优先先算算法法搜搜寻寻逃逃出出迷迷宫宫的的路路径径 这篇文章主要介绍了10分钟教你python动画演示深度优先算法搜寻逃出迷宫的路径,非常不错具 一定的...
  • 深度优先算法(DFS 算法)是什么? 寻找起始节点与目标节点之间路径的算法,常用于搜索逃出迷宫的路径。主要思想是,从入口开始,依次搜寻周围可能的节点坐标,但不会重复经过同一个节点,且不能通过障碍节点。如果走...
  • 深度优先算法(DFS 算法)是什么? 寻找起始节点与目标节点之间路径的算法,常用于搜索逃出迷宫的路径。主要思想是,从入口开始,依次搜寻周围可能的节点坐标,但不会重复经过同一个节点,且不能通过障碍节点。如果走...
  • 简单生成随机迷宫算法___Prim和DFS

    千次阅读 2019-06-25 02:19:05
    快要大四了,要赶紧复习下数据结构好找工作,哈哈哈哈哈,所以最近在看图相关的算法,光看书没什么感觉,准备实践一下,写个迷宫算法 主要Prim算法和DFS算法实现了一遍,没有BFS是因为Prim的思路跟BFS的其实差不太多,...
  • 寻路算法--迷宫寻路

    2020-08-18 12:15:13
    首先寻路算法属于图论算法,要想寻路先得有图,什么是图,这个就不细讲了,很多专门讲这个的文章,简单的说图就是一些点再加上连接这些点的边就构成了图,只要把迷宫抽象成图就能应用图论算法了。    ...
  • Day1 实验要求: 1)迷宫游戏是非常经典的游戏,在该题中要求随机生成一个迷宫,并求解迷宫; 2)要求查找并理解迷宫生成的算法,...项目的关键是基于A算法生成迷宫路径,所以我们先要搞懂什么是A算法已经怎样来实现A*算法
  • A*算法,转基因干饭迷宫老鼠与游戏中的寻路

    千次阅读 多人点赞 2021-03-29 19:47:24
    目录 Catalogue转基因干饭迷宫老鼠问题描述问题分析我不可以BFS,DFS或者Dijkstra 算法吗? A*算法A*算法是用来干什么的?A*算法如何工作开始工作! 转基因干饭迷宫老鼠 问题描述 相信大家应该很熟悉迷宫老鼠问题...
  • 1、define 的用法和 const 的用法, 以及两者之间的区别。 2,函数参数没有 具体的形式,只有数据类型?...5、stl中stack的实现的分析,本只想知道其中用什么数据结构实现的,结构挖出这篇文章来,真心
  • VC编程迷宫游戏

    2013-09-28 13:00:00
    玩过RPG游戏的朋友一定遇到过各种各样的迷宫迷宫道路错综复杂,千变万化,如《仙剑奇侠传》,那么这些迷宫是怎样生成的呢?生成迷宫算法又是什么呢?下面就给出一个随机生成二维迷宫的方法,并用VC编程实现。
  • 什么是递归:顾名思义,递归就是自己调用自己。我自己理解递归的本质是不断的开辟方法栈的过程 /** * 迷宫回溯 */ public class MazeBacktrack { public static void main(String[] args) { // 构造一个7行6...
  • 下面代码来实现一个迷宫问题 主要代码(这里用到了回溯,也就是在if(setWay()))假如是先想下走了,这里开辟个新栈运行setWay如果上下左右都走不通,会把当前坐标设置成3,然后回到上一个坐标的程序里,继续...
  • 我跟同学探讨了一下,他c++写的,我java写的。 不管怎么说菜是原罪啊。 日后好好学习算法 第三题 7-3 Link-Cut-tree(DFS and similar) Description Lct prepares to study an Algorithm named
  • 障碍’x’表示,路’.'表示。 怎么做呢,可以看出来,这又是一个构造的题目。 在矩阵里面,我们可以感受一下,曲折的路线是最长的,所以我们就构造曲折的路径,然后在构造好的图上跑一下bfs求一下距离为k的点在...
  • 算法

    2020-11-27 14:34:44
    各种算法中也会使用到递归,比如快排,归并排序,二分查找,分治算法等. 将栈解决的问题–>递归代码比较简洁 递归需要遵守的重要规则 执行一个方法时,就创建一个新的受保护的独立空间(栈空间) 方法的局部...
  • 如何python来开发一个迷宫,在上次利用python中的pygame包开发一个贪吃蛇后,这次依旧可以运用上次贪吃蛇的设计思路,想要实现迷宫主要是算法,生成不同的地图,三大迷宫生成算法 (Maze generation algorithm) – ...
  • java迷宫

    千次阅读 2016-07-03 20:20:46
    终于放假了,可以研究一些好玩的东西了,先把之前用c语言写的迷宫用swing冲写了下界面,算法部分并没有做什么修改,原来的链接 这个比拼图还要简单,因为并不涉及线程,只要在按键wsad后重绘就行。 尝试了菜单栏的...
  • 迷宫问题

    2011-01-06 22:56:00
    对于迷宫问题很好奇,想递归的方式解决,但是不知道思路是什么,一直对于递归没有什么想法,想最简洁的方法解决迷宫找路的问题,本来写了一个算法,是比较简单,但是在一些情况下会出错,但是看网上很多人写的太...
  • 回溯算法

    2019-04-22 11:42:00
    回溯的描述: 回溯算法将解空间看作...也可以迷宫的方式去理解回溯,设想把你放在一个迷宫里,想要走出迷宫,最直接的办法是什么呢?没错,试。先选一条路走起,走不通就往回退尝试别的路,走不通继续往回退,...
  • 总共有10幅图都是小迷宫游戏,图什么的都挺漂亮,就是有点贵应该是纸比较好,要30多块钱,我就觉得划不来(典型的铁公鸡),我就跟女儿说家里有,买了其他东西就回来了,然后网上查了一下,主要用到的是一个算法,...

空空如也

空空如也

1 2 3 4 5 ... 9
收藏数 163
精华内容 65
关键字:

迷宫用什么算法