理解A*尋路算法具體過程
這兩天研究了下 A* 尋路算法, 主要學習了這篇文章, 但這篇翻譯得不是很好, 我花了很久才看明白文章中的各種指代. 特寫此篇博客用來總結, 并寫了尋路算法的代碼, 覺得有用的同學可以看看. 另外因為圖片制作起來比較麻煩, 所以我用的是原文里的圖片.
簡易地圖
尋路步驟
從起點A開始, 把它作為待處理的方格存入一個”開啟列表”, 開啟列表就是一個等待檢查方格的列表. 尋找起點A周圍可以到達的方格, 將它們放入”開啟列表”, 并設置它們的”父方格”為A. 從”開啟列表”中刪除起點 A, 并將起點 A 加入”關閉列表”, “關閉列表”中存放的都是不需要再次檢查的方格
F = G + H
我們假設橫向移動一個格子的耗費為10, 為了便于計算, 沿斜方向移動一個格子耗費是14. 為了更直觀的展示如何運算 FGH, 圖中方塊的左上角數字表示 F, 左下角表示 G, 右下角表示 H. 看看是否跟你心里想的結果一樣?
把它從 “開啟列表” 中刪除, 并放到 “關閉列表” 中. 檢查它所有相鄰并且可以到達 (障礙物和 “關閉列表” 的方格都不考慮) 的方格. 如果這些方格還不在 “開啟列表” 里的話, 將它們加入 “開啟列表”, 計算這些方格的 G, H 和 F 值各是多少, 并設置它們的 “父方格” 為 C. 如果某個相鄰方格 D 已經在 “開啟列表” 里了, 檢查如果用新的路徑 (就是經過C 的路徑) 到達它的話, G值是否會更低一些, 如果新的G值更低, 那就把它的 “父方格” 改為目前選中的方格 C, 然后重新計算它的 F 值和 G 值 (H 值不需要重新計算, 因為對于每個方塊, H 值是不變的). 如果新的 G 值比較高, 就說明經過 C 再到達 D 不是一個明智的選擇, 因為它需要更遠的路, 這時我們什么也不做.
如何找回路徑
將整個過程抽象
把起始格添加到 “開啟列表”
最后從目標格開始, 沿著每一格的父節點移動直到回到起始格, 這就是路徑.
主要代碼
程序中的 “開啟列表” 和 “關閉列表”
List <
Point > CloseList;
List <
Point > OpenList;
Point 類
public class Point
{
public Point ParentPoint {
get ;
set ; }
public int F {
get ;
set ; }
public int G {
get ;
set ; }
public int H {
get ;
set ; }
public int X {
get ;
set ; }
public int Y {
get ;
set ; }
public Point (
int x,
int y){
this .X = x;
this .Y = y;}
public void CalcF (){
this .F =
this .G +
this .H;}
}
尋路過程
public Point
FindPath (Point start, Point end,
bool IsIgnoreCorner)
{OpenList.Add(start);
while (OpenList.Count !=
0 ){
var tempStart = OpenList.MinPoint();OpenList.RemoveAt(
0 );CloseList.Add(tempStart);
var surroundPoints = SurrroundPoints(tempStart, IsIgnoreCorner);
foreach (Point point
in surroundPoints){
if (OpenList.Exists(point))FoundPoint(tempStart, point);
else NotFoundPoint(tempStart, end, point);}
if (OpenList.Get(end) !=
null )
return OpenList.Get(end);}
return OpenList.Get(end);
}
完整代碼
using System;
using System.Collections.Generic;
using System.Linq;namespace Maze
{class Maze{
public const int OBLIQUE =
14 ;
public const int STEP =
10 ;
public int [,] MazeArray {
get ;
private set ; }List<Point> CloseList;List<Point> OpenList;
public Maze (
int [,] maze){
this .MazeArray = maze;OpenList =
new List<Point>(MazeArray.Length);CloseList =
new List<Point>(MazeArray.Length);}
public Point
FindPath (Point start, Point end,
bool IsIgnoreCorner){OpenList.Add(start);
while (OpenList.Count !=
0 ){
var tempStart = OpenList.MinPoint();OpenList.RemoveAt(
0 );CloseList.Add(tempStart);
var surroundPoints = SurrroundPoints(tempStart, IsIgnoreCorner);
foreach (Point point
in surroundPoints){
if (OpenList.Exists(point))FoundPoint(tempStart, point);
else NotFoundPoint(tempStart, end, point);}
if (OpenList.Get(end) !=
null )
return OpenList.Get(end);}
return OpenList.Get(end);}
private void FoundPoint (Point tempStart, Point point){
var G = CalcG(tempStart, point);
if (G < point.G){point.ParentPoint = tempStart;point.G = G;point.CalcF();}}
private void NotFoundPoint (Point tempStart, Point end, Point point){point.ParentPoint = tempStart;point.G = CalcG(tempStart, point);point.H = CalcH(end, point);point.CalcF();OpenList.Add(point);}
private int CalcG (Point start, Point point){
int G = (Math.Abs(point.X - start.X) + Math.Abs(point.Y - start.Y)) ==
2 ? STEP : OBLIQUE;
int parentG = point.ParentPoint !=
null ? point.ParentPoint.G :
0 ;
return G + parentG;}
private int CalcH (Point end, Point point){
int step = Math.Abs(point.X - end.X) + Math.Abs(point.Y - end.Y);
return step * STEP;}
public List<Point>
SurrroundPoints (Point point,
bool IsIgnoreCorner){
var surroundPoints =
new List<Point>(
9 );
for (
int x = point.X -
1 ; x <= point.X+
1 ;x++)
for (
int y = point.Y -
1 ; y <= point.Y +
1 ; y++){
if (CanReach(point,x, y,IsIgnoreCorner))surroundPoints.Add(x, y);}
return surroundPoints;}
private bool CanReach (
int x,
int y){
return MazeArray[x, y] ==
0 ;}
public bool CanReach (Point start,
int x,
int y,
bool IsIgnoreCorner){
if (!CanReach(x, y) || CloseList.Exists(x, y))
return false ;
else {
if (Math.Abs(x - start.X) + Math.Abs(y - start.Y) ==
1 )
return true ;
else {
if (CanReach(Math.Abs(x -
1 ), y) && CanReach(x, Math.Abs(y -
1 )))
return true ;
else return IsIgnoreCorner;}}}}
public class Point{
public Point ParentPoint {
get ;
set ; }
public int F {
get ;
set ; }
public int G {
get ;
set ; }
public int H {
get ;
set ; }
public int X {
get ;
set ; }
public int Y {
get ;
set ; }
public Point (
int x,
int y){
this .X = x;
this .Y = y;}
public void CalcF (){
this .F =
this .G +
this .H;}}
public static class ListHelper{
public static bool Exists (
this List<Point> points, Point point){
foreach (Point p
in points)
if ((p.X == point.X) && (p.Y == point.Y))
return true ;
return false ;}
public static bool Exists (
this List<Point> points,
int x,
int y){
foreach (Point p
in points)
if ((p.X == x) && (p.Y == y))
return true ;
return false ;}
public static Point
MinPoint (
this List<Point> points){points = points.OrderBy(p => p.F).ToList();
return points[
0 ];}
public static void Add (
this List<Point> points,
int x,
int y){Point point =
new Point(x, y);points.Add(point);}
public static Point
Get (
this List<Point> points, Point point){
foreach (Point p
in points)
if ((p.X == point.X) && (p.Y == point.Y))
return p;
return null ;}
public static void Remove (
this List<Point> points,
int x,
int y){
foreach (Point point
in points){
if (point.X == x && point.Y == y)points.Remove(point);}}}
}
program.cs
using System;
namespace Maze
{
class Program {
static void Main (
string []
args ){
int [,]
array = {{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},{ 1, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1},{ 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1},{ 1, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1},{ 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1},{ 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1},{ 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1},{ 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1}};Maze maze =
new Maze(
array );Point start =
new Point(
1 ,
1 );Point end =
new Point(
6 ,
10 );
var parent = maze.FindPath(start, end,
false );Console.WriteLine(
"Print path:" );
while (
parent !=
null ){Console.WriteLine(
parent .X +
", " +
parent .Y);
parent =
parent .ParentPoint;}}}
}
總結
以上是生活随笔 為你收集整理的C#实现A*算法 的全部內容，希望文章能夠幫你解決所遇到的問題。
如果覺得生活随笔 網站內容還不錯，歡迎將生活随笔 推薦給好友。
