迷宮遞歸演算法

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