AI贪吃蛇前瞻——基于Dijkstra算法的最短路径问题

在贪吃蛇流程结构优化之后，我又不满足于亲自操刀控制这条蠢蠢的蛇，干脆就让它升级成AI，我来看程序自己玩，哈哈。

一、Dijkstra算法原理

作为一种广为人知的单源最短路径算法，Dijkstra用于求解带权有向图的单源最短路径的问题。所谓单源，就是一个源头，也即一个起点。该算法的本质就是一个广度优先搜索，由中心向外层层层拓展，直到遇到终点或者遍历结束。该算法在搜索的过程中需要两个表S及Q，S用来存储已扫描过的节点，Q存储剩下的节点。起点s距离dist[s] = 0;其余点的值为无穷大（具体实现时，表示为某一不可能达到的数字即可）。开始时，从Q中选择一点u，放入S，以u为当前点，修改u周围点的距离。重复上述步骤，直到Q为空。

二、Dijkstra算法在AI贪吃蛇问题中的变化

2.1 地图的表示方法

与平时见到的各种连通图问题不同，贪吃蛇游戏中的地图可以看成是标准的矩形，也即，一个二维数组，图中各个相邻节点的权值为1。因此，我们可以用一个边长*边长的二维数组作为算法的主体数据结构，讲地图有关的数据都集成在数组里。既然选择了二维数组，就要考虑数组元素类型的问题，即我们的数组应该存储哪些信息。作为主要的数据结构，我们希望我们的数组能存储自身的坐标，起点到自身的最短路径，因此我们可以定义这样的一个结构体：

1. typedef struct loca{  
2.     int x;  
3.     int y;  
4. }Local;  
5.     
6. typedef struct unit{  
7.     int value;  
8.     Local local;  
9. }Unit;  

又因为我们需要得到最短路径以求得贪吃蛇下一步的方向，所以在结构体里加一个指针，指向前一个节点的位置。

1. typedef struct loca{  
2.     int x;  
3.     int y;  
4. }Local;  
5.     
6. typedef struct unit{  
7.     int value;  
8.     Local local;  
9.     struct unit *pre;  
10. }Unit;  

假设地图为一个正方形，因此创建一个边长*边长大小的二维数组：

1. #define N 5  
2.     
3. Unit mapUnit[N][N];  

2.2 队列——待处理节点的集合

有了mapUnit之后，我们还需要一个数据结构来存储接下来需要处理的节点的信息。在此我选择了一个队列，由于C语言不提供标准的接口，就自己草草的写了一个。

1. typedef struct queue{  
2.     int head,tail;  
3.     Local queue[N*N];  
4. }Queue;  
5.     
6. Queue que;  

使用了一个定长的数组来作为队列结构，所以为了应对所有的结果，将其长度设为N*N。也正因为是定长数组，队列的进队与出队只需操作表示下标值的head与tail即可。这样虽然不节约空间，但胜在实现方便。

1. void push(int x,int y)  
2. {  
3.     que.tail++;  
4.     que.queue[que.tail].x = x;  
5.     que.queue[que.tail].y = y;  
6. }  
7.     
8. void pop()  
9. {  
10.     que.head++;  
11. }  

由于push操作有一个自增操作，所以在初始化时需要将tail设为-1，这样在push第一个节点时可保证head与tail指向同一个位置。

2.3 console坐标——地图的初始化

在我的贪吃蛇链表实现中，前端展示时通过后台的计算逻辑+Pos函数来实现的，也就是现在后台计算结果，再推动前台的变化。因此Pos()，也就是使光标跳转到控制台某位置的函数就尤为重要，这也直接影响了整个项目各元素的坐标表示方法。

简单来说就是console的坐标表示类似于坐标轴中第四象限的表示方法，当然元素都为正值。

所以对于一个N*N的数组，我们可以这样初始化：

