迷宫问题C语言实现

#include <stdio.h>

//#define DEBUG 1

#include "../lib/debug.h"

#define OK (0)

#define NOK (-1)

#define MAZE_SIZE 4

enum Tagderection

{

RIGHT = 0,

DOWN,

LEFT,

UP,

END

};

typedef struct TagPosition

{

int x;

int y;

/* 当前位置是上个位置往哪个方向走得到的，回溯的时候取下个方向 */

int dire;

}Position;

typedef struct TagMazePath

{

Position pos[MAZE_SIZE*MAZE_SIZE]; /* 迷宫最长路径为 MAZE_SIZE*MAZE_SIZE */

int top;

}MazePath;

/* 初始化迷宫，1表示可以走，0表示不能走 */

void MazeInit(int maze[][MAZE_SIZE])

{

int i,j;

for(i = 0; i < MAZE_SIZE; i++)

for (j = 0; j < MAZE_SIZE; j++)

maze[i][j] = 0;

for(i = 0; i < MAZE_SIZE ; i++)

maze[0][i] = 1;

for(i = 0; i < MAZE_SIZE ; i++)

maze[i][MAZE_SIZE-1] = 1;

for(i = 0; i < MAZE_SIZE; i++)

maze[i][0] = 1;

for(i = 0; i < MAZE_SIZE; i++)

maze[MAZE_SIZE-1][i] = 1;

return ;

}

/*************************************************

打印出迷宫的出路

*************************************************/

void MazeDisplayPath(MazePath my_path)

{

int i;

for(i = 0; i <= my_path.top ; i++)

{

printf("%d,%d ",my_path.pos[i].x,my_path.pos[i].y);

}

printf("\n");

}

/*************************************************

打印出迷宫，X表示可以走，0表示不能走

*************************************************/

int MazeDisplay(int maze[][MAZE_SIZE])

{

int i,j;

for(i = 0; i < MAZE_SIZE; i++)

for (j = 0; j < MAZE_SIZE; j++)

{

if(1 == maze[i][j])

printf("X");

else

printf("0");

if((MAZE_SIZE-1) == j)

printf("\n");

}

return ;

}

/*************************************************

迷宫入口入栈

*************************************************/

void MazePathInit(MazePath *my_path)

{

my_path->top = 0;

my_path->pos[0].x = 0;

my_path->pos[0].y = 0;

my_path->pos[0].dire = UP;

}

/*************************************************

判断栈是否为空，为空返回OK,否则返回NOK

*************************************************/

int PathEmpty(MazePath my_path)

{

if(my_path.top >= 0)

return NOK;

else

return OK;

}

/*************************************************

是否找到迷宫出口，找到则返回OK，否则返回NOK

*************************************************/

int MazeFoundWay(MazePath my_path)

{

if(my_path.pos[my_path.top].x != (MAZE_SIZE-1) || my_path.pos[my_path.top].y != (MAZE_SIZE-1))

return NOK;

else

return OK;

}

/*************************************************

判断移动是否合法，合法返回OK，否则返回NOK

*************************************************/

int MoveValid(int maze[][MAZE_SIZE],int mark[][MAZE_SIZE],MazePath my_path,int move_diretion)

{

int cur_x,cur_y,next_x,next_y;

cur_x = my_path.pos[my_path.top].x;

cur_y = my_path.pos[my_path.top].y;

switch(move_diretion)

{

case RIGHT:

next_x = cur_x;

next_y = cur_y + 1;

break;

case DOWN:

next_x = cur_x + 1;

next_y = cur_y;

break;

case LEFT:

next_x = cur_x;

next_y = cur_y - 1;

break;

case UP:

next_x = cur_x - 1;

next_y = cur_y;

break;

default:

return NOK;

}

if(next_x < 0 || next_x >= MAZE_SIZE || next_y < 0 || next_y >= MAZE_SIZE)

{

DB("Meet the wall");

return NOK;

}

if(1 == mark[next_x][next_y])

{

DB("Already passes this position");

return NOK;

}

if(0 == maze[next_x][next_y])

{

DB("This position is not way");

return NOK;

}

return OK;

}

/*************************************************

向选定的方向前进一步

*************************************************/

void MoveForward(int maze[][MAZE_SIZE],int mark[][MAZE_SIZE],MazePath *my_path,int move_diretion)

{

int cur_x,cur_y,next_x,next_y;

cur_x = my_path->pos[my_path->top].x;

cur_y = my_path->pos[my_path->top].y;

switch(move_diretion)

{

case RIGHT:

next_x = cur_x;

next_y = cur_y + 1;

break;

case DOWN:

next_x = cur_x + 1;

next_y = cur_y;

break;

case LEFT:

next_x = cur_x;

next_y = cur_y - 1;

break;

case UP:

next_x = cur_x - 1;

next_y = cur_y;

break;

default:

exit(1);

}

mark[next_x][next_y] = 1;

my_path->top ++;

my_path->pos[my_path->top].x = next_x;

my_path->pos[my_path->top].y = next_y;

my_path->pos[my_path->top].dire = move_diretion;

return ;

}

/*************************************************

回退到上个位置继续查找路径

*************************************************/

void MoveBack(int maze[][MAZE_SIZE],int mark[][MAZE_SIZE],MazePath *my_path)

{

int cur_x,cur_y;

cur_x = my_path->pos[my_path->top].x;

cur_y = my_path->pos[my_path->top].y;

mark[cur_x][cur_y] = 0;

my_path->top --;

}

/*************************************************

迷宫问题解法函数，采用回溯算法

*************************************************/

void MazeFindWayOut(int maze[][MAZE_SIZE])

{

int i,j;

int move_diretion;

int diretion_start = RIGHT;

MazePath my_path;

int mark[MAZE_SIZE][MAZE_SIZE] = {0}; /* 标记该位置是否到过 */

MazePathInit(&my_path); /* 迷宫入口入栈 */

mark[0][0] = 1;

while(OK != PathEmpty(my_path))

{

if( OK == MazeFoundWay(my_path))

{

DB("Find way out");

MazeDisplayPath(my_path);

#if 0

/* 如果是只要找到一条路径，那么在这里退出 */

return;

#else

diretion_start = my_path.pos[my_path.top].dire + 1;

DB("back");

MoveBack(maze,mark,&my_path);

continue;

#endif

}

for(move_diretion = diretion_start ; move_diretion < END ; move_diretion++)

{

if(OK == MoveValid(maze,mark,my_path,move_diretion))

{

MoveForward(maze,mark,&my_path,move_diretion);

break;

}

}

/* 死路，回溯 */

if(END == move_diretion)

{

/* 本位置是从上个位置的哪个方向移动得到 */

/* 回溯后则从上个位置的下个方向开始移动 */

diretion_start = my_path.pos[my_path.top].dire + 1;

DB("back");

MoveBack(maze,mark,&my_path);

}

else

{

diretion_start = RIGHT;

}

}

}

int main(int argc, char **argv)

{

int maze[MAZE_SIZE][MAZE_SIZE];

MazeInit(maze);

MazeDisplay(maze);

MazeFindWayOut(maze);

return;

}