PHP树生成迷宫及A*自动寻路算法

PHP树生成迷宫及A*自动寻路算法

迷宫算法是采用树的深度遍历原理,这样生成的迷宫相当的细,而且死胡同数量相对较少!

任意两点之间都存在唯一的一条通路。

至于A*寻路算法是最大众化的一全自动寻路算法

完整代码已上传,http://download.csdn.net/detail/hello_katty/8885779 ,此处做些简单解释,还需要大家自己思考动手。废话不多说,贴上带代码

迷宫生成类:

/** 生成迷宫类
 * @date 2015-07-10
 * @edit http://www.lai18.com
 * @version 1
 **/
class Maze{

    // Maze Create

    private $_w;

    private $_h;

    private $_grids;

    private $_walkHistory;

    private $_walkHistory2;

    private $_targetSteps;

    // Construct

    public function Maze() {

        $this->_w = 6;

        $this->_h = 6;

        $this->_grids = array();

    }

    // 设置迷宫大小

    public function set($width = 6, $height = 6) {

        if ( $width > 0 ) $this->_w = $width;

        if ( $height > 0 ) $this->_h = $height;

        return $this;

    }

    // 取到迷宫

    public function get() {

        return $this->_grids;

    }

    // 生成迷宫

    public function create() {

        $this->_init();

        return $this->_walk(rand(0, count($this->_grids) -1 ));

    }

    // 获取死胡同点

    public function block($n = 0, $rand = false) {

        $l = count($this->_grids);

        for( $i = 1; $i < $l; $i++ ) {

            $v = $this->_grids[$i];

            if ( $v == 1 || $v == 2 || $v == 4 || $v == 8 ) {

                $return[] = $i;

            }

        }

        // 随机取点

        if ( $rand ) shuffle($return);

        if ( $n == 0 ) return $return;

        if ( $n == 1 ) {

            return array_pop($return);

        } else {

            return array_slice($return, 0, $n);

        }

    }

    /**

    生成迷宫的系列函数

    */

    private function _walk($startPos) {

        $this->_walkHistory = array();

        $this->_walkHistory2 = array();

        $curPos = $startPos;

        while ($this->_getNext0() != -1) {

            $curPos = $this->_step($curPos);

            if ( $curPos === false ) break;

        }

        return $this;

    }

    private function _getTargetSteps($curPos) {

        $p = 0;

        $a = array();

        $p = $curPos - $this->_w;

        if ($p > 0 && $this->_grids[$p] === 0 && ! $this->_isRepeating($p)) {

            array_push($a, $p);

        } else {

            array_push($a, -1);

        }

        $p = $curPos + 1;

        if ($p % $this->_w != 0 && $this->_grids[$p] === 0 && ! $this->_isRepeating($p)) {

            array_push($a, $p);

        } else {

            array_push($a, -1);

        }

        $p = $curPos + $this->_w;

        if ($p < count($this->_grids) && $this->_grids[$p] === 0 && ! $this->_isRepeating($p)) {

            array_push($a, $p);

        } else {

            array_push($a, -1);

        }

        $p = $curPos - 1;

        if (($curPos % $this->_w) != 0 && $this->_grids[$p] === 0 && ! $this->_isRepeating($p)) {

            array_push($a, $p);

        } else {

            array_push($a, -1);

        }

        return $a;

    }

    private function _noStep() {

        $l = count($this->_targetSteps);

        for ($i = 0; $i < $l; $i ++) {

            if ($this->_targetSteps[$i] != -1) return false;

        }

        return true;

    }

    private function _step($curPos) {

        $this->_targetSteps = $this->_getTargetSteps($curPos);

        if ( $this->_noStep() ) {

            if ( count($this->_walkHistory) > 0 ) {

                $tmp = array_pop($this->_walkHistory);

            } else {

                return false;

            }

            array_push($this->_walkHistory2, $tmp);

            return $this->_step($tmp);

        }

        $r = rand(0, 3);

        while ( $this->_targetSteps[$r] == -1) {

            $r = rand(0, 3);

        }

        $nextPos = $this->_targetSteps[$r];

        $isCross = false;

        if ( $this->_grids[$nextPos] != 0)

            $isCross = true;

        if ($r == 0) {

            $this->_grids[$curPos] ^= 1;

            $this->_grids[$nextPos] ^= 4;

        } elseif ($r == 1) {

            $this->_grids[$curPos] ^= 2;

            $this->_grids[$nextPos] ^= 8;

        } elseif ($r == 2) {

            $this->_grids[$curPos] ^= 4;

            $this->_grids[$nextPos] ^= 1;

        } elseif ($r == 3) {

            $this->_grids[$curPos] ^= 8;

            $this->_grids[$nextPos] ^= 2;

        }

        array_push($this->_walkHistory, $curPos);

        return $isCross ? false : $nextPos;

    }