1. void InitializeMapUnit()  
2. {  
3.     que.head = 0;  
4.     que.tail = -1;  
5.     
6.     for(int i = 0;i<N;i++)  
7.         for(int j = 0;j<N;j++)  
8.         {  
9.             mapUnit[i][j].local.x = i;  
10.             mapUnit[i][j].local.y = j;  
11.             mapUnit[i][j].pre = NULL;  
12.             mapUnit[i][j].value = N*N;   
13.         }  
14. }  

将队列的初始化放在这个函数里实属无奈，这两行语句，又不能在初始化时赋值，又不能在函数体外赋值，放main函数嫌它乱，单独一个函数嫌它慢….就放在地图初始化里了…

三、计算，BFS！

3.1 设置起点

基础的结构与初始化完成后，就需要开始计算了。在此之前，我们需要一个坐标，来作为路径问题的出发点。

1. void setOrigin(int x,int y)  
2. {  
3.     mapUnit[x][y].value = 0;  
4.     push(x,y);  
5. }  

将地图上该点位置的值设为0后，将其压入队列中。在第一轮的BFS中，它四周的点，将成为第二轮计算的原点。

3.2 BFS框架

在该地图的BFS中，我们将依托队列各个元素，来处理它们的邻接节点。两个循环，可以揭示大体的框架：

1. void bfs(int end_x,int end_y)  
2. {  
3.     //当前需要处理的节点   
4.     for(int i = head;i<=tail;i++)  
5.     {  
6.         //  四个方向   
7.         for(int j = 0;j<4;j++)  
8.         {  
9.             // 新节点   
10.             if(mapUnit[new_x][new_y].value == N*N)  
11.             {  
12.                 //设置属性   
13.             }  
14.             //  处理过的节点，取小值  
15.             else       
16.             {  
17.                 //属性更改Or不变   
18.             }  
19.         }  
20.     }  
21.     //下一轮   
22.     bfs();  
23. }  

3.3 变化的队列

BFS的主体循环依赖于队列的head与tail，但是对新节点的push操作改变了tail的值，所以我们需要在循环开始前将此时（上一轮BFS的结果）的队列状态保存下来，避免队列变化对BFS的影响。

1. int head = que.head;  
2. int tail = que.tail;  
3. //当前队列  
4. for(int i = head;i<=tail;i++)  
5. {  
6.     // TODO...   
7. }   

3.4 节点的坐标

在原来写的BFS中，要获取一个节点的下标需要将一个结构体层层剥开，数组的下标是一个结构体某元素的某元素，绕来绕去，可读性早已被献祭了。

所以这次我吸取了教训，在内循环，也就是处理周围节点时，将其坐标先存储在变量中，用来确保程序的可读性。

1. for(int i = head;i<=tail;i++)  
2. {  
3.         int base_x = que.queue[i].x;  
4.         int base_y = que.queue[i].y;  
5.             
6.         //  四个方向   
7.         for(int j = 0;j<4;j++)  
8.         {  
9.             int new_x = base_x + direct[j][0];  
10.             int new_y = base_y + direct[j][1];  
11.                 
12.             // TODO...   
13.         }   
14. }  

所以我们可以构建出这样一个移动的二维数组：

1. //          方向， 上       下       左   右   
2. int direct[4][2] = {{0,-1},{0,1},{-1,0},{1,0}};  

3.4.1 数组越界的处理

在得到了待处理节点的坐标后，需要对其进行判断，确保它在数组内部。

1. if(stepRight(new_x,new_y) == false)  
2.     continue;  

函数细节如下：

1. bool stepRight(int x,int y)  
2. {  
3.     if(x >= N || y >= N ||  
4.         x < 0 || y < 0)  
5.         return false;  
6.     return true;  
7. }  

3.5 新节点的处理

终于到了访问邻接坐标的时候。一个节点四周的节点，有可能没有被访问过，也可能以及被访问过。我们在初始化时就将所有节点的值设为了一个MAX，通过对值得判断，可以推断出其是否为新节点。

