数码资讯
PHP树深层编程迷宫及A*自动布线算法实例分析
本文介绍了php树的深层编程迷宫和A*自动布线算法，供大家参考，具体分析如下： 一位同事推荐了一个迷宫，它看起来不错，变成了PHP。 迷宫的迷宫，使用树的深度遍历原理，是相当薄的，死胡同的数目相对较小。 任何两点之间都有一条独特的路径。 A*路由算法是目前最流行的自动路由算法。 没有太多的谈话，把代
选购提示
关注价格、性能、续航、售后和真实使用场景，理性比较后再下单。
本文介绍了php树的深层编程迷宫和A*自动布线算法，供大家参考，具体分析如下：
一位同事推荐了一个迷宫，它看起来不错，变成了PHP。
迷宫的迷宫，使用树的深度遍历原理，是相当薄的，死胡同的数目相对较小。
任何两点之间都有一条独特的路径。
A*路由算法是目前最流行的自动路由算法。
没有太多的谈话，把代码。
迷宫生成类：
复制代码如下：类迷宫{
迷宫创建
私人_w美元；
私人_h美元；
私人_grids美元；
私人_walkhistory美元；
私人_walkhistory2美元；
私人_targetsteps美元；
/构建
公共函数Maze（）{
美元-> _w = 6；
美元-> _h = 6；
美元-> _grids =阵（）；
}
设置迷宫的大小
公共函数集（宽度= 6，高度= 6）{
如果（$宽度> 0）美元-> _w = $宽度；
如果（$高> 0）美元-> _h = $高度；
返回$此；
}
到迷宫中去
公共函数获取（）{
返回_grids美元->；
}
生成迷宫
公共函数创建（）{
美元-> _init（）；
返回这个-> _walk（rand（0，计数（美元-> _grids）- 1））；
}
获取/死/终止点
公共功能块（$ = 0，$ = false）{
$ L =计数（美元-> _grids）；
（$ i = 1；$ i $ l；$ + +）{
$ V =美元-> _grids {我}；
如果（$ V = = 1 = = 2 = = $ V $ V | | | | 4 | | { $ V = = 8）
$；
}
}
随机访问点
如果（$）洗牌（回报）；
如果（$ = 0）返回$返回；
如果（$ = 1）{
返回array_pop（美元收益）；
{人}
返回array_slice（美元的回报，0，$ N）；
}
}
| ---------------------------------------------------------------
|系列函数生成的迷宫
| ---------------------------------------------------------------
* /
私有函数_walk（$ StartPos）{
美元-> _walkhistory =阵（）；
美元-> _walkhistory2 =阵（）；
curpos =美元，让美元；
而美元->（_getnext0（）！= 1）{
curpos美元=美元-> _step（$ curpos）；
如果（$ curpos = false）打破；
}
返回$此；
}
私有函数_gettargetsteps（$ curpos）{
$ = 0；
$ =数组（）；
P = $ curpos -美元-> _w；
如果（P - > _grids { $ P } = > 0 0！美元-> _isrepeating（P））{
array_push（$，$ P）；
{人}
array_push（$，1）；
}
P = curpos + 1美元；
如果（$ P%美元-> _w！= 0美元-> _grids { $ P } = 0美元这-> _isrepeating（P）{！）
array_push（$，$ P）；
{人}
array_push（$，1）；
}
P = $ curpos +美元-> _w；
If ($p _grids) $this->_grids{$p} = 0 $this->_isRepeating ($p)) {!
array_push（$，$ P）；
{人}
array_push（$，1）；
}
P = curpos美元1美元；
如果（（$ curpos %美元-> _w）！= 0美元-> _grids { $ P } = 0美元这-> _isrepeating（P）{！）
array_push（$，$ P）；
{人}
array_push（$，1）；
}
返回$；
}
私有函数_nostep（）{
$ L =计数（美元-> _targetsteps）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _targetsteps {我}！= - 1）返回false；
}
返回true；
}
私有函数_step（$ curpos）{
这_targetsteps =美元->美元-> _gettargetsteps（$ curpos）；
如果（美元-> _nostep（））{
如果（计数（美元-> _walkhistory）> 0）{
TMP = array_pop美元（美元-> _walkhistory）；
{人}
返回false；
}
array_push（美元->美元_walkhistory2，TMP）；
返回这个-> _step（$ TMP）；
}
$ =兰德（0, 3）；
而（美元-> _targetsteps { $ R } = = 1）{
$ =兰德（0, 3）；
}
nextpos美元=美元-> _targetsteps { $ R }；
跨美元=假；
如果（美元-> _grids { $ nextpos }！= 0）
$跨=真；
如果（$ = 0）{
美元-> _grids { 1 } ^ curpos美元；
美元-> _grids { 4 } ^ nextpos美元；
} elseif（r = = 1）{
美元-> _grids { 2 } ^ curpos美元；
美元-> _grids { 8 } ^ nextpos美元；
} elseif（r = = 2）{
美元-> _grids { 4 } ^ curpos美元；
美元-> _grids { 1 } ^ nextpos美元；
} elseif（r = = 3）{
美元-> _grids { 8 } ^ curpos美元；
美元-> _grids { 2 } ^ nextpos美元；
}
array_push（美元-> _walkhistory，curpos美元）；
跨虚假回归：nextpos美元美元；
}
私有函数_isrepeating（P）{
$ L =计数（美元-> _walkhistory）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _walkhistory { } = =我美元$ P）返回true；
}
$ L =计数（美元-> _walkhistory2）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _walkhistory2 { } = =我美元$ P）返回true；
}
返回false；
}
私有函数_getnext0（）{
$ L =计数（美元-> _grids）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _grids {我} = = 0美元）返回的我；
}
返回- 1；
}
私有函数_init（）{
美元-> _grids =阵（）；
为（$ Y = 0；Y元_h；Y元+ +）{
为（$ x = 0；X元_w；X元+ +）{
array_push（美元-> _grids，0）；
}
}
返回$此；
}
}
A*路由算法
复制代码代码如下：类爱仕达{
/ / A
私人_open美元；
私人_closed美元；
私人_start美元；
私人_end美元；
私人_grids美元；
私人_w美元；
私人_h美元；
/构建
公共函数AStar（）{
美元-> _w = null；
美元-> _h = null；
美元-> _grids = null；
}
公共函数集（宽度、高度、网格）{
美元-> _w = $宽度；
美元-> _h = $高度；
美元-> _grids = $网格；
返回$此；
}
/ /迷宫寻路
公共函数搜索（$ = false，$ = false）{
返回这个-> _search（美元开始，美元）；
}
| ---------------------------------------------------------------
|自动路由算法
| ---------------------------------------------------------------
* /
公共功能_search（$开始= false，美元= false）{
如果（开始）！= = false）美元-> _start = $开始；
如果（$）！= = false）美元-> _end =美元；
_sh美元=美元-> _geth（$开始）；
$ $；
$点{ F } = $ _sh；
{一} $点= 0；
点错} = {美元_sh美元；
$点{ 'p' } = null；
美元-> _open { } = $点；
美元-> _closed {开始} = $点美元；
而（0 _open））{
$心智=假；
foreach（美元-> _open美元美元关键= maxnode）{
如果（$心智=假|美元美元|心智> maxnode { F }）{
极小指标=美元美元的关键；
}
}
nownode美元=美元-> _open { $极小指标}；
unset（美元-> _open { $极小指标}）；
如果（$ nownode {我的} = =美元-> _end）{
$ =数组（）；
而（$ nownode { 'p' }！= NULL）{
array_unshift（$ TP，nownode美元{ 'p' }）；
nownode美元=美元-> _closed { $ nownode { 'p' } }；
}
array_push（$ TP，美元-> _end）；
打破；
}
美元-> _setpoint（$ nownode {我的}）；
}
美元-> _closed =阵（）；
美元-> _open =阵（）；
返回$ TP；
}
私有函数_setpoint（$我）{
$点=美元-> _grids { $我}；
将所有可选方向放入队列中
如果（$ 1）{
接下来我=美元美元美元-> _w；
美元-> _checkpoint（$我一美元）；
}
如果（$ 2）{
$ $ = $ ME + 1；
美元-> _checkpoint（$我一美元）；
}
如果（$ 4）{
我+下=美元美元美元-> _w；
美元-> _checkpoint（$我一美元）；
}
如果（$ 8）{
$ $ = $ 1；
美元-> _checkpoint（$我一美元）；
}
}
私有函数_checkpoint（指向美元，一美元）{
如果（美元-> _closed { $下}）{
_g美元=美元-> _closed { } {一} $指向+ $这-> _getg（合一）；
如果（$ _g < {一} $检查）{
美元-> _closed {一} {一}美元的美元_g =；
美元-> _closed {一} { } $ F =美元-> _closed {一} {一} $'+美元-> _closed {一} { } $ H；
美元-> _closed {一} {美元'p' } = $题目；
}
{人}
$点{ 'p' } = $题目；
点错} = {美元美元-> _geth（合一）；
{一} = $点-> _getg美元（合一）；
$点{ F } = { } $点H + $点{一}；
下一个点；
美元-> _open { } = $点；
美元-> _closed {一} = $点美元；
}
}
私有函数_getg（合点）{
返回ABS（美元-> _start $点）；
}
私有函数_geth（合点）{
返回ABS（美元-> _end $点）；
}
}
完整的实例代码在这里下载。
每个人都需要直接去演示，看看效果如何！
希望本文能对大家的PHP程序设计有所帮助。
一位同事推荐了一个迷宫，它看起来不错，变成了PHP。
迷宫的迷宫，使用树的深度遍历原理，是相当薄的，死胡同的数目相对较小。
任何两点之间都有一条独特的路径。
A*路由算法是目前最流行的自动路由算法。
没有太多的谈话，把代码。
迷宫生成类：
复制代码如下：类迷宫{
迷宫创建
私人_w美元；
私人_h美元；
私人_grids美元；
私人_walkhistory美元；
私人_walkhistory2美元；
私人_targetsteps美元；
/构建
公共函数Maze（）{
美元-> _w = 6；
美元-> _h = 6；
美元-> _grids =阵（）；
}
设置迷宫的大小
公共函数集（宽度= 6，高度= 6）{
如果（$宽度> 0）美元-> _w = $宽度；
如果（$高> 0）美元-> _h = $高度；
返回$此；
}
到迷宫中去
公共函数获取（）{
返回_grids美元->；
}
生成迷宫
公共函数创建（）{
美元-> _init（）；
返回这个-> _walk（rand（0，计数（美元-> _grids）- 1））；
}
获取/死/终止点
公共功能块（$ = 0，$ = false）{
$ L =计数（美元-> _grids）；
（$ i = 1；$ i $ l；$ + +）{
$ V =美元-> _grids {我}；
如果（$ V = = 1 = = 2 = = $ V $ V | | | | 4 | | { $ V = = 8）
$；
}
}
随机访问点
如果（$）洗牌（回报）；
如果（$ = 0）返回$返回；
如果（$ = 1）{
返回array_pop（美元收益）；
{人}
返回array_slice（美元的回报，0，$ N）；
}
}
| ---------------------------------------------------------------
|系列函数生成的迷宫
| ---------------------------------------------------------------
* /
私有函数_walk（$ StartPos）{
美元-> _walkhistory =阵（）；
美元-> _walkhistory2 =阵（）；
curpos =美元，让美元；
而美元->（_getnext0（）！= 1）{
curpos美元=美元-> _step（$ curpos）；
如果（$ curpos = false）打破；
}
返回$此；
}
私有函数_gettargetsteps（$ curpos）{
$ = 0；
$ =数组（）；
P = $ curpos -美元-> _w；
如果（P - > _grids { $ P } = > 0 0！美元-> _isrepeating（P））{
array_push（$，$ P）；
{人}
array_push（$，1）；
}
P = curpos + 1美元；
如果（$ P%美元-> _w！= 0美元-> _grids { $ P } = 0美元这-> _isrepeating（P）{！）
array_push（$，$ P）；
{人}
array_push（$，1）；
}
P = $ curpos +美元-> _w；
If ($p _grids) $this->_grids{$p} = 0 $this->_isRepeating ($p)) {!
array_push（$，$ P）；
{人}
array_push（$，1）；
}
P = curpos美元1美元；
如果（（$ curpos %美元-> _w）！= 0美元-> _grids { $ P } = 0美元这-> _isrepeating（P）{！）
array_push（$，$ P）；
{人}
array_push（$，1）；
}
返回$；
}
私有函数_nostep（）{
$ L =计数（美元-> _targetsteps）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _targetsteps {我}！= - 1）返回false；
}
返回true；
}
私有函数_step（$ curpos）{
这_targetsteps =美元->美元-> _gettargetsteps（$ curpos）；
如果（美元-> _nostep（））{
如果（计数（美元-> _walkhistory）> 0）{
TMP = array_pop美元（美元-> _walkhistory）；
{人}
返回false；
}
array_push（美元->美元_walkhistory2，TMP）；
返回这个-> _step（$ TMP）；
}
$ =兰德（0, 3）；
而（美元-> _targetsteps { $ R } = = 1）{
$ =兰德（0, 3）；
}
nextpos美元=美元-> _targetsteps { $ R }；
跨美元=假；
如果（美元-> _grids { $ nextpos }！= 0）
$跨=真；
如果（$ = 0）{
美元-> _grids { 1 } ^ curpos美元；
美元-> _grids { 4 } ^ nextpos美元；
} elseif（r = = 1）{
美元-> _grids { 2 } ^ curpos美元；
美元-> _grids { 8 } ^ nextpos美元；
} elseif（r = = 2）{
美元-> _grids { 4 } ^ curpos美元；
美元-> _grids { 1 } ^ nextpos美元；
} elseif（r = = 3）{
美元-> _grids { 8 } ^ curpos美元；
美元-> _grids { 2 } ^ nextpos美元；
}
array_push（美元-> _walkhistory，curpos美元）；
跨虚假回归：nextpos美元美元；
}
私有函数_isrepeating（P）{
$ L =计数（美元-> _walkhistory）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _walkhistory { } = =我美元$ P）返回true；
}
$ L =计数（美元-> _walkhistory2）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _walkhistory2 { } = =我美元$ P）返回true；
}
返回false；
}
私有函数_getnext0（）{
$ L =计数（美元-> _grids）；
（$ i = 0；$ i $ l；$ + +）{
如果（美元-> _grids {我} = = 0美元）返回的我；
}
返回- 1；
}
私有函数_init（）{
美元-> _grids =阵（）；
为（$ Y = 0；Y元_h；Y元+ +）{
为（$ x = 0；X元_w；X元+ +）{
array_push（美元-> _grids，0）；
}
}
返回$此；
}
}
A*路由算法
复制代码代码如下：类爱仕达{
/ / A
私人_open美元；
私人_closed美元；
私人_start美元；
私人_end美元；
私人_grids美元；
私人_w美元；
私人_h美元；
/构建
公共函数AStar（）{
美元-> _w = null；
美元-> _h = null；
美元-> _grids = null；
}
公共函数集（宽度、高度、网格）{
美元-> _w = $宽度；
美元-> _h = $高度；
美元-> _grids = $网格；
返回$此；
}
/ /迷宫寻路
公共函数搜索（$ = false，$ = false）{
返回这个-> _search（美元开始，美元）；
}
| ---------------------------------------------------------------
|自动路由算法
| ---------------------------------------------------------------
* /
公共功能_search（$开始= false，美元= false）{
如果（开始）！= = false）美元-> _start = $开始；
如果（$）！= = false）美元-> _end =美元；
_sh美元=美元-> _geth（$开始）；
$ $；
$点{ F } = $ _sh；
{一} $点= 0；
点错} = {美元_sh美元；
$点{ 'p' } = null；
美元-> _open { } = $点；
美元-> _closed {开始} = $点美元；
而（0 _open））{
$心智=假；
foreach（美元-> _open美元美元关键= maxnode）{
如果（$心智=假|美元美元|心智> maxnode { F }）{
极小指标=美元美元的关键；
}
}
nownode美元=美元-> _open { $极小指标}；
unset（美元-> _open { $极小指标}）；
如果（$ nownode {我的} = =美元-> _end）{
$ =数组（）；
而（$ nownode { 'p' }！= NULL）{
array_unshift（$ TP，nownode美元{ 'p' }）；
nownode美元=美元-> _closed { $ nownode { 'p' } }；
}
array_push（$ TP，美元-> _end）；
打破；
}
美元-> _setpoint（$ nownode {我的}）；
}
美元-> _closed =阵（）；
美元-> _open =阵（）；
返回$ TP；
}
私有函数_setpoint（$我）{
$点=美元-> _grids { $我}；
将所有可选方向放入队列中
如果（$ 1）{
接下来我=美元美元美元-> _w；
美元-> _checkpoint（$我一美元）；
}
如果（$ 2）{
$ $ = $ ME + 1；
美元-> _checkpoint（$我一美元）；
}
如果（$ 4）{
我+下=美元美元美元-> _w；
美元-> _checkpoint（$我一美元）；
}
如果（$ 8）{
$ $ = $ 1；
美元-> _checkpoint（$我一美元）；
}
}
私有函数_checkpoint（指向美元，一美元）{
如果（美元-> _closed { $下}）{
_g美元=美元-> _closed { } {一} $指向+ $这-> _getg（合一）；
如果（$ _g < {一} $检查）{
美元-> _closed {一} {一}美元的美元_g =；
美元-> _closed {一} { } $ F =美元-> _closed {一} {一} $'+美元-> _closed {一} { } $ H；
美元-> _closed {一} {美元'p' } = $题目；
}
{人}
$点{ 'p' } = $题目；
点错} = {美元美元-> _geth（合一）；
{一} = $点-> _getg美元（合一）；
$点{ F } = { } $点H + $点{一}；
下一个点；
美元-> _open { } = $点；
美元-> _closed {一} = $点美元；
}
}
私有函数_getg（合点）{
返回ABS（美元-> _start $点）；
}
私有函数_geth（合点）{
返回ABS（美元-> _end $点）；
}
}
完整的实例代码在这里下载。
每个人都需要直接去演示，看看效果如何！
希望本文能对大家的PHP程序设计有所帮助。
声明：本文内容用于数码产品信息整理与选购参考，具体价格、库存、售后政策以官方渠道和电商页面实时信息为准。