A星(AStar)算法的实现

最新推荐文章于 2022-06-30 10:18:15 发布
最新推荐文章于 2022-06-30 10:18:15 发布
阅读量6.1k 收藏 50
点赞数 8
分类专栏： c/c++ 计算机视觉 Python 文章标签： AStar A星 c++ python 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a1053904672/article/details/108020572
版权
Python 同时被 3 个专栏收录
33 篇文章 3 订阅
订阅专栏
c/c++
5 篇文章 1 订阅
订阅专栏
计算机视觉
4 篇文章 5 订阅
订阅专栏

关于AStar的原理这里简述一下，

首先有一张地图，然后准备一个open list 和 close list，open list存放所有可能的路径，但是需要注意的是这个列表是动态怎加的，也就是每走一步就把当前可能的路径都加进去，然后每次从open list中去除一个最小代价的点，最为下一步的路径，并用该点计算之后可能的路径 在加入到open list中去，然后把这个代价最小的点放到close list中，表示该点已经走过了，如此循环直到从open list取出的最小代价点为 终点，此时通过回溯找到路径；代价的计算方法具有多样性，如何计算可以自行百度；

首先是python的实现：

import numpy as np
import heapq


class Node:

    def __init__(self, coord, parent=None, g=0, h=0):
        self.coord = coord
        self.parent: Node = parent
        self.g = g
        self.h = h
        self.f = g + h
        self.master = 0
        # self.iter = self.gen_data()

    # def gen_data(self):
    #     cur_node = self
    #     while 1:
    #         if cur_node is None:
    #             break
    #         yield cur_node
    #         cur_node = cur_node.parent
    #
    # def __iter__(self):
    #     return self.iter

    def __gt__(self, other):
        return self.f > other.f

    def __lt__(self, other):
        return self.f < other.f

    def __eq__(self, other):
        return self.f == other.f

    def __str__(self):
        return "<(%s,%s) G: %s,H: %s,F: %s> " % (self.coord[0], self.coord[1], self.g, self.h, self.f)

    __repr__ = __str__


class Walker:
    def __init__(self, node):
        self.node = node
        self.iter = self.gen_data()

    def gen_data(self):
        cur_node = self.node
        while 1:
            if cur_node is None:
                break
            yield cur_node
            cur_node = cur_node.parent

    def __iter__(self):
        return self.iter


class AStar:
    def __init__(self, world_map, bar_value, direct_cost, oblique_cost):
        self.world_map = world_map
        self.bar_value = bar_value
        self.direct_cost = direct_cost
        self.oblique_cost = oblique_cost
        self.map_cache = np.zeros_like(world_map)

    def new_node(self, prev_node: Node, end_node, x, y, weight):
        coord = x, y
        height, width = self.world_map.shape
        if x < 0 or x >= width or y < 0 or y >= height:
            return
        color = self.world_map[y, x]
        if color == self.bar_value:
            return
        H = abs(end_node.coord[0] - x) * self.direct_cost + abs(end_node.coord[1] - y) * self.direct_cost
        G = prev_node.g + weight
        t_node = Node(coord, prev_node, G, H)
        return t_node

    def get_neighbors(self, p_node, end_node):
        coord = p_node.coord
        up = self.new_node(p_node, end_node, coord[0], coord[1] - 1, self.direct_cost)
        down = self.new_node(p_node, end_node, coord[0], coord[1] + 1, self.direct_cost)
        left = self.new_node(p_node, end_node, coord[0] - 1, coord[1], self.direct_cost)
        right = self.new_node(p_node, end_node, coord[0] + 1, coord[1], self.direct_cost)

        # return up, down, left, right
        left_up = self.new_node(p_node, end_node, coord[0] - 1, coord[1] - 1, self.oblique_cost)
        right_up = self.new_node(p_node, end_node, coord[0] + 1, coord[1] - 1, self.oblique_cost)
        left_down = self.new_node(p_node, end_node, coord[0] - 1, coord[1] + 1, self.oblique_cost)
        right_down = self.new_node(p_node, end_node, coord[0] + 1, coord[1] + 1, self.oblique_cost)

        return up, down, left, right, left_up, right_up, left_down, right_down

    def find_path(self, start_node, end_node):
        open_ls = []
        close_ls = []
        self.map_cache[:, :] = 0
        heapq.heappush(open_ls, start)
        self.map_cache[start_node.coord[1], start_node.coord[0]] = 1
        while 1:
            if len(open_ls) == 0:
                print("failed!")
                break
            cur_node: Node = heapq.heappop(open_ls)
            if cur_node.coord == end_node.coord:
                print("success")
                return cur_node
            for node in self.get_neighbors(cur_node, end_node):
                if node is None:
                    continue
                if self.map_cache[node.coord[1], node.coord[0]] != 0:
                    continue
                heapq.heappush(open_ls, node)
                self.map_cache[node.coord[1], node.coord[0]] = 1
            close_ls.append(cur_node)
            self.map_cache[cur_node.coord[1], cur_node.coord[0]] = 2


