a-star | 易学教程

How to design the heuristic for A* when there are multiple goals in the grid map?

阅读更多关于 How to design the heuristic for A* when there are multiple goals in the grid map?

问题 I am facing a problem that I have to use A* to search through the map, and there are multiple goals in this map to reach. My aim is to expand the least nodes in the map, any idea on how to design the heuristic for this A* algorithm? thanks 回答1: Assuming by "multiple goals" you mean you want to reach any one , just take the minimum of all the heuristics. Assuming your heuristic is consistent, this is still a consistent heuristic. If instead you're trying to reach all of them , this is

Adding waypoints to A* graph search

阅读更多关于 Adding waypoints to A* graph search

问题 I have the ability to calculate the best route between a start and end point using A*. Right now, I am including waypoints between my start and end points by applying A* to the pairs in all permutations of my points. Example: I want to get from point 1 to point 4. Additionally, I want to pass through points 2 and 3. I calculate the permutations of (1, 2, 3, 4): 1 2 3 4 1 2 4 3 1 3 2 4 1 3 4 2 1 4 2 3 1 4 3 2 2 1 3 4 2 1 4 3 2 3 1 4 2 3 4 1 2 4 1 3 2 4 3 1 3 1 2 4 3 1 4 2 3 2 1 4 3 2 4 1 3 4 1

The path does not reach the end node in my A* algorithm

阅读更多关于 The path does not reach the end node in my A* algorithm

问题 Following on from How to speed up least-cost path model at large spatial extents, I tried to code an A* algorithm in Netlogo to increase my least-cost path model at large spatial extents. Here is my code: to findPath [ID-start-node ID-end-node] let currentNodesInList [ ] let current-node node ID-start-node let end-node node ID-end-node ask current-node [ set color red] ask end-node [ set color red] set currentNodesInList lput current-node currentNodesInList while [not member? end-node

A* Algorithm with Manhattan Distance Heuristic

阅读更多关于 A* Algorithm with Manhattan Distance Heuristic

问题 I've been working on a 15-puzzle solver in C. And I had some issues with the huge amounts of memory that my code uses. I won't be posting my code because it's too long... I've implemented most of the libraries I'm using and it will probably just bring confusion to you. Let's start on the basics. The things that I'm using right now are: (All of them implemented in C) - Fibonacci Heap: /* Struct for the Fibonacci Heap */ typedef struct _fiboheap { int size; // Number of nodes in the heap node

What are some common admissible heuristics for distance? [closed]

阅读更多关于 What are some common admissible heuristics for distance? [closed]

问题 Closed . This question needs to be more focused. It is not currently accepting answers. Want to improve this question? Update the question so it focuses on one problem only by editing this post. Closed 4 years ago . What are the most common heuristics used to estimate distance in intelligent search problems? In particular, I'm interested in metrics that can (usually) be used as admissible heuristics for A* search. I came across straight line distance and Manhattan distance but are there any

Robotic Path Planning - A* (Star)

阅读更多关于 Robotic Path Planning - A* (Star)

问题 I'm implementing A* path planning algorithm for my main robots exploration behavior in C++. As the robot moves, it maps the environment around itself as a 2D graph. From this graph, I have set a Vector2D Tuple {x, y} which holds the location of this waypoint, where I want the robot to navigate too. The first thing I do with A* is to have a Node class, which holds information about the current node; double f; // F, final score double g; // Movement cost double h; // Hueristic cost (Manhatten)

A* Algorithm with Manhattan Distance Heuristic

阅读更多关于 A* Algorithm with Manhattan Distance Heuristic

I've been working on a 15-puzzle solver in C. And I had some issues with the huge amounts of memory that my code uses. I won't be posting my code because it's too long... I've implemented most of the libraries I'm using and it will probably just bring confusion to you. Let's start on the basics. The things that I'm using right now are: (All of them implemented in C) - Fibonacci Heap: /* Struct for the Fibonacci Heap */ typedef struct _fiboheap { int size; // Number of nodes in the heap node min; // Pointer to the minimun element in the Heap funCompare compare; // Function to compare within

Robotic Path Planning - A* (Star)

阅读更多关于 Robotic Path Planning - A* (Star)

I'm implementing A* path planning algorithm for my main robots exploration behavior in C++. As the robot moves, it maps the environment around itself as a 2D graph. From this graph, I have set a Vector2D Tuple {x, y} which holds the location of this waypoint, where I want the robot to navigate too. The first thing I do with A* is to have a Node class, which holds information about the current node; double f; // F, final score double g; // Movement cost double h; // Hueristic cost (Manhatten) Node* parent; Vector2d position; As A* starts, I have my starting node as my Robots starting position

AI: Fastest algorithm to find if path exists?

阅读更多关于 AI: Fastest algorithm to find if path exists?

问题 I am looking for a pathfinding algorithm to use for an AI controlling an entity in a 2D grid that needs to find a path from A to B. It does not have to be the shortest path but it needs to be calculated very fast. The grid is static (never changes) and some grid cells are occupied by obstacles. I'm currently using A* but it is too slow for my purposes because it always tries to calculate the fastest path. The main performance problem occurs when the path does not exist, in which case A* will

Path finding Algorithms : A* Vs Jump Point Search

阅读更多关于 Path finding Algorithms : A* Vs Jump Point Search

I know that A* is better than Dijkstra's algorithm because it takes heuristic values into account, but from A* and Jump Point search which is the most efficient algorithm for finding the shortest path in an environment with obstacles? and what are the differences? Jump Point Search is an improved A* based on some conditions on the graph. Thus, if you meet these conditions (uniform-cost grid mostly), JPS is strictly better than A* (same optimality, best cases can be order of magnitudes better and worse case is probably the same complexity but with a slightly worse constant), but if you do not