四种寻路算法计算步骤比较

四种算法是DFS,BFS,Heuristic DFS, Heuristic BFS (A*)

用了两张障碍表，一张是典型的迷宫：

char Block[SY][SX]=

{{1,1,1,1,1,1,1,1,1,1,1 },

{1,0,1,0,1,0,0,0,0,0,1 },

{1,0,1,0,0,0,1,0,1,1,1 },

{1,0,0,0,1,0,1,0,0,0,1 },

{1,0,1,1,0,0,1,0,0,1,1 },

{1,0,1,0,1,1,0,1,0,0,1 },

{1,0,0,0,0,0,0,0,1,0,1 },

{1,0,1,0,1,0,1,0,1,0,1 },

{1,0,0,1,0,0,1,0,1,0,1 },

{1,1,1,1,1,1,1,1,1,1,1 }};

第二张是删掉一些障碍后的:

char Block[SY][SX]=

{{1,1,1,1,1,1,1,1,1,1,1 },

{1,0,1,0,1,0,0,0,0,0,1 },

{1,0,1,0,0,0,1,0,1,1,1 },

{1,0,0,0,0,0,1,0,0,0,1 },

{1,0,0,1,0,0,1,0,0,1,1 },

{1,0,1,0,0,1,0,1,0,0,1 },

{1,0,0,0,0,0,0,0,1,0,1 },

{1,0,1,0,0,0,1,0,1,0,1 },

{1,0,0,1,0,0,1,0,0,0,1 },

{1,1,1,1,1,1,1,1,1,1,1 }};

结果：

尝试节点数 合法节点数 步数

深度优先 416/133 110/43 19/25

广度优先 190/188 48/49 19/15

深度+启发 283/39 82/22 19/19

广度+启发 189/185 48/49 19/15

所以可以看出深度+启发是最好的，效率高路径也挺短。A*第一是不真实二是慢三是空间消耗较大。

附：dfs+heu的源程序，bc++ 3.1通过

1. #include <iostream.h>

2. #include <memory.h>

3. #include <stdlib.h>

5. #define SX 11 //宽

6. #define SY 10 //长

8. int dx[4]={0,0,-1,1}; //四种移动方向对x和y坐标的影响

9. int dy[4]={-1,1,0,0};

11. /*char Block[SY][SX]= //障碍表

12. {{ 1,1,1,1,1,1,1,1,1,1,1 },

13. { 1,0,1,0,1,0,0,0,0,0,1 },

14. { 1,0,1,0,0,0,1,0,1,1,1 },

15. { 1,0,0,0,0,0,1,0,0,0,1 },

16. { 1,0,0,1,0,0,1,0,0,1,1 },

17. { 1,0,1,0,0,1,0,1,0,0,1 },

18. { 1,0,0,0,0,0,0,0,1,0,1 },

19. { 1,0,1,0,0,0,1,0,1,0,1 },

20. { 1,0,0,1,0,0,1,0,0,0,1 },

21. { 1,1,1,1,1,1,1,1,1,1,1 }};*/

23. char Block[SY][SX]= //障碍表

24. {{ 1,1,1,1,1,1,1,1,1,1,1 },

25. { 1,0,1,0,1,0,0,0,0,0,1 },

26. { 1,0,1,0,0,0,1,0,1,1,1 },

27. { 1,0,0,0,1,0,1,0,0,0,1 },

28. { 1,0,1,1,0,0,1,0,0,1,1 },

29. { 1,0,1,0,1,1,0,1,0,0,1 },

30. { 1,0,0,0,0,0,0,0,1,0,1 },

31. { 1,0,1,0,1,0,1,0,1,0,1 },

32. { 1,0,0,1,0,0,1,0,1,0,1 },

33. { 1,1,1,1,1,1,1,1,1,1,1 }};

35. int MaxAct=4; //移动方向总数

36. char Table[SY][SX]; //已到过标记

37. int Level=-1; //第几步

38. int LevelComplete=0; //这一步的搜索是否完成

39. int AllComplete=0; //全部搜索是否完成

40. char Act[1000]; //每一步的移动方向，搜索1000步，够了吧？

41. int x=1,y=1; //现在的x和y坐标