1. if(mapUnit[new_x][new_y].value == N*N)  
2. {  
3.     // ...  
4. }  
5. else    //取小值   
6. {  
7.     // ...  
8. }  

3.5.1 未处理节点的处理

对于未处理的节点，对其的操作有两部。一是初始化，值的初始化与指针的初始化。由于两点间的距离为1，所以该节点的值为前一个节点的值+1，当然，他的pre指针也指向前一个节点。

1. mapUnit[new_x][new_y].value = mapUnit[base_x][base_y].value +1;  
2. mapUnit[new_x][new_y].pre = &mapUnit[base_x][base_y];  
3. push(new_x,new_y);  

3.5.2 已处理节点的处理

对于已处理过的节点，需要先将其做一个判断，即寻找最短路径，将其自身的value与前一节点value+1比较，再处理。

1. mapUnit[new_x][new_y].value = MIN(mapUnit[new_x][new_y].value,mapUnit[base_x][base_y].value +1);  
2. if(mapUnit[new_x][new_y].value != mapUnit[new_x][new_y].value)  
3. mapUnit[new_x][new_y].pre = &mapUnit[base_x][base_y];  

3.6 队列的刷新

在处理完一层节点后，新的节点导致了队列中tail的增加，但是head并没有减少，所以在新一轮BFS前，需要将队列的head移动到真正的头部去。

1. for(int i = head;i<=tail;i++)  
2.     pop();  

在这儿也需要当前BFS轮数前的队列数据。

3.7 最短路径

在地图的遍历完成之后，我们就可以任取一点，得到起点到该点的最短路径。

1. void getStep(int x,int y)  
2. {  
3.     Unit *scan = &mapUnit[x][y];  
4.     if(scan->pre!= NULL)  
5.     {  
6.         int x = scan->local.x;  
7.         int y = scan->local.y;  
8.         scan = scan->pre;  
9.         getStep(scan->local.x,scan->local.y);  
10.         printf(" -> ");  
11.     }  
12.     printf("(%d,%d)",x,y);  
13. }  

四、此路不通——障碍的引入

在贪吃蛇中，由于蛇身长度的存在，以及蛇头咬到自身就结束的特例，我们需要在算法中加入障碍的元素。

对于这个新加入的元素，我们设置一个坐标结构体的数组，来存储所有的障碍。

1. #define WALL_CNT 3   
2. Local Wall[WALL_CNT];  

用一个函数来设置障碍：

1. void setWall(void)  
2. {  
3.     Wall[0].x = 1;  
4.     Wall[0].y = 1;  
5.         
6.     Wall[1].x = 1;  
7.     Wall[1].y = 2;  
8.         
9.     Wall[2].x = 2;  
10.     Wall[2].y = 1;  
11. }  

由于这个项目里数据用于模块测试的随机性，所以手动设置每一个坐标。在之后的贪吃蛇AI中，将接受一个数组——蛇身，来自动完成赋值。

如果将障碍与地图边界等同来看，就能将障碍的判断整合进stepRight()函数。

1. bool stepRight(int x,int y)  
2. {  
3. //  out of map   
4.     if(x >= N || y >= N ||  
5.         x < 0 || y < 0)  
6.         return false;  
7. //  wall  
8.     for(int i = 0;i<WALL_CNT;i++)  
9.         if(Wall[i].x == x && Wall[i].y == y)  
10.             return false;  
11.         
12.     return true;  
13. }  

五、简单版本的测试

完成了上诉的模块后，项目就可以无BUG但是低效的跑了。我们来试一试，在一个5*5的地图中，起点在中间，为（2，2），终点在起点的上上方，为（2，0），设置三面围墙，分别是（1，1），（2，1），（3，1）。如下：

看看效果。

图中二维数组打印了各个坐标点的value，即该点到起点的最短路径。25为墙，0为起点。可以看到到终点需要六步，路径是先往左，再往上，左后向右到终点。

