数据结构学习笔记--迷宫

原创 2007年10月06日 20:39:00
 
人类建造迷宫已有5000年的历史。在世界的不同文化发展时期,这些奇特的建筑物始终吸引人们沿着弯弯曲曲、困难重重的小路吃力地行走,寻找真相。关于迷宫,有一个引人入胜的希腊神话,这也是为什么现今每当人们提到这个问题,总是兴致勃勃(对于年青人,估计是RPG玩多了)。这则神话讲的是,从前弥诺斯王统治着克里特岛。有一年,他没有给海神波塞冬送去允诺的祭物公牛,海神十分生气,决意报复。他附体在公牛身上,勾引了弥诺斯王的妻子帕西法厄王后。不久,王后生下一个牛首人身的怪物弥诺陶洛斯(Minotaur)。为了把怪物藏起来避免家丑外扬,弥诺斯王命令岛上最优秀的工匠代达罗斯造了一座迷宫:一所稀奇古怪的地下房子,走廊离亮处越来越远,根本找不到出口。发狂的弥诺陶洛斯在一堵堵墙壁之间徘徊游荡,左突右冲,以雅典王进贡的童男童女充饥。终于有一天,雅典王子忒修斯(Theseus)带着宝剑冒充进贡的童男进入迷宫。他一路退下弥诺斯王的女儿阿里阿德涅送给他的线团的线,杀死了牛头怪物弥诺陶洛斯,又沿着这根线找到出口,活着离开迷宫...
迷宫其实是专为人设计的,因为人的记忆力有限,在庞大复杂的迷宫内记住所走过的每一条路是很困难的。记得当初玩那部经典的DOS版仙剑时深有体会,游戏基本上就是一开始先角色间对话,然后开始走迷宫,在迷宫的最深处或出口总有一个BOSS等着你,等干掉BOSS后再是对话、走迷宫。游戏就在走迷宫、杀BOSS、再走迷宫这样的模式下循环反复。虽然模式简单但却吸引了一大批玩家为此乐此不疲,乃至续篇不断(现在好象出到四了)。可以说游戏的灵魂设计就在迷宫中,如果没有了迷宫,估计也没多少人像现在这样津津乐道了。
好啦,说了这么多,还是来研究一下怎么让计算机走迷宫吧。以下先讨论两种最普遍的方法,即回溯法与递归法,在最后将介绍一种“另类”的方式,这种算法思想最初是由玩家提出来的。以下所有代码均采用C++编写。并在WINXPsp2+VC6/MinGW2.05下调试通过。
一、回溯
回溯法使用栈的方式,这与当初忒修斯使用的方法很像,只不过这里用栈代替了英雄手中的线团。简单描述一下:每到达一个能走的新位置时都要把当前位置与来时的方向压栈,当遇到死路时就弹出栈顶位置,顺着下一方向继续走,直到到达出口(找到一条通路)或退回到入口(迷宫没有出口)时结束。若到达出口,此时从入口到出口的一条通路就保存在栈中,依次弹出并输出即可。下面是具体实现。
给出代码前先说两句,为了便于比较,我将3种算法类统一了一下接口,3个类均从基类Player派生。基类Player定义了公用的成员函数:计算下一位置的NextPos(),判断当前位置是否可通的CanPass(),以及标记当前位置的MarkPrint()。对外接口有两个:与迷宫类相连接的PutInto()、搜寻路径的SeekPath()。基类中有两个保护型成员变量:类指针pMaze指向待探索的迷宫类Maze,整型数组指针mark指向迷宫数据的本地拷贝,供CanPass()与MarkPrint()使用。Maze类中存储了迷宫的相关数据,包括迷宫有多少行、多少列,用来表示迷宫的一维整型数组的大小以及出入口的位置。在Maze类中重载了全局的>>运算符用来输入迷宫数据,并且构造函数内定义了一个默认的迷宫(就是书上那个)。此外还有一个点类Point,用来表示迷宫中的每一个位置。由于所有类都要用到所以把它放入一个单独的文件里。
所有类的定义与实现都放在了一个头文件里面,下面给出该文件的第一部分:(很长,作好心理准备^_^)
 
