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

最新推荐文章于 2024-05-21 19:00:05 发布
最新推荐文章于 2024-05-21 19:00:05 发布
阅读量420 收藏 6
点赞数 12
文章标签： c语言 数据结构 深度优先
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/ee268/article/details/137960370
版权

文章目录

前言

原题：
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);
    }
}
Fist.
关注
  • 12
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
牛客网---C语言完成迷宫问题
weixin_57535054的博客
02-01 1692
首先malloc一个N行M列的空间，然后用scanf进行接收测试案例 因为测试案例不止一个，所以我们需要用到while(scanf("%d%d",&N,&M)!=EOF) 持续接收。 然后我们需要创建一个结构体 结构体里包含所在位置的行和列。 然后我们还需要一个栈 进行存储。 因为C语言没有栈的库函数，所以我们需要自行写一...
牛客网华为机试答案c语言,《牛客网》——华为机试在线训练——迷宫问题
weixin_29481259的博客
05-19 420
定义一个二维数组N*M(其中2<=N<=10;2<=M<=10)，如5×5数组下所示：intmaze[5][5]={0,1,0,0,0,0,1,0,1,0,0,0,0,0,0,0,1,1,1,0,0,0,0,1,0,};它表示一个迷宫，其中的1表示墙壁，0表示可以走的路，只能横着走或竖着走，不能斜着走，要求编程序找出从左上角...
校招经典笔试题----迷宫问题(2)----C语言版
m0_73096566的博客
12-25 367
校招经典笔试题----迷宫问题(2)----C语言版
牛客网：迷宫问题
weixin_61635597的博客
09-07 1161
滴滴迷宫问题的解题
迷宫问题（C语言实现）（牛客网百度笔试真题）
originalHSL的博客
07-01 774
1.定义一个二维数组表示迷宫，其中 0 表示可以通过的路，1 表示障碍物。3.使用深度优先搜索或广度优先搜索算法在迷宫中搜索路径，记录经过的路径。4.如果搜索到终点，则返回路径，否则返回无解。2.定义起点和终点坐标。
校招经典笔试题----迷宫问题(1)--C语言版
m0_73096566的博客
12-22 318
迷宫问题(1)
牛客网（华为机试--迷宫问题）（借鉴他人）
qq_46179561的博客
02-18 521
#include <string.h> #include <stdlib.h> #include <stdio.h> int maze[10][10]; int flag = 0; int DRV_SearchMaze(int max_line, int max_col, int line, int col) { if (flag) { return 0; } ...
迷宫问题c语言
user2604530353的博客
08-20 27
牛客网练习题，数据结构
C语言的迷宫问题及迷宫进阶
weixin_47851265的博客
10-20 1294
萌新一个，有问题大家可以一起在评论下学习交流，不用互杠，没必要，你杠就是你对，和谐相处，共建程序猿美好世界。 1.迷宫问题 链接：迷宫问题__牛客网 来源：牛客网 [编程题]迷宫问题 定义一个二维数组N*M（其中2<=N<=10;2<=M<=10），如5×5数组下所示： intmaze[5][5]={ 0,1,0,0,0, 0,1,1,1,0, 0,0,0,0,0, 0,1,1,1,0, 0,0,0,1,0, }; 它表示一...
C语言重解经典回溯算法案例-迷宫问题
12-25
C语言重解经典回溯算法案例-迷宫问题 --- Word版本...
C语言开发----纯c语言迷宫源码.rar
04-10
C语言开发----纯c语言迷宫源码
C语言 数据结构中求解迷宫问题实现方法
12-31
C语言 数据结构中求解迷宫问题实现方法  在学习数据结构栈的这一节遇到了求迷宫这个问题，拿来分享一下~  首先求迷宫问题通常用的是“穷举求解” 即从入口出发，顺某一方向试探，若能走通，则继续往前走，否则...
C语言迷宫问题
03-11
用C语言编程实现寻找迷宫中的一条简单路径；用户输入迷宫中的起点坐标和终点坐标，运行结果为一条从起点到终点的简单路径。
迷宫问题c语言 深度优先搜索
07-23
迷宫问题c语言 深度优先搜索
【LinuxC语言】目录操作
最新发布
m0_62599305的博客
05-21 121
在Linux系统中，目录操作是文件系统管理的重要组成部分。对于使用C语言进行系统编程的开发者来说，熟悉和掌握目录操作函数是必不可少的。这些函数使开发者能够创建、删除、读取和遍历目录，从而实现对文件系统的精细控制。本文将详细介绍Linux系统中C语言用于目录操作的常用函数，涵盖其函数原型、参数、返回值及示例代码，帮助读者全面理解和运用这些函数。Linux系统中，C语言提供了丰富的目录操作函数，使得开发者可以方便地管理和操作文件系统。
数据结构-查找-哈希表
2202_75509654的博客
05-19 323
hash;
数据结构-线段树
knoci的博客
05-19 1021
线段树（Segment Tree）是一种数据结构，它主要用于维护区间信息（要求满足结合律），它可以实现 𝑂(log⁡𝑛) 的区间修改，还可以同时支持多种操作（加、乘）。从数据结构的角度来说，线段树是用一个完全二叉树来存储对应于其每一个区间（segment）的数据。该二叉树的每一个结点中保存着相对应于这一个区间的信息。同时，线段树所使用的这个二叉树是用一个数组保存的，与堆（Heap）的实现方式相同。例如，给定一个长度为N的数组arr，其所对应的线段树TT的根结点代表整个数组所在的区间对应的信息，及。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值