    private function _isRepeating($p) {

        $l = count($this->_walkHistory);

        for ($i = 0; $i < $l; $i ++) {

            if ($this->_walkHistory[$i] == $p) return true;

        }

        $l = count($this->_walkHistory2);

        for ($i = 0; $i < $l; $i ++) {

            if ($this->_walkHistory2[$i] == $p) return true;

        }

        return false;

    }

    private function _getNext0() {

        $l = count($this->_grids);

        for ($i = 0; $i <= $l; $i++ ) {

            if ( $this->_grids[$i] == 0) return $i;

        }

        return -1;

    }

    private function _init() {

        $this->_grids = array();

        for ($y = 0; $y < $this->_h; $y ++) {

            for ($x = 0; $x < $this->_w; $x ++) {

                array_push($this->_grids, 0);

            }

        }

        return $this;

    }

}

A*寻路算法

/** 寻路算法
 * @date 2015-07-10
 * @edit http://www.lai18.com
 * @version 1
 **/
class AStar{

    // A-star

    private $_open;

    private $_closed;

    private $_start;

    private $_end;

    private $_grids;

    private $_w;

    private $_h;

    // Construct

    public function AStar(){

        $this->_w = null;

        $this->_h = null;

        $this->_grids = null;

    }

    public function set($width, $height, $grids) {

        $this->_w = $width;

        $this->_h = $height;

        $this->_grids = $grids;

        return $this;

    }

    // 迷宫中寻路

    public function search($start = false, $end = false) {

        return $this->_search($start, $end);

    }

    /**

    自动寻路 - A-star 算法

       */

    public function _search($start = false, $end = false) {

        if ( $start !== false ) $this->_start = $start;

        if ( $end !== false ) $this->_end = $end;

        $_sh = $this->_getH($start);

        $point[‘i‘] = $start;

        $point[‘f‘] = $_sh;

        $point[‘g‘] = 0;

        $point[‘h‘] = $_sh;

        $point[‘p‘] = null;

        $this->_open[] = $point;

        $this->_closed[$start] = $point;

        while ( 0 < count($this->_open) ) {

            $minf = false;

            foreach( $this->_open as $key => $maxNode ) {

                if ( $minf === false || $minf > $maxNode[‘f‘] ) {

                    $minIndex = $key;

                }

            }

            $nowNode = $this->_open[$minIndex];

            unset($this->_open[$minIndex]);

            if ( $nowNode[‘i‘] == $this->_end ) {

                $tp = array();

                while( $nowNode[‘p‘] !== null ) {

                    array_unshift($tp, $nowNode[‘p‘]);

                    $nowNode = $this->_closed[$nowNode[‘p‘]];

                }

                array_push($tp, $this->_end);

                break;

            }

            $this->_setPoint($nowNode[‘i‘]);

        }

        $this->_closed = array();

        $this->_open = array();

        return $tp;

    }

    private function _setPoint($me) {

        $point = $this->_grids[$me];

        // 所有可选方向入队列

        if ( $point & 1 ) {

            $next = $me - $this->_w;

            $this->_checkPoint($me, $next);

        }

        if ( $point & 2 ) {

            $next = $me + 1;

            $this->_checkPoint($me, $next);

        }

        if ( $point & 4 ) {

            $next = $me + $this->_w;

            $this->_checkPoint($me, $next);

        }

        if ( $point & 8 ) {

            $next = $me - 1;

            $this->_checkPoint($me, $next);

        }

    }

    private function _checkPoint($pNode, $next) {

        if ( $this->_closed[$next] ) {

            $_g = $this->_closed[$pNode][‘g‘] + $this->_getG($next);

            if ( $_g < $check[‘g‘] ) {

                $this->_closed[$next][‘g‘] = $_g;

                $this->_closed[$next][‘f‘] = $this->_closed[$next][‘g‘] + $this->_closed[$next][‘h‘];

                $this->_closed[$next][‘p‘] = $pNode;

            }

        } else {

            $point[‘p‘] = $pNode;

            $point[‘h‘] = $this->_getH($next);

            $point[‘g‘] = $this->_getG($next);

            $point[‘f‘] = $point[‘h‘] + $point[‘g‘];

            $point[‘i‘] = $next;

            $this->_open[] = $point;

            $this->_closed[$next] = $point;

        }

    }

    private function _getG($point) {

        return abs($this->_start - $point);

    }