# #
if __name__ == '__main__':
    import time
    import cv2
    default_bar_value = 70
    default_set_path = 255
    DIRECT_WEIGHT = 10
    OBLIQUE_WEIGHT = 14
    # create a map
    maps = np.zeros((650, 750), np.intc) + 1
    maps[40:, 20:30] = default_bar_value
    maps[:400, 100:110] = default_bar_value
    maps[100:, 200:210] = default_bar_value
    maps[:200, 300:310] = default_bar_value
    maps[220:230, 210:710] = default_bar_value
    maps[220:600, 710:720] = default_bar_value
    maps[600:610, 300:720] = default_bar_value
    maps[300:610, 300:310] = default_bar_value

    start = Node((10, 10))  # start coord
    end = Node((600, 400))  # end coord
    finder = AStar(maps, default_bar_value, DIRECT_WEIGHT, OBLIQUE_WEIGHT)
    t0 = time.time()
    node = finder.find_path(start, end)
    print("耗时:", time.time()-t0)

    for node in Walker(node):
        maps[node.coord[1], node.coord[0]] = default_set_path

    maps = maps.astype(np.uint8)
    maps = maps.reshape((*maps.shape, 1))
    maps = maps.repeat(3, 2)
    cv2.circle(maps, tuple(start.coord), 5, (0, 255, 0), 5)
    cv2.circle(maps, tuple(end.coord), 5, (255, 0, 0), 5)
    maps[maps[:, :, 0] == default_set_path] = 50, 255, 50
    maps[maps[:, :, 0] == default_bar_value] = 0, 0, 255
    cv2.imshow("result", maps)
    cv2.waitKey()
    cv2.destroyAllWindows()

需要注意的这里为了提高性能，省去了一些步骤，所以个标准的算法略微区别

一下是c++的实现：

// dllmain.cpp : 定义 DLL 应用程序的入口点。
#include "pch.h"
#include <iostream>
#include <algorithm>
#include <set>
#include <vector>

using namespace std;

struct Coord
{
    int x;
    int y;

    bool operator==(const Coord& c) {
        return x == c.x && y == c.y;
    }
    Coord() {
        x = 0;
        y = 0;
    }
    Coord(int x, int y) {
        this->x = x;
        this->y = y;
    }
};

struct Point
{
    int x;
    int y;
    Point* next;

    Point(int x, int y) {
        this->x = x;
        this->y = y;
        next = nullptr;
    }
};

struct Node
{
    Coord coord;
    Node* parent;
    int g;
    int h;
    int f;
    Node(Coord coord) {
        this->coord.x = coord.x;
        this->coord.y = coord.y;
        this->parent = 0;
        this->g = 0;
        this->h = 0;
        this->f = 0;
    }
    Node(Coord coord, Node* parent) {

        this->coord.x = coord.x;
        this->coord.y = coord.y;
        this->parent = parent;
        this->g = 0;
        this->h = 0;
        this->f = 0;
    }
    Node(Coord coord, Node* parent, int g, int h) {

        this->coord.x = coord.x;
        this->coord.y = coord.y;
        this->parent = parent;
        this->g = g;
        this->h = h;
        this->f = g + h;
    }
};

class HeapCompare_f
{
public:

    bool operator() (const Node* x, const Node* y) const
    {
        return x->f > y->f;
    }
};