#ifndef MAZE_H
#define MAZE_H
#include 
"../Stack.h"
#include 
"Point.h"
#include 
<iostream>
#include 
<string>
class Maze {
    
//迷宫的四周加上墙壁
    void AddWall() {
        
for (int x = 0; x < col; x++)
            data[x] 
= data[(row - 1* col + x] = 1;
        
for (int y = 1; y < row - 1; y++)
            data[y 
* col] = data[y * col + col] = 1;
    }
public:
    
int* data;//迷宫数据,用一维整型数组表示
    int row;//最大行数
    int col;//最大列数
    int size;//数组大小
    Point entry;//入口坐标
    Point exit;//出口坐标
    Maze() : row(10), col(10), size(100) {
        
//默认迷宫数据
        int dat[100= {
            
1,1,1,1,1,1,1,1,1,1,
            
1,0,0,1,0,0,0,1,0,1
            
1,1,0,1,0,0,0,1,0,1,
            
1,0,0,0,0,1,1,0,0,1,
            
1,0,1,1,1,0,0,0,0,1,
            
1,0,0,0,1,0,0,0,1,1,
            
1,0,1,0,0,0,1,0,0,1,
            
1,0,1,1,1,0,1,1,0,1,
            
1,1,0,0,0,0,0,0,0,1,
            
1,1,1,1,1,1,1,1,1,1
        };
        data 
= new int[100];
        
for (int i = 0; i < 100; i++)
            data[i] 
= dat[i];
        entry.X 
= entry.Y = 1;
        exit.X 
= exit.Y = 8;
    }
    
~Maze() { delete []data; }
    friend std::istream
& operator>>(std::istream& is,
        Maze
& maze) {
        
using namespace std;
        cout 
<< "输入迷宫宽度(列数):" << endl;
        
is >> maze.col;
        maze.col 
+= 2;
        cout 
<< "输入迷宫高度(行数):" << endl;
        
is >> maze.row;
        maze.row 
+= 2;
        maze.size 
= maze.row * maze.col;
        
if (maze.data)
            delete []maze.data;
        maze.data 
= new int[maze.size];
        maze.AddWall();
        cout 
<< "输入迷宫数据(空格分离):" << endl;
        
for (int i = 1; i < maze.row - 1; i++)
            
for (int j = 1; j < maze.col - 1; j++)
                
is >> maze.data[i * maze.col + j];
        cout 
<< "输入入口坐标(空格分离):" << endl;
        
is >> maze.entry;
        cout 
<< "输入出口坐标(空格分离):" << endl;
        
is >> maze.exit;
        cout 
<< "迷宫创建完毕!" << endl;
        
return is;
    }
};
class Player {
protected:
    Maze
* pMaze;//指向某一迷宫
    int* mark;//搜寻时做标记用
    
//得到下一位置
    Point NextPos(Point cur, int direct) {
        direct 
% 2 ? cur.Y += 2 - direct 
            : cur.X 
+= 1 - direct;
        
return cur;
    }
    
//判断当前位置是否可通
    bool CanPass(Point cur) {
        
return mark[cur.Y * pMaze->col + cur.X] 
            
? false : true;
    }
    
//标记当前位置
    void MarkPrint(Point cur) {
        mark[cur.Y 
* pMaze->col + cur.X] = 1;
    }
public:
    Player() : pMaze(
0), mark(0) {}
    
virtual ~Player() { delete []mark; }
    
//连接到指定迷宫
    void PutInto(Maze* maze) {
        pMaze 
= maze;
        mark 
= new int[maze->size];
        
//将迷宫数据复制到mark中
        for (int i = 0; i < maze->size; i++)
            mark[i] 
= maze->data[i];
    }
    
//搜寻函数
    virtual void SeekPath() = 0;
};
class StackSeek : public Player {
    
struct Path {
        
int order;
        Point seat;
        
int direct;
        Path() : order(
0), direct(0) {}
        Path(
int ord, Point po, int di)
            : order(ord), seat(po), direct(di) {}
    };
    Stack
<Path> s;//保存路径的工作栈
    
//输出一条通路
    void PrintPath() {
        
using namespace std;
        
while (s.GetLength()) {
            Path path 
= s.pop();
            cout 
<< path.seat;
        }
        cout 
<< "完毕!" << endl;
    }
public:
    
void SeekPath() {
        
using namespace std;
        cout 
<< "栈式搜索:" << endl;
        Point curpos 
= pMaze->entry;
        
int curstep = 1;
        
do {
            
//若当前位置可通则将当前位置压
            
//栈,向当前位置的东方向继续探索
            if (CanPass(curpos)) {
                MarkPrint(curpos);
                s.push(Path(curstep, curpos, 
0));
                
if (curpos == pMaze->exit) {
                    PrintPath();
                    
return;
                }
                curpos 
= NextPos(curpos, 0);
                
++curstep;
            } 
else {
                
if (s.GetLength()) {//栈未空
                    
//依次弹出栈顶4个方向均探索过的位置
                    Path LastPath = s.pop();
                    
while (LastPath.direct == 3 && s.GetLength()) {
                        MarkPrint(LastPath.seat);
                        LastPath 
= s.pop();
                    }
                    
//若栈顶位置还有未探索的方向则继续探索下一位置
                    if (LastPath.direct < 3) {
                        LastPath.direct
++;
                        s.push(LastPath);
                        curpos 
= NextPos(LastPath.seat, LastPath.direct);
                    }
                }
            }
//if (CanPass(curpos))
        } while (s.GetLength());
        cout 
<< "迷宫没有通路!" << endl;
    }
//SeekPath()
};
因为只有回溯法需要设立一个栈来保存位置信息,所以表示位置信息的结构Path定义在了StackSeek类的私有部分。Player类只包括3个算法类的公共部分,它是不完整的,所以将SeekPath()定义成纯虚函数,表明Player类不可直接实例化。当初为了更好地体现类的封装特性,把Maze类中的所有变量都设成私有的了,然后将Player类声明为Maze类的友元。结果编译时报错,这才想起友元的特权是不能被继承的,只好作罢。注意代码中的第一句:#include “../Stack.h”,这里就不给出Stack.h文件的具体内容了,因为我的栈类是从之前学习线形表时做过的单链表类派生出来的,如果在这里把所有连带的结点类、线形表类、链表类都搬上来那就显得太罗嗦了,而且也没有必要。如果想测试代码可以自己写一个Stack类,非常简单,这里只用到了push()、pop()与GetLength()函数,网上都有标准实现的。下面给出Point.h文件的内容:
#ifndef POINT_H
#define POINT_H
class Point {
public:
    
int X;
    
int Y;
    Point(
int x = 0int y = 0
        : X(x), Y(y) {}
    
bool operator==(const Point& po) {
        
return X == po.X && Y == po.Y ?
            
true : false;
    }
    friend std::istream
& operator>>(std::istream& is,
        Point
& po) {
        
is >> po.X >> po.Y;
        
return is;
    }
    friend std::ostream
& operator<<(std::ostream& os,
        Point
& po) {
        os 
<< "(" << po.X << "," << po.Y << ")";
        
return os;
    }
};
#endif
 
在Point类中除了用来表示坐标的两个公有成员变量X、Y以外还重载了输入输出和判等运算符,为了以后少写点代码。
二、递归
一般来说栈与递归是可以相互转化的,使用递归的地方都可以改成栈的方式,反过来也一样。但在求解迷宫问题时,栈与递归代表了两种不同的指导思想,如果说栈式的搜索方法象征着英雄忒修斯的话,那么使用递归法则更像一位手握大权的领导。当他站在迷宫入口处时,他才懒得亲自去走,这时这位领导会吩咐他的手下,让他们分别向着迷宫的各个方向去探索;当遇到岔路口时留一个人守在这里,再分出几股人,朝着每个方向继续探索;最后总会有一个人发现出口。发现出口的这个人将出口的位置报告给离他最近的路口处留守的人,再由这个人报告给上一个路口的人,依次层层上报,最后消息传到了领导那里,于是这位领导就顺着这条画好的通路大摇大摆地通过了迷宫。
了解了这种思想后对于递归法就很好理解了。在递推的过程中实际上是系统自动地进行了压栈,而在回归时又自动地进行了弹栈,只不过这个栈位于系统的堆栈区,对普通用户来说是不可见的。下面给出算法实现,也就是Maze.h这个大文件的第二部分:
class RecursionSeek : public Player {
    
bool seek(Point cur) {
        
using namespace std;
        
if (cur == pMaze->exit) {//发现出口
            cout << pMaze->exit;
            
return true;//回溯
        }
        
//探索当前位置的4个方向
        for (int direct = 0; direct < 4; direct++) {
            Point next 
= NextPos(cur, direct);
            
if (CanPass(next)) {
                MarkPrint(next);
                
if (seek(next)) { //此方向可找到出口
                    cout << cur;  //打印当前位置
                    return true;
                }
            }
        }
        
return false;
    }
public:
    
void SeekPath() {
        
using namespace std;
        cout 
<< "递归式搜索:" << endl;
        
if (seek(pMaze->entry))
            cout 
<< "完毕!" << endl;
        
else
            cout 
<< "迷宫没有通路!" << endl;
    }
};
 
比起StackSeek类来说,使用递归算法的类要简短地多,这也说明了递归程序的好处:简洁清晰、可读性强。这里只说一点,因为栈与递归都是等探索完成之后才开始“走”的,所以这两种方法最后打印出的路径是从出口到入口的,如果想倒过来也很简单,可以每次把位置坐标先压入一个栈中,等到全部完成后再依次弹栈打印。
三、另一种方法
简单说完前面两种常规方法后,下面再来看另一种搜寻迷宫的方式,那就是“贴着一边走”。还记得在玩游戏时是怎么走迷宫的吗?不算那些边走边画地图的迷宫“狂人”,一般玩家都知道,走迷宫时只要贴着一边的墙走就肯定能走出去,见下图:

  
这个迷宫就是书上的例图。图中蓝色线条表示贴着左侧墙壁走的路线,红色线条的是右侧。这种方法虽效率不高,但最适合人的思维模式,因为根本不用记走过的路,简单可靠,而且实现起来也很容易。拿靠左边走来说,每走一步时先看左侧能走不,能就向左转,否则再看前方能不能走,能的话就朝前走,否则就向右拐。这种方法的缺点也很明显:点儿背的时候要走很多冤枉路。所以严格来说这种方式谈不上一种算法,下边给出具体实现:(Maze.h文件的最后一部分)
class StupidSeek : public Player {
    
bool LFirst; //true左转优先flase右转优先
    std::string habits;
    
int face; //当前面对的方向
    void TurnLeft() {
        face 
= (face + 3% 4;
    }
    
void TurnRight() {
        face 
= (face + 1% 4;
    }
public:
    StupidSeek(
const std::string& str) {
        LFirst 
= str == "left first" ? true : false;
        habits 
= LFirst ? "(贴着左墙走)" : "(贴着右墙走)";
    }
    
void SeekPath() {
        
using namespace std;
        cout 
<< "傻瓜式搜索:" << habits << endl;
        Point curpos 
= pMaze->entry;
        face 
= 0;
        
while (1) {
            
if (curpos == pMaze->exit) {
                cout 
<< curpos;
                
break;
            }
            
//
            
//为便于说明以下注释均假设
            
// LFirst=true,即贴左墙走
            
//
            
//若左边通则左拐
            if (CanPass(NextPos(curpos, (face + (LFirst ? 3 : 1)) % 4))) {
                cout 
<< curpos;
                LFirst 
? TurnLeft() : TurnRight();
                curpos 
= NextPos(curpos, face);
            
//若左边不通而前方可通则直行
            } else if (CanPass(NextPos(curpos, face))) {
                cout 
<< curpos;
                curpos 
= NextPos(curpos, face);
            
//左边与前面均不通则右拐
            } else 
                LFirst 
? TurnRight() : TurnLeft();
        }
        cout 
<< "完毕!" << endl;
    }
};
#endif
 
上述算法将贴两边走都实现了,测试时只须传给构造函数一个字符串”left first”或”right first”,用以区别两种模式。我总觉得计算机使用这种方法感觉很傻,所以叫傻瓜式搜索,呵呵~
OK,3种算法都讲完了,下边该测试了,首先用书上给出的迷宫进行测试,如果把#define TEST前的注释去掉,可以测试我随便做的一个5*5的迷宫。
#include "Maze.h"
//#define TEST
#if defined TEST
#include 
<sstream>
#endif
int main() {
    Maze maze;
//使用默认迷宫测试
#if defined TEST
    std::stringstream input(
"/
        5 5 /
        
0 1 0 1 1 /
        
0 0 0 1 1 /
        
0 1 0 0 0 /
        
0 0 1 0 1 /
        
1 0 1 0 0 /
        
1 1 5 5 /
    
");
    input >> maze;
#endif
    
//请来4个家伙
    Player* hero = new StackSeek;
    Player
* leader = new RecursionSeek;
    Player
* fool = new StupidSeek("left first");
    Player
* blockhead = new StupidSeek("right first");
    
//统统扔到迷宫里
    hero->PutInto(&maze);
    leader
->PutInto(&maze);
    fool
->PutInto(&maze);
    blockhead
->PutInto(&maze);
    
//走不出来的不给吃饭^_^
    hero->SeekPath();
    leader
->SeekPath();
    fool
->SeekPath();
    blockhead
->SeekPath();
    
return 0;
}
 
下图是在MinGw中的输出结果,为了节省空间对输出格式进行了一些修改:

 
然后是去掉#define TEST前面注释的结果,这次换成在VC6中进行测试:

 
测试程序很简单,因为大部分工作都在类里面做了。可以看出栈与递归法的结果相同,对于书上的迷宫来说靠右边走要比左边强,这从之前的图中也可看出来,而在我自己画的迷宫中贴左墙要快一些。这里使用了sstream头文件,可以免去每次测试时输入烦琐的迷宫数据,这在调试程序的时候很有用。虽然我们学得的数据结构是用C语言描述的,但我总喜欢使用C++实现其中的算法,因为同时在学习C++,而且使用C++编写代码比C轻松不少,并且可读性也更强。总感觉C并不适合描述数据结构。书在前言中也说了C语言不是抽象数据类型的理想描述工具,所以又从C++中借来了引用等新语法。
到此为止,前4章的内容就都完成了,总体来说在学习过程中没有遇到什么问题,所以只写了两篇文章。甚至迷宫这篇本是不打算写的,但因十一放假这些天一直在下雨,在家待着没意思,所以才写的。不打算写是因为只讨论迷宫的一般解法没有什么价值,迷宫本来是给人设计的嘛,都让电脑去解了还有什么意思。但寻找迷宫最短路径及如何随机生成迷宫却在许多方面都有意义的,而这需要结合图的优先遍历。但现在讨论它为时尚早,等到学完图那章之后或许会写一个迷宫--续什么的。(恩,能不能坚持到那个时候还不好说,数据结构很复杂呢^_^)
版权声明:本文为博主原创文章,未经博主允许不得转载。

相关文章推荐

python数据结构学习笔记-2016-11-02-02-迷宫问题

7.4 迷宫问题         7.4.1 回溯         蛮力法(brute-force method):穷举所有可能,一一验证。这种方法效率较低。         回溯...

python数据结构学习笔记-2017-01-08-01-N皇后问题、迷宫问题和跳马问题的递归解决

N皇后问题         棋盘ADT #-*-coding: utf-8-*- # 二维数组实现棋盘ADT from myarray2d import Array2D class Bo...

栈的使用-迷宫算法实现代码-摘自数据结构实现java版本(个人笔记整理)

//首先cell类 package list; public class Cell { private int x;//坐标x private int y;//左边y private...

学习笔记------数据结构(C语言版)数组之三元组顺序表

//TSMatrix.cpp #include"predefined.h" #include"TSMatrix.h" Status TransposeSMatrix(TSMatrix M,TSMa...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:深度学习:神经网络中的前向传播和反向传播算法推导
举报原因:
原因补充:

(最多只允许输入30个字)