深度优先遍历求迷宫问题和地下迷宫问题

最新推荐文章于 2023-01-09 12:52:05 发布
最新推荐文章于 2023-01-09 12:52:05 发布
阅读量428 收藏 7
点赞数 8
分类专栏： 算法 C/C++ 数据结构 文章标签： 深度优先 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Miraitowa_GT/article/details/127366970
版权
C/C++ 同时被 3 个专栏收录
12 篇文章 3 订阅
订阅专栏
数据结构
11 篇文章 2 订阅
订阅专栏
算法
7 篇文章 1 订阅
订阅专栏

迷宫问题

这一题难度中等，两道题都用到的是深度优先遍历，深度优先遍历就是遍历所有结点。

题目

题目链接：https://www.nowcoder.com/questionTerminal/cf24906056f4488c9ddb132f317e03bc
在这里插入图片描述

题解

用一个函数去递归探路，走一个标记一个，如果不通就回来，最后输出格式让输出起点到终点，我们就用栈的方式，这样就能保证输出格式。

#include<stdio.h>
#include<stdlib.h>
#include<stdbool.h>
#include<assert.h>
typedef struct Postion
{
    int row;//列
    int col;//行
}PT;
/
typedef PT STDataType;
typedef struct Stack
{
    STDataType* a;//是一个指针指向这个数组
    int top;//栈顶
    int capacity;//容量
}ST;

//栈需要的接口
// 初始化栈
void StackInit(ST* ps);
// 销毁栈
void StackDestory(ST* ps);
//入栈
void StackPush(ST* ps, STDataType x);
//出栈
void StackPop(ST* ps);
//取栈顶的数据
STDataType StackTop(ST* ps);
//栈的数据个数
int StackSize(ST* ps);
//检测栈是否为空，如果为空返回非零结果，如果非空返回0 
bool StackEmpty(ST* ps);//用布尔来判断真假更好用，但是注意引用头文件

void StackInit(ST* ps)
{
    assert(ps);
    ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
    if (ps->a == NULL)
    {
        printf("malloc fail\n");
        exit(-1);
    }
    ps->capacity = 4;
    ps->top = 0;
}

void StackDestory(ST* ps)
{
    assert(ps);
    free(ps->a);
    ps->a = NULL;
    ps->top = ps->capacity = 0;
}

void StackPush(ST* ps, STDataType x)
{
    assert(ps);

    //满了怎么办？---增容
    if (ps->top == ps->capacity)
    {
        STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
        if (tmp == NULL)
        {
            printf("realloc fail\n");
            exit(-1);
        }
        else
        {
            ps->a = tmp;
            ps->capacity *= 2;//乘等2才会变成它的二倍
        }
    }

    ps->a[ps->top] = x;
    ps->top++;
}

void StackPop(ST* ps)
{
    assert(ps);
    //栈空了，调用pop，直接中止程序并报错
    assert(ps->top > 0);

    ps->top--;
}

STDataType StackTop(ST* ps)
{
    assert(ps);
    //栈空了，调用top，直接中止程序并报错
    assert(ps->top > 0);

    return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
    assert(ps);

    return ps->top;//top所在数组的下标就是栈的长度
}

bool StackEmpty(ST* ps)
{
    assert(ps);

    return ps->top == 0;//如果为空返回非零结果，如果不为空返回0
}

ST Path;
/



void PrintMaze(int** maze, int N, int M)
{
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < M; ++j)
        {
            printf("%d ", maze[i][j]);
        }
        printf("\n");
    }
    printf("\n");
}
//输出栈里面的坐标
void PrintPath(ST* ps)
{
    //path数据倒入rpath
    ST rPath;
    StackInit(&rPath);
    while (!StackEmpty(&Path))
    {
        StackPush(&rPath, StackTop(&Path));//把Path栈顶数据入到rPath这个栈
        StackPop(&Path);
    }
    while (!StackEmpty(&rPath))
    {
        PT top = StackTop(&rPath);
        printf("(%d,%d)\n", top.row, top.col);
        StackPop(&rPath);
    }
    StackDestory(&rPath);
}
//判断一个方向可不可以通
bool IsPass(int** maze, int N, int M, PT pos)
{
    if (pos.row >= 0 && pos.row < N
        && pos.col >= 0 && pos.col < M
        && maze[pos.row][pos.col] == 0)
    {
        return true;
    }
    else
    {
        return false;
    }
}



