牛客网 - 迷宫问题（C语言）

最新推荐文章于 2024-12-24 23:26:09 发布

原创最新推荐文章于 2024-12-24 23:26:09 发布 · 594 阅读

8 ·

CC 4.0 BY-SA版权

文章标签：

#c语言 #数据结构 #深度优先

文章目录

前言
一、题目要求
- 1.输入
- 2.输出
二、思路与算法
三、代码实现
四、完整代码

前言

原题：
https://www.nowcoder.com/practice/cf24906056f4488c9ddb132f317e03bc?tpId=37&tqId=21266&ru=/exam/oj

一、题目要求

1.输入

输入两个整数，N与M，分别代表二维数组的行数与列数。再输入对应的值，1代表墙壁，0代表可走的路，迷宫只有唯一一条通道可走。
（0，0）为入口
（N - 1， M - 1）为出口
数据范围：2 <= N <= 10，2 <= M<= 10
数组中仅包含0和1
示例：

2.输出

纵向输出从入口到出口的路径
示例：
在这里插入图片描述

二、思路与算法

本题采用深度优先搜索+栈的思路，从入口开始走，每次走过的路标记为2（入栈），若走到某一条不通的路线，则返回到该路线的起点处（把不通的路线出栈），再走没走过的路，直到找到出口为止。
C语言实现栈教程移步下方链接⬇️⬇️⬇️🥺
http://t.csdnimg.cn/8cAkt
在这里插入图片描述

三、代码实现

1.创建迷宫

typedef struct path {
    int row;
    int col;
} path;

int main(){
    int i = 0;
    int N = 0, M = 0;//用来接收迷宫的行数（N）与列数（M）

    while (scanf("%d%d", &N, &M) != EOF){//可能会创建多个迷宫，因此用EOF来判断循环是否终止
        int** maze = (int**)malloc(sizeof(int*)*N);//动态开辟行数，N行
        for (i = 0; i < N; i++){
            maze[i] = (int*)malloc(sizeof(int)*M);//给每一行都为M个数，M列
        }
        for (i = 0; i < N; i++){
            int j = 0;
            for (j = 0; j < M; j++){
                scanf("%d", &maze[i][j]);//布置迷宫
            }
        }
        path cur = {0,0};//创建一个用来存放迷宫坐标的结构体，赋初始值为迷宫的入口
        stack exitPath;//创建用来存放迷宫出口路径的栈
        StackInit(&exitPath);//初始化栈
        FindMazeExit(maze, N, M, cur, &exitPath);//寻找迷宫的出口路径
        PrintMazeExitPath(exitPath);//打印迷宫的出口路径
    }
}

2.寻找迷宫的出口路径

//判断当前路径的坐标是否可走
bool isPass(int** maze, int row, int col, path cur){
    if (cur.row < row && cur.col < col
    && cur.row >= 0 && cur.col >= 0 && maze[cur.row][cur.col] == 0){
        return true;
    }
    return false;
}

//寻找出路
bool FindMazeExit(int** maze, int N, int M, path cur, stack* exitPath){
    StackPush(exitPath, cur);//将当前到达的路径坐标入栈
    maze[cur.row][cur.col] = 2;//走过的路赋值为2

    if (cur.row == N - 1 && cur.col == M - 1){//若当前坐标为出口返回真
        return true;
    }
    path next = cur;//存放当前坐标，寻找下一个可通的坐标

    //向迷宫的上方寻找
    next.row--;
    if (isPass(maze, N, M, next)){//若该坐标可走
        if (FindMazeExit(maze, N, M, next, exitPath)){//则递归该坐标
            return true;
        }
    }

    //向迷宫的下方寻找
    next = cur;
    next.row++;
    if (isPass(maze, N, M, next)){
        if (FindMazeExit(maze, N, M, next, exitPath)){
            return true;
        }
    }

    //向迷宫的左方寻找
    next = cur;
    next.col++;
    if (isPass(maze, N, M, next)){
        if (FindMazeExit(maze, N, M, next, exitPath)){
            return true;
        }
    }

    //向迷宫的右方寻找
    next = cur;
    next.col--;
    if (isPass(maze, N, M, next)){
        if (FindMazeExit(maze, N, M, next, exitPath)){
            return true;
        }
    }

    StackPop(exitPath);//如果当前路径的坐标为死路，就将当前坐标出栈
    return false;//并且返回false
}

3.输出迷宫的出口路径

