A*与二叉堆结合

        把昨天的A*用C++类封装了下,然后用open表用二叉堆,效率上比SORT快,参照的是<在A*寻路中使用二叉堆
>,效率快了不少,我用70*70的地图测试,昨天的sort时间609ms,今天的94ms.

        我还添加了4个方向或者8方向,一般4方向现在没用了,效率低很多,还加了个在障碍物是否拐角绕开,效率影响不大.然后为了A*类能在后面中重复利用,在判断地图格子是否可通时,继承接口类实现IsObstruction(int r,int c),可根据不同地图存储信息判断障碍物,在游戏里也不需要改变地图数据结构.还加了个地图移动成本,也通过上面接口类实现.效率上会有所降低.

        二叉堆中存储的是节点,包含6个int,如果改成单独int索引,在交换数据时会快点点吧.

1. //CAStarFindPath.h
2. #pragma once
3. #include <vector>
4. #include <algorithm>
5. #include "BinaryHeap.h"
7. class IMapData  //需要实现的地图数据接口       
8. {
9. public:
10.     //该格子是否障碍物 能否通过 true是障碍物不能通过
11.     virtual bool IsObstruction(int r,int c)=0;  
12.     virtual int GetMapCost(int r,int c)//格子地图成本 不需要时返回1
13.     {
14.         return 1;
15.     }
16. };
18. class CAStarFindPath //A*类
19. {
20. public:
21.     CAStarFindPath(void);
22. public:
23.     ~CAStarFindPath(void);
24. private:
25.     int m_R,m_C;    //行列
26.     int m_srcR,m_srcC,m_desR,m_desC;    //源 目的
27.     bool m_turnCorner;      //是否绕过拐角
28.     bool m_eight;           //4方向和8方向扩展
29.     bool m_cost;            //地图成本
30.     CBinaryHeap openList;   //open表
31.     std::vector<Node> closeList;    //close表
32.     std::vector<Point> bestList;    //最短路径表
33.     IMapData *m_Map;
34. public:
35.     void SetMapSize(int sizeR,int sizeC,IMapData *mapData); //设置地图大小和地图数据接口
36.     void SetMapCost(bool cost=false);   //地图成本开销 默认关
37.     void SetCorner(bool eight=true,bool turn=false);            //设置4或8个方向 拐角默认关
38.     bool FindPath(int beginR,int beginC,int endR,int endC); //寻找路径无路径时返回false
39.     std::vector<Point> GetPath(void);   //获取路径
40.     int GetStepNum();   //获取步长
41. private:
42.     void KuoZhan(Node &node);   //扩展新节点
43.     bool IsReach(int r,int c);  //是否可到通过
44.     int GetCost(int r,int c);//获取地图成本
45.     void Generate(Node &node,int r,int c);  //产生新节点
46.     bool Check(Node &value);        //是否重复
47.     bool DaYu(Node & l,Node & r);   //大于比较
48.     void Init(Node &start);     //初始
49.     void BestPath(Node &best);  //最优路径
50.     int ABS(int a,int b)
51.     {
52.         return a>b?(a-b):(b-a);
53.     }
54. };
55. 1. //CAStarFindPath.cpp
    2. #include "AStarFindPath.h"
    3. using namespace std;
    4. CAStarFindPath::CAStarFindPath(void)
    5. {
    6. }
    8. CAStarFindPath::~CAStarFindPath(void)
    9. {
    10. }
    12. void CAStarFindPath::SetMapSize(int sizeR,int sizeC,IMapData *mapData)
    13. {
    14.     m_R=sizeR,m_C=sizeC;
    15.     m_Map=mapData;
    16. }
    18. void CAStarFindPath::SetMapCost(bool cost)
    19. {
    20.     m_cost=cost;
    21. }
    23. void CAStarFindPath::SetCorner(bool eight,bool turn)
    24. {
    25.     m_eight=eight;
    26.     m_turnCorner=turn;
    27. }
    29. bool CAStarFindPath::FindPath(int sr,int sc,int dr,int dc)
    30. {
    31.     m_srcR=sr,m_srcC=sc,m_desR=dr,m_desC=dc;
    32.     Node temp,best;
    33.     temp.r=sr;
    34.     temp.c=sc;
    35.     temp.g=0;
    36.     temp.h=ABS(m_srcR,m_desR)+ABS(m_srcC,m_desC);
    37.     temp.f=temp.g+temp.h;
    38.     temp.parent=-1;
    39.     Init(temp);
    40.     while (!openList.Empty())
    41.     {
    42.         openList.Top(best);
    43.         openList.Pop();
    44.         if (best.r==dr&&best.c==dc)//找到
    45.         {
    46.             BestPath(best);
    47.             return true;
    48.         }
    49.         KuoZhan(best);
    50.         closeList.push_back(best);
    51.     }
    52.     //没路径
    53.     bestList.clear();
    54.     return false;
    55. }
    57. vector<Point> CAStarFindPath::GetPath(void)
    58. {
    59.     return bestList;
    60. }
    62. int CAStarFindPath::GetStepNum()
    63. {
    64.     return bestList.size();
    65. }
    67. void CAStarFindPath::KuoZhan(Node &node)
    68. {
    69.     bool flag[4]={true,true,true,true};
    70.     if (IsReach(node.r-1,node.c))// 上 
    71.     {
    72.         Generate(node,node.r-1,node.c);
    73.     }
    74.     else 
    75.     {
    76.         flag[0]=false,flag[1]=false;
    77.     }
    78.     if (IsReach(node.r,node.c+1))//右
    79.     {
    80.         Generate(node,node.r,node.c+1);
    81.     }
    82.     else 
    83.     {
    84.         flag[1]=false,flag[2]=false;
    85.     }
    86.     if (IsReach(node.r+1,node.c))// 下
    87.     {
    88.         Generate(node,node.r+1,node.c);
    89.     }
    90.     else 
    91.     {
    92.         flag[2]=false,flag[3]=false;
    93.     }
    94.     if (IsReach(node.r,node.c-1))// 左 
    95.     {
    96.         Generate(node,node.r,node.c-1);
    97.     }
    98.     else 
    99.     {
    100.         flag[3]=false,flag[0]=false;
    101.     }
    102.     if (!m_eight)
    103.     {
    104.         return;
    105.     }
    106.     if (!m_turnCorner)
    107.     {
    108.         for(int i=0;i<4;i++)
    109.             flag[i]=true;
    110.     }
    111.     if (flag[0]&&IsReach(node.r-1,node.c-1))// 左上 
    112.     {
    113.         Generate(node,node.r-1,node.c-1);
    114.     }
    115.     if (flag[1]&&IsReach(node.r-1,node.c+1))//右上
    116.     {
    117.         Generate(node,node.r-1,node.c+1);
    118.     }
    119.     if (flag[2]&&IsReach(node.r+1,node.c+1))// 右下
    120.     {
    121.         Generate(node,node.r+1,node.c+1);
    122.     }
    123.     if (flag[3]&&IsReach(node.r+1,node.c-1))// 左下 
    124.     {
    125.         Generate(node,node.r+1,node.c-1);
    126.     }
    127. }
    129. bool CAStarFindPath::IsReach(int r,int c)
    130. {
    131.     if (m_Map->IsObstruction(r,c)||r<0||c<0||r>m_R||c>m_C)
    132.         return false;
    133.     return true;
    134. }
    136. int CAStarFindPath::GetCost(int r,int c)
    137. {
    138.     if (m_cost)
    139.         return m_Map->GetMapCost(r,c);
    140.     return 1;
    141. }
    143. void CAStarFindPath::Generate(Node &node,int r,int c)
    144. {
    145.     Node child;
    146.     child.r=r;
    147.     child.c=c;
    148.     int pos=openList.Find(child);
    149.     vector<Node>::iterator posCL;
    150.     for (posCL=closeList.begin();posCL!=closeList.end();++posCL)
    151.     {
    152.         if (posCL->r==r&&posCL->c==c)
    153.         {
    154.             break;
    155.         }
    156.     }
    157.     int cost=GetCost(r,c);
    158.     if (pos)    //在openlist中
    159.     {
    160.         if (node.g+cost>=child.g)   //在新节点的g比在open中的小就更新open中的
    161.             return;
    162.         child.parent=closeList.size();
    163.         child.g=node.g+cost;
    164.         child.f=child.g+child.h;
    165.         openList.Change(pos,child);
    166.     }
    167.     else if (!pos&&posCL==closeList.end())//不再open和close中
    168.     {
    169.         child.parent=closeList.size();
    170.         child.g=node.g+cost;    //计成本的地图
    171.         child.h=ABS(m_desR,r)+ABS(m_desC,c);    //(tr-r)*(tr-r)+(tc-c)*(tc-c)
    172.         child.f=child.g+child.h;
    173.         openList.Push(child);
    174.     }
    175. }
    177. void CAStarFindPath::Init(Node &start)
    178. {
    179.     if (!openList.Empty())
    180.     {
    181.         openList.Clear();
    182.     }
    183.     openList.Push(start);
    184.     if (!closeList.empty())
    185.     {
    186.         closeList.clear();
    187.     }
    188. }
    190. void CAStarFindPath::BestPath(Node &best)
    191. {
    192.     Node mudi=best;
    193.     Point node;
    194.     if (!bestList.empty())
    195.     {
    196.         bestList.clear();
    197.     }
    198.     while (mudi.parent>-1)
    199.     {
    200.         node.r=mudi.r;
    201.         node.c=mudi.c;
    202.         bestList.push_back(node);
    203.         mudi=closeList[mudi.parent];
    204.     }
    205. }