bool GetMazePath(int** maze, int N, int M, PT cur)
{

    StackPush(&Path, cur);

    //判断走到出口
    if (cur.row == N - 1 && cur.col == M - 1)
    {
        return true;
    }

    //探测cur上下左右四个方向
    PT next;//next就是下一个可以通的方向
    //把我们走过的地方致成2
    maze[cur.row][cur.col] = 2;

    //假设我们探测的顺序就是上下左右--上就是我们的列加-1；下就是我们的列+1；左就是我们的行-1；右就是我们的行+1；
    //上
    next = cur;
    next.row -= 1;
    if (IsPass(maze, N, M, next))
    {
        if (GetMazePath(maze, N, M, next))
        {
            return true;
        }
    }

    //下
    next = cur;
    next.row += 1;
    if (IsPass(maze, N, M, next))
    {
        if (GetMazePath(maze, N, M, next))
        {
            return true;
        }
    }

    //左
    next = cur;
    next.col -= 1;
    if (IsPass(maze, N, M, next))
    {
        if (GetMazePath(maze, N, M, next))
        {
            return true;
        }
    }

    //右
    next = cur;
    next.col += 1;
    if (IsPass(maze, N, M, next))
    {
        if (GetMazePath(maze, N, M, next))
        {
            return true;
        }
    }
    StackPop(&Path);
    return false;
}
int main()
{
    int N = 0, M = 0;
    while (scanf("%d%d", &N, &M) != EOF)
    {
        //动态开辟二维数组
        int** maze = (int**)malloc(sizeof(int*) * N);//我们用的是数组指针，所以malloc的要用二级指针,数组指针类型是int*，那么我们返回数组指针的地址自然是int**。动态申请的列
        //想要判空就加个判空
        for (int i = 0; i < N; ++i)//动态申请的行，并让我们的列（数组指针）连接上
        {
            maze[i] = (int*)malloc(sizeof(int) * M);//M是列
        }

        //二维数组的输入（赋值）
        for (int i = 0; i < N; ++i)
        {
            for (int j = 0; j < M; ++j)
            {
                scanf("%d ", &maze[i][j]);
            }
        }

        StackInit(&Path);
        PT entry = { 0, 0 };
        //PrintfMaze(maze,N,M);//方便调试的
        if (GetMazePath(maze, N, M, entry))
        {
            //printf("找到通路\n");
            PrintPath(&Path);
        }
        else
        {
            printf("没有找到通路\n");
        }
        StackDestory(&Path);

        //释放的话同理--先把行释放掉，再释放列，否则会发生内存泄漏
        for (int i = 0; i < N; ++i)
        {
            free(maze[i]);//释放行
        }
        free(maze);//释放列
        maze = NULL;
    }


    return 0;
}

地下迷宫

地下迷宫是一道滴滴公司曾经的笔试题，难度还是挺高的。

题目

题目链接：https://www.nowcoder.com/questionTerminal/571cfbe764824f03b5c0bfd2eb0a8ddf
在这里插入图片描述

题解

将所有通路全部找到，然后比较出最短的一条，输出原理和迷宫问题类似

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

typedef struct Postion
{
	int row;
	int col;
}PT;
/
typedef PT STDataType;

typedef struct Stack
{
	STDataType* a;
	int top;
	int capacity;
}ST, Stack;

void StackInit(ST* ps);
void StackDestory(ST* ps);
// 入栈
void StackPush(ST* ps, STDataType x);
// 出栈
void StackPop(ST* ps);
STDataType StackTop(ST* ps);

int StackSize(ST* ps);
bool StackEmpty(ST* ps);

void StackInit(ST* ps)
{
	assert(ps);

	ps->a = (STDataType*)malloc(sizeof(STDataType) * 4);
	if (ps->a == NULL)
	{
		printf("malloc fail\n");
		exit(-1);
	}

	ps->capacity = 4;
	ps->top = 0;
}

void StackDestory(ST* ps)
{
	assert(ps);
	free(ps->a);
	ps->a = NULL;
	ps->top = ps->capacity = 0;
}

