迷宫递归算法

A. 用递归求解迷宫问题

b[9][9] = {....};
a[81][81] = {};
f(i=1,j=1,k=0){
if(i<0 || j<0 ||i>9 ||j>9){
return ;
}
if(i == 8 && j==8){
echo a;
return;

}
if(b[i][j] == 0){
return;
}
a[k][0]=i;
a[k][1]=j;
f(i+1,j,k+1);//往右的结果
a[k][0]=i;
a[k][1]=j;
f(i,j+1,k+1);//往下的结果
a[k][0]=i;
a[k][1]=j;
f(i-1,j,k+1);//往上的结果
a[k][0]=i;
a[k][1]=j;
f(i,j-1,k+1);//往左的结果

}

如果你思路不明白可以再问，哈

B. 求解c语言一递归迷宫问题

给你给伪算法：（设坐标为x,y,坐标向右和下延生。）
函数：
｛
判断当前是不是（7,7)，如果是，表示走出迷宫。打印轨迹
1 尝试往左先走一步（x-1，如果x小于0，或者对应位置标识为阻塞）
2 1如果成功，用本函数递归调用左走一步的坐标，并记下当前位置到轨迹列表。
3 尝试往前先走一步（y+1，如果y小于0，或者对应位置标识为阻塞）
4 3如果成功，用本函数递归调用前走一步的坐标,并记下当前位置到轨迹列表。
5 尝试往右先走一步（x+1，如果x小于0，或者对应位置标识为阻塞）
6 5如果成功，用本函数递归调用前走一步的坐标,并记下当前位置到轨迹列表。
如果是（0，0），表示没有合适的路径可走出迷宫。
如果不是（0，0），将轨迹列表最后一位弹出。
｝

C. 迷宫算法 上下左右 优先级问题

迷宫一般采用递归算法，而且出口位置在算法开始时候是不知道的吧。而且迷宫的出口也不会固定到哪一个方向。如果采用枚举方法一般是按顺时针或者逆时针找，这样才可以用循环来做，如果采用优先，只能将每个方向定位，设一个常量，那样的话每次递归都要判断一下，非常麻烦，估计还比不用优先还慢一些。

D. 用递归算法找出迷宫中所有可行的路径

回溯啊、、、
int ans[1000][2],t=0； //ans数组里存的是每一步的解
void dfs(int x,int y)
{
if (x==x0&&y==y0) {print();return ;} //x0 y0是出口坐标 print（）是输出一个合法解的函数 这个很 简单你自己写吧
然后是枚举下一步可以到达的点 因为我不知道走的规则所以写不出来 只能先假设xx yy是x、y能到达的一个点吧 你可以用for循环枚举能到的点

for (xx.....)
for (yy....)
if (xx,yy满足条件）
{
t++;
ans[t][0]=xx;
ans[t][1]=yy;
dfs(xx,yy)
t--;
}
}

E. 求解迷宫的递归算法

#include<stdio.h>
#include<malloc.h>
#define M 10
#define N 10
struct node
{
int flag;
int x,y;
};
struct link
{
struct node lnode;
struct link *next;
struct link *pri;
};
struct link *head;
struct node maze[M][N];
int maze_flag[M][N]={{1,1,1,1,1,1,1,1,1,1},
{1,1,0,1,0,0,0,1,0,1},
{1,0,0,1,0,0,0,1,0,1},
{1,0,0,0,0,1,1,0,0,1},
{1,0,1,1,1,0,0,0,0,1},
{1,0,0,0,1,0,0,0,0,1},
{1,0,1,0,0,0,1,0,0,1},
{1,0,1,1,1,0,1,1,0,1},
{1,1,0,0,0,0,0,0,0,1},
{1,1,1,1,1,1,1,1,1,1}};
int judge(int i,int j);
void in_link(struct node nmaze);
void out_link();
void out_put();
void main()
{
int i,j;
head=(struct link *)malloc(sizeof(struct link));
head->next=head;
head->pri=head;
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
maze[i][j].x=i;
maze[i][j].y=j;
maze[i][j].flag=maze_flag[i][j];
}
}
printf("the maze is:\n");
for(i=0;i<M;i++)
{
for(j=0;j<N;j++)
{
printf("%2d",maze_flag[i][j]);
}
printf("\n");
}
head->next=(struct link *)malloc(sizeof(struct link));
head->pri=head->next;
head->next->pri=head;
head->next->next=head;
head->next->lnode.x=1;
head->next->lnode.y=1;
head->next->lnode.flag=1;
printf("wether to find the way?\n");
if(judge(1,1)==1)
printf("the end!\n");
}
int judge(int i,int j)
{
struct node (*pmaze)[N]=maze;
if(pmaze[i][j+1].flag==0)
{
j++;
if((pmaze[i][j].x==M-2)&&(pmaze[i][j].y==N-2))
{
printf("success to find the way!\n");
out_put();
return(1);
}
pmaze[i][j].flag=1;
in_link(pmaze[i][j]);
printf("goin to judge\n");
return(judge(i,j));

}
else
{
if(pmaze[i+1][j].flag==0)
{
i++;
if((pmaze[i][j].x==M-2)&&(pmaze[i][j].y==N-2))
{
printf("success to find the way!\n");
out_put();
return(1);
}
pmaze[i][j].flag=1;
in_link(pmaze[i][j]);
return(judge(i,j));
}
else
{
if(pmaze[i][j-1].flag==0)
{
j--;
if((pmaze[i][j].x==M-2)&&(pmaze[i][j].y==N-2))
{
printf("success to find the way!\n");
out_put();
return(1);
}
pmaze[i][j].flag=1;
in_link(pmaze[i][j]);
return(judge(i,j));
}
else
{
if(pmaze[i-1][j].flag==0)
{
i--;
if((pmaze[i][j].x==M-2)&&(pmaze[i][j].y==N-2))
{
printf("success to find the way!\n");
out_put();
return(1);
}
pmaze[i][j].flag=1;
in_link(pmaze[i][j]);
return(judge(i,j));
}
else
{
out_link();
struct link *q;
q=head;
while(q->next!=head)
{
q=q->next;
}
judge(q->lnode.x,q->lnode.y);
}
}
}
}
}
void in_link(struct node nmaze)
{
struct link *p;
p=head;
while(p->next!=head)
{
p=p->next;
}
p->next=(struct link *)malloc(sizeof(struct link));
p->next->pri=p;
head->pri=p->next;
p->next->next=head;
p=p->next;
p->lnode.x=nmaze.x;
p->lnode.y=nmaze.y;
p->lnode.flag=nmaze.flag;
}
void out_link()
{
struct link *p;
p=head;
while(p->next!=head)
{
p=p->next;
}
p->pri->next=p->next;
head->pri=p->pri;
free(p);
}
void out_put()
{
struct link *r;
r=head;
while(r->next!=NULL)
{
r=r->next;
printf("%2d%2d\n",r->lnode.x,r->lnode.y);
}
printf("%d%d\n",r->lnode.x,r->lnode.y);
}

