八数码游戏分析—启发式搜索算法（2）

 大家通过阅读 八数码游戏分析——启发式搜索（一） 应该对解决八数码的启发式搜索算法有了一个大致的印象了，那么我就开始介绍基于 八数码游戏分析——启发式搜索（一）的一种改进的算法。

改进的启发式搜索策略：八数码的下一个格局中每个棋子移动到正确位置所需要的步数要少于当前格局中每个棋子移动到正确位置所需要的步数。

首先来解释一下什么是棋子移动到正确位置的步数。

      我们在 八数码游戏分析——启发式搜索（一） 中提到每个数码的位置与最终格局的对比，如果位置相同，则说明此数码在正确位置。

还是拿那个图来说明：

 

                                                 图2.1

假设图2.1右边的格局是最终状态，那么可以看出左边格局中正确位置的数码就是红色字体标识的数码，分别是3，4，5，7。

我们把初始数码中的每个未移动到正确位置的数码拿出来单独分析

我们拿数码2来分析，如下图：

                                                 图2.2

 

可以看出数码2移动到正确位置需要一步，我们再拿数码8来分析：

                                                                 图2.3

从图2.3可以看出，数码8移动到正确位置为两步

因此，一次可以得出数码1和数码6移动到正确位置都为一步，所以当前状态的每个棋子移动到正确位置的步数总和为：5步

那么当前状态的下一状态如下图所示：

                                                                                            图2.4

图2.4中，红色字体标识的是在正确位置的数码，八数码旁边的（n）表示当前数码格局中每个棋子移动到正确位置的步数总和为n步。

由此可以看出图2.4的左下方格局满足条件（一共要4步），所以左下方的格局为下一步格局。可能现在大家还没有看出此算法相对于前一个算法的优越性，

好，我们再向后继续推：

 

                                                                               图2.5

细心的朋友一定还记得，在 八数码游戏分析——启发式搜索（一）中，推到这一步的时候有两个一样的格局可以选择，而此算法在下一步只有右下方的格局总步数（3步）少于当前格局总步数（4步）。

不仅如此，经过大量的测试证明，八数码问题运用此算法到达最终格局所用的步数也是最少的！

下面贴一个测试c程序：

[cpp] view plain copy