class AStar
{
public:
    int* world_map;
    int width;
    int height;
    int bar_value;
    int direct_cost;
    int oblique_cost;
    int set_path_value;
    Node** neighbors;
    Node** map_cache;
    vector<Node*> open_ls;
    vector<Node* > close_ls;
    AStar(int* world_map, int width, int height, int bar_value, int dircect_cost, int oblique_cost, int set_path_value);
    ~AStar();
    Node* new_node(Node* parent, Coord end, int x, int y, int cost);
    void get_neighbors(Node* parent, Coord coord);
    Point* find_path(Coord start, Coord end);
    void free_ls();
};

AStar::AStar(int* world_map, int width, int height, int bar_value, int direct_cost, int oblique_cost, int set_path_value)
{
    this->world_map = world_map;
    this->width = width;
    this->height = height;
    this->bar_value = bar_value;
    this->direct_cost = direct_cost;
    this->oblique_cost = oblique_cost;
    this->map_cache = new Node * [(size_t)width * (size_t)height];
    this->neighbors = new Node * [8];
    this->set_path_value = set_path_value;
}


AStar::~AStar()
{
    delete[] map_cache;
    delete[] neighbors;
}

Node* AStar::new_node(Node* parent, Coord end, int x, int y, int cost)
{
    if (x < 0 || x >= width || y < 0 || y >= height)
    {
        return nullptr;
    }
    if (world_map[y * width + x] >= bar_value) {
        return nullptr;
    }
    int H = abs(end.x - x) * direct_cost + abs(end.y - y) * direct_cost;
    int G = parent->g + cost;
    Node* node = new Node(Coord(x, y), parent, G, H);
    return node;
}

void AStar::get_neighbors(Node* parent, Coord end)
{
    Coord cd = parent->coord;
    Node* up, * down, * left, * right, * left_up, * right_up, * left_down, * right_down;
    up = new_node(parent, end, cd.x, cd.y - 1, direct_cost);
    down = new_node(parent, end, cd.x, cd.y + 1, direct_cost);
    left = new_node(parent, end, cd.x - 1, cd.y, direct_cost);
    right = new_node(parent, end, cd.x + 1, cd.y, direct_cost);
    left_up = new_node(parent, end, cd.x - 1, cd.y - 1, oblique_cost);
    right_up = new_node(parent, end, cd.x + 1, cd.y - 1, oblique_cost);
    left_down = new_node(parent, end, cd.x - 1, cd.y + 1, oblique_cost);
    right_down = new_node(parent, end, cd.x + 1, cd.y + 1, oblique_cost);
    neighbors[0] = up;
    neighbors[1] = down;
    neighbors[2] = left;
    neighbors[3] = right;
    neighbors[4] = left_up;
    neighbors[5] = right_up;
    neighbors[6] = left_down;
    neighbors[7] = right_down;
}

void AStar::free_ls() {
    typename vector< Node* >::iterator iter_node;
    for (iter_node = open_ls.begin(); iter_node != open_ls.end(); iter_node++)
    {
        //if (*iter_node != nullptr)
        delete (*iter_node);
    }
    for (iter_node = close_ls.begin(); iter_node != close_ls.end(); iter_node++)
    {
        //if (*iter_node != nullptr)
        delete (*iter_node);
    }
    open_ls.clear();
    close_ls.clear();
}

