php a星算法,A*（A星）算法Go lang实现

氢气青丘

于 2021-04-02 04:47:16 发布

阅读量357

点赞数

文章标签： php a星算法

本文详细介绍了A*算法在静态路网中寻找最短路径的应用，指出其作为启发式搜索方法的高效性。文章通过Go语言展示了A*算法的具体实现，包括地图数据结构、相邻节点获取、开放列表管理等关键步骤，并提供了寻找路径的完整流程。

摘要由CSDN通过智能技术生成

ce30856e325f?utm_campaign=maleskine&utm_content=note&utm_medium=reader_share&utm_source=weibo

A算法，A(A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是解决许多搜索问题的有效算法。算法中的距离估算值与实际值越接近，最终搜索速度越快。

A* (A-Star)算法是一种静态路网中求解最短路径最有效的直接搜索方法，也是许多其他问题的常用启发式算法。注意——是最有效的直接搜索算法，之后涌现了很多预处理算法(如ALT，CH，HL等等)，在线查询效率是A*算法的数千甚至上万倍。

公式表示为： f(n)=g(n)+h(n),

其中， f(n) 是从初始状态经由状态n到目标状态的代价估计，

g(n) 是在状态空间中从初始状态到状态n的实际代价，

h(n) 是从状态n到目标状态的最佳路径的估计代价。

(对于路径搜索问题，状态就是图中的节点，代价就是距离)

h(n)的选取

保证找到最短路径(最优解的)条件，关键在于估价函数f(n)的选取(或者说h(n)的选取)。

我们以d(n)表达状态n到目标状态的距离，那么h(n)的选取大致有如下三种情况：

如果h(n)< d(n)到目标状态的实际距离，这种情况下，搜索的点数多，搜索范围大，效率低。但能得到最优解。

如果h(n)=d(n)，即距离估计h(n)等于最短距离，那么搜索将严格沿着最短路径进行，此时的搜索效率是最高的。

如果 h(n)>d(n)，搜索的点数少，搜索范围小，效率高，但不能保证得到最优解。

A*同样可以用于其他搜索问题，只需要对应状态和状态的距离即可。

package main

import (

"container/heap"

"fmt"

"math"

"strings"

)

import "strconv"

type OpenList []*_AstarPoint

func (self OpenList) Len() int { return len(self) }

func (self OpenList) Less(i, j int) bool { return self[i].fVal < self[j].fVal }

func (self OpenList) Swap(i, j int) { self[i], self[j] = self[j], self[i] }

func (this *OpenList) Push(x interface{}) {

// Push and Pop use pointer receivers because they modify the slice's length,

// not just its contents.

*this = append(*this, x.(*_AstarPoint))

}

func (this *OpenList) Pop() interface{} {

old := *this

n := len(old)

x := old[n-1]

*this = old[0 : n-1]

return x

}

type _Point struct {

x int

y int

view string

}

//========================================================================================

// 保存地图的基本信息

type Map struct {

points [][]_Point

blocks map[string]*_Point

maxX int

maxY int

}

func NewMap(charMap []string) (m Map) {

m.points = make([][]_Point, len(charMap))

m.blocks = make(map[string]*_Point, len(charMap)*2)

for x, row := range charMap {

cols := strings.Split(row, " ")

m.points[x] = make([]_Point, len(cols))

for y, view := range cols {

m.points[x][y] = _Point{x, y, view}

if view == "X" {

m.blocks[pointAsKey(x, y)] = &m.points[x][y]

}

} // end of cols

} // end of row

m.maxX = len(m.points)

m.maxY = len(m.points[0])

return m

}

func (this *Map) getAdjacentPoint(curPoint *_Point) (adjacents []*_Point) {

if x, y := curPoint.x, curPoint.y-1; x >= 0 && x < this.maxX && y >= 0 && y < this.maxY {