第二章 趣味迷宫

最新推荐文章于 2015-10-18 22:01:55 发布
最新推荐文章于 2015-10-18 22:01:55 发布
阅读量1.6k 收藏
点赞数
分类专栏： 程序员之路 文章标签： 程序员之路
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/starcuan/article/details/19181969
版权


这一章来谈一谈迷宫的走法，以及做一个简单的迷宫游戏，可以自己DIY迷宫地图
我们将迷宫问题难度上升一点，就是找一条最近的路径走出迷宫
一般针对最短路径问题，bfs是最简单的选择，A*是较好的选择，但是A*过程较繁琐，今天我们将采用IDA*算法来实现这个寻找迷宫出口问题
算法思想和流程：
IDA*算法简单的讲就是迭代+A*的实现，因实现过程非常简单，而且效率还很优，所以掌握IDA*势在必行
1、没有学习IDA*算法以前，觉得如果是最短路径问题，则dfs是无法实现的，bfs可以实现，但是IDA*告诉了我dfs怎么实现最短路径问题，而且实现的更好
2、、回顾下IDA*的步骤，没有了A*的优先队列，甚至连bfs广搜所需的简单队列和判重数组都不用，从一个阈值开始递归，这个值一般可以理解为递归的最大深度，若找不到目标点，则这个值进行扩大，列入++操作，再重新递归操作，找到则返回，返回的一定是最优值
3、回顾下IDA*的判断函数（IDA*的精髓啊）：当前局面的估价函数值+当前的搜索深度 > 预定义的最大搜索深度时，就进行剪枝。
实现起来较容易，代码量也很少 
//最近的路走出迷宫
//IDA*算法实现
#include <iostream>
using namespace std;

#define M 15//行
#define N 20//列
int map[][N]={
	{0,0,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1},
	{1,0,1,0,1,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1},
	{1,0,1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,0,1},
	{1,0,1,0,1,0,0,0,1,0,1,0,1,0,1,0,0,1,0,1},
	{1,0,1,0,1,1,1,0,1,0,1,0,1,0,1,1,0,1,0,1},
	{1,0,0,0,0,0,0,0,1,0,0,0,1,0,0,0,0,1,0,1},
	{1,0,1,1,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1},
	{1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1},
	{1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1},
	{1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1},
	{1,0,1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1},
	{1,0,1,0,1,0,1,0,0,0,0,0,0,0,0,0,0,1,0,1},
	{1,0,1,0,1,0,1,1,1,1,1,1,1,1,1,1,0,1,0,1},
	{1,0,0,0,1,0,0,0,0,0,0,0,0,0,0,1,0,0,0,1},
	{1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,0,0}
};
int dir[][2]={-1,0,0,-1,1,0,0,1};
int starti=0,startj=0;//开始点坐标
int endi=M-1,endj=N-1;//结束点坐标
int maxDeep;//最大深度
int H(int i,int j){//估价函数
	return abs(endi-i)+abs(endj-j);
}

bool dfs(int curi,int curj,int depth){
	if(depth+H(curi,curj)>maxDeep)//IDA*估价剪枝
		return false;
	if(curi==endi&&curj==endj)
		return true;
	
	for(int i=0;i<4;i++){
		int ni=curi+dir[i][0];
		int nj=curj+dir[i][1];
		if(ni>=0&&ni<M&&nj>=0&&nj<N&&map[ni][nj]==0){
			map[ni][nj]=2;
			if(dfs(ni,nj,depth+1))return true;
			map[ni][nj]=0;
		}
	}
	return false;
}
int IDAstar(){
	maxDeep=H(starti,startj);
	map[starti][startj]=2;
	while(!dfs(starti,startj,0))maxDeep++;
	return maxDeep;
}
int main(){
    cout<<IDAstar();
    return 0;
}

下面我们的主要任务就是做一个这样的游戏了，可以模拟动态的走出这个迷宫，还可以自己DIY通路和障碍，动手开始吧
HTML代码如下，只要复制粘贴，保存html打开就能见到后面的效果了 
<!DOCTYPE html>
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
<meta http-equiv="Content-Type" content="text/html; charset=utf-8"/>
    <title></title>