42. int TargetX=9,TargetY=8; //目标x和y坐标

43. int sum1=0,sum2=0;

45. void Test( );

46. void Back( );

47. int ActOK( );

48. int GetNextAct( );

50. void main( )

51. {

52.     memset(Act,0,sizeof(Act)); //清零

53.     memset(Table,0,sizeof(Table));

54.     Table[y][x]=1; //做已到过标记

55.     while (!AllComplete) //是否全部搜索完

56.     {

57.         Level++;LevelComplete=0; //搜索下一步

58.         while (!LevelComplete)

59.         {

60.             Act[Level]=GetNextAct( ); //改变移动方向

61.             if (Act[Level]<=MaxAct)

62.                 sum1++;

63.             if (ActOK( )) //移动方向是否合理

64.             {

65.                 sum2++;

66.                 Test( ); //测试是否已到目标

67.                 LevelComplete=1; //该步搜索完成

68.             }

69.             else

70.             {

71.                 if (Act[Level]>MaxAct) //已搜索完所有方向

72.                     Back( ); //回上一步

73.                 if (Level<0) //全部搜索完仍无结果

74.                     LevelComplete=AllComplete=1; //退出

75.             }

76.         }

77.     }

78. }

80. void Test( )

81. {

82.     if ((x==TargetX)&&(y==TargetY)) //已到目标

83.     {

84.         for (int i=0;i<=Level;i++)

85.             cout<<(int)Act; //输出结果

86.         cout<<endl;

87.         cout<<Level+1<<" "<<sum1<<" "<<sum2<<endl;

88.         LevelComplete=AllComplete=1; //完成搜索

89.     }

90. }

92. int ActOK( )

93. {

94.     int tx=x+dx[Act[Level]-1]; //将到点的x坐标

95.     int ty=y+dy[Act[Level]-1]; //将到点的y坐标

96.     if (Act[Level]>MaxAct) //方向错误？

97.         return 0;

98.     if ((tx>=SX)||(tx<0)) //x坐标出界？

99.         return 0;

100.     if ((ty>=SY)||(ty<0)) //y坐标出界？

101.         return 0;

102.     if (Table[ty][tx]==1) //已到过？

103.         return 0;

104.     if (Block[ty][tx]==1) //有障碍？

105.         return 0;

106.     x=tx;

107.     y=ty; //移动

108.     Table[y][x]=1; //做已到过标记

109.     return 1;

110. }

112. void Back( )

113. {

114.     x-=dx[Act[Level-1]-1];

115.     y-=dy[Act[Level-1]-1]; //退回原来的点

116.     Table[y][x]=0; //清除已到过标记

117.     Act[Level]=0; //清除方向

118.     Level--; //回上一层

119. }

121. int GetNextAct( ) //找到下一个移动方向。这一段程序有些乱，

122. //仔细看!

123. {

124.     int dis[4];

125.     int order[4];

126.     int t=32767;

127.     int tt=2;

128.     for (int i=0;i<4;i++)

129.     dis=abs(x+dx-TargetX)+abs(y+dy-TargetY);

130.     for (i=0;i<4;i++)

131.     if (dis<t)

132.     {

133.         order[0]=i+1;

134.         t=dis;

135.     }

136.     if (Act[Level]==0)

137.         return order[0];

138.     order[1]=-1;

139.     for (i=0;i<4;i++)

140.     if ((dis==t)&&(i!=(order[0]-1)))

141.     {

142.         order[1]=i+1;

143.         break;

144.     }

145.     if (order[1]!=-1)

146.     {

147.         for (i=0;i<4;i++)

148.             if (dis!=t)

149.             {

150.                 order[tt]=i+1;

151.                 tt++;

152.             }

153.     }

154.     else

155.     {

156.         for (i=0;i<4;i++)

157.         if (dis!=t)

158.         {

159.             order[tt-1]=i+1;

160.             tt++;

161.         }

162.     }

164.     if (Act[Level]==order[0])

165.         return order[1];

166.     if (Act[Level]==order[1])

167.         return order[2];

168.     if (Act[Level]==order[2])

169.         return order[3];

170.     if (Act[Level]==order[3])

171.         return 5;

172. }