Point* AStar::find_path(Coord start, Coord end)
{
    memset(map_cache, 0, (size_t)width * (size_t)height);
    Node* start_node = new Node(start);
    open_ls.push_back(start_node);
    make_heap(open_ls.begin(), open_ls.end(), HeapCompare_f());
    push_heap(open_ls.begin(), open_ls.end(), HeapCompare_f());
    map_cache[start.y * width + start.x] = start_node;
    Node* cur_node = nullptr;
    while (true)
    {
        if (open_ls.empty()) {
            printf("failed.\n");
            break;
        }
        cur_node = open_ls.front();
        pop_heap(open_ls.begin(), open_ls.end(), HeapCompare_f());
        open_ls.pop_back();
        if (cur_node->coord == end) {
            printf("success.\n");
            break;
        }
        get_neighbors(cur_node, end);
        for (size_t i = 0; i < 8; i++)
        {
            Node* node = neighbors[i];
            if (node == nullptr) continue;
            Node** cache_node = &map_cache[node->coord.y * width + node->coord.x];
            if (*cache_node != 0)
            {
                delete node;
                continue;
            }
            open_ls.push_back(node);
            push_heap(open_ls.begin(), open_ls.end(), HeapCompare_f());
            *cache_node = node;  //map_cache[node->coord.y * width + node->coord.x] = node;
        }
        close_ls.push_back(cur_node);
        map_cache[cur_node->coord.y * width + cur_node->coord.x] = cur_node;
    }
    Point* last = nullptr;
    if (cur_node == nullptr) goto end;
    last = new Point(cur_node->coord.x, cur_node->coord.y); //printf("x:%d,y:%d\n", cur_node->coord.x, cur_node->coord.y);
    while (true)
    {
        if (set_path_value > 0)
            world_map[cur_node->coord.y * width + cur_node->coord.x] = set_path_value;
        cur_node = cur_node->parent;
        if (!cur_node) { break; }
        Point* t = new Point(cur_node->coord.x, cur_node->coord.y);  //printf("x:%d,y:%d\n", cur_node->coord.x, cur_node->coord.y);
        t->next = last;
        last = t;
    }
end:
    free_ls();
    return last;
}



extern "C" {
    __declspec(dllexport)int CreateAStar(int* world_map, int width, int height, int bar_value, int direct_cost, int oblique_cost, int set_path_value);
    __declspec(dllexport)Point* FindPath(int id, int start_x, int start_y, int end_x, int end_y);
    __declspec(dllexport)void AStarFree(int id);
    __declspec(dllexport)void free_node_ls(Point** node_var);
}
#define MAX_NUMS 64
AStar* FINDER_OBJ_LIST[MAX_NUMS];
int CUR_INDEX = 0;
int CreateAStar(int* world_map, int width, int height, int bar_value, int direct_cost, int oblique_cost, int set_path_value) {
    std::cout << "Hello CreateAStar!\n";
    if (CUR_INDEX >= MAX_NUMS)
        CUR_INDEX = 0;
    int id = CUR_INDEX;
    if ( FINDER_OBJ_LIST[CUR_INDEX]!=0 )
    {
        int i= MAX_NUMS;
        for (i = 0; i < MAX_NUMS; i++)
        {
            if (FINDER_OBJ_LIST[i] == 0)
                break;
        }
        if (i != MAX_NUMS){
            CUR_INDEX = i;
        }
        else {
            delete FINDER_OBJ_LIST[CUR_INDEX];
        }  
    }
    FINDER_OBJ_LIST[CUR_INDEX] = new AStar(world_map, width, height, bar_value, direct_cost, oblique_cost, set_path_value);
    CUR_INDEX++;
    return id;
}

Point* FindPath(int id,int start_x,int start_y,int end_x,int end_y) {
    if (id > MAX_NUMS || id < 0) return 0;
    auto a = FINDER_OBJ_LIST[id];
    if (a == 0) return 0;
    std::cout << "Hello FindPath!\n";
    return a->find_path(Coord(start_x, start_y), Coord(end_x, end_y));
}

void AStarFree(int id) {
    if (id > MAX_NUMS||id<0) return;
    auto a = FINDER_OBJ_LIST[id];
    if (a == 0) return;
    std::cout << "Hello AStarFree!\n";
    delete a;
    FINDER_OBJ_LIST[id] = 0;
}

void free_node_ls(Point** node_var) {
    Point* node = *node_var;
    Point* next;
    for (;;)
    {
        if (!node)
            break;
        next = node->next;
        delete node;
        node = next;
        //printf("free\n");
    }
    //if (node) {
    *node_var = 0;
    //}
}