// 入栈
void StackPush(ST* ps, STDataType x)
{
	assert(ps);

	// 满了-》增容
	if (ps->top == ps->capacity)
	{
		STDataType* tmp = (STDataType*)realloc(ps->a, ps->capacity * 2 * sizeof(STDataType));
		if (tmp == NULL)
		{
			printf("realloc fail\n");
			exit(-1);
		}
		else
		{
			ps->a = tmp;
			ps->capacity *= 2;
		}
	}

	ps->a[ps->top] = x;
	ps->top++;
}

// 出栈
void StackPop(ST* ps)
{
	assert(ps);
	// 栈空了，调用Pop，直接中止程序报错
	assert(ps->top > 0);

	//ps->a[ps->top - 1] = 0;
	ps->top--;
}

STDataType StackTop(ST* ps)
{
	assert(ps);
	// 栈空了，调用Top，直接中止程序报错
	assert(ps->top > 0);

	return ps->a[ps->top - 1];
}

int StackSize(ST* ps)
{
	assert(ps);

	return ps->top;
}

bool StackEmpty(ST* ps)
{
	assert(ps);

	return ps->top == 0;
}

Stack path;
Stack minpath;


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

// 输出栈里面的坐标路径
void PirntPath(Stack* ps)
{
	// path数据倒到rPath
	Stack rPath;
	StackInit(&rPath);
	while (!StackEmpty(ps))
	{
		StackPush(&rPath, StackTop(ps));
		StackPop(ps);
	}

	while (StackSize(&rPath) > 1)
	{
		PT top = StackTop(&rPath);
		printf("[%d,%d],", top.row, top.col);
		StackPop(&rPath);
	}

	PT top = StackTop(&rPath);
	printf("[%d,%d]", top.row, top.col);
	StackPop(&rPath);

	StackDestory(&rPath);
}

bool IsPass(int** maze, int N, int M, PT pos)
{
	if (pos.row >= 0 && pos.row < N
		&& pos.col >= 0 && pos.col < M
		&& maze[pos.row][pos.col] == 1)
	{
		return true;
	}
	else
	{
		return false;
	}
}

void StackCopy(Stack* ppath, Stack* pcopy)
{
	pcopy->a = (STDataType*)malloc(sizeof(STDataType*)*ppath->capacity);
	memcpy(pcopy->a, ppath->a, sizeof(STDataType)*ppath->top);
	pcopy->top = ppath->top;
	pcopy->capacity = ppath->capacity;
}

void GetMazePath(int** maze, int N, int M, PT cur, int P)
{
	StackPush(&path, cur);

	// 如果走到出口
	if (cur.row == 0 && cur.col == M - 1)
	{
		// 找到了更短的路径，更新minpath；
		if (P >= 0 && StackEmpty(&minpath)
			|| StackSize(&path) < StackSize(&minpath))
		{
			StackDestory(&minpath);
			StackCopy(&path, &minpath);
		}
	}

	// 探测cur位置得上下左右四个方向
	PT next;
	maze[cur.row][cur.col] = 2;

	// 上
	next = cur;
	next.row -= 1;
	if (IsPass(maze, N, M, next))
	{
		GetMazePath(maze, N, M, next, P - 3);

	}

	// 下
	next = cur;
	next.row += 1;
	if (IsPass(maze, N, M, next))
	{
		GetMazePath(maze, N, M, next, P);
	}


	// 左
	next = cur;
	next.col -= 1;
	if (IsPass(maze, N, M, next))
	{
		GetMazePath(maze, N, M, next, P - 1);
	}

	// 右
	next = cur;
	next.col += 1;
	if (IsPass(maze, N, M, next))
	{
		GetMazePath(maze, N, M, next, P - 1);
	}

	// 恢复一下
	maze[cur.row][cur.col] = 1;
	StackPop(&path);
}