    private function _getH($point) {

        return abs($this->_end - $point);

    }

}

延伸阅读

《编程实用算法实现整理》系列技术文章整理收藏

1算法导论:选择排序的原理与实现

2一道PHP冒泡排序算法笔试题

3WordPress的用户密码计算算法

4PHP实现四种常用的排序算法

5非常直观的数据结构与算法演示

6深入探讨各种背包算法问题

7图解插入排序算法

8图解堆排序Heap Sort算法

9约瑟夫环(Josephus)问题的C++算法模拟

10趣味算法之兔子产子问题

11一些常见算法的JavaScript实现

12趣味算法之猴子吃桃问题

13平方根sqrt()函数的底层算法效率

14二叉搜索树的一些相关算法介绍

15欧几里德算法(辗转相处法)练手

16蚂蚁爬木杆问题的算法思路

17计算机编程中一些重要的算法

18面试中常见的一些算法问题

19JavaScript排序算法之希尔排序

20JavaScript排序算法之堆排序

21JavaScript排序算法之归并排序

22JavaScript排序算法之选择排序

23JavaScript排序算法之快速排序

24JavaScript排序算法之冒泡排序

25JavaScript排序算法之插入排序

26合并排序算法解说与例子

27丑数Ugly Number查找算法

28求大数阶乘的算法

29各排序算法的C++实现与性能测试

30算法导论中一个蒙提霍尔问题

31实现一个栈并获取其最小元素

32亲身体验一下KMP算法

33面试算法题的快速思考方法

34矩阵逆时针旋转的算法

35Hash魔法:分布式哈希算法

36Hash魔法:一致性 hash 算法

37字符串逆序的各种实现算法

38用递归实现的快速排序

39收集一些top软件公司经典算法面试题

40趣味算法:猴子搬香蕉问题

41一些主流的个性化推荐算法评析

42趣味算法:生男生女的比例

43趣味算法:老鼠试毒瓶问题

44使用PHP内置的DES算法函数实现数据加密解密

45第九话:数据结构与算法的关系

46第12话:什么样的算法才是好算法

47第11话:算法的五个基本特征

48第13话:算法的性能分析

49第10话:什么是算法?

50第16话:算法的空间复杂度

51第15话:算法的最坏情况与平均情况

52第14话:如何计算算法的时间复杂度

53顺序栈的进栈操作

54顺序栈:栈的顺序存储结构

55栈的定义与大概理解

56栈的抽象数据类型ADT

57链栈:栈的链式存储结构

58链栈的进栈操作

59获取顺序栈的栈顶元素

60顺序栈的出栈操作

61为什么要使用栈这种数据结构

62链栈的置空操作与判断链栈是否为空

63递归,栈的重要应用之一

64栈是如何实现递归的

65链栈的出栈操作

66链栈的初始化与遍历

67漫谈递归:递归的思想

68漫谈递归:递归需要满足的两个条件

69漫谈递归:字符串回文现象的递归判断

70漫谈递归:二分查找算法的递归实现

71漫谈递归:递归的效率问题

72漫谈递归:递归与循环

73漫谈递归:循环与迭代是一回事吗?

74漫谈递归:从斐波那契开始了解尾递归

75漫谈递归:尾递归与CPS

76漫谈递归:补充一些Continuation的知识

77漫谈递归:PHP里的尾递归及其优化

78漫谈递归:从汇编看尾递归的优化

79快速排序里的学问:从猜数字开始

80快速排序里的学问:再看看称球问题

81快速排序里的学问:信息熵

82快速排序里的学问:快速排序的过程

83快速排序里的学问:霍尔与快速排序

84快速排序里的学问:霍尔快排的实现

85快速排序里的学问:枢纽元选择与算法效率

86快速排序里的学问:随机化快排

87Java程序员必须掌握的8大排序算法

88RSA,DSA等加解密算法介绍

89权限项目总结(一)权限设计

延伸阅读

版权声明:本文为博主原创文章,未经博主允许不得转载。

时间: 2024-10-14 14:57:43

PHP树生成迷宫及A*自动寻路算法的相关文章

PHP树生成迷宫及A*自己主动寻路算法

PHP树生成迷宫及A*自己主动寻路算法 迷宫算法是採用树的深度遍历原理.这样生成的迷宫相当的细,并且死胡同数量相对较少! 随意两点之间都存在唯一的一条通路. 至于A*寻路算法是最大众化的一全自己主动寻路算法 完整代码已上传,http://download.csdn.net/detail/hello_katty/8885779 ,此处做些简单解释,还须要大家自己思考动手.废话不多说,贴上带代码 迷宫生成类: /** 生成迷宫类 * @date 2015-07-10 * @edit http://w

