迷宫求解

#include<stdio.h>
#include<memory.h>
#include<stdlib.h>

#define TRUE 1
#define STACK_INIT_SIZE 100
#define OVERFLOW -2
#define RANGE 100
#define STACKINCREMENT 10
#define OK 1
#define ERROR 0
#define FALSE 0

typedef int Status;

typedef struct{
int x;
int y;
}PosType;

typedef struct{
int ord;
PosType seat;
int di;
}SElemType;

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

typedef struct{
Status block[RANGE][RANGE];
Status path[RANGE][RANGE];
}MazeType;

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 Push(MazeType &maze, SqStack &S, SElemType e)
{
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;
maze.path[e.seat.y][e.seat.x]=1;
return OK;
}

Status Pop (MazeType &maze, SqStack &S, SElemType &e)
{
if (S.top == S.base)
return ERROR;
e = *--S.top;
maze.path[e.seat.y][e.seat.x]=0;
return OK;
}

Status StackEmpty (SqStack S)
{
if (S.top == S.base)
return OK;
else
return ERROR;
}

Status Pass(PosType P, MazeType maze)
{
return !maze.block[P.y][P.x];
}

void FootPrint(PosType P, MazeType &maze)
{
maze.block[P.y][P.x] = 1;
return;
}

PosType NextPos(PosType curpos, int di)
{
PosType temp;
switch (di)
{
case 1: temp.x = curpos.x + 1; 	temp.y = curpos.y; 		break;
case 2: temp.x = curpos.x; 		temp.y = curpos.y + 1; 	break;
case 3: temp.x = curpos.x - 1; 	temp.y = curpos.y; 		break;
case 4: temp.x = curpos.x; 		temp.y = curpos.y - 1; 	break;
default: break;
}
return temp;
}
void MarkPrint(PosType p, MazeType &maze)
{
maze.block[p.y][p.x] = 1;
return;
}

Status posCompare(PosType a, PosType b)
{
if (a.x == b.x && a.y == b.y)
return OK;
else
return ERROR;
}

Status MazePath(MazeType &maze, PosType start, PosType end)
{
SqStack S;
InitStack(S);
PosType curpos = start;
int curstep = 1;
SElemType e;
do
{
if (Pass(curpos, maze))
{
FootPrint(curpos, maze);
e = (SElemType){curstep, curpos, 1};
Push(maze, S, e);
if (posCompare(curpos, end))
{
return TRUE;
}
curpos = NextPos(curpos, 1);
curstep++;
}
else
{
if (!StackEmpty(S))
{
Pop(maze, S, e);
while (e.di == 4 && !StackEmpty(S))
{
MarkPrint(e.seat, maze);
Pop(maze, S, e);
}
if (e.di < 4)
{
e.di++;
Push(maze, S, e);
curpos = NextPos(e.seat, e.di);
}
}
}
}while (!StackEmpty(S));
return FALSE;
}
int main()
{
/*test code begin*/
MazeType test = {
{
{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}
}
};
memset(test.path, 0, sizeof(test.path));
PosType posStart = PosType{1,1};
PosType posStop = PosType{8,8};
MazePath(test, posStart, posStop);
for (int i = 0; i <= 10; i++)
{
for (int j = 0; j <= 10; j++)
printf("%d\t", test.path[i][j]);
printf("\n");
}
/*test code end*/
return 0;
}