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 = 20;
const int HEIGHT_BLOCK_NUM = 20;
const int WINDOWS_WIDTH = 800;
const int WINDOWS_HEIGHT = 800;
const int MAX_MARK = 20;
const int MIN_MARK = 0;

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

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[][2]);
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 = 0; i < 8; ++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])) > 1 ? 14 : 10;
                b.g = (abs(temp_x - end_block.x) + abs(temp_y - end_block.y)) * 10;
                pq.push(b);
                us.insert(position2mark(temp_x, temp_y));
                local_vec.push_back(b);
            }
        }
        draw();
    }
    closegraph();
    return 0;
}

int randInt(int left, int right)
{
    return rand() % (right - left + 1) + 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 = 0; i < WINDOWS_WIDTH; i += width)
    {
        line(i, 0, i, WINDOWS_HEIGHT);
    }

    for (int i = 0; i < WINDOWS_HEIGHT; i += height)
    {
        line(0, i, WINDOWS_WIDTH, i);
    }
    int arr[2][2];
    COLORREF prev_color = getfillcolor();
    
    setfillcolor(BLUE);
    for (Block b : local_vec)
    {
        position2rectangle(b, arr);
        fillrectangle(arr[0][0], arr[0][1], arr[1][0], arr[1][1]);
    }


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

    

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

    setfillcolor(prev_color);
    Sleep(1000);
}

void position2rectangle(struct Block&b, int rect[][2])
{
    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[0][0] = temp_x;
    rect[0][1] = temp_y;
    rect[1][0] = temp_x + width;
    rect[1][1] = temp_y + height;
}

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

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

运行展示