原生js生成迷宫 (一)

这个系列分为两部分,第一部分为迷宫的生成及操作,第二部分为自动寻路算法. 我们先看效果: See the Pen QGKBjm by fanyipin (@fanyipin) on CodePen. 我们直入正题,先说一说生成迷宫的思路. 整个思路十分简单: 首先我们将迷宫视为一个m行n列的单元格组合,每一个单元格便可以表示为maze[i][j].接下来迷宫与m*n单元格的区别是什么呢?对,迷宫就是相当于不同单元格以某种规律相互连通,也就相当于我们把相邻的两个单元格之间的重合线给去掉,然后按照某

canvas——随机生成迷宫

先上图. 效果 代码 随机生成迷宫要求任意两点都能够找到相同的路径,也就是说,迷宫是一个连通图.随机生成迷宫可以使用普里姆算法.广度优先算法.深度优先算法等实现.这里将使用普里姆算法通过生成最小数的方法,实现迷宫图. 初始迷宫 迷宫有路和墙,白色表示路,黑色表示墙.每一个格子代表一个顶点,这里一共有100个顶点,需要找出99条边,使顶点连接起来,也就是要打通99块墙. 迷宫使用二位数组保存,为迷宫指定路的行数和列数,生成初始数组. 普利姆算法不了解的话,可以参考这篇博客的解析. /* * thi

hdu 1269 迷宫城堡 (tarjan算法学习)

迷宫城堡 Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others) Total Submission(s): 7056    Accepted Submission(s): 3137 Problem Description 为了训练小希的方向感,Gardon建立了一座大城堡,里面有N个房间(N<=10000)和M条通道(M<=100000),每个通道都是单向的,就是说若称某通道连通了A

迷宫的深度广度算法

解决杭电1010题目的意思就是求从开始点到终点的经过的边的个数和(即经过的总的点数减去一)等于给定的T 对于迷宫问题,由于所求的路径不一定是最短的,所以不适合用广度优先遍历. 基础知识 奇偶剪枝:t表示非最短路径走的步数,开始点为(sx,sy),结束点位(ex,ey) 那么从开始点到结束点的最短路径为 abs(ex-sx)+abs(ey-sy)  ,那么t-(abs(ex-sx)+abs(ey-sy))为非奇数, 因为步数是成对出现上下,左右. 还有一个修剪知识  假设 N行,M列矩阵中有wal

【BZOJ】3052: [wc2013]糖果公园 树分块+待修改莫队算法

[题目]#58. [WC2013]糖果公园 [题意]给定n个点的树,m种糖果,每个点有糖果ci.给定n个数wi和m个数vi,第i颗糖果第j次品尝的价值是v(i)*w(j).q次询问一条链上每个点价值的和或修改一个点的糖果ci.n,m,q<=10^5. [算法]树分块+带修改莫队算法 [题解]参考:WC 2013 糖果公园 park 题解 by vfleaking 首先树分块,参考王室联邦的方法.确定块大小为B,一遍DFS可以分成若干大小为[B,3B]的块,性质是块内两点距离至多为B. 定义(x,

Unity_Dungeonize 随机生成迷宫

本文对随机生成迷宫的实现思路进行记录,其作用在于为游戏过程提供随机性以及节省开发周期,下面是Dungeonize的结构 随机迷宫的生成主要包括几个阶段 1.生成房间体结构,为墙体,自定义房间,自定义物体生成平台 1 for (var i = 0; i < room_count; i++) { 2 Room room = new Room (); 3 if (rooms.Count == 0) { 4 //初始房间生成玩家和任务事件监听 5 room.x = (int)Mathf.Floor (m

深度优先算法生成迷宫——Python实现

import random #warning: x and y confusing sx = 10 sy = 10 dfs = [[0 for col in range(sx)] for row in range(sy)] maze = [[' ' for col in range(2*sx+1)] for row in range(2*sy+1)] #1:up 2:down 3:left 4:right operation = {1:(0,-1),2:(0,1),3:(-1,0),4:(1,0

自己动手写ORM(01):解析表达式树生成Sql碎片

什么是ORM框架:   ORM即对象关系映射(Object Relational Mapping,简称ORM),是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术.简单的说,ORM是通过使用描述对象和数据库之间映射的元数据,将程序中的对象自动持久化到关系数据库中. 自己也用过很多ORM框架,比如微软的EF,Hibernate.轻量级一点的有Depper等等.这些框架说白了就是让我们能像操作对象那样去操作数据库. 鄙人是个比较懒的程序猿,总想这写更少的代码做更多的事情,最近不是很忙,于是