1 .Preface
/**
* There have been many data to introduce the algorithm. So I will try to simply explain it and explain the program in detail.
*/
/**
* Prerequisites:
* 1). a survival skill in CPP programing language.
* 2). a curious mind for maze problem.
*
*/
//Image this, you have maze, just as following:
/*
*
* 1 1 1 1 1 1 1 1 1 1
*-> 1 0 0 1 0 0 0 1 0 1
* 1 0 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 0 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 -->exit
* 1 1 1 1 1 1 1 1 1 1
*/
//the entrance is [1,1], and exit is [8,8].
//How could you find a valid way to get through this?
/*
* when start with [1, 1] , we will arrive some special position, which provide us many paths .For example, if we reside in [1, 1], there have two paths for us, [ 2, 1] and [ 1, 2]. Those speical nodes connect each other and compose a complexity topology network.
*
*
* To solve this problem, we could do as following:
* step 1: just go ahead as one pleases , but record all nodes which has arrived.
* step 2: if arrive a dead end, that mean you was choose a wrong path. So you need to go back the same way, find the last node which you did a choice, and step into another choice.
* step 3: Then repeat step 1 untill arrive the exit.
*
*/
2.Source code
/**
* Now, check this source code. I divided this problem with three parts: a stack, a map, and a boy who provide solve solution. First, let us put that poor little boy into this maze.( brutally )
*/
2. 1 Tool--stack.h
/**
* To traverse the network totally, the little boy must ensure he can go back the same way. So he save all of nodes,which he has been arrived,into a stack. The feature of stack is
* first in, first out. That's what we lack.
*/
/**
* For make this stack more useful, a class template is created.
*/
#ifndef STACK_H
#define STACK_H
typedef int INDEX;
template < class ELEM>
class STACK{
public:
STACK( int capacity); //capacity
~STACK( void);
/*
* some basic operation function.
*/
bool pop( ELEM &item);
bool push( ELEM item);
/*
* sometimes, we want to visit those elements in the stack simply, instead of
* pop them from stack.
*/
bool reset_v( void); //reset view point
bool pop_v( ELEM &item); //view stack
private:
/*
* the bottom of stack
*/
ELEM *base;
/*
* the top of stack.
*/
INDEX top;
/*
* the current position for pop
*/
INDEX cur;
/*
* the current postion for visit stack
*/
INDEX v_cur;
};
#define STACK_MAX 1000
/**
* This is just a simply stack, and even don't consider dynamic extension.
*/
template <class ELEM>
STACK<ELEM>::STACK(int capacity)
{
if( ( capacity<=0)
||( capacity>STACK_MAX))
{
this->base = NULL;
return ;
}
this->base = NULL;
this->base = new ELEM[capacity];
this->top = capacity -1;
this->cur = -1;
this->v_cur = -1;
}
template <class ELEM>
STACK<ELEM>::~STACK( void)
{
if( NULL!=this->base)
{
delete [](this->base);
this->base = NULL;
}
}
template <class ELEM>
bool STACK<ELEM>::push( ELEM item)
{
if( (NULL==this->base)
||(this->top==this->cur))
return false;
this->cur ++;
this->base[this->cur] = item;
return true;
}
template <class ELEM>
bool STACK<ELEM>::pop( ELEM &item)
{
if( (NULL==this->base)
||(this->cur<0))
return false;
item = this->base[this->cur];
this->cur--;
return true;
}
/**
* This function is used to visit stack.
*/
template <class ELEM>
bool STACK<ELEM>::pop_v( ELEM &item)
{
if( (NULL==this->base)
||(this->v_cur<0))
return false;
item = this->base[this->v_cur];
this->v_cur--;
return true;
}
/**
* reset the posion of visit at current postion of stack.
* That is necessary before use pop_v().
*/
template <class ELEM>
bool STACK<ELEM>::reset_v( void)
{
this->v_cur = this->cur;
return true;
}
#endif
2.2 Tool--map.h
/**
* Obviously, a map is necessary. By the help of the map, the boy could concentrate on hisself's work rather than be busy with some things about map. That make the code is more clear and simple.
*/
/**
* Map is a 2D matrix. For a element in the matrix, it compose by three parts:
* X coordinate, Y coordinate and additional data in which we could save some
* attribute information about this node.
*/
#ifndef MAP_H
#define MAP_H
#define MAP_MAX 15
typedef int COORDINATE;
template <class NODE>
class MAP{
public:
MAP( int width);
~MAP( void);
/*
* get a node which reside in [x,y]. The information of node
* will be write into @nod.
*/
bool cur( COORDINATE x, COORDINATE y , NODE &nod);
/*
* get a node reside in [ x-1, y].
*/
bool left( COORDINATE x, COORDINATE y , NODE &nod);
bool right( COORDINATE x, COORDINATE y, NODE &nod);
bool up( COORDINATE x, COORDINATE y, NODE &nod);
bool down( COORDINATE x, COORDINATE y, NODE &nod);
/*
* set a map node
*/
bool set( COORDINATE x, COORDINATE y, NODE &nod);
private:
/*
* point to the map
*/
NODE **p;
int wid;
};
/**
* Init the size of map. Because we don't know any thing about the size,
* nither width, nor height. So we use a trick.
*/
template <class NODE>
MAP<NODE>::MAP( int width)
{
if( width>MAP_MAX)
{
this->p = NULL;
return;
}
this->p = NULL;
#if 0
this->p = ( NODE **)malloc( sizeof(NODE)*width*width);
#else
this->p = new NODE*[width];
for( int i=0; i<width; i++)
this->p[i] = new NODE[width];
#endif
this->wid = width;
}
template <class NODE>
MAP<NODE>::~MAP( void)
{
if( NULL!=this->p)
{
#if 0
free (this->p);
#else
for( int i=0; i<this->wid; i++)
delete []this->p[i];
delete []this->p;
#endif
this->p = NULL;
this->wid = 0;
}
}
template <class NODE>
bool MAP<NODE>::cur(COORDINATE x, COORDINATE y, NODE &nod)
{
if( (x<0||x>=this->wid)
||(y<0||y>=this->wid))
return false;
nod = this->p[x][y];
return true;
}
template <class NODE >
bool MAP<NODE >::left( COORDINATE x, COORDINATE y, NODE &nod)
{
if( (x<0||x>=this->wid)
||(y<=0||y>=this->wid))
return false;
nod = this->p[ x][y-1];
return true;
}
template <class NODE>
bool MAP<NODE>::right( COORDINATE x, COORDINATE y, NODE &nod)
{
if( (x<0||x>=this->wid)
||(y<0||y>=this->wid-1))
return false;
nod = this->p[x][y+1];
return true;
}
template <class NODE>
bool MAP<NODE>::up( COORDINATE x, COORDINATE y, NODE &nod)
{
if( (x<=0||x>=this->wid)
||(y<0||y>=this->wid))
return false;
nod = this->p[x-1][y];
return true;
}
template <class NODE>
bool MAP<NODE>::down( COORDINATE x, COORDINATE y, NODE &nod)
{
if( (x<0||x>=this->wid-1)
||(y<0||y>=this->wid))
return false;
nod = this->p[x+1][y];
return true;
}
template <class NODE>
bool MAP<NODE>::set( COORDINATE x, COORDINATE y, NODE &nod)
{
if( (x<0||x>=this->wid)
||(y<0||y>=this->wid))
return false;
if( NULL==this->p)
{
return false;
}
this->p[x][y] = nod;
return true;
}
#endif
2.3 Operator--boy
#include <stdio.h>
#include <iostream>
/**
* To traverse the network totally, the little boy must ensure he can go back the same way.
* So he save all of nodes,which he has been arrived,into a stack. The feature of stack is
* first in, first out. That's what we lack.
*/
#include "../stack.h"
/**
* Obviously, a map is necessary. By the help of the map, the boy could
* concentrate on hisself's work rather than be busy with some things about map.
* That make the code is more clear and simple.
*/
#include "map.h"
//map node
typedef unsigned char UINT8;
#define MAP_WID 10
#define END_X (MAP_WID-2) //8
#define END_Y (MAP_WID-2) //8
#define STACK_DEPTH 200
enum ORIEN{
O_RIGHT,
O_DOWN,
O_LEFT,
O_UP,
O_INVIALID,
O_MAX,
};
enum TERRAIN {
T_NOR = 0,
T_BLOCK = 1,
T_INVALID = 2,
};
/**
* map information, 1 meaning for T_BLOCK. 0 meaning for T_NOR.
*/
static int map_v[MAP_WID][MAP_WID] = {
1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 0, 0, 1, 0, 0, 0, 1, 0, 1,
1, 0, 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, 0, 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,
};
/*
* basic element in map was used to record all information about
* a node.
*/
typedef struct {
COORDINATE x;
COORDINATE y;
TERRAIN val;
ORIEN orien;
bool hasComing;
} ELEMENT;
/**
* And this is that poor boy. He will provide a algorithm to solve
* this maze problem. Of course, he need some tools: stack and
* map.
*/
class BOY {
public:
BOY( void);
~BOY( void);
/*
* begin to traverse this maze.
*/
bool work( void);
/*
* show information
*/
bool ShowMap( void);
bool ShowStack( void);
private:
/*
* two important functions, they compose the core of this algorithm.
*/
bool forward( void);
bool backward( void);
/*
* work for those function above.
*/
bool hasNBranch( ELEMENT &c_elem, ELEMENT &nod, ORIEN &from); //has a new branch
bool isEnd( void); //arrive the end
bool findVisible( ELEMENT &c_elem, ELEMENT &nod, ORIEN& from);
bool wasCome( ELEMENT &c_elem);
/*
* tool 1
*/
MAP<ELEMENT> map;
/*
* tool 2
*/
STACK<ELEMENT> stack;
/*
* current position
*/
ELEMENT cur;
};
BOY::BOY(void):map(MAP_WID), stack(STACK_DEPTH)
{
cur.x = 1;
cur.y = 1;
cur.val = T_NOR;
cur.orien = O_INVIALID;
ELEMENT tmp_elem;
COORDINATE i,j;
for( i=0; i<MAP_WID; i++)
for( j=0; j<MAP_WID; j++)
{
tmp_elem.x = i;
tmp_elem.y = j;
tmp_elem.orien = O_INVIALID;
tmp_elem.hasComing = false;
tmp_elem.val = ( TERRAIN)map_v[i][j];
this->map.set( tmp_elem.x, tmp_elem.y, tmp_elem);
}
}
BOY::~BOY( void)
{}
bool BOY::work(void)
{
bool isContinue = true;
while( isContinue)
{
printf("this->cur[ %d, %d]
", this->cur.x, this->cur.y);
/*
* go ahead until encounter a dead end or arrive the exit.
*/
while( this->forward( ))
{
printf("this->cur[ %d, %d]
", this->cur.x, this->cur.y);
if( this->isEnd( ) )
return true;
}
/*
* when the boy has encounter a dead end, he need to backtrack.
* find a valid path.
*/
printf("back>
");
isContinue=this->backward( );
}
return false;
}
/**
* based on current position, try to forward a step. If success, the previous postion
* will be push in the stack. and update the information of past node as arrived.
* if fail, that meaning current node is a dead end.
*/
bool BOY::forward(void)
{
ELEMENT tmp_elem;
ORIEN tmp_from = O_RIGHT;
if( !this->hasNBranch( this->cur, tmp_elem, tmp_from))
{
return false;
}
this->cur.orien = tmp_from;
this->stack.push( this->cur);
this->cur = tmp_elem;
this->cur.hasComing = true;
this->map.set( this->cur.x, this->cur.y, this->cur);
return true;
}
/**
* one of the core function. when the boy arrived a dead end,
* this function will be call . It go back the same way untill find
* a valid node that could give the little boy a new path(or a branch).
*/
bool BOY::backward(void)
{
ELEMENT tmp_elem;
ORIEN tmp_from = O_RIGHT;
while( this->stack.pop( tmp_elem))
{
this->cur = tmp_elem;
if( this->hasNBranch( this->cur, tmp_elem, tmp_from))
{
return true;
}
}
return false;
}
/**
* check whether @c_elem node has a valid path that deserve to visit.
* as same as other function, all information will be write into @elem
* and @from.
*/
bool BOY::hasNBranch( ELEMENT &c_elem, ELEMENT &elem, ORIEN &from)
{
ELEMENT tmp_elem;
ORIEN tmp_from = from;
while(1)
{
//find next visible position.
//Y:continue
//N:this node is a ending
if( !this->findVisible( c_elem, tmp_elem, tmp_from))
{
return false;
}
//was coming?
//Y:coninue
//N:right way
if( !this->wasCome( tmp_elem))
{//this is a new branch
break;
}
tmp_from =(ORIEN)( tmp_from + 1); //next orientation
}
elem = tmp_elem;
from = tmp_from;
return true;
}
/**
* arrive the exit of maze ?
*/
bool BOY::isEnd(void)
{
if( (this->cur.x==END_X)
&&(this->cur.y ==END_Y))
{
return true;
}
return false;
}
/**
* find a visible path that is not block. It use @c_elem as the current view point,
* if success , write information into @elem and @from.
*/
bool BOY::findVisible( ELEMENT &c_elem, ELEMENT &elem, ORIEN& from)
{
ELEMENT tmp;
/*
* check valid path clockwise.
*/
switch( from)
{
case O_RIGHT:
if( (this->map.right( c_elem.x, c_elem.y, tmp))
&&( tmp.val == T_NOR))
{
elem = tmp;
from = O_RIGHT;
return true;
}
case O_DOWN:
if( (this->map.down( c_elem.x, c_elem.y, tmp))
&&( tmp.val == T_NOR))
{
elem = tmp;
from = O_DOWN;
return true;
}
case O_LEFT:
if( (this->map.left( c_elem.x, c_elem.y, tmp))
&&( tmp.val == T_NOR))
{
elem = tmp;
from = O_LEFT;
return true;
}
case O_UP:
if( (this->map.up( c_elem.x, c_elem.y, tmp))
&&( tmp.val == T_NOR))
{
elem = tmp;
from = O_UP;
return true;
}
default :;
}
return false;
}
/**
* Though this function is very tiny, it hold a important position
* in the totally algorithm. The upper function will call this to ensure
* whether a node is deserve to visit. By add a series of strategies
* we could improve the algorithm.
*/
bool BOY::wasCome( ELEMENT &c_elem)
{
#if 1
//label
return c_elem.hasComing;
#else
//标准1
if( c_elem.hasComing)
return true;
//标准2
ELEMENT elem;
this->stack.reset_v();
while( this->stack.pop_v( elem))
{
if( (c_elem.x==elem.x)
&&(c_elem.y==elem.y))
return true;
}
return false; //wasn't coming
#endif
}
/**
* show the status of map
*/
bool BOY::ShowMap(void)
{
printf("-----------MAP---------------------
");
COORDINATE i,j;
for( i=0; i<MAP_WID; i++)
{
for( j=0; j<MAP_WID; j++)
{
ELEMENT tmp;
if(!this->map.cur( i, j, tmp))
{
printf("error: [ %d, %d]
", i, j);
return false;
}
printf("%3d", tmp.val);
}
printf("
");
}
return true;
}
/**
* show the status of stack, just visit it and don't pop element from it
*/
bool BOY::ShowStack(void)
{
printf("-----------STACK---------------------
");
ELEMENT tmp_elem;
this->stack.reset_v( );
while( this->stack.pop_v( tmp_elem))
{
printf("[ %d, %d]
", tmp_elem.x, tmp_elem.y);
}
}
int main()
{
BOY boy;
boy.ShowMap( );
boy.work( );
boy.ShowStack( );
return 0;
}