1. /* 
2. 程序名：八数码问题 
3. 作者：侯青青       完成时间：2010.7.5 
4. 描述： 
5. 主要函数列表： 
6.       1.show()     显示当前待调整数码矩阵 
7.       2.exchange() 交换数码中的 begin[row_one][column_one] 与 begin[row_two][column_two] 这两个数 
8.       3.judge()    判断待调整的数码与最终数码相比正确位置数码的个数 
9.       4.yidong()   将待调整数码从开始位置移动到终止位置，并将其过程输出 
10.       5.shuru()    有用户输入待调整的数码矩阵最初状态的数，并将其存入到begin[][]数组中 
11. 其它说明：此程序运用到启发式搜索的策略， 
12.           （1）：将空格的地方存储零，这样便于操作 
13.           （2）：每次交换0上下左右4个方向元素的位置，八数码的下一个格局中每个棋子移动到正确位置所需要的步数要少于 
14.                   当前格局中每个棋子移动到正确位置所需要的步数则算成功，则重复步骤2，失败的话则跳回上一轮交换。 
15.           （3）：当交换到最终所有的数码的位置都正确时结束 
16. */  
17.   
18. #include"stdio.h"  
19. #include"math.h"  
20. #define num 3 //宏定义数码的行列数为3  
21.   
22. /*显示当前待调整数码矩阵*/  
23. void show(int begin[num][num])    
24. {  
25.     for(int i = 0; i < num; i++)  
26.     {  
27.         for(int j = 0; j < num; j++)  
28.             printf("%d ", begin[i][j]);  
29.         printf("\n");  
30.     }  
31.     printf("\n");  
32. }  
33.   
34. /*交换数码中的 begin[row_one][column_one] 与 begin[row_two][column_two] 这两个数*/  
35. void exchange(int begin[num][num], int row_one, int column_one, int row_two, int column_two)    
36. {  
37.     int temp;  
38.     temp = begin[row_two][column_two] ;  
39.     begin[row_two][column_two] = begin[row_one][column_one];  
40.     begin[row_one][column_one] = temp;  
41. }  
42.   
43. /*判断待调整的数码与最终数码相比每个棋子要移动到正确位置需要的步数*/  
44. int judge(int begin[num][num], int end[num][num])   
45. {  
46.     int count=0;           //count记录所有棋子移动到正确位置需要的步数  
47.     for(int i = 0; i < num; i++)   //检查当前图形的正确度  
48.         for(int j = 0; j < num; j++)  
49.         {  
50.             if(begin[i][j] == 0)  
51.                 continue;  
52.             else if(begin[i][j] != end[i][j])  
53.             {  
54.                 for(int k=0; k<num; k++)  
55.                     for(int w=0; w<num; w++)  
56.                         if(begin[i][j] == end[k][w])  
57.                             count = count + fabs(i-k) + fabs(j-w);  
58.             }  
59.         }  
60.     return count;           //返回步数  
61. }  
62.    
63. /* 将待调整数码从开始位置移动到终止位置，并将其过程输出*/  
64. int yidong(int begin[num][num], int end[num][num], int right, int jishu, int ji_shu[50][3][3], int biaoji, int row, int column) //biaoji存储上一轮移动的反方向代号  
65. {   
66.     int temp_zhi;  
67.     show(begin);   //显示数组矩阵  
68.     int temp;               //存储当前待调整数码正确的个数  
69.     if(right == 0)  //如果待调整数码与最终数码完全相同时，返回1  
70.         return 1;  
71.     if(row > 0 && biaoji != 0)             //存储0的位置不是在第一行  
72.     {  
73.         exchange(begin, row - 1, column, row , column);  //将0与其上面的元素交换存储位置  
74.         temp = judge(begin, end);  
75.         if(temp >= right)   //如果交换后步数大于等于原来的步数  
76.             exchange(begin, row - 1, column, row , column); //再将其交换回来         
77.         else if(temp < right)          //如果交换后步数小于原来的步数  
78.         {  
79.             temp_zhi = yidong(begin, end, temp, jishu+1, ji_shu, 2, row-1, column);  
80.             if( temp_zhi == 1)  //进行下一步的移动  
81.                 return 1;  
82.             exchange(begin, row - 1, column, row , column); //再将其交换回来  
83.         }  
84.     }  
85.     if(column > 0 && biaoji != 1)  
86.     {  
87.         exchange(begin, row, column - 1, row , column); //将0与其左边的元素交换存储位置  
88.         temp = judge(begin, end);         
89.         if(temp >= right)     
90.            exchange(begin, row, column - 1, row , column);            
91.         else if(temp < right)  
92.         {  
93.             temp_zhi = yidong(begin, end, temp, jishu+1, ji_shu ,3, row, column - 1);  
94.             if(temp_zhi == 1)    
95.                  return 1;  
96.             exchange(begin, row, column - 1, row , column);  
97.         }  
98.     }  
99.   
100.     if(row < num-1 && biaoji != 2)  
101.     {  
102.         exchange(begin, row + 1, column, row , column); //将0与其下面的元素交换存储位置  
103.         temp = judge(begin, end);     
104.         if(temp >= right)   
105.             exchange(begin, row + 1, column, row , column);  
106.         else if(temp < right)  
107.         {  
108.             temp_zhi =yidong(begin, end, temp, jishu+1, ji_shu, 0, row+1, column);  
109.            if(temp_zhi == 1)    
110.               return 1;  
111.            exchange(begin, row + 1, column, row , column);  
112.         }  
113.     }  
114.     if(column < num-1 && biaoji != 3)  
115.     {  
116.         exchange(begin, row, column + 1, row , column); //将0与其右边的元素交换存储位置  
117.         temp = judge(begin, end);     
118.         if(temp >= right)     
119.             exchange(begin, row, column + 1, row , column);       
120.         else if(temp < right)    
121.         {  
122.             temp_zhi = yidong(begin, end, temp, jishu+1, ji_shu, 1, row, column+1);  
123.             if(temp_zhi == 1)    
124.                return 1;  
125.             exchange(begin, row, column + 1, row , column);   
126.         }  
127.     }  
128.     return 0;   //移动失败，返回0  
129. }  
130.   
131. /*有用户输入待调整的数码矩阵最初状态的数，并将其存入到begin[][]数组中*/  
132. void shuru(int begin[][num],int blank[])    
133. {  
134.     int temp, node, zero = 0;  
135.     for (int i = 0; i < num; i++)  
136.         for(int j = 0; j < num; j++)  
137.         {  
138.             node = 1;  
139.             printf("请输入第%d行，第%d列的元素的值：", i+1, j+1);  
140.             scanf("%d", &temp);  
141.             for (int q = 0; q <= i && node == 1; q++)  //当输入的值有重复的，提示重新输入  
142.                 for (int w = 0; w < j; w++)  
143.                     if(temp == begin[q][w])  
144.                     {  
145.                         printf("输入重复，请重新输入\n");  
146.                         node = 0;  
147.                             j--;  
148.                         break;  
149.                     }  
150.             if(temp < 0 || temp > num*num-1)   //当输入的值不是在数码的区间范围内时，提示重新输入  
151.             {  
152.                 printf("请输入从%d到%d的数\n", zero, num*num-1);  
153.                 node = 0;  
154.                 j--;  
155.             }  
156.             if(node == 1)   //如果输入满足条件    
157.             {  
158.                 if(temp == 0) //如果输入的值为零，由blank[0]记录行号，blank[1]记录列号  
159.                 {  
160.                     blank[0] = i;  
161.                     blank[1] = j;  
162.                 }  
163.                 begin[i][j] = temp;//将满足条件的值存储起来  
164.             }  
165.         }  
166. }  
167.   
168. int main()  
169. {  
170.     int jishu = 0, ji_shu[50][3][3];//jishu存储已经遍历过的八数码图形的个数，jishu[][][]存储已经遍历过的八数码图形的形状  
171.     int row;     //存储数字零的行数  
172.     int column;  //存储数字零的列数  
173.     int begin[num][num], blank[2],count=1;    
174.     int end[num][num] = {1, 2, 3, 8, 0, 4, 7, 6, 5};  //给最终状态的数码矩阵赋值  
175.     printf ("-------%d数码游戏开始！--------\n", num);  
176.     shuru(begin, blank);   //输入带调整状态的数码矩阵的值  
177.     row = blank[0];  
178.     column = blank[1];  
179.     if(yidong (begin, end,judge(begin,end),jishu,ji_shu,4,row,column) == 0)    
180.        printf("\n此8数码的问题可能无解！");  
181.     getchar();getchar();  
182.     return 0;  
183. }  

 

下面是运行结果示例：

 

 

欢迎大家转载，如有转载请注明文章来自：   http://blog.csdn.net/q345852047