A*算法实现（图形化表示）——C++描述

概要

　　A*算法是一种启发式寻路算法，BFS是一种盲目的无目标的搜索算法，相比于BFS，A*算法根据适应度构建优先队列，根据适应度值可以很好的向目标点移动，具体详情，请看搜索相关文档，我在只是实现了在无障碍的情况下的A*算法，有障碍的情况类似。

开发环境

　　visual studio 2017 + eaysX

实现

 #include<stdio.h>
 #include<vector>
 #include<queue>
 #include<graphics.h>
 #include<stdlib.h>
 #include<time.h>
 #include<unordered_set>

 using namespace std;

 const int WIDTH_BLOCK_NUM = ;
 const int HEIGHT_BLOCK_NUM = ;
 const int WINDOWS_WIDTH = ;
 const int WINDOWS_HEIGHT = ;
 const int MAX_MARK = ;
 const int MIN_MARK = ;

 int dir_x[] = { ,,,,,-,-,- };
 int dir_y[] = { ,-,,,-,,-, };

 struct Block
 {
 public:
     int x, y;
     int f;
     int g;
     Block(int x, int y, int f, int g)
     {
         this->x = x;
         this->y = y;
         this->f = f;
         this->g = g;
     }
     Block() {}
     friend bool operator<(Block a, Block b) {
         return a.f + a.g > b.f + b.g;
     }
 };
 priority_queue<Block>pq;
 vector<Block>vec;
 vector<Block>local_vec;
 unordered_set<int>us;
 Block start_block, end_block;

 int randInt(int left, int right);
 void init();
 void draw();
 void position2rectangle(struct Block&b, int rect[][]);
 bool is_valid(int x, int y);
 int position2mark(int x, int y);

 int main()
 {
     srand(time(NULL));
     init();
     initgraph(WINDOWS_WIDTH, WINDOWS_HEIGHT);
     Block temp = start_block;
     pq.push(temp);
     us.insert(position2mark(temp.x, temp.y));

     while (!(temp.x == end_block.x&&temp.y == end_block.y))
     {
         temp = pq.top();
         pq.pop();
         vec.push_back(temp);
         for (int i = ; i < ; ++i) {
             int temp_x = temp.x + dir_x[i];
             int temp_y = temp.y + dir_y[i];
             if (is_valid(temp_x, temp_y) && !us.count(position2mark(temp_x, temp_y))) {
                 Block b;
                 b.x = temp_x;
                 b.y = temp_y;
                 b.f = temp.f + (abs(dir_x[i]) + abs(dir_y[i])) >  ?  : ;
                 b.g = (abs(temp_x - end_block.x) + abs(temp_y - end_block.y)) * ;
                 pq.push(b);
                 us.insert(position2mark(temp_x, temp_y));
                 local_vec.push_back(b);
             }
         }
         draw();
     }
     closegraph();
     return ;
 }

 int randInt(int left, int right)
 {
     return rand() % (right - left + ) + left;
 }

 void init()
 {
     start_block.x = randInt(MIN_MARK, MAX_MARK);
     start_block.y = randInt(MIN_MARK, MAX_MARK);
     end_block.x = randInt(MIN_MARK, MAX_MARK);
     end_block.y = randInt(MIN_MARK, MAX_MARK);
     while (start_block.x==end_block.x||start_block.y==end_block.y)
     {
         end_block.x = randInt(MIN_MARK, MAX_MARK);
         end_block.y = randInt(MIN_MARK, MAX_MARK);
     }
 }

 void draw()
 {
     int width = WINDOWS_WIDTH / WIDTH_BLOCK_NUM;
     int height = WINDOWS_HEIGHT / HEIGHT_BLOCK_NUM;
     for (int i = ; i < WINDOWS_WIDTH; i += width)
     {
         line(i, , i, WINDOWS_HEIGHT);
     }

     for (int i = ; i < WINDOWS_HEIGHT; i += height)
     {
         line(, i, WINDOWS_WIDTH, i);
     }
     int arr[][];
     COLORREF prev_color = getfillcolor();

     setfillcolor(BLUE);
     for (Block b : local_vec)
     {
         position2rectangle(b, arr);
         fillrectangle(arr[][], arr[][], arr[][], arr[][]);
     }

     setfillcolor(RED);
     for (Block b : vec)
     {
         position2rectangle(b, arr);
         fillrectangle(arr[][], arr[][], arr[][], arr[][]);
     }

     setfillcolor(GREEN);
     position2rectangle(start_block, arr);
     fillrectangle(arr[][], arr[][], arr[][], arr[][]);
     position2rectangle(end_block, arr);
     fillrectangle(arr[][], arr[][], arr[][], arr[][]);

     setfillcolor(prev_color);
     Sleep();
 }

 void position2rectangle(struct Block&b, int rect[][])
 {
     int width = WINDOWS_WIDTH / WIDTH_BLOCK_NUM;
     int height = WINDOWS_HEIGHT / HEIGHT_BLOCK_NUM;
     int temp_x = b.x*width;
     int temp_y = b.y*height;
     rect[][] = temp_x;
     rect[][] = temp_y;
     rect[][] = temp_x + width;
     rect[][] = temp_y + height;
 }

 bool is_valid(int x, int y)
 {
     if (x <  || y <  || x >= WIDTH_BLOCK_NUM || y >= HEIGHT_BLOCK_NUM) {
         return false;
     }
     return true;
 }

 int position2mark(int x, int y)
 {
     return x + y * WIDTH_BLOCK_NUM;
 }

运行展示