问题 F: 算法3-3：迷宫

题目描述

有一个 10 x 10 的迷宫，起点是‘S’，终点是‘E’，墙是‘#’，道路是空格。一个机器人从起点走到终点。当机器人走到一个通道块，前面已经没有路可走时，它会转向到当前方块的右手方向继续走。如果机器人能够过，则留下足迹‘*’，如果走不通，则留下标记‘!’。

下面给出书中的算法，请你模拟机器人的走法输出最终的状态。

输入格式

一个 10 x 10 的二维字符数组。

输出格式

机器人走过的路径状态。

输入样例

##########
#S #   # #
#  #   # #
#    ##  #
# ###    #
#   #    #
# #   #  #
# ### ## #
##      E#
##########

输出样例  

##########
#**#!!!# #
# *#!!!# #
#**!!##  #
#*###    #
#***#    #
# #***#  #
# ###*## #
##   ****#
##########

数据范围与提示

输入可以用文件重定向：

freopen("迷宫-in.txt","r",stdin);

提示： 
位置，元素以及迷宫的类型定义： 
typedef struct{
 int r, c; // 以行号和列号作为“坐标位置”类型 
}PosType; 
 typedef struct{ 
 int ord; // 通道块在路径上的序号 
 PosType seat; // 通道块在迷宫中的“坐标位置” 
 int di; // 从此通道块走向下一通道块的“方向” 
}SElemType; // 定义堆栈元素的类型 
 typedef struct{ 
 char arr[10][11]; 
}MazeType; // 定义迷宫类型（二维字符数组） 

总结： 可以试着自己写个dfs（深度优先搜索）。

代码展示 

#include<bits/stdc++.h>
#include<iostream>
#include<stack>
#include<string>
#include<cctype>
#include<iomanip>
using namespace std;

typedef int Status;
typedef int DirectiveType;//方向
#define STACK_INIT_SIZE 100
#define STACKINCREMENT 10
#define OVERFLOW -2
#define ERROR 0
#define OK 1
#define RANGE 100
#define ROW 10
#define COL 10
#define step ord
char maze[20][20];

typedef struct{
	int row;
	int col;
}PosType;//记录坐标

typedef struct{
	int ord;
	PosType seat;
	int di;
}SElemType;///栈的元素类型

typedef struct{
	SElemType *base;
	SElemType *top;
	int stacksize;
}SqStack;

Status InitStack(SqStack &s){
	s.base=(SElemType *)malloc(STACK_INIT_SIZE*sizeof(SElemType));
	if(!s.base)  exit(OVERFLOW);
	s.top=s.base;
	s.stacksize=STACK_INIT_SIZE;
	return OK;
}

Status DestroyStack(SqStack &s){
	free(s.base);
	s.base=NULL;
	s.top=NULL;
	s.stacksize=0;
	return OK;
}

Status ClearStack(SqStack &s){
	if(!s.base)  return ERROR;
	s.top=s.base;
	return OK;
}

Status Push(SqStack &s,SElemType e){
	if(!s.base)  return ERROR;
	if(s.top-s.base>=s.stacksize){
		s.base=(SElemType *)realloc(s.base,(s.stacksize+STACKINCREMENT)*sizeof(SElemType));
		if(!s.base)  exit(OVERFLOW);
		s.top=s.base+s.stacksize;
		s.stacksize+=STACKINCREMENT;
	}
	*s.top++=e;
	return OK;
}

Status Pop(SqStack &s,SElemType &e){
	if(!s.base||s.top==s.base)  return ERROR;
	e=*--s.top;
	return OK;
}

Status StackEmpty(SqStack &s){
	if(s.top==s.base)  return 1;
	return 0;
}

bool Pass(char maze[][20],PosType curpos){
	if(maze[curpos.row][curpos.col]==' '||maze[curpos.row][curpos.col]=='S'||maze[curpos.row][curpos.col]=='E')  return true;
	else return false;
}

void FootPrint(char maze[][20],PosType curpos){
	maze[curpos.row][curpos.col]='*';
}

void MarkPrint(char maze[][20],PosType curpos){
	maze[curpos.row][curpos.col]='!';
}

PosType NextPos(PosType curpos,DirectiveType di){
	PosType pos=curpos;
	switch(di){
		case 1: pos.col++;break;
		case 2: pos.row++;break;
		case 3: pos.col--;break;
		default: pos.row--;break;
	}
	return pos;
}

Status MazePath(char maze[][20],PosType start,PosType end){
	SqStack s;
	SElemType e;
	InitStack(s);
	PosType curpos=start;
	int curstep=1;
	do{
		if(Pass(maze,curpos)){
			FootPrint(maze,curpos);
			e.di=1;
			e.ord=curstep;
			e.seat=curpos;
			Push(s,e);
			if(curpos.row==end.row&&curpos.col==end.col)  return OK;
			curpos=NextPos(curpos,e.di);  curstep++;
		}
		else{
			if(!StackEmpty(s)){
				Pop(s,e);
				while(e.di==4&&!StackEmpty(s)){
					MarkPrint(maze,e.seat);
					Pop(s,e);
				}
				if(e.di<4){
					e.di++;
					Push(s,e);
					curpos=NextPos(e.seat,e.di);
				}
			}
		}
	}
	while(!StackEmpty(s));
	return ERROR;
}

int main(){
	//freopen("/config/workspace/test/test","r",stdin);
	PosType start,end;
	int k1,k2;
	for(int i=0;i<10;i++){
		for(int j=0;j<10;j++){
			scanf("%c",&maze[i][j]);
			//cin>>maze[i][j];为什么这一句不行？
			if(maze[i][j]=='S'){
				start.row=i;
				start.col=j;
				k1=i;k2=j;
			}
			if(maze[i][j]=='E'){
				end.row=i;
				end.col=j;
			}
		}
		getchar();
	}
	int ok=MazePath(maze,start,end);
	if(!ok)  maze[k1][k2]='!';
	for(int i=0;i<10;i++){
		for(int j=0;j<10;j++){
			cout<<maze[i][j];
		}
		cout<<endl;
	}
	return 0;
}

算法源于网络，此处仅作为作业记录