|
|
| (One intermediate revision by one other user not shown) |
| Line 1: |
Line 1: |
| {{refimprove|date=January 2013}}
| | Oscar is how he's known as and he totally enjoys this title. [http://Www.Eadv.org/patient-corner/leaflets/eadv-leaflets/genital-herpes/ Minnesota] is exactly [http://happywedding.lonnieheart.gethompy.com/zbxe/wc_apply/372747 home std test kit] where he's been living for years. Since home std test kit she was eighteen she's been working as a receptionist but her promotion never comes. One of the extremely over the counter std test best issues in the world for me is to do [http://www.gaysphere.net/blog/167593 http://www.gaysphere.net/blog/167593] aerobics and now I'm home std test kit attempting to make money with it.<br><br>Have a look at my page :: [http://flashtrue.com/stay-yeast-infection-free-using-these-useful-tips/ home std test kit] |
| {{Tree search algorithm}}
| |
| | |
| [[Image:Pathfinding 2D Illustration.svg|250px|thumb|right|Equivalent paths between A and B in a 2D environment]]
| |
| | |
| '''Pathfinding''' or '''pathing''' is the plotting, by a computer application, of the shortest route between two points. It is a more practical variant on [[Maze#Solving mazes|solving mazes]]. This field of research is based heavily on [[Dijkstra's algorithm]] for finding the shortest path on a [[Glossary_of_graph_theory#Weighted_graphs_and_networks|weighted graph]].
| |
| | |
| == Algorithms ==
| |
| At its core, a pathfinding method searches a [[graph (data structure)|graph]] by starting at one [[Vertex (graph theory)|vertex]] and exploring adjacent [[node (computer science)|node]]s until the destination node is reached, generally with the intent of finding the shortest route. Although graph searching methods such as a [[breadth-first search]] would find a route if given enough time, other methods, which "explore" the graph, would tend to reach the destination sooner. An analogy would be a person walking across a room; rather than examining every possible route in advance, the person would generally walk in the direction of the destination and only deviate from the path to avoid an obstruction, and make deviations as minor as possible.
| |
| | |
| Two primary problems of pathfinding are to find a path between two nodes in a [[graph (data structure)|graph]] and to find the [[shortest path problem|optimal shortest path]]. Basic algorithms such as [[Breadth-first search|breadth-first]] and [[Depth-first search|depth-first]] search address the first problem by [[Brute-force search|exhausting]] all possibilities; starting from the given node, they iterate over all potential paths until they reach the destination node. These algorithms run in <math>O(|V|+|E|)</math>, or linear time, where V is the number of vertices, and E is the number of [[Edge (graph theory)|edges]] between vertices.
| |
| | |
| The more complicated problem is finding the optimal path. The exhaustive approach in this case is known as the [[Bellman–Ford algorithm]], which yields a time complexity of <math>O(|V||E|)</math>, or quadratic time. However, it is not necessary to examine all possible paths to find the optimal one. Algorithms such as [[A* search algorithm|A*]] and [[Dijkstra's algorithm]] strategically eliminate paths, either through [[Heuristic (computer science)|heuristics]] or through [[dynamic programming]]. By eliminating impossible paths, these algorithms can achieve time complexities as low as <math>O(|E|\log(|V|))</math>.<ref>http://lcm.csa.iisc.ernet.in/dsa/node162.html</ref>
| |
| | |
| The above algorithms are among the best general algorithms which operate on a graph without preprocessing. However, in practical travel-routing systems, even better time complexities can be attained by algorithms which can pre-process the graph to attain better performance.<ref>{{cite book
| |
| |chapter=Engineering route planning algorithms
| |
| |author=Delling, D. and Sanders, P. and Schultes, D. and Wagner, D.
| |
| |title=Algorithmics of large and complex networks
| |
| |pages=117–139
| |
| |year=2009
| |
| |publisher=Springer
| |
| |doi=10.1007/978-3-642-02094-0_7
| |
| }}
| |
| </ref> One such algorithm is [[contraction hierarchies]].
| |
| | |
| ===Dijkstra's Algorithm===
| |
| | |
| A common example of a graph-based pathfinding algorithm is [[Dijkstra's algorithm]]. This algorithm begins with a start node and an "open set" of candidate nodes. At each step, the node in the open set with the lowest distance from the start is examined. The node is marked "closed", and all nodes adjacent to it are added to the open set if they have not already been examined. This process repeats until a path to the destination has been found. Since the lowest distance nodes are examined first, the first time the destination is found, the path to it will be the shortest path.<ref>http://students.ceid.upatras.gr/~papagel/project/kef5_7_1.htm</ref>
| |
| | |
| Dijkstra's algorithm fails if there is a negative [[Edge (graph theory)|edge]] weight. In the hypothetical situation where Nodes A, B, and C form a connected undirected graph with edges AB = 3, AC = 4, and BC = −2, the optimal path from A to C costs 1, and the optimal path from A to B costs 2. Dijkstra's Algorithm starting from A will first examine B, as that is the closest. It will assign a cost of 3 to it, and mark it closed, meaning that its cost will never be reevaluated. Therefore, Dijkstra's cannot evaluate negative edge weights. However, since for many practical purposes there will never be a negative edgeweight, Dijkstra's algorithm is largely suitable for the purpose of pathfinding.
| |
| | |
| ===A* Algorithm===
| |
| | |
| [[A*]] is a variant of Dijkstra's algorithm commonly used in games. A* assigns a weight to each open node equal to the weight of the edge to that node plus the approximate distance between that node and the finish. This approximate distance is found by the [[Heuristic (computer science)|heuristic]], and represents a minimum possible distance between that node and the end. This allows it to eliminate longer paths once an initial path is found. If there is a path of length x between the start and finish, and the minimum distance between a node and the finish is greater than x, that node need not be examined.<ref>http://www.raywenderlich.com/4946/introduction-to-a-pathfinding</ref>
| |
| | |
| A* uses this heuristic to improve on the behavior relative to Dijkstra's algorithm. When the heuristic evaluates to zero, A* is equivalent to Dijkstra's algorithm. As the heuristic estimate increases and gets closer to the true distance, A* continues to find optimal paths, but runs faster (by virtue of examining fewer nodes). When the value of the heuristic is exactly the true distance, A* examines the fewest nodes. (However, it is generally impractical to write a heuristic function that always computes the true distance.) As the value of the heuristic increases, A* examines fewer nodes but no longer guarantees an optimal path. In many applications (such as video games) this is acceptable and even desirable, in order to keep the algorithm running quickly.
| |
| | |
| === Sample algorithm ===
| |
| | |
| This is a fairly simple and easy-to-understand pathfinding algorithm for tile-based maps. To start off, you have a map, a start coordinate and a destination coordinate. The map will look like this, <tt>X</tt> being walls, <tt>S</tt> being the start, <tt>0</tt> being the finish and <tt>_</tt> being open spaces, the numbers along the top and right edges are the column and row numbers:
| |
| | |
| 1 2 3 4 5 6 7 8
| |
| X X X X X X X X X X | |
| X _ _ _ X X _ X _ X 1
| |
| X _ X _ _ X _ _ _ X 2
| |
| X S X X _ _ _ X _ X 3
| |
| X _ X _ _ X _ _ _ X 4
| |
| X _ _ _ X X _ X _ X 5
| |
| X _ X _ _ X _ X _ X 6
| |
| X _ X X _ _ _ X _ X 7
| |
| X _ _ 0 _ X _ _ _ X 8
| |
| X X X X X X X X X X
| |
| | |
| First, create a list of coordinates, which we will use as a queue. The queue will be initialized with one coordinate, the end coordinate. Each coordinate will also have a counter variable attached (the purpose of this will soon become evident). Thus, the queue starts off as ((3,8,0)).
| |
| | |
| Then, go through every element in the queue, including elements added to the end over the course of the algorithm, and to each element, do the following:
| |
| | |
| # Create a list of the four adjacent cells, with a counter variable of the current element's counter variable + 1 (in our example, the four cells are ((2,8,1),(3,7,1),(4,8,1),(3,9,1)))
| |
| # Check all cells in each list for the following two conditions:
| |
| ## If the cell is a wall, remove it from the list
| |
| ## If there is an element in the main list with the same coordinate and an equal or higher counter, remove it from the list
| |
| # Add all remaining cells in the list to the end of the main list
| |
| # Go to the next item in the list
| |
| | |
| Thus, after turn 1, the list of elements is this: ((3,8,0),(2,8,1),(4,8,1))
| |
| * After 2 turns: ((3,8,0),(2,8,1),(4,8,1),(1,8,2),(4,7,2))
| |
| * After 3 turns: (...(1,7,3),(4,6,3),(5,7,3))
| |
| * After 4 turns: (...(1,6,4),(3,6,4),(6,7,4))
| |
| * After 5 turns: (...(1,5,5),(3,5,5),(6,6,5),(6,8,5))
| |
| * After 6 turns: (...(1,4,6),(2,5,6),(3,4,6),(6,5,6),(7,8,6))
| |
| * After 7 turns: ((1,3,7)) – problem solved, end this stage of the algorithm – note that if you have multiple units chasing the same target (as in many games – the finish to start approach of the algorithm is intended to make this easier), you can continue until the entire map is taken up, all units are reached or a set counter limit is reached
| |
| | |
| Now, map the counters onto the map, getting this:
| |
| | |
| 1 2 3 4 5 6 7 8
| |
| X X X X X X X X X X | |
| X _ _ _ X X _ X _ X 1
| |
| X _ X _ _ X _ _ _ X 2
| |
| X S X X _ _ _ X _ X 3
| |
| X 6 X 6 _ X _ _ _ X 4
| |
| X 5 6 5 X X 6 X _ X 5
| |
| X 4 X 4 3 X 5 X _ X 6
| |
| X 3 X X 2 3 4 X _ X 7
| |
| X 2 1 0 1 X 5 6 _ X 8
| |
| X X X X X X X X X X
| |
| | |
| Now, start at S (7) and go to the nearby cell with the lowest number (unchecked cells cannot be moved to). The path traced is (1,3,7) -> (1,4,6) -> (1,5,5) -> (1,6,4) -> (1,7,3) -> (1,8,2) -> (2,8,1) -> (3,8,0). In the event that two numbers are equally low (for example, if S was at (2,5)), pick a random direction – the lengths are the same. The algorithm is now complete.
| |
| | |
| == In video games ==
| |
| | |
| Pathfinding in the context of [[video game]]s concerns the way in which a moving entity finds a path around an obstacle; the most frequent context is [[real-time strategy]] games (in which the player directs units around a play area containing obstacles), but forms of this are found in most modern video games. Pathfinding has grown in importance as games and their environments have become more complex, and as a result, many [[Game artificial intelligence|AI software packages]] have been developed to solve the problem.
| |
| | |
| Real-time strategy games typically contain large areas of open terrain which is often relatively simple to route across, although it is common for more than one unit to travel simultaneously; this creates a need for different, and often significantly more complex algorithms to avoid traffic jams at choke-points in terrain, or when units come into contact with each other. In strategy games the map is normally divided into tiles, which act as nodes in the pathfinding algorithm.
| |
| | |
| More open endedly structured genres such as [[first-person shooter]]s often have more enclosed (or a mixture of open and enclosed) areas that are not as simply divided into nodes, which has given rise to the use of [[navigation mesh]]es. These are constructed by placing nodes in the game world that store details of which nodes are accessible from it.
| |
| | |
| == Algorithms used in pathfinding ==
| |
| *[[Dijkstra's algorithm]]
| |
| *[[A* search algorithm]]
| |
| *[[D*]] a family of [[dynamic pathfinding]] algorithms for problems in which constraints vary over time
| |
| | |
| == References ==
| |
| {{reflist}}
| |
| | |
| == External links ==
| |
| *http://www.policyalmanac.org/games/aStarTutorial.htm
| |
| *http://theory.stanford.edu/~amitp/GameProgramming/
| |
| *http://sourceforge.net/projects/argorha
| |
| *http://www.ai-blog.net/archives/000152.html
| |
| *http://qiao.github.com/PathFinding.js/visual/
| |
| *[https://code.google.com/p/straightedge/ StraightEdge] Open Source Java 2D path finding (using A<nowiki>*</nowiki>) and lighting project. Includes applet demos.
| |
| *[https://github.com/CBCJVM/python-pathfinding python-pathfinding] Open Source Python 2D path finding (using Dijkstra's Algorithm) and lighting project.
| |
| | |
| [[Category:Game artificial intelligence]]
| |