void PrintMazeExitPath(stack p){
    //因为保存的路径是颠倒的，所以要反转一下再输出
    stack reversePath;//创建一个用来保存反转后路径的栈
    StackInit(&reversePath);//初始化
    while (!StackEmpty(&p)){//若栈为空，循环停止
        StackPush(&reversePath, StackTop(&p));//取出栈顶数据，并入到reversePath
        StackPop(&p);//将栈顶出栈
    }
    //打印反转后的路径
    while (!StackEmpty(&reversePath)){//若栈为空，循环停止
        path cur = StackTop(&reversePath);//将栈顶数据取出
        printf("(%d,%d)\n", cur.row, cur.col);//打印坐标
        StackPop(&reversePath);//出栈
    }
}

四、完整代码

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>
#include <assert.h>

typedef struct path {
    int row;
    int col;
} path;

typedef path StackDataType;

typedef struct Stack {
	StackDataType* vals;
	int top;
	int capacity;
}stack;

void StackInit(stack* p) {
	assert(p);

	p->vals = (StackDataType*)malloc(sizeof(StackDataType) * 4);
	p->capacity = 4;
	p->top = 0;
}

void StackDestroy(stack* p) {
	assert(p);
	free(p->vals);
	p->vals = NULL;
	p->capacity = p->top = 0;
}

void StackPush(stack* p, StackDataType x) {
	assert(p);

	if (p->top == p->capacity) {
		StackDataType* tmp = (StackDataType*)realloc(p->vals, sizeof(StackDataType) * (p->capacity * 2));
		if (tmp) {
			p->capacity *= 2;
			p->vals = tmp;
		}
		else {
			printf("realloc fail!\n");
			exit(-1);
		}
	}
	p->vals[p->top] = x;
	p->top++;
}

void StackPop(stack* p) {
	assert(p);

	if (p->top > 0) {
		p->top--;
	}
	else {
		printf("stack no data\n");
		exit(-1);
	}
}

StackDataType StackTop(stack* p) {
	assert(p);

	if (p->top == 0) {
		printf("stack no data\n");
		exit(-1);
	}
	else {
		return p->vals[p->top - 1];
	}
}

int StackSize(stack* p) {
	assert(p);

	return p->top;
}

bool StackEmpty(stack* p) {
	assert(p);

	return p->top == 0;
}

void PrintMaze(int** maze, int row, int col){
    int i = 0;
    for (i = 0; i < row; i++){
        int j = 0;
        for (j = 0; j < col; j++){
            printf("%d ", maze[i][j]);
        }
        printf("\n");
    }
}

bool isPass(int** maze, int row, int col, path cur){
    if (cur.row < row && cur.col < col
    && cur.row >= 0 && cur.col >= 0 && maze[cur.row][cur.col] == 0){
        return true;
    }
    return false;
}

bool FindMazeExit(int** maze, int N, int M, path cur, stack* exitPath){
    StackPush(exitPath, cur);
    maze[cur.row][cur.col] = 2;

    if (cur.row == N - 1 && cur.col == M - 1){
        return true;
    }
    path next = cur;

    next.row--;
    if (isPass(maze, N, M, next)){
        if (FindMazeExit(maze, N, M, next, exitPath)){
            return true;
        }
    }

    next = cur;
    next.row++;
    if (isPass(maze, N, M, next)){
        if (FindMazeExit(maze, N, M, next, exitPath)){
            return true;
        }
    }

    next = cur;
    next.col++;
    if (isPass(maze, N, M, next)){
        if (FindMazeExit(maze, N, M, next, exitPath)){
            return true;
        }
    }

    next = cur;
    next.col--;
    if (isPass(maze, N, M, next)){
        if (FindMazeExit(maze, N, M, next, exitPath)){
            return true;
        }
    }

    StackPop(exitPath);
    return false;
}

void PrintMazeExitPath(stack p){
    stack reversePath;
    StackInit(&reversePath);
    while (!StackEmpty(&p)){
        StackPush(&reversePath, StackTop(&p));
        StackPop(&p);
    }
    while (!StackEmpty(&reversePath)){
        path cur = StackTop(&reversePath);
        printf("(%d,%d)\n", cur.row, cur.col);
        StackPop(&reversePath);
    }
}

int main(){
    int i = 0;
    int N = 0, M = 0;

    while (scanf("%d%d", &N, &M) != EOF){
        int** maze = (int**)malloc(sizeof(int*)*N);
        for (i = 0; i < N; i++){
            maze[i] = (int*)malloc(sizeof(int)*M);
        }
        for (i = 0; i < N; i++){
            int j = 0;
            for (j = 0; j < M; j++){
                scanf("%d", &maze[i][j]);
            }
        }
        path cur = {0,0};
        stack exitPath;
        StackInit(&exitPath);
        FindMazeExit(maze, N, M, cur, &exitPath);
        PrintMazeExitPath(exitPath);
    }
}