F. python基于递归算法实现的走迷宫问题

Python基于递归算法实现的走迷宫问题
本文实例讲述了Python基于递归算法实现的走迷宫问题。分享给大家供大家参考，具体如下：
什么是递归?
简单地理解就是函数调用自身的过程就称之为递归。
什么时候用到递归？
如果一个问题可以表示为更小规模的迭代运算，就可以使用递归算法。
迷宫问题：一个由0或1构成的二维数组中，假设1是可以移动到的点，0是不能移动到的点，如何从数组中间一个值为1的点出发，每一只能朝上下左右四个方向移动一个单位，当移动到二维数组的边缘，即可得到问题的解，类似的问题都可以称为迷宫问题。
在python中可以使用list嵌套表示二维数组。假设一个6*6的迷宫,问题时从该数组坐标[3][3]出发，判断能不能成功的走出迷宫。
maze=[[1,0,0,1,0,1],
[1,1,1,0,1,0],
[0,0,1,0,1,0],
[0,1,1,1,0,0],
[0,0,0,1,0,0],
[1,0,0,0,0,0]]
针对这个迷宫问题，我们可以使用递归的思想很好的解决。对于数组中的一个点，该点的四个方向可以通过横纵坐标的加减轻松的表示，每当移动的一个可移动的点时候，整个问题又变为和初始状态一样的问题，继续搜索四个方向找可以移动的点，知道移动到数组的边缘。
所以我们可以这样编码：
# 判断坐标的有效性，如果超出数组边界或是不满足值为1的条件，说明该点无效返回False，否则返回True。
def valid(maze,x,y):
if (x>=0 and x<len(maze) and y>=0 and y<len(maze[0]) and maze[x][y]==1):
return True
else:
return False
# 移步函数实现
def walk(maze,x,y):
# 如果位置是迷宫的出口，说明成功走出迷宫
if(x==0 and y==0):
print("successful!")
return True
# 递归主体实现
if valid(maze,x,y):
# print(x,y)
maze[x][y]=2 # 做标记，防止折回
# 针对四个方向依次试探，如果失败，撤销一步
if not walk(maze,x-1,y):
maze[x][y]=1
elif not walk(maze,x,y-1):
maze[x][y]=1
elif not walk(maze,x+1,y):
maze[x][y]=1
elif not walk(maze,x,y+1):
maze[x][y]=1
else:
return False # 无路可走说明，没有解
return True
walk(maze,3,3)
递归是个好东西呀！

G. 求一个求从迷宫的一点到另一点的最短路径的递归算法

typedef struct node
{
int i;
struct node **nearby;//相邻结点可以有多个，所以这里用指针的指针
} MAPNODE;
MAPNODE a,b;
int minpath(a,b)//从a结点到b结点可以分成两步，1.从a到b的相邻结点。2.从相邻结点到b结点，这就是一个递归的过程
{
int dis=0;
int min=999999;//一个足够大的数据
MAPNODE **p;
if(a.i==b.i)//序号相同表示是同一结点，path为0
{
dis=0;
}
else
{
for(p=b.nearby;*p!=0;p++)
{
dis=0;
dis+=minpath(a,*p);
dis<min?min=dis:;
}
}
return dis;
}

H. 迷宫算法（递归和非递归）

去csdn找下，csdn的博客也可以找，下载那可以找相关资料找找
网~站：www.csdn.net
下载：download.csdn.net 注册个账号就能下载
博客：blog.csdn.net