int main()
{

    int MAP_WIDTH = 20;
    int MAP_HEIGHT = 20;

    int BarValue = 9;
    int AreaValue = 1;


    int direct_cost = 10;
    int oblique_cost = 14;

    int is_direction = 0;

    int map[] = {
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,   // 00
        1, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 9, 1,   // 01
        1, 9, 9, 1, 1, 9, 9, 9, 1, 9, 1, 9, 1, 9, 1, 9, 9, 9, 1, 1,   // 02
        1, 9, 9, 1, 1, 9, 9, 9, 1, 9, 1, 9, 1, 9, 1, 9, 9, 9, 1, 1,   // 03
        1, 9, 1, 1, 1, 1, 9, 9, 1, 9, 1, 9, 1, 1, 1, 1, 9, 9, 1, 1,   // 04
        1, 9, 1, 1, 9, 1, 1, 1, 1, 9, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1,   // 05
        1, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 1, 1, 1, 1, 1,   // 06
        1, 9, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 9, 9, 9, 9, 9, 9, 9, 1,   // 07
        1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1,   // 08
        1, 9, 1, 9, 9, 9, 9, 9, 9, 9, 1, 1, 9, 9, 9, 9, 9, 9, 9, 1,   // 09
        1, 9, 1, 1, 1, 1, 9, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,   // 10
        1, 9, 9, 9, 9, 9, 1, 9, 1, 9, 1, 9, 9, 9, 9, 9, 1, 1, 1, 1,   // 11
        1, 9, 1, 9, 1, 9, 9, 9, 1, 9, 1, 9, 1, 9, 1, 9, 9, 9, 1, 1,   // 12
        1, 9, 1, 9, 1, 9, 9, 9, 1, 9, 1, 9, 1, 9, 1, 9, 9, 9, 1, 1,   // 13
        1, 9, 1, 1, 1, 1, 9, 9, 1, 9, 1, 9, 1, 1, 1, 1, 9, 9, 1, 1,   // 14
        1, 9, 1, 1, 9, 1, 1, 1, 1, 9, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1,   // 15
        1, 9, 9, 9, 9, 1, 1, 1, 1, 1, 1, 9, 9, 9, 9, 1, 1, 1, 1, 1,   // 16
        1, 1, 9, 9, 9, 9, 9, 9, 9, 1, 1, 1, 9, 9, 9, 1, 9, 9, 9, 9,   // 17
        1, 9, 1, 1, 1, 1, 1, 1, 1, 1, 1, 9, 1, 1, 1, 1, 1, 1, 1, 1,   // 18
        1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,   // 19
    };
    AStar a = AStar(map, MAP_WIDTH, MAP_HEIGHT, BarValue, direct_cost, oblique_cost, 7);
    a.find_path(Coord(0, 0), Coord(3, 3));
    for (int i = 0; i < MAP_HEIGHT; i++)
    {
        for (int j = 0; j < MAP_WIDTH; j++)
        {
            printf("%d  ", map[i * MAP_WIDTH + j]);
        }
        cout << endl;
    }
}

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

c++的实现包好了 导出为 dll，以及测试

效果图如下：

