#第一类 简单迷宫(不含多条出路,不带环)(0代表墙,1代表通路)
###思路分析:
####1.以入口为起点,寻找出口(除了起点以外的边缘上的点)
####2.判定当前点坐标是否可以走。(坐标合法且不为0)
####3.如果合法则将当前点标记成走过的并入栈(维护一个栈可以记录走过的路径,栈的长度就是路径的长度)
####4.判断当前点是否是出口,是出口就return(该迷宫不存在别的出口),如果不是出口,以顺时针的方向(上,右,下,###左)探测临界点是否可以走(不为0且不为已经走过的点),并以递归形式重复步骤2-4.
####5.当一个点的4个方向都已经探测过,就返回上一层栈帧。
maze.h
#pragma once
#include<stdio.h>
#include<windows.h>
#include<assert.h>
//要定义的有:
//一个结构体为结构体pos,用于记录迷宫每个店的横纵坐标
//两个栈path和shortpath,记录通路的最短距离,栈内元素序列即是最短
//迷宫(迷宫地图,入口点)
#define N 6
#define Stack_size 20
typedef struct pos //迷宫内每个点的坐标
{
int row;
int col;
}pos;
typedef pos DataType;
typedef struct Stack //存放节点信息的栈
{
DataType* _array; //数组指针
size_t _top; //栈顶
size_t _end; //最大容量
}Stack;
typedef struct maze //迷宫
{
int mz[N][N];
pos entry; //入口点
}maze;
###function.h
#include"maze.h"
void StackInit(Stack* s)//栈的初始化
{
assert(s);
s->_array = (DataType*)malloc(sizeof(DataType)*Stack_size);
s->_end = Stack_size;
s->_top = 0;
}
void StackPush(Stack* s, DataType x)//入栈
{
assert(s);
if (s->_end == s->_top)//栈已满
{
s->_end *= 2;
s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*(s->_end));
s->_array[s->_top] = x;
(s->_top)++;
}
else
{
s->_array[s->_top] = x;
(s->_top)++;
}
}
void StackPop(Stack* s)//出栈
{
assert(s);
if (s->_top == 0)
{
printf("the stack is empty");
}
else
{
s->_top--;
}
}
int StackEmpty(Stack* s)//判断栈是否为空
{
if (s->_top == 0)
{
return 1;
}
else
{
return 0;
}
}
DataType StackTop(Stack* s)//取栈顶元素
{
assert(s);
int num = s->_top;
DataType i = s->_array[(--num)];
return i;
}
void mazeinit(maze *M)//迷宫初始化
{
assert(M);
int a[N][N] = {
{ 0, 0, 0, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0 },
{ 0, 0, 1, 0, 0, 0 },
{ 0, 0, 1, 1, 1, 0 },
{ 0, 0, 1, 0, 1, 1 },
{ 0, 0, 1, 0, 0, 0 }
};
for (size_t i = 0;i < N;i++)
{
for (size_t j = 0;j < N;j++)
{
M->mz[i][j] = a[i][j];
}
}
M->entry.row = 5;
M->entry.col = 2;
}
void mazeprint(maze *M)
{
assert(M);
for (int i = 0;i < N;i++)
{
for (int j = 0;j < N;j++)
{
printf("%d ", (M->mz)[i][j]);
}
printf("\n");
}
printf("\n");
}
int can_stay(pos cur, maze *M)//判断是否能入栈
{
if (cur.row >= 0 && cur.row < N&&cur.col >= 0 && cur.col < N //坐标合法
&&M->mz[cur.row][cur.col] != 0 && M->mz[cur.row][cur.col] != 2) //该点不为墙也不为走过的点
{
return 1;
}
return 0;
}
void assign_pos(pos cur, maze **M)//标记
{
(*M)->mz[cur.row][cur.col] = 2;
}
int check_exit(pos cur, maze *M)//检查是否到达出口
{
if ((cur.row == 0) || (cur.row == N - 1) || (cur.col == 0) || (cur.col == N - 1))
{
if ((cur.row) != ((M->entry).row) && (cur.col) != ((M->entry).col))
{
return 1;
}
}
return 0;
}
void print_stack(Stack *s)
{
printf("找到出口!\n\n");
printf("栈顶\n");
for (size_t i = 0;i < s->_top;i++)
{
printf("[%d %d]\n", s->_array[i].row, s->_array[i].col);
}
printf("栈底\n\n");
printf("路径长度为%u\n", s->_top);
}
void simple_getpath(maze *M, pos cur, Stack *s)
{
assert(M);
//2.判定当前点坐标是否可以走。(坐标合法且不为0)
if (can_stay(cur, M) == 1)
{
//3.如果合法则将当前点标记成走过的并入栈
//(维护一个栈可以记录走过的路径,栈的长度就是路径的长度)
assign_pos(cur, &M);
StackPush(s, cur);
}
else
{
return;
}
if (check_exit(cur, M) == 1)
{
print_stack(s);
return;
}
//4.判断当前点是否是出口,是出口就return(该迷宫不存在别的出口),
//如果不是出口,以顺时针的方向(上,右,下,左)探测临界点是否可以走(不为0且不为已经走过的点),
//并以递归形式重复步骤2-4.
//up
pos up = cur;
up.row -= 1;
simple_getpath(M, up, s);
//right
pos right = cur;
right.col += 1;
simple_getpath(M, right, s);
//down
pos down = cur;
down.row += 1;
simple_getpath(M, down, s);
//left
pos left = cur;
left.col -= 1;
simple_getpath(M, left, s);
//5.当一个点的4个方向都已经探测过,就返回上一层栈帧。
StackPop(s);
return;
}
###test.c
#include"function.h"
void simplemaze()
{
maze M;
Stack path;
StackInit(&path);
mazeinit(&M);
mazeprint(&M);
simple_getpath(&M, M.entry, &path);
mazeprint(&M);
}
int main()
{
simplemaze();
system("pause");
return 0;
}
#第二类 多通路迷宫(不带环)
###思路:
####这个迷宫与简单迷宫非常类似,唯一不同就是有多通路,我们要求解离开迷宫的最短距离,每当移动到出口时,我们的栈path就记录了该条路径,再与shortpath进行比较(初次遇到出口时直接令shortpath和path相等即可),让shortpath始终保留最短的通路,直到再次回到起点(所有栈帧均释放完毕)。
###function.h
#include"maze.h"
void StackInit(Stack* s)//栈的初始化
{
assert(s);
s->_array = (DataType*)malloc(sizeof(DataType)*Stack_size);
s->_end = Stack_size;
s->_top = 0;
}
void StackPush(Stack* s, DataType x)//入栈
{
assert(s);
if (s->_end == s->_top)//栈已满
{
s->_end *= 2;
s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*(s->_end));
s->_array[s->_top] = x;
(s->_top)++;
}
else
{
s->_array[s->_top] = x;
(s->_top)++;
}
}
void StackPop(Stack* s)//出栈
{
assert(s);
if (s->_top == 0)
{
printf("the stack is empty");
}
else
{
s->_top--;
}
}
int StackEmpty(Stack* s)//判断栈是否为空
{
if (s->_top == 0)
{
return 1;
}
else
{
return 0;
}
}
DataType StackTop(Stack* s)//取栈顶元素
{
assert(s);
int num = s->_top;
DataType i = s->_array[(--num)];
return i;
}
//1.创建迷宫(二维数组)并初始化
//2.将迷宫入口的值设为2,入栈,然后依次对上,右,下,左依次进行判断,
//如果不越界&&坐标不为0 || 当前坐标值比下一步的坐标值小,则进行递归,并入栈,递归出口为当前节点不为起点
//3.每当遇到出口,如果shortpath为空或者path比shortpath短,则将path的值依次赋给shortpath。
void mazeinit(maze *M)//迷宫初始化
{
assert(M);
int a[N][N] = {
{ 0, 0, 0, 0, 0, 0 },
{ 0, 1, 1, 1, 1, 1 },
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 0, 0, 0, 0 },
{ 0, 1, 1, 1, 1, 1 },
{ 0, 1, 0, 0, 0, 0 }
};
for (size_t i = 0;i < N;i++)
{
for (size_t j = 0;j < N;j++)
{
M->mz[i][j] = a[i][j];
}
}
M->entry.row = 5;
M->entry.col = 1;
}
void mazeprint(maze *M)
{
assert(M);
for (int i = 0;i < N;i++)
{
for (int j = 0;j < N;j++)
{
printf("%d ", (M->mz)[i][j]);
}
printf("\n");
}
printf("\n");
}
int can_stay(pos cur, maze *M)//判断是否能入栈
{
if (cur.row >= 0 && cur.row < N&&cur.col >= 0 && cur.col < N //坐标合法
&&M->mz[cur.row][cur.col] != 0 && M->mz[cur.row][cur.col] != 2) //该点不为墙也不为走过的点
{
return 1;
}
return 0;
}
void assign_pos(pos cur, maze **M)//标记
{
(*M)->mz[cur.row][cur.col] = 2;
}
int check_exit(pos cur, maze *M)//检查是否到达出口
{
if ((cur.row == 0) || (cur.row == N - 1) || (cur.col == 0) || (cur.col == N - 1))
{
if ((cur.row) != ((M->entry).row) && (cur.col) != ((M->entry).col))
{
return 1;
}
}
return 0;
}
void print_stack(Stack *s)
{
printf("找到出口!\n\n");
printf("栈顶\n");
for (size_t i = 0;i < s->_top;i++)
{
printf("[%d %d]\n", s->_array[i].row, s->_array[i].col);
}
printf("栈底\n\n");
printf("路径长度为%u\n", s->_top);
}
void get_shortpath(maze *M, pos cur, Stack *path,Stack *shortpath)
{
assert(M);
//2.判定当前点坐标是否可以走。(坐标合法且不为0)
if (can_stay(cur, M) == 1)
{
//3.如果合法则将当前点标记成走过的并入栈
//(维护一个栈可以记录走过的路径,栈的长度就是路径的长度)
assign_pos(cur, &M);
StackPush(path, cur);
}
else
{
return;
}
if (check_exit(cur, M) == 1)
{
if ((shortpath->_top == 0) || (shortpath->_top > path->_top))
{
shortpath->_top = path->_top;
memcpy(shortpath, path, sizeof(path));
print_stack(path);
StackPop(path);
return;
}
}
//4.判断当前点是否是出口,是出口就return(该迷宫不存在别的出口),
//如果不是出口,以顺时针的方向(上,右,下,左)探测临界点是否可以走(不为0且不为已经走过的点),
//并以递归形式重复步骤2-4.
//up
pos up = cur;
up.row -= 1;
get_shortpath(M, up, path,shortpath);
//right
pos right = cur;
right.col += 1;
get_shortpath(M, right, path, shortpath);
//down
pos down = cur;
down.row += 1;
get_shortpath(M, down, path, shortpath);
//left
pos left = cur;
left.col -= 1;
get_shortpath(M, left, path, shortpath);
//5.当一个点的4个方向都已经探测过,就返回上一层栈帧。
StackPop(path);
return;
}
###maze.h
#pragma once
#include<stdio.h>
#include<windows.h>
#include<assert.h>
//要定义的有:
//一个结构体为结构体pos,用于记录迷宫每个店的横纵坐标
//两个栈path和shortpath,记录通路的最短距离,栈内元素序列即是最短
//迷宫(迷宫地图,入口点)
#define N 6
#define Stack_size 20
typedef struct pos //迷宫内每个点的坐标
{
int row;
int col;
}pos;
typedef pos DataType;
typedef struct Stack //存放节点信息的栈
{
DataType* _array; //数组指针
size_t _top; //栈顶
size_t _end; //最大容量
}Stack;
typedef struct maze //迷宫
{
int mz[N][N];
pos entry; //入口点
}maze;
###test.c
#include"function.h"
void simplemaze()
{
maze M;
Stack path;
Stack shortpath;
StackInit(&path);
StackInit(&shortpath);
mazeinit(&M);
mazeprint(&M);
get_shortpath(&M, M.entry, &path,&shortpath);
mazeprint(&M);
}
int main()
{
simplemaze();
system("pause");
return 0;
}
#第三类 带环迷宫
#####带环迷宫是这三种迷宫中最难的一种,也是最容易弄错的一种,如果是用上面两种把走过的路标记为2的方法做带环问题,有一些通路可能会被忽略。所以这里用的方法是:将入口点标记成2,之后每移动一步就将下一个点的值设为X+1(x是上一个点的值,每个点的值表示从起点算X-1步可以到达。
####而判断是否可以入栈的规则也有变化**((坐标合法&&不为0)|| 该点值 - 1 > 上一个点的坐标)**.
####这里肯定有人会为什么规则是这样的,打个比方:
####点A的值为10(从起点通过9步到达),他的相邻点B的值是11(从起点通过10步到达),这时候就不用走,因为已经有另一条路通过相同的步数到达B。
####点A的值是10,相邻点B的值是10,这时候就一定不能走,因为如果走,B的值就得改成11,比原先的步数还要多,这一定不是最短的路程。
####点A的值是10,相邻点B的值是12,这时候就可以走,因为通过A到B可以比原先另一种方式节省一步。
###function.h
#include"maze.h"
void StackInit(Stack* s)//栈的初始化
{
assert(s);
s->_array = (DataType*)malloc(sizeof(DataType)*Stack_size);
s->_end = Stack_size;
s->_top = 0;
}
void StackPush(Stack* s, DataType x)//入栈
{
assert(s);
if (s->_end == s->_top)//栈已满
{
s->_end *= 2;
s->_array = (DataType*)realloc(s->_array, sizeof(DataType)*(s->_end));
s->_array[s->_top] = x;
(s->_top)++;
}
else
{
s->_array[s->_top] = x;
(s->_top)++;
}
}
void StackPop(Stack* s)//出栈
{
assert(s);
if (s->_top == 0)
{
printf("the stack is empty");
}
else
{
s->_top--;
}
}
int StackEmpty(Stack* s)//判断栈是否为空
{
if (s->_top == 0)
{
return 1;
}
else
{
return 0;
}
}
DataType StackTop(Stack* s)//取栈顶元素
{
assert(s);
int num = s->_top;
DataType i = s->_array[(--num)];
return i;
}
//1.创建迷宫(二维数组)并初始化
//2.将迷宫入口的值设为2,入栈,然后依次对上,右,下,左依次进行判断,
//如果不越界&&坐标不为0 || 当前坐标值比下一步的坐标值小,则进行递归,并入栈,递归出口为当前节点不为起点
//3.每当遇到出口,如果shortpath为空或者path比shortpath短,则将path的值依次赋给shortpath。
void mazeinit(maze *M)//迷宫初始化
{
assert(M);
int a[N][N] = {
{ 0,0,0,0,0,0 },
{ 0,1,1,1,0,0 },
{ 0,1,0,1,0,0 },
{ 0,1,0,1,0,0 },
{ 0,1,1,1,1,1 },
{ 0,1,0,0,0,0 },
};
for (size_t i = 0;i < N;i++)
{
for (size_t j = 0;j < N;j++)
{
M->mz[i][j] = a[i][j];
}
}
M->entry.row = 5;
M->entry.col = 1;
}
void mazeprint(maze *M)
{
assert(M);
for (int i = 0;i < N;i++)
{
for (int j = 0;j < N;j++)
{
printf("%d ", (M->mz)[i][j]);
}
printf("\n");
}
printf("\n");
}
int can_stay(pos cur, maze *M,int value)//判断是否能入栈
{
if (cur.row >= 0 && cur.row < N&&cur.col >= 0 && cur.col < N) //坐标合法
{
if (M->mz[cur.row][cur.col] == 1 || M->mz[cur.row][cur.col] - 1>value )
{
return 1;
} //该点不为墙且大于前一个点的值+1
}
return 0;
}
void assign_pos(pos cur, maze **M,int value)//标记
{
(*M)->mz[cur.row][cur.col] = value;
}
int check_exit(pos cur, maze *M)//检查是否到达出口
{
if ((cur.row == 0) || (cur.row == N - 1) || (cur.col == 0) || (cur.col == N - 1))
{
if ((cur.row) != ((M->entry).row) && (cur.col) != ((M->entry).col))
{
return 1;
}
}
return 0;
}
void print_stack(Stack *s)
{
printf("找到出口!\n\n");
printf("栈顶\n");
for (size_t i = 0;i < s->_top;i++)
{
printf("[%d %d]\n", s->_array[i].row, s->_array[i].col);
}
printf("栈底\n\n");
printf("路径长度为%u\n", s->_top);
}
void get_shortpath(maze *M, pos cur, Stack *path,Stack *shortpath,int value)
{
assert(M);
//2.判定当前点坐标是否可以走。(坐标合法且不为0)
if (can_stay(cur, M,value) == 1)
{
//3.如果合法则将当前点标记成走过的并入栈
//(维护一个栈可以记录走过的路径,栈的长度就是路径的长度)
assign_pos(cur, &M,value);
value += 1;
StackPush(path, cur);
}
else
{
return;
}
if (check_exit(cur, M) == 1)
{
if ((shortpath->_top == 0) || (shortpath->_top > path->_top))
{
shortpath->_top = path->_top;
memcpy(shortpath, path, sizeof(path));
print_stack(path);
StackPop(path);
return;
}
}
//4.判断当前点是否是出口,是出口就return(该迷宫不存在别的出口),
//如果不是出口,以顺时针的方向(上,右,下,左)探测临界点是否可以走(不为0且不为已经走过的点),
//并以递归形式重复步骤2-4.
//up
pos up = cur;
up.row -= 1;
get_shortpath(M, up, path,shortpath,value);
//right
pos right = cur;
right.col += 1;
get_shortpath(M, right, path, shortpath,value);
//down
pos down = cur;
down.row += 1;
get_shortpath(M, down, path, shortpath,value);
//left
pos left = cur;
left.col -= 1;
get_shortpath(M, left, path, shortpath,value);
//5.当一个点的4个方向都已经探测过,就返回上一层栈帧。
StackPop(path);
return;
}
###maze.h
#pragma once
#include<stdio.h>
#include<windows.h>
#include<assert.h>
//要定义的有:
//一个结构体为结构体pos,用于记录迷宫每个店的横纵坐标
//两个栈path和shortpath,记录通路的最短距离,栈内元素序列即是最短
//迷宫(迷宫地图,入口点)
#define N 6
#define Stack_size 20
typedef struct pos //迷宫内每个点的坐标
{
int row;
int col;
}pos;
typedef pos DataType;
typedef struct Stack //存放节点信息的栈
{
DataType* _array; //数组指针
size_t _top; //栈顶
size_t _end; //最大容量
}Stack;
typedef struct maze //迷宫
{
int mz[N][N];
pos entry; //入口点
}maze;
###test.c
#include"function.h"
void simplemaze()
{
maze M;
Stack path;
Stack shortpath;
StackInit(&path);
StackInit(&shortpath);
mazeinit(&M);
mazeprint(&M);
get_shortpath(&M, M.entry, &path,&shortpath,2);
mazeprint(&M);
}
int main()
{
simplemaze();
system("pause");
return 0;
}