任务完成，看似不错。把终点换近一些看看，就（1，4）吧。

喔，问题出来了。我取一个非常近的点，但是整张图都被遍历了，效率太低了，要改进。

还有一个问题，如果将起点周围四个点都设置为墙，结果应该是无法得到其余点的最短路径，但现阶段的结果还不尽如人意：

六、优化

6.1 遍历的半途结束

在BFS中，如果找到了终点，那就可以退出遍历，直接输出结果。不过这样的一个递归树，要随时终止可不容易。我一开始想到了"万恶之源"goto，不过goto不能跨函数跳转，随后又想到了非本地跳转setjmp与longjmp。

"与刺激的abort()和exit()相比,goto语句看起来是处理异常的更可行方案。不幸的是，goto是本地的：它只能跳到所在函数内部的标号上，而不能将控制权转移到所在程序的任意地点（当然，除非你的所有代码都在main体中）。

为了解决这个限制，C函数库提供了setjmp()和longjmp()函数，它们分别承担非局部标号和goto作用。头文件<setjmp.h>申明了这些函数及同时所需的jmp_buf数据类型。"

有了这随时能走的"闪现"功能，跳出复杂嵌套函数还是事儿嘛？

1. #include <setjmp.h>  
2. jmp_buf jump_buffer;  
3.     
4. int main (void)  
5. {  
6.     //...  
7.     if(setjmp(jump_buffer) == 0)  
8.         bfs(finishing_x,finishing_y);  
9.     //...  
10. }  

    由于跳转需要判断当前节点是否为终点，而终点又是一个局部变量，所以需要改变bfs函数，使其携带终点参数。

    再在处理完一个节点后，判断其是否为终点，是则退出。

11. for(int i = head;i<=tail;i++)  
12. {  
13.     //...  
14.     //  四个方向   
15.     for(int j = 0;j<4;j++)  
16.     {  
17.         //...  
18.         if(mapUnit[new_x][new_y].value == N*N)  
19.         {  
20.             //...  
21.         }  
22.         else    //取小值   
23.         {  
24.             //...  
25.         }  
26.         if(new_x == end_x && new_y == end_y)  
27.         {  
28.             longjmp(jump_buffer, 1);  
29.         }  
30.     }  
31. }  

6.2 无最短路径时的处理

在判断某一点的路径时，可先判断其是否存在最短路径，存在则输出，否则给出提示信息。

1. void getStepNext(int x,int y)  
2. {  
3.     Unit *scan = &mapUnit[x][y];  
4.     if(scan->pre!= NULL)  
5.     {  
6.         int x = scan->local.x;  
7.         int y = scan->local.y;  
8.         scan = scan->pre;  
9.         getStepNext(scan->local.x,scan->local.y);  
10.         printf(" -> ");  
11.     }  
12.     printf("(%d,%d)",x,y);  
13. }  
14.     
15. void getStep(int x,int y,int orgin_x,int orgin_y)  
16. {  
17.     Unit *scan = &mapUnit[x][y];  
18.     Pos(0,10);  
19.         
20.     if(scan->pre == NULL)  
21.     {  
22.         printf("NO Path To Point (%d,%d) From Point (%d,%d)!\n",x,y,orgin_x,orgin_y);  
23.     }  
24.     else  
25.     {  
26.         getStepNext(x,y);  
27.     }  
28. }  

七、优化后效果

八、写在后面

算法大体上完成了，将其改为贪吃蛇AI也只需做少量修改。尽量抽个时间把AI写完，不过可能需要一段时间。

在最短路径的解法上，Dijkstra算法并不是最理想的解法。盲目搜索的效率很低。考虑到地图上存在着两点间距离等信息，可以使用一种启发式搜索算法，如BFS(Best-First Search)，以及大名鼎鼎的A*算法。在中文互联网我能找到的有关于A*算法的资料不多，将来得花些时间好好研究下。

源码地址：https://github.com/MagicXyxxx/Algorithms