<style type="text/css">
body,div,h2,ul,li{margin:0;padding:0;}
body{font:12px/1.5 Arail;}
.box{width:860px;margin:10px auto;background:#eee;border:1px solid #b8b8b8;overflow:hidden}
.title{height:30px;line-height:30px;font-size:14px;padding:0 15px 0 35px;border-bottom:1px solid #b8b8b8;background:#fafafa url(http://js.alixixi.com/img/mm/ico.gif) 5px 50% no-repeat;}
.title span{float:left;}
.title a{float:right;color:#06f;outline:none;}
.title a:hover{color:red;}
    .box .tool {
        width:300px;
        float:left;
    }
    .box .content {
        width:480px;
        margin-left:310px;
    }
    .tool div {
        margin:10px auto;
        height:40px;
        text-align:center;
    }
    .content .tag {
        height:30px;
        line-height:30px;
    }
    .content td {
        width:10px;
        height:10px;
        font-size:xx-large;
        line-height:10px;
        border:1px solid #c3c3c3;
        background:#fff;
        text-align:center;
    }
</style>
<script type="text/javascript">
    //一些常量
    
    var matrix = [
	[0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1],
	[1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1],
	[1, 0, 1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1],
	[1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 1],
	[1, 0, 1, 0, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 1],
	[1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1],
	[1, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1],
	[1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1],
	[1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1],
	[1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1],
	[1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1],
	[1, 0, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1],
	[1, 0, 1, 0, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 1],
	[1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1],
    [1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0]
    ];
    var M = 15, N = 20;
    var dir = [[-1, 0], [0, -1], [1, 0], [0, 1]];
    var starti = 0, startj = 0;//开始点坐标
    var endi = M - 1, endj = N - 1;//结束点坐标
    function H(i,j){//估价函数
        return Math.abs(endi - i) + Math.abs(endj - j);
    }

    var BLACK="#000";
    var BLUE="#06f";
    var WHITE="#fff";
</script>
<script type="text/javascript">
    //一些公共函数
    //获取ID
    var $ = function (id) { return typeof id === "string" ? document.getElementById(id) : id };
    //获取tagName
    var $$ = function (tagName, oParent) { return (oParent || document).getElementsByTagName(tagName) };
    //获取class
    var $$$ = function (sClass, oParent) {
        var aClass = [],
        i = 0,
        reClass = new RegExp("(\\s|^)" + sClass + "($|\\s)"),
        aElement = $$("*", oParent);
        for (i = 0; i < aElement.length; i++) reClass.test(aElement[i].className) && aClass.push(aElement[i]);
        return aClass
    };
</script>
<script type="text/javascript">
    //创建数独对象
    var Maze = function () { this.initialize.apply(this, arguments) };
    Maze.prototype = {
        initMatrix: function (matrix,Map) {
            for (var i = 0; i < M; i++) {
                matrix[i] = new Array(N);
                for (var j = 0; j < N; j++) {
                    matrix[i][j] = Map[i][j];
                }
            }
        },
        renewMatrix: function (matrix,Map) {
            for (var i = 0; i < M; i++) {
                for (var j = 0; j < N; j++) {
                    matrix[i][j] = Map[i][j];
                }
            }
        },
        initialize: function (obj ,Map) {
            var oThis = this;
            this.Parent = $(obj);//获得table对象
            this.Table = $$("table", this.Parent)[0];
            this.tag = $$$("tag", this.Parent)[0];
            this.ButtonA = $$$("answer", this.Parent)[0];
            this.ButtonB = $$$("restore", this.Parent)[0];
            this.ButtonC = $$$("show", this.Parent)[0];
            this.ButtonD = $$$("diy", this.Parent)[0];

            this.matrix = new Array(M);//存放数独矩阵
            this.diyMatrix = new Array(M);//diy迷宫
            this.Td = [];//table中的所有td列矩阵

            this.maxDeep = 0;
            this.stime = null;//计时

            this.initMatrix(this.matrix, Map);
            this.initMatrix(this.diyMatrix, Map);

            this.dom = document.documentElement || document.body;
            this.ButtonA.onclick = function () {
                oThis.tag.innerText = "运行";
                oThis.initOperation();
                oThis.show();
                oThis.answer();
                oThis.print();
            }
            this.ButtonB.onclick = function () {
                oThis.tag.innerText = "还原迷宫";
                oThis.initOperation();
                oThis.show();
            }
            this.ButtonC.onclick = function () {
                oThis.tag.innerText = "显示答案";
                oThis.initOperation();
                oThis.answer();
                oThis.show();
            }
            this.ButtonD.onclick = function () {
                oThis.tag.innerText = "DIY迷宫";
                oThis.initOperation();
                oThis.show();
                oThis.diy();
            }
            this.create(Map);
        },
        initOperation: function () {//初始化操作
            var oThis = this;
            oThis.renewMatrix(oThis.matrix, oThis.diyMatrix);
            clearInterval(oThis.stime);
        },
        create: function (Map) {
            var oThis = this;
            var aFrag = document.createDocumentFragment();
            var i = 0, j = 0;
            for (i = 0; i < M; i++) {
                var tr = document.createElement("tr");
                oThis.Td.push([]);
                for (j = 0; j < N; j++) {
                    var td = document.createElement("td");
                    if (Map[i][j] == 1) td.style.backgroundColor = BLACK;
                    oThis.Td[i].push(td);
                    
                    tr.appendChild(td);
                }
                aFrag.appendChild(tr);
            }
            this.Table.appendChild(aFrag);
        },
        print: function () {
            var oThis = this;
            var curi = starti, curj = startj;
            var preDir = -3;//访问的上一个方向
            
            this.stime = setInterval(function () {
                oThis.Td[curi][curj].style.backgroundColor = BLUE;
                if (curi == endi && curj == endj) clearTimeout(oThis.stime);
                for (var i = 0; i < 4; i++) {
                    var ni = curi + dir[i][0];
                    var nj = curj + dir[i][1];
                    if (ni >= 0 && ni < M && nj >= 0 && nj < N && Math.abs(i - preDir) != 2 && oThis.matrix[ni][nj] == 2) {
                        curi = ni, curj = nj;
                        preDir = i;
                        break;
                    }
                }
            }, 100);
        },
        show: function () {
            for (var i = 0; i < M; i++)
                for (var j = 0; j < N; j++) {
                    if (this.matrix[i][j] == 2)
                        this.Td[i][j].style.backgroundColor = BLUE;
                    else if (this.matrix[i][j] == 1)
                        this.Td[i][j].style.backgroundColor = BLACK;
                    else this.Td[i][j].style.backgroundColor = WHITE;
                }
        },
        find:function(obj){
            for (var i = 0; i < M; i++)
                for (var j = 0; j < N; j++)
                    if (this.Td[i][j] == obj)
                        return { i: i, j: j };
        },
        diy: function () {
            var oThis=this;
            for (var i = 0; i < M; i++) {
                for (var j = 0; j < N; j++) {
                    this.Td[i][j].onclick = function () {
                        var pos = oThis.find(this);
                        var i=pos.i,j=pos.j;
                        if (oThis.diyMatrix[i][j] == 0) {
                            oThis.diyMatrix[i][j] = 1;
                            this.style.backgroundColor = BLACK;
                        } else {
                            oThis.diyMatrix[i][j] = 0;
                            this.style.backgroundColor = WHITE;
                        }
                    }
                }
            }
        },
        answer: function () {
            this.IDAstar();
            //this.show();
        },
        dfs:function(curi, curj, depth) {
        
            if (depth + H(curi, curj) > this.maxDeep)//IDA*估价剪枝
                return false;
            if (curi == endi && curj == endj)
                return true;

            for (var i = 0; i < 4; i++) {
                var ni = curi + dir[i][0];
                var nj = curj + dir[i][1];
                if (ni >= 0 && ni < M && nj >= 0 && nj < N && this.matrix[ni][nj] == 0) {
                    this.matrix[ni][nj] = 2;
                    if (this.dfs(ni, nj, depth + 1) == true) return true;
                    this.matrix[ni][nj] = 0;
                }
            }
            return false;
        },
        IDAstar:function(){
            this.maxDeep = H(starti, startj);
            this.matrix[starti][startj]=2;
            while (this.dfs(starti, startj, 0) == false) {
                if (this.maxDeep > 100) break;
                this.maxDeep = this.maxDeep + 1;
            }
        }
    };
    window.onload = function () {
        var Box = $$$("box");
        //创建实例
        new Maze(Box[0], matrix);
    };
</script>
</head>
<body>
<div class="box">
    <h2 class="title"><span>迷宫模拟</span></h2>

    <div class="tool">
        <div><button class="answer">运行</button></div>
        <div><button class="restore">还原迷宫</button></div>
        <div><button class="show">显示答案</button></div>
        <div><button class="diy">DIY迷宫</button></div>
    </div>

    <div class="content">
        <div class="tag">默认迷宫</div>
        <table class="sudoku">
            
        </table>
    </div>
</div>

</body>
</html>



效果如下：
初始状态：

点击运行：
蓝色条会一直动
点击显示答案会将最近的路径显示出来
点击DIY迷宫可以自己DIY，然后再点击运行或者显示答案，会重新计算结果


后记：
我一直觉得编程没有那么枯燥，也可以是玩出来的


王川
2014/2/13
_王川
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
07-05
通过alpha-belta剪枝的极大极小值算法实现简单的五子棋+A*算法与IDA*算法解决走迷宫问题
对于DFS，BFS，A*与IDA*等寻路算法的总结跟感悟
热门推荐
漏れた玩具博客
01-01 1万+
一周前看见了贪吃蛇AI算法，受到震撼于是就把以前的win32贪吃蛇加了个AI实现，让我这个渣渣写了好几天才完工，终于能吃完全屏了，虽然离自己看的那个贪吃蛇AI的gif还有些距离emmmm，贪吃蛇AI不可避免的用到了寻路算法，所以今天当做复习总结提一提， 不说了，进入正题吧，常见的搜索有深度优先搜索，广度优先搜索，迭代加深搜索，双向广度优先先搜索，A*搜索，IDA*搜索等，这些搜索分为盲...
HDU 1813 Escape from Tetris (IDA*)
ithome
09-26 110
传送门：http://acm.hdu.edu.cn/showproblem.php?pid=1813 题意：给你一个n*n的迷宫，其中0代表有一个人在这个位置，1代表墙，现在要求一个路线，使所有的人通过这个路线都可以走到迷宫的边界 注意当到达边界就相当于出去了不用继续走了，一个格子可以容纳很多人。 题解：先用BFS求出迷宫内部的点走到边界的最小步数（为了后面的IDA*剪枝），因为有很多状...
泳池迷宫
leafinsnowfield的专栏
07-26 734
class PoolPuzzleOne { public static void main(String[] args) { int x=0; while(x<4) { x=x-1; if(x<1) { System.out.print("a"); System.out.print(" "); System.out.print("nois
Head First Java第2章练习泳池迷宫
蒙面人的小黑屋
10-19 3681
为了输出对比更明显，稍稍更改了下： 1、最后输出e2.count=10代码： public class EchoTest{ public static void main(String[] args){ Echo e1=new Echo(); Echo e2=new Echo(); int x=0; while(x<4){ System.out.print("此时x
10以内加法迷宫，趣味练习，幼小衔接
最新发布
05-07
"10以内加法迷宫"是一种创新的教学方法，旨在通过趣味性的方式帮助孩子们理解和掌握10以内的加法运算。这种方法将传统的数学学习与游戏元素结合，激发孩子的学习兴趣，提高他们的计算能力和逻辑思维。 在"10以内...
深入浅出强化学习原理入门-第二章作业-迷宫
01-28
在本项目中，我们主要探讨的是强化学习的基本概念和应用，特别是通过一个具体的实例——迷宫问题，来深入了解马尔可夫决策过程（Markov Decision Process, MDP）。强化学习是一种机器学习方法，它通过与环境的交互，...
java 二维数组 随机生成迷宫
10-20
在Java编程中，二维数组常被用来表示矩阵或者游戏中的地图，包括生成迷宫这样的问题。迷宫生成是一种常见的算法挑战，它涉及到随机性、路径探索以及数据结构的使用。本篇文章将深入探讨如何利用二维数组来随机生成...
6.5英寸二分频迷宫式音箱数模.stp
05-27
6.5英寸二分频迷宫式音箱数模，diy 3d数模，供音响爱好者参考，喇叭孔请根据喇叭的实际尺寸开，固定螺丝最好使用钢丝螺套
C语言程序设计趣味迷宫
03-30
#include main() { int a,b; scanf("%d,%d",&a,&b); max(a,b); printf max; }
人脸照片生成趣味迷宫
架构设计
07-21 242
每个人的脸轮廓、眼睛、鼻子、嘴巴的特征不同，就拿眼睛来说，眼睛有单双眼皮、大小和瞳孔位置的特征参数，我们可以通过组合这些参数得到不同的眼睛，每种眼睛对应一个精心设计的、外形类似但规则的迷宫，我们检测人脸照片，识别眼睛属于哪个模型，进而用迷宫替换。这样本来的人脸照片便处理成由四个迷宫组成的人脸迷宫。基本可以保证每个人的迷宫会互不相同，同时保留人脸特征。 技术难点：1、单独提取脸轮廓、眼睛、鼻子、嘴...
A*和IDA*算法
kaqiur
10-18 3933
A*算法（A-Star） 为了赋予计算机“智慧”，我们必须更有智慧（:-P），计算机可以通过一个“估价函数”确定一个状态的“前途”的量，人呢……必须找到这个估价函数。 通常，估价函数计为f^(n)，f^中，^在f上方，读作f-hat（帽子）。估价函数的定义如下： f^(n)=g^(n)+h^(n) n是状态的表示，通常是状态的编号之类的。在编程中，可以写作f_hat()或者直接写成
[Wikioi 1215]迷宫
某沙茶的OI代码库
05-09 1345
#include #include #include #include #define MAXN 20 using namespace std; int map[MAXN][MAXN],n; //map[第i行][第j列]=0:该格无障碍，1:该格有障碍,mx=最终要到达的点的行数，my=最终要到达的点的列数 int visit[MAXN][MAXN];//visit数组记录
第十四章 我的毕业之作—苏州大学过程化管理系统
王川的私房菜
03-11 3327
大四上学期忙活着考研，虽然考研不顺利，但是上学期着急忙慌的在所难免，没做什么事情，也没有找工作，所以去年6月份接的项目一直推迟到现在才算大功告成。这虽然不是我做的最后一个项目，但是这是我的毕业设计，导师就是我一直跟随的陈老师。 这个系统在我所做的这几个系统中算是代码量最大的系统了，而且，也将成为今后苏大所有老师给学生打成绩的媒介，（呵呵，这应该也算是一种牛B吧，虚荣下） 代码实现方面到没有什么
第一章 趣味数独
王川的私房菜
02-12 2836
我一直觉得编程是一件极其有意思的事情，虽然没有特别聪明的头脑，也没有对某领域做过深入研究（其实也不知道要研究哪些领域，老师觉得研究哪个领域都可，要看以后做什么了，不知道这么想对不对，但有一点一定是正确的，那就是打好基础，将基本的数据结构和算法掌握透彻才是现在的王道），但很是着迷于一些算法、密码什么的，我本人不太喜欢看书，所以大部分事情都是在电脑上进行，刷了LeetCode上的150题，并对这些题深
第五章 图着色问题
王川的私房菜
02-18 2571
图着色问题是最著名的NP-完全问题，由此还引出了著名的四色定理，四色猜想还曾是一百年来历史上最难的数学难题之一，当然，我不是学数学的，对这些猜想证明一窍不通，也不感冒，但是，图着色问题作为一道算法题目确是很值得研究的，所以作为一名的大学生程序员的我，把它另作一章是无可厚非的 问题描述自不必多说，对于这个问题，我首先想到的就是用搜索+回溯的思想，一个一个的去试，先拿1种颜色图，不行再加一种，等等，
第四章 微信飞机大战
王川的私房菜
02-16 2190
微信打飞机的游戏前段时间曾风靡一时，这一章再贴一款游戏，网上叫JetBrains WebStorm的人实现的不错，特此贴上他的代码，代码注释比较齐全，里面没有很难理解的算法，之所以加这一章，是因为我们在写代码时不仅要实现（即算法），更多的时候要求的是算法的质量。鉴于这款游戏复杂度不高，实现较容易，看一看大牛人的实现代码，有很大的借鉴意义，将主体代码贴上， 文件下载：
C语言教程：第七章-递归编程解析
"C语言第七章-递归完整版资料.ppt" C语言的第七章主要聚焦于递归这一编程概念，这是程序设计中一个非常重要且基础的工具。递归是解决问题的一种策略，它通过调用自身来解决更小规模的相同问题，直到达到基本情况...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值