独舞人生
关注
  • 8
    点赞
  • 踩
  • 50
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
图搜索的经典启发式算法A星(A*、A Star)算法详解
Linshaodan520的博客
04-19 1773
从广度优先搜索算法开始介绍，扩展地介绍到 A* 算法，并对比分析了几种方法之间的特点
AStar寻路算法
weixin_46084262的博客
12-19 4114
AStar算法是一种图形搜索算法，常用于寻路。他是以广度优先搜索为基础，集Dijkstra算法和最佳优先(best fit)于一身的一种算法。
AStar算法
梦回唐朝
09-01 2万+
什么是AStar: 是一种静态路网中求解最短路最有效的直接搜索方法,估价值跟实例值非常接近; 启发式搜索 : 启发式搜索就是在状态空间中的搜索对每一个搜索的位置进行评估,得到最好的位置,在从这个位置进行搜索直到目标.这样可以省略大量无谓的搜索路径,提高了效率; 在启发式搜索中,对位置的估价是十分重要的.采用了不同的估价,可以有不同的效果; (估价函数就一种规则,制定的规则不同,...
通俗易懂的Astar算法
阿辉学长博客
07-23 1764
(1)main.cpp /********************************************************************** * Copyright (C) 2015-2020 * * NodeName: planning * FileName: main.cpp * * Description: * * History: * guohui zhang 2020/07/23 1.0.0 build this module.
A星(A*、A Star)路径规划算法详解（附MATLAB代码）
热门推荐
晨少的博客
06-27 3万+
一、A* 算法原理 二、A* 算法实现步骤 三、A* 算法MATLAB代码举个例子来说，A*算法通常要将地图网格化，如下图所示： 假设有一只乌龟在追小白兔，乌龟此时的位置是（2,2），小白兔的位置是（6,6），假设小白兔静止不动。 根据A *算法的原理，乌龟只能向左、向右、向上、向下走，那么（1,2）、（2,1）、（3,2）、（2,3）是乌龟下一轮可以到达的点，这些点叫做 待探索的点步骤一 寻找下一步可以到达的节点，将这些待探索的点加入待探索数组 frontier 中，也叫边界数组。 计算出新加入点的代价
【寻路】超级简单的A星寻路算法实现
不文不武的禾文
06-30 614
A星寻路算法是一种计算最短路径的算法，通过遍历周围所有可以前进的点，计算出最优路径。 它吸取了Dijkstra 算法中的优点，为每个边长设置权值，不停的计算每个顶点到起始顶点的距离（G），以获得最短路线，同时也汲取贪婪最佳优先搜索算法中不断向目标前进优势，并持续计算每个顶点到目标顶点的距离（Heuristic distance），以引导搜索队列不断想目标逼近，从而搜索更少的顶点，保持寻路的高效。......
astar算法实现
11-22
在给定的"Test"压缩包文件中，可能包含的是一个简单的A*算法实现示例，可能包括源代码、测试用例以及相关的解释文档。通过阅读和分析这些文件，你可以进一步了解如何在实际项目中应用A*算法，以及如何在C++环境中...
A星寻路算法&B星寻路算法 c++实现 MFC
11-26
A星(AStar)和B星(BStar)寻路算法是计算机科学中用于解决最短路径问题的两种高效算法，尤其在游戏开发、图形界面、网络路由等领域广泛应用。这两种算法都是基于图的启发式搜索方法，旨在找到从起点到终点的最优路径。...
c++游戏开发 AStar A星寻路算法.zip
01-23
在C++中实现A星寻路算法，需要对数据结构（如队列和图）有深入理解，同时熟悉面向对象编程，以便将算法逻辑封装成易于理解和维护的类。通过实践和调试，开发者可以不断优化算法，使其适应不同类型的游戏场景，提供更...
astar:a星寻路算法javascript的实现
07-24
astar 最近更新 新增了JPS（跳点寻路），欢迎大家提issue 新增了TS版本，进一步的优化代码，以及进一步的简化用法，欢迎大家提issue 商业项目放心使用，有问题会及时更新！ 最近要用到寻路算法，偷懒网上搜了一批，...
用cocos实现A星寻路算法
02-25
A星(A*)寻路算法是游戏开发中常用的一种路径规划算法，它在二维或三维空间中寻找从起点到终点的最短路径。Cocos是一个强大的跨平台2D游戏开发框架，支持多种编程语言，如C++, Lua和JavaScript。在这个课程作业中，你...
Astar算法实验
06-12
用c编写的Astar算法，运用了走迷宫的例子。BUG较少，综合了网上的优秀代码，并进一步形成自己的代码。代码基本有注释，风格良好，能够很快看懂。内含有比较规范的报告文档，包含所有流程图，说明图，以及文档风格绝对不错，无需更改，建议下载！
图
weixin_42398418的博客
05-29 157
GraphAdjList.py #coding: utf-8 class Vertex(object): """顶点""" def __init__(self,node): self.id=node self.adjacent={} self.distance=float("inf") self.visited=False self.previous=None def addNeighbor(se
A星算法（Java实现）
KesarChen的博客
02-25 1万+
一、适用场景在一张地图中，绘制从起点移动到终点的最优路径，地图中会有障碍物，必须绕开障碍物。二、算法思路1. 回溯法得到路径(如果有路径)采用“结点与结点的父节点”的关系从最终结点回溯到起点，得到路径。2. 路径代价的估算：F = G+HA星算法的代价计算使用了被称作是启发式的代价函数。 先说明一下各符号意义：G表示的是 * 从起点到当前结点的实际路径代价 * (为啥叫实际？就是已经走过了，边走边
A星算法
cqs123111的博客
03-29 1万+
A星算法 1.简述 A星算法就是试图在地图中找到一条最短路径，但不保证一定存在。 任务 小猫去找青蛙玩（好TM弱智啊~） 条件 黑色方块无法通行，每走一个格子小猫消耗的体力都为1。 2.如果说你是小猫，你会怎么走？ 嗯，毫无疑问 你肯定这么走。。。很简单的对吧，但是你这么走的时候，真的没经过思考？并非如此吧，你要找最短路径是不是直接连线是最快的？但是连线有障碍物阻挡了，所以逼迫你先往上走出障碍物的区域，然后一路直线当然就是最短路径了。 BUT，你所做的思考，都是建立在你脑海里已经有整张地图的概念上，代
JAVA-Astar算法实现
weixin_34357962的博客
09-18 418
JAVA实现Astar寻径算法： 此算法的演示Applet程序请连接：http://www.dotnet.pp.ru/SMQ/AppletAstar.htm 此算法的主要公式：F=G+H * G = 从起点，沿着产生的路径，移动到网格上指定方格的移动耗费。 * H = 从此点阵到结束点阵的预估移动耗费，这被称为开启式的。 * F = 等G+H的值，表示的一个权重值。...
java astar_JAVA-Astar算法实现
weixin_42160398的博客
02-12 563
JAVA实现Astar寻径算法：此算法的主要公式：F=G+H* G = 从起点，沿着产生的路径，移动到网格上指定方格的移动耗费。* H = 从此点阵到结束点阵的预估移动耗费，这被称为开启式的。* F = 等G+H的值，表示的一个权重值。首先将开始点存入到开启列表当中(待检查的点)，检查开始点，将周围的点阵的F，G，H值算出，将周围点阵加入到开启列表当中，将周围点阵的父节点指向当前查找的节点，然后将...
a星算法实现
最新发布
05-30
以下是一个基于 Python 的 A*算法示例代码： ```python class Node: def __init__(self, row, col): self.row = row self.col = col self.g = 0 self.h = 0 self.parent = None def __eq__(self, other): return self.row == other.row and self.col == other.col def __lt__(self, other): return self.g + self.h < other.g + other.h def astar_search(maze, start, end): # 定义四个方向的移动 directions = [(0,1), (0,-1), (1,0), (-1,0)] # 初始化起点和终点 start_node = Node(start[0], start[1]) end_node = Node(end[0], end[1]) # 初始化开放列表和关闭列表 open_list = [] close_list = [] # 将起点添加到开放列表 open_list.append(start_node) # 开始搜索 while open_list: # 取出开放列表中最小的节点 current_node = min(open_list) # 将当前节点从开放列表中移除 open_list.remove(current_node) # 将当前节点放入关闭列表中 close_list.append(current_node) # 如果当前节点是终点，返回搜索结果 if current_node == end_node: path = [] while current_node: path.append((current_node.row, current_node.col)) current_node = current_node.parent return path[::-1] # 扩展当前节点的邻居节点 for direction in directions: row = current_node.row + direction[0] col = current_node.col + direction[1] # 如果邻居节点不在地图范围内或者是障碍物或者是在关闭列表中，忽略 if row < 0 or row >= len(maze) or col < 0 or col >= len(maze[0]) or maze[row][col] == 1 or Node(row, col) in close_list: continue # 如果邻居节点不在开放列表中，添加到开放列表中 neighbor_node = Node(row, col) if neighbor_node not in open_list: neighbor_node.parent = current_node neighbor_node.g = current_node.g + 1 neighbor_node.h = abs(row - end_node.row) + abs(col - end_node.col) open_list.append(neighbor_node) # 如果邻居节点在开放列表中，尝试更新其g值和父节点 else: for node in open_list: if node == neighbor_node: if current_node.g + 1 < node.g: node.g = current_node.g + 1 node.parent = current_node # 如果搜索失败，返回空列表 return [] ``` 以上代码实现了一个基本的 A*算法，用于在地图中寻找从起点到终点的最短路径。在代码中，Node类表示节点，包含节点的行列坐标、g值、h值和父节点等信息。astar_search函数实现了A*算法的搜索过程，其中使用开放列表和关闭列表记录已经访问过的节点，使用启发函数计算节点的估价值，以确定下一步搜索的方向。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值