数据结构-递归寻路

本文转载http://blog.csdn.net/feixiaoxing/article/details/6894981

寻路是游戏设计中需要使用到一种功能，那么我们怎么样以一个点作为起始点，快速地寻找到目标点呢？其实寻路的方法不难。一种简单有效的方法就是回溯法。如果我们从一个点出发，那么这个点周围肯定有若干条路，只要有一条路存在，我们就一直走下去，直到发现没有路走为止；要是发现路走不下去了怎么办，那就只好回头了，我们只能从剩下的选项中继续选择一条路，继续尝试。如果很不幸，所有的尝试都结束了，还是没有发现目标节点，那只能说明，我们真的无路可走。

    a）首先，我们用矩阵表示地图：其中1表示路，0表示没有路，2表示终点，起始地点为（1,0）

[cpp]  view plain copy

1. #define MAX_NUMBER_LENGTH 6  
2.   
3. static int gPath[MAX_NUMBER_LENGTH][MAX_NUMBER_LENGTH] = {  
4.     {0 , 0, 0, 0, 1, 1},  
5.     {1,  1, 0, 0, 1, 0},  
6.     {0 , 1, 1, 1, 1, 0},  
7.     {0 , 0, 1, 0, 1, 2},  
8.     {0 , 0, 1, 0, 1, 0},  
9.     {0 , 0, 1, 1, 1, 0}  
10. };  
11.   
12. static int gValue[MAX_NUMBER_LENGTH][MAX_NUMBER_LENGTH] = {0}; /* 记录已走过的路 */  

     b）其实，我们编写一个判断函数，判断当前节点是否合法

[cpp]  view plain copy

1. int check_pos_valid(int x, int y)  
2. {  
3.     /* 节点是否出边界 */  
4.     if(x < 0 || x>= MAX_NUMBER_LENGTH || y < 0 || y >= MAX_NUMBER_LENGTH)  
5.         return 0;  
6.   
7.     /* 当前节点是否存在路 */  
8.     if(0 == gPath[x][y])  
9.         return 0;  
10.   
11.     /* 当前节点是否已经走过 */  
12.     if('#' == gValue[x][y])  
13.         return 0;  
14.   
15.     return 1;  
16. }  

     c）接着，我们编写一个递归的寻找算法即可

[cpp]  view plain copy

1. int find_path(int x, int y)  
2. {  
3.     if(check_pos_valid(x,y))  
4.     {  
5.         if(2 == gPath[x][y]){  
6.             gValue[x][y] = '#';  
7.             return 1;  
8.         }  
9.   
10.         gValue[x][y] = '#';  
11.         if(find_path(x, y-1))  
12.             return 1;  
13.   
14.         if(find_path(x-1, y))  
15.             return 1;  
16.   
17.         if(find_path(x, y+1))  
18.             return 1;  
19.   
20.         if(find_path(x+1, y))  
21.             return 1;  
22.         gValue[x][y] = 0;  
23.         return 0;  
24.     }  
25.   
26.     return 0;  
27. }  

     d）为了验证我们的算法是否正确，可以编写一个打印函数

[cpp]  view plain copy

1. void print_path()  
2. {  
3.     int outer;  
4.     int inner;  
5.   
6.     for(outer = 0; outer < MAX_NUMBER_LENGTH; outer++){  
7.         for(inner = 0; inner < MAX_NUMBER_LENGTH; inner++){  
8.             printf("%c ", gValue[outer][inner]);  
9.         }  
10.         printf("\n");  
11.     }  
12. }  

    e）上面c中所描述的算法只是寻找一条路，那么如果想遍历所有的道路，算法应该怎么修改呢？

[cpp]  view plain copy

1. void find_path(int x, int y)  
2. {  
3.     if(check_pos_valid(x,y))  
4.     {  
5.         if(2 == gPath[x][y]){  
6.             gValue[x][y] = '#';  
7.             print_path();  
8.             gValue[x][y] = 0;  
9.             return ;  
10.         }  
11.   
12.         gValue[x][y] = '#';  
13.         find_path(x, y-1);  
14.         find_path(x-1, y);  
15.         find_path(x, y+1);  
16.         find_path(x+1, y);  
17.         gValue[x][y] = 0;  
18.     }  
19. }  

思考题：

    上面的题目介绍了寻路的方法，介绍了如何遍历所有的可能路径。当然你可以从这所有的寻找路径中寻找出一条最短的路径。但是朋友们可以思考一下，有没有一种方法，可以一下子寻找到最优的路径呢？