皮皮网
皮皮网

【日线指标源码】【分销返利商城源码】【hero引擎源码下载】迷宫递归 源码_迷宫递归算法

时间:2024-12-24 08:55:16 来源:调用qq登录源码asp

1.迷宫求解问题
2.递归|深度优先搜索解迷宫(C++)
3.关于计算机C++编程的迷宫迷宫迷宫问题的解题思路?

迷宫递归 源码_迷宫递归算法

迷宫求解问题

       /*迷宫源程序*/

       #include <graphics.h>

       #include <stdlib.h>

       #include <stdio.h>

       #include <conio.h>

       #include <dos.h>

       #define N /*迷宫的大小,可改变*/

       int oldmap[N][N];/*递归用的递归递归数组,用全局变量节约时间*/

       int yes=0;/*yes是判断是否找到路的标志,1找到,0没找到*/

       int way[][2],源码wayn=0;/*way数组是显示路线用的,wayn是统计走了几个格子*/

       void Init(void);/*图形初始化*/

       void Close(void);/*图形关闭*/

       void DrawPeople(int *x,int *y,int n);/*画人工探索物图*/

       void PeopleFind(int (*x)[N]);/*人工探索*/

       void WayCopy(int (*x)[N],int (*y)[N]);/*为了8个方向的递归,把旧迷宫图拷贝给新数组*/

       int FindWay(int (*x)[N],算法int i,int j);/*自动探索函数*/

       void MapRand(int (*x)[N]);/*随机生成迷宫函数*/

       void PrMap(int (*x)[N]);/*输出迷宫图函数*/

       void Result(void);/*输出结果处理*/

       void Find(void);/*成功处理*/

       void NotFind(void);/*失败处理*/

       void main(void)/*主函数*/

       {

       int map[N][N]; /*迷宫数组*/

       char ch;

       clrscr();

       printf("\n Please select hand(1) else auto\n");/*选择探索方式*/

       scanf("%c",&ch);

       Init(); /*初始化*/

       MapRand(map);/*生成迷宫*/

       PrMap(map);/*显示迷宫图*/

       if(ch=='1')

       PeopleFind(map);/*人工探索*/

       else

       FindWay(map,1,1);/*系统自动从下标1,1的地方开始探索*/

       Result();/*输出结果*/

       Close();

       }

       void Init(void)/*图形初始化*/

       {

       int gd=DETECT,gm;

       initgraph(&gd,&gm,"c:\\tc");

       }

       void DrawPeople(int *x,int *y,int n)/*画人工控制图*/

       { /*如果将以下两句注释掉,则显示人工走过的迷宫迷宫路径,*/

       setfillstyle(SOLID_FILL,递归递归日线指标源码WHITE); /*设置白色实体填充样式*/

       bar(+(*y)*-6,+(*x)*-6,+(*y)*+6,+(*x)*+6);

       /*恢复原通路*/

       switch(n)/*判断x,y的变化,8个方向的源码变化*/

       {

       case 1: (*x)--;break; /*上*/

       case 2: (*x)--;(*y)++;break ;/*右上*/

       case 3: (*y)++;break; /*右*/

       case 4: (*x)++;(*y)++;break; /*右下*/

       case 5: (*x)++;break; /*下*/

       case 6: (*x)++;(*y)--;break; /*左下*/

       case 7: (*y)--;break; /*左*/

       case 8: (*x)--;(*y)--;break; /*左上*/

       }

       setfillstyle(SOLID_FILL,RED);/*新位置显示探索物*/

       bar(+(*y)*-6,+(*x)*-6,+(*y)*+6,+(*x)*+6);

       }

       void PeopleFind(int (*map)[N])/*人工手动查找*/

       {

       int x,y;

       char c=0;/*接收按键的变量*/

       x=y=1;/*人工查找的初始位置*/

       setcolor();

       line(,,,);

       outtextxy(,,"d");

       line(,,,);

       outtextxy(,,"a");

       line(,,,);

       outtextxy(,,"w");

       line(,,,);

       outtextxy(,,"x");

       line(,,,);

       outtextxy(,,"q");

       line(,,,);

       outtextxy(,,"e");

       line(,,,);

       outtextxy(,,"z");

       line(,,,);

       outtextxy(,,"c");/*以上是画8个方向的控制介绍*/

       setcolor(YELLOW);

       outtextxy(,,"Press 'Enter' to end");/*压回车键结束*/

       setfillstyle(SOLID_FILL,RED);

       bar(+y*-6,+x*-6,+y*+6,+x*+6);/*入口位置显示*/

       while(c!=)/*如果按下的不是回车键*/

       {

       c=getch();/*接收字符后开始各个方向的探索*/

       if(c=='w'&&map[x-1][y]!=1)

       DrawPeople(&x,&y,1);/*上*/

       else

       if(c=='e'&&map[x-1][y+1]!=1)

       DrawPeople(&x,&y,2);/*右上*/

       else

       if(c=='d'&&map[x][y+1]!=1)

       DrawPeople(&x,&y,3);/*右*/

       else

       if(c=='c'&&map[x+1][y+1]!=1)

       DrawPeople(&x,&y,4);/*右下*/

       else

       if(c=='x'&&map[x+1][y]!=1)

       DrawPeople(&x,&y,5);/*下*/

       else

       if(c=='z'&&map[x+1][y-1]!=1)

       DrawPeople(&x,&y,6); /*左下*/

       else

       if(c=='a'&&map[x][y-1]!=1)

       DrawPeople(&x,&y,7); /*左*/

       else if(c=='q'&&map[x-1][y-1]!=1)

       DrawPeople(&x,&y,8); /*左上*/

       }

       setfillstyle(SOLID_FILL,WHITE); /*消去红色探索物,恢复原迷宫图*/

       bar(+y*-6,算法+x*-6,+y*+6,+x*+6);

       if(x==N-2&&y==N-2)/*人工控制找成功的话*/

       yes=1; /*如果成功标志为1*/

       }

       void WayCopy(int (*oldmap)[N],int (*map)[N])/*拷贝迷宫数组 */

       {

       int i,j;

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

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

       oldmap[i][j]=map[i][j];

       }

       int FindWay(int (*map)[N],int i,int j)/*递归找路*/

       {

       if(i==N-2&&j==N-2)/*走到出口*/

       {

       yes=1;/*标志为1,表示成功*/

       return;

       }

       map[i][j]=1;/*走过的地方变为1*/

       WayCopy(oldmap,map); /*拷贝迷宫图*/

       if(oldmap[i+1][j+1]==0&&!yes)/*判断右下方是否可走*/

       {

       FindWay(oldmap,i+1,j+1);

       if(yes)/*如果到达出口了,再把值赋给显示路线的迷宫迷宫way数组,也正是这个原因,所以具体路线是从最后开始保存*/

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       WayCopy(oldmap,map);

       if(oldmap[i+1][j]==0&&!yes)/*判断下方是否可以走,如果标志yes已经是1也不用找下去了*/

       {

       FindWay(oldmap,i+1,j);

       if(yes)

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       WayCopy(oldmap,map);

       if(oldmap[i][j+1]==0&&!yes)/*判断右方是否可以走*/

       {

       FindWay(oldmap,i,j+1);

       if(yes)

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       WayCopy(oldmap,map);

       if(oldmap[i-1][j]==0&&!yes)/*判断上方是否可以走*/

       {

       FindWay(oldmap,i-1,j);

       if(yes)

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       WayCopy(oldmap,map);

       if(oldmap[i-1][j+1]==0&&!yes)/*判断右上方是否可以走*/

       {

       FindWay(oldmap,i-1,j+1);

       if(yes)

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       WayCopy(oldmap,map);

       if(oldmap[i+1][j-1]==0&&!yes)/*判断左下方是否可以走*/

       {

       FindWay(oldmap,i+1,j-1);

       if(yes)

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       WayCopy(oldmap,map);

       if(oldmap[i][j-1]==0&&!yes)/*判断左方是否可以走*/

       {

       FindWay(oldmap,i,j-1);

       if(yes)

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       WayCopy(oldmap,map);

       if(oldmap[i-1][j-1]==0&&!yes)/*判断左上方是否可以走*/

       {

       FindWay(oldmap,i-1,j-1);

       if(yes)

       {

       way[wayn][0]=i;

       way[wayn++][1]=j;

       return;

       }

       }

       return;

       }

       void MapRand(int (*map)[N])/*开始的随机迷宫图*/

       {

       int i,j;

       cleardevice();/*清屏*/

       randomize(); /*随机数发生器*/

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

       {

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

       {

       if(i==0||i==N-1||j==0||j==N-1)/*最外面一圈为墙壁*/

       map[i][j]=1;

       else

       if(i==1&&j==1||i==N-2&&j==N-2)/*出发点与终点表示为可走的*/

       map[i][j]=0;

       else

       map[i][j]=random(2);/*其它的随机生成0或1*/

       }

       }

       }

       void PrMap(int (*map)[N])/*输出迷宫图*/

       {

       int i,j;

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

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

       if(map[i][j]==0)

       {

       setfillstyle(SOLID_FILL,WHITE);/*白色为可走的路*/

       bar(+j*-6,+i*-6,+j*+6,+i*+6);

       }

       else

       {

       setfillstyle(SOLID_FILL,BLUE);/*蓝色为墙壁*/

       bar(+j*-6,+i*-6,+j*+6,+i*+6);

       }

       }

       void Find(void)/*找到通路*/

       {

       int i;

       setfillstyle(SOLID_FILL,RED);/*红色输出走的具体路线*/

       wayn--;

       for(i=wayn;i>=0;i--)

       {

       bar(+way[i][1]*-6,+way[i][0]*-6,+

       way[i][1]*+6,+way[i][0]*+6);

       sleep(1);/*控制显示时间*/

       }

       bar(+(N-2)*-6,+(N-2)*-6,+

       (N-2)*+6,+(N-2)*+6); /*在目标点标红色*/

       setcolor(GREEN);

       settextstyle(0,0,2);/*设置字体大小*/

       outtextxy(,,"Find a way!");

       }

       void NotFind(void)/*没找到通路*/

       {

       setcolor(GREEN);

       settextstyle(0,0,2);/*设置字体大小*/

       outtextxy(,,"Not find a way!");

       }

       void Result(void)/*结果处理*/

       {

       if(yes)/*如果找到*/

       Find();

       else/*没找到路*/

       NotFind();

       getch();

       }

       void Close(void)/*图形关闭*/

       {

       closegraph();

       }

递归|深度优先搜索解迷宫(C++)

       递归在深度优先搜索中起着关键作用,它通过遍历节点的递归递归子节点,如树中1-2-4-3的源码顺序,有效地进行迷宫探索。算法深度优先搜索通常通过递归函数实现,迷宫迷宫例如在求解迷宫问题时,递归递归函数接收迷宫Grid、源码分销返利商城源码已访问路径visitedPoint和当前坐标curLocation作为参数。

       基本策略如下:

       Base Case(基本情况):当找到终点或者无更多可探索路径时,结束递归。

       Recursive Case(递归情况):检查周围可移动点,将它们加入visitedPoint,然后递归调用solveMazeHelper函数。

       递归过程中,hero引擎源码下载visitedPoint作为引用传递以避免频繁拷贝导致的性能损失。如果找到解决方案,函数会返回路径。然而,如果搜索失败,需要在返回false时从visitedPoint中移除新加入的元素,以保持路径的奖多多网站源码准确性。

       算法核心完成后,可以简化为仅接受迷宫Grid作为参数的函数。具体实现包含自定义坐标GridLocation和二维数组Grid,代码在Visual Studio环境下可以编译通过。文件结构如下:

       头文件:grid.hpp、GridLocation.h

       源文件:GridLocation.cpp、maze.cpp

       以上代码展示了深度优先搜索在迷宫求解中的轻快app封装源码应用和实现细节。

关于计算机C++编程的迷宫问题的解题思路?

       /*走通用迷宫问题的思路是:从给定的任意一个起点开始,向各个方向都有走动的可能,按照一定的顺序进行。

       判断如果该方向上能走,(能走要是:不是以前走过的地方,不是墙壁,不是地图之外)就走这一步,然后记录下这一步。

       如果不能走,就换下一个方向,如果能走就继续下一步。各个方向都不能走,说明到了死路,这时候就返回上一步去走下一个方向。如此继续。

       每走动一步都要检测是不是到达目标了,如果到达就输出结果。

       如果不能走到目标,返回到最除起点也不能走了,说明无解。

       我的示意程序如下:

       */

       /*地图路径求解程序,用VC++编写的,*/

       #include<stdio.h>

       #include<stdlib.h>

       #define

       ROW

       9/*定义行数*/

       #define

       COL

       /*定义列数*/

       typedef

       struct

       RowAndColPath{

       int

       r;

       int

       c;

       }RowAndColPath;/*定义结构体实现走步过程的记录*/

       int

       Move[4][2]={ { 0,1},{ 1,0},{ -1,0},{ 0,-1}};/*4个方向*/

       RowAndColPath

       path[ROW*COL];/*走动过程的记录*/

       bool

       ResultFlag=false;/*找到解的标志*/

       bool

       GettingPath(int

       step,int

       CurrentRow,int

       CurrentCol,int

       ResultRow,int

       ResultCol,int

       MapWay[][COL]);/*递归求解方法*/

       void

       main()

       {

       int

       MapWay[ROW][COL]={

       { 1,1,1,1,1,1,1,1,0,1,1,1,1},

       { 0,0,0,1,1,0,0,0,0,1,1,1,1},

       { 1,1,0,1,1,1,1,1,0,0,1,1,1},

       { 1,1,0,0,0,0,1,1,1,0,1,1,1},

       { 1,1,0,1,1,0,0,0,0,0,0,0,1},

       { 1,1,0,0,1,1,1,1,1,1,1,0,1},

       { 1,1,1,0,0,0,0,0,0,1,1,0,1},

       { 1,1,1,0,1,1,1,1,0,0,0,0,1},

       { 1,1,1,0,0,0,1,1,1,1,1,1,1}};/*定义地图*/

       int

       CurrentRow=1,CurrentCol=0,ResultRow=0,ResultCol=8;/*定义初始和结束位置*/

       path[0].r=CurrentRow;

       path[0].c=CurrentCol;/*初始位置进入历史的第一步*/

       if(GettingPath(1,CurrentRow,CurrentCol,ResultRow,ResultCol,MapWay))/*如果走动成功*/

       printf("恭喜!查找成功!\n");

       else

       printf("抱歉,查找失败!\n");

       }

       bool

       GettingPath(int

       step,int

       CurrentRow,int

       CurrentCol,int

       ResultRow,int

       ResultCol,int

       MapWay[][COL])

       {

       int

       i,j;

       for(i=0;i<4;i++)/*依次对4个方向搜索*/

       {

       if(ResultFlag)

       return

       true;

       CurrentRow+=Move[i][0];

       CurrentCol+=Move[i][1];/*先按该方向前进一步*/

       if((CurrentRow>=0)&&(CurrentRow<ROW)&&(CurrentCol>=0)&&(CurrentRow<COL))/*如果还在地图内部*/

       {

       if(MapWay[CurrentRow][CurrentCol]==0)/*下一步可以走*/

       {

       for(j=0;j<step;j++)/*判断是不是重复了以前走过的路*/

       {

       if((path[j].r==CurrentRow)&&(path[j].c==CurrentCol))

       break;

       }

       if(j==step)/*如果没有走过这个点,就走*/

       {

       path[step].r=CurrentRow;

       path[step].c=CurrentCol;/*计入该步*/

       step++;

       if((CurrentRow==ResultRow)&&(CurrentCol==ResultCol))/*如果已到达目的地*/

       {

       ResultFlag=true;

       printf("路径如下:\n\n");

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

       printf("第

       %d

       步:\t%d\t%d\n",j,path[j].r,path[j].c);

       return

       true;

       }

       else

       {

       if(step>=ROW*COL)/*如果已经走遍了地图,就宣布失败*/

       return

       0;

       if(!ResultFlag)

       GettingPath(step,CurrentRow,CurrentCol,ResultRow,ResultCol,MapWay);/*没有到达目的,继续走*/

       }

       }

       else/*如果已经走过这一点,退回去*/

       {

       CurrentRow-=Move[i][0];

       CurrentCol-=Move[i][1];;

       }

       }

       else/*如果该点不可走,退回去*/

       {

       CurrentRow-=Move[i][0];

       CurrentCol-=Move[i][1];;

       }

       }

       else/*如果该步出地图了,退回去*/

       {

       CurrentRow-=Move[i][0];

       CurrentCol-=Move[i][1];;

       }

       }

       if(ResultFlag)

       return

       true;

       return

       false;/*无路可走*/

       }

更多内容请点击【娱乐】专栏