int main()
{
	int N = 0, M = 0, P = 0;
	while (scanf("%d%d%d", &N, &M, &P) != EOF)
	{
		// int a[n][m]; // vs2013 不支持
		// 动态开辟二维数组
		int** maze = (int**)malloc(sizeof(int*)*N);
		for (int i = 0; i < N; ++i)
		{
			maze[i] = (int*)malloc(sizeof(int)*M);
		}

		// 二维数组得输入
		for (int i = 0; i < N; ++i)
		{
			for (int j = 0; j < M; ++j)
			{
				scanf("%d", &maze[i][j]);
			}
		}

		StackInit(&path);
		StackInit(&minpath);
		// PrintMaze(maze, N, M);
		PT entry = { 0, 0 };
		GetMazePath(maze, N, M, entry, P);
        
        if(!StackEmpty(&minpath))
        {
            PirntPath(&minpath);
        }
        else
        {
            printf("Can not escape!\n");
        }
		

		StackDestory(&path);
		StackDestory(&minpath);

		for (int i = 0; i < N; ++i)
		{
			free(maze[i]);
		}
		free(maze);
		maze = NULL;
	}

	return 0;
}
#唐解元
关注
专栏目录
MATLAB实现迷宫的递归深度优先遍历算法
09-24
深度优先遍历是一种图遍历策略，特别适合解决寻找路径的问题，如在迷宫中找到从起点到终点的所有可能路径。 首先，我们要理解迷宫可以被抽象为一个二维矩阵，其中0代表可通行的路径，1代表障碍物。DFS算法的基本...
数据结构实践——迷宫问题之图深度优先遍历解法
likaiwalkman@csdn - Code Study Area
01-29 756
本文是针对[数据结构基础系列(7)：图]的实践项目。 【项目 - 迷宫问题之图深度优先遍历解法】   　　设计一个程序，采用深度优先遍历算法的思路，解决迷宫问题。   　　（1）建立迷宫对应的图数据结构，并建立其邻接表表示。   　　（2）采用深度优先遍历的思路设计算法，输出从入口(1,1)点到出口(M,N)的所有迷宫路径。  [模型建立]  　　将迷宫中的每一格作为一个顶点，
迷宫问题----深度优先遍历
weixin_43570155的博客
01-20 636
什么是深度优先搜索： 深度优先搜索是一种：枚举所有完整路径以遍历所有情况的搜索方法。   我们可以想象我们正在走一个迷宫，没有上帝视角也没有通信设施，我们只能一条路一条路的去试（枚举），以当前位置为起点，沿着一条路走，碰到岔路口的时候，选择其中一个岔路口前进，如果选择的的这个岔路口是死路，就退回这个岔口道，然后选择另一个岔路前进。如果这个岔口道的所有道路都是死路，那么就退回到上一个岔口道，选择一条...
7-7 求解迷宫从入口到出口的路径 (15 分) java
qq_53369749的博客
11-14 2050
求解迷宫从入口到出口的路径。输入一个迷宫，求从入口通向出口的可行路径。为简化问题，迷宫用二维数组 int maze[10][10]来存储障碍物的分布，假设迷宫的横向和纵向尺寸的大小是一样的，并由程序运行读入, 若读入迷宫大小的值是n（3<n<=10），则该迷宫横向或纵向尺寸都是n，规定迷宫最外面的一圈是障碍物，迷宫的入口是maze[1][1]，出口是maze[n-2][n-2], 若maze[i][j] = 1代表该位置是障碍物，若maze[i][j] = 0代表该位置是可以行走的空位（0&lt
迷宫问题 | 深度优先
qq_57663276的博客
01-09 1504
深度优先解决迷宫问题
基于C++深度优先遍历迷宫【100013186】
最新发布
08-16
c++实现的深度优先遍历迷宫，迷宫大小为20*20，代码简练清楚，内涵关键注释。代码与网上都不一样。 深度优先遍历迷宫，核心思想是借助一个栈，站在一个节点上时，将它附近可以走的节点存在栈中，再按顺序找到下一个...
Java深度优先遍历算法随机生成迷宫
12-14
Java深度优先遍历算法在计算机科学中是一种常用的搜索策略，特别是在解决迷宫生成问题时。这个资源使用Eclipse IDE开发，旨在通过深度优先遍历（DFS, Depth-First Search）来随机生成迷宫。DFS是一种递归的遍历方法...
java图的深度优先遍历实现随机生成迷宫
08-28
Java 图的深度优先遍历实现随机生成迷宫 本文主要介绍了使用 Java 实现图的深度优先遍历算法来生成随机迷宫的方法。该算法的思想是从任意一点开始访问，往四个方向中的随机一个访问，每访问到一个可访问的点，就...
JavaScript树的深度优先遍历和广度优先遍历算法示例
10-18
两种常见的遍历方法是深度优先遍历（Depth-First Search, DFS）和广度优先遍历（Breadth-First Search, BFS）。在JavaScript中，我们可以使用递归或非递归的方法来实现这两种遍历。 1. **深度优先遍历**： 深度...
问题 F: 【递归入门】走迷宫（迷宫问题）
Rhao的博客
02-24 622
题目链接：http://codeup.cn/problem.php?cid=100000608&pid=5 题目描述 有一个nm格的迷宫(表示有n行、m列)，其中有可走的也有不可走的，如果用1表示可以走，0表示不可以走，文件读入这nm个数据和起始点、结束点(起始点和结束点都是用两个数据来描述的，分别表示这个点的行号和列号)。现在要你编程找出所有可行的道路，要求所走的路中没有重复的点，走时只...
用python深度优先遍历解迷宫问题
Free雅轩的博客
07-08 2042
这篇文章主要给大家介绍了关于python迷宫问题深度优先遍历的相关资料,深度优先搜索算法(Depth-First-Search),是搜索算法的一种,需要的朋友可以参考下 一、迷宫介绍 用python解迷宫问题，迷宫是一个二维列表，本次用深度优先解开迷宫问题。定义起点和终点，从一个位置到下一个位置只能通过向上或下或左或右，走一步来实现，从起点出发，如何找到一条到达终点的通路。 二、深度优先遍历 简单那我们的案例来讲就是，随便选择一条路，一直走，走不动了，再回头重新选择新的路 # 1 为墙，0 为
回溯算法（十进制转二进制）
Smile
09-28 4122
【概念】 回溯算法实际上一个类似枚举的搜索尝试过程，主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。许多复杂的，规模较大的问题都可以使用回溯法，有...
迷宫问题 -- 深度优先搜索算法DFS
xuechanba的博客
10-14 6860
以下部分内容来自于B站视频 – 麦克老师讲算法 视频链接：https://www.bilibili.com/video/BV1bK4y1C7W2?p=2&spm_id_from=pageDriver. 迷宫示例图像如下： 程序实现使用了递归思想，没有用到堆栈知识。 实现的代码： #include <iostream> using namespace std; /* * 由于这里使用数组的原因, 而数组的初始值是为0的, * 所以不能让 0 表示空地, 1 表示障碍物。 * 这
迷宫问题（maze problem）—— 深度优先与广度优先搜索求解
热门推荐
Dablelv 的博客专栏。
05-02 6万+
1.问题简介给定一个迷宫，指明起点和终点，找出从起点出发到终点的有效可行路径，就是迷宫问题（maze problem）。迷宫可以以二维数组来存储表示。0表示通路，1表示障碍。注意这里规定移动可以从上、下、左、右四方方向移动。坐标以行和列表示，均从0开始，给定起点（0,0）和终点（4,4），迷宫表示如下：int maze[5][5]={ {0,0,0,0,0}, {0,1,0,1,0}
深度优先搜索解决迷宫问题
A_king
02-25 645
深度优先搜索解决迷宫问题
迷宫问题：深度优先搜索和广度优先搜索
MTALAB的博客
07-10 2015
算法：深度优先和广度优先
第12周项目5-迷宫问题之图深度优先遍历解法
进击的葱
11-19 739
问题： /* * Copyright(c)2015,烟台大学计算机学院 * All right reserved. * 文件名称：项目5.cbp * 作者： * 完成日期；2015年11月19日 * 版本号；v1.0 * 问题描述： 设计一个程序，采用深度优先遍历算法的思路，解决迷宫问题。 　　（1）建立迷宫对应的图数据结构，并建立其邻接表表示。
第十二周--迷宫问题之图深度优先遍历
sunsunzice的博客
11-17 362
/ 作 者：孙子策 完成日期：2016.11.17 问题描述：设计一个程序，采用深度优先遍历算法的思路，解决迷宫问题。 　　（1）建立迷宫对应的图数据结构，并建立其邻接表表示。 　　（2）采用深度优先遍历的思路设计算法，输出从入口(1,1)点到出口(M,N)的所有迷宫路径。 [模型建立] 　　将迷宫中的每一格作为一个顶点，相邻格子可以到达，则对应的顶点之间存在边
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

#唐解元

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值