迷宫问题c语言

已于 2023-04-17 19:20:40 修改
阅读量71 收藏
点赞数 1
文章标签： 算法 c++ 开发语言
于 2023-04-13 10:58:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/clmm_/article/details/130091462
版权

示例1

输入：

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

复制输出：

(0,0)
(1,0)
(2,0)
(2,1)
(2,2)
(2,3)
(2,4)
(3,4)
(4,4)

示例2

输入：

5 5
0 1 0 0 0
0 1 0 1 0
0 0 0 0 1
0 1 1 1 0
0 0 0 0 0

复制输出：

(0,0)
(1,0)
(2,0)
(3,0)
(4,0)
(4,1)
(4,2)
(4,3)
(4,4)

核心算法是用GetMazePath递归来探索路径

#include<stdlib.h>
#include<assert.h>
#include <stdio.h>
typedef struct Position
{
	int row;
	int col;
}PT;
typedef PT ElemType;
typedef struct Stack
{
	int top;//栈顶
	ElemType* a;//后续使用动态开辟空间
	int capacity;//容量
}ST;
void StackInit(ST* ps)//初始化
{
	assert(ps);
	ps->top = 0;
	ps->a = NULL;
	ps->capacity = 0;
}
void StackPush(ST* ps, ElemType x)//增
{
	assert(ps);
	//检查空间，如果满了就二倍增容
	//如果是第一次增容则先开辟四个空间
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : (2 * ps->capacity);
		ElemType* tmp = (ElemType*)realloc(ps->a, sizeof(ST) * newcapacity);
		//如果ps->a为NULL，则此时realloc的作用与malloc一样
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			exit(0);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;

	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool StackEmpty(ST* ps)//判断是否为空
{
	assert(ps);
	if (ps->top == 0)//为空
	{
		return true;
	}

	else//不为空
	{
		return false;
	}
}
void StackPop(ST* ps)//删
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
	//printf("栈顶数据删除成功\n");
}

ElemType StackTop(ST* ps)//查看栈顶
{
	assert(ps);
	//找栈顶的话得保证指向的空间不为空
	assert(!StackEmpty(ps));
	//此时的top-1就是栈顶数据
	return ps->a[ps->top - 1];
}
void StackDestory(ST* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}
bool IsPass(int** maze,PT pos, int n, int m)
{
	if (pos.row >= n || pos.row < 0 || pos.col < 0 || pos.col >= m)
	{
		return false;
	}

	if (maze[pos.row][pos.col] == 0)
	{
		return true;
	}

	else
	{
		return false;
	}
}
ST path;
bool GetMazePath(int** maze, int n, int m, PT cur)
{
	StackPush(&path, cur);
	if (cur.row == n - 1 && cur.col == m - 1)
	{
		return true;
	}
	
	PT next = cur;
	maze[cur.row][cur.col] = 2;
	//上
	next = cur;
	next.row -= 1;
	if (IsPass(maze, next, n, m))
	{
		if (GetMazePath(maze, n, m, next))
		{
			return true;
		}
	}

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

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

	//右
	next = cur;
	next.col += 1;
	if (IsPass(maze, next, n, m))
	{
		if (GetMazePath(maze, n, m, next))
		{
			return true;
		}
	}
	StackPop(&path);
	return false;
}
void PrintPath()
{
	ST _path;
	StackInit(&_path);
	while (!StackEmpty(&path))
	{
		StackPush(&_path, StackTop(&path));
		StackPop(&path);
	}

	while (!StackEmpty(&_path))
	{
		PT top = StackTop(&_path);
		StackPop(&_path);
		cout << "(" << top.row << "," << top.col << ")" << endl;
	}
	StackDestory(&_path);
}
int main()
{
	int row = 0, col = 0;
	StackInit(&path);

	while (cin >> row >> col)
	{
		int** maze = new int* [row];
		int i = 0, j = 0;
		for (i = 0; i < row; i++)
		{
			maze[i] = new int[col];
		}

		for (i = 0; i < row; i++)
		{
			for (j = 0; j < col; j++)
			{
				cin >> maze[i][j];
			}
		}

		PT entery;
		entery.row = 0, entery.col = 0;
		if (GetMazePath(maze, row, col, entery))
		{
			PrintPath();
			cout << "找到通路" << endl;
		}
		else
		{
			cout << "未找到通路" << endl;
		}

		for (i = 0; i < row; i++)
		{
			delete[] maze[i];
		}

		delete[] maze;
		maze = NULL;
	}
	StackDestory(&path);
	return 0;
}

图的查找升级版！等以后有能力再解决

输入 #1

8
2 3 13
2 6  6
3 5  7
4 4 14
5 2 21
5 6  4
6 3 15
7 2 14
0 0  0

 输出 #1

67

typedef int ElemType;
typedef struct Stack
{
	int top;//栈顶
	ElemType* a;//后续使用动态开辟空间
	int capacity;//容量
}ST;
typedef struct position
{
	int row;
	int col;
}PT;
void StackInit(ST* ps)//初始化
{
	assert(ps);
	ps->top = 0;
	ps->a = NULL;
	ps->capacity = 0;
}
void StackPush(ST* ps, ElemType x)//增
{
	assert(ps);
	//检查空间，如果满了就二倍增容
	//如果是第一次增容则先开辟四个空间
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : (2 * ps->capacity);
		ElemType* tmp = (ElemType*)realloc(ps->a, sizeof(ST) * newcapacity);
		//如果ps->a为NULL，则此时realloc的作用与malloc一样
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			exit(0);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;

	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool StackEmpty(ST* ps)//判断是否为空
{
	assert(ps);
	if (ps->top == 0)//为空
	{
		return true;
	}

	else//不为空
	{
		return false;
	}
}
void StackPop(ST* ps)//删
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
	//printf("栈顶数据删除成功\n");
}
ElemType StackSize(ST* ps)//判断栈的长度
{
	assert(ps);
	return ps->top;
}
ElemType StackTop(ST* ps)//查看栈顶
{
	assert(ps);
	//找栈顶的话得保证指向的空间不为空
	assert(!StackEmpty(ps));
	//此时的top-1就是栈顶数据
	return ps->a[ps->top - 1];
}
void StackDestory(ST* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}


//第二个栈
typedef PT ElemType2;
typedef struct Stack2
{
	int top;//栈顶
	ElemType2* a;//后续使用动态开辟空间
	int capacity;//容量
}ST2;
void StackInit(ST2* ps)//初始化
{
	assert(ps);
	ps->top = 0;
	ps->a = NULL;
	ps->capacity = 0;
}
void StackPush(ST2* ps, ElemType2 x)//增
{
	assert(ps);
	//检查空间，如果满了就二倍增容
	//如果是第一次增容则先开辟四个空间
	if (ps->top == ps->capacity)
	{
		int newcapacity = ps->capacity == 0 ? 4 : (2 * ps->capacity);
		ElemType2* tmp = (ElemType2*)realloc(ps->a, sizeof(ST2) * newcapacity);
		//如果ps->a为NULL，则此时realloc的作用与malloc一样
		if (tmp == NULL)
		{
			printf("realloc fail!\n");
			exit(0);
		}
		ps->a = tmp;
		ps->capacity = newcapacity;

	}
	ps->a[ps->top] = x;
	ps->top++;
}
bool StackEmpty(ST2* ps)//判断是否为空
{
	assert(ps);
	if (ps->top == 0)//为空
	{
		return true;
	}

	else//不为空
	{
		return false;
	}
}
void StackPop(ST2* ps)//删
{
	assert(ps);
	assert(!StackEmpty(ps));
	ps->top--;
	//printf("栈顶数据删除成功\n");
}

ElemType2 StackTop(ST2* ps)//查看栈顶
{
	assert(ps);
	//找栈顶的话得保证指向的空间不为空
	assert(!StackEmpty(ps));
	//此时的top-1就是栈顶数据
	return ps->a[ps->top - 1];
}
void StackDestory(ST2* ps)
{
	assert(ps);
	if (ps->a)
	{
		free(ps->a);
	}
	ps->a = NULL;
	ps->top = 0;
	ps->capacity = 0;
}

bool IsPass(int maze[11][11], int n, PT next)
{
	if (next.row == n + 1 && next.col == n){
	
		return true;
	}

	if (next.row == n && next.col == n + 1){
		return true;	
	}

	if (next.row == n + 1 && next.col == n + 1) {
		return true;
	}

	if (next.row > n || next.col > n) {
		return false;
	}
	else {
		return true;
	}

}
ST st;
ST2 path;//路线
int data_1 = 0, data_2 = 0;

int StackCalc(ST* ps){
	int sum = 0;
	assert(ps);
	while (!StackEmpty(&st)){
		sum += StackTop(&st);
		StackPop(&st);
	}
	return sum;
}
void StackClean(ST* ps)
{
	assert(ps);
	while (!StackEmpty(ps))
	{
		StackPop(ps);
	}
}
int data_max = 0;
int data_max2 = 0;
//找迷宫通路，并记录最大的和，还有最大和的路线
void GetMazePath(int maze[11][11], int n, PT cur) {
	PT next = cur;
	int temp = 0;


	//StackPush(&path, cur);
	StackPush(&st, maze[cur.row][cur.col]);
	if (cur.row == n + 1 && cur.col == n + 1) {
		temp = StackCalc(&st);
		if (temp > data_max) {
			data_max = temp;
		}
		if (temp > data_max2 && temp < data_max) {
			data_max2 = temp;
		}
		StackClean(&st);
		return;
	}

	//往下走
	next.row += 1;
	if (IsPass(maze, n, next)) {
		GetMazePath(maze, n, next);
	}
	

	
	//往右走
	next = cur;
	next.col += 1;
	if (IsPass(maze, n, next)) {
		GetMazePath(maze, n, next);
		
	}
	
	//StackPop(&path);
}
int main(){
	StackInit(&st);
	StackInit(&path);

	int n = 0;
	cin >> n;
	int maze[11][11] = { 0 };
	int i = 0;
	int row = 1, col = 1, input = 1;
	while (row != 0 && col != 0 && input != 0) {
		cin >> row >> col >> input;
		maze[row][col] = input;
	}
	PT entery = { 1,1 };
	
	//第一次找最大
	GetMazePath(maze, n, entery);
	int sum = 0;
	sum += data_max;

	/*while (!StackEmpty(&path))
	{
		row = StackTop(&path).row;
		col = StackTop(&path).col;
		maze[row][col] = 0;
		StackPop(&path);
	}*/


	//第二次找次大
	GetMazePath(maze, n, entery);
	sum += data_max2;


	cout << sum + maze[1][1] << endl;
	StackDestory(&st);
	StackDestory(&path);

	return 0;
}

clmm_
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
C语言迷宫问题
田野麦子
03-08 2346
主要思路： 用一个包含坐标和方向的结点数据类型来存储迷宫中的结点； 用一个路径栈来实现通路的探测以及路径的回溯； 关键： 要注意迷宫边界点方向探测的条件限定，否则会产生不可预测的结果。 /*----------------------------------------------- 功能：迷宫问题，寻找一条简单通路（无重复路径） 输出示例： The path from (0, 0) to (...
迷宫问题（c语言）
坏鱼儿恋夏的博客
01-15 1091
#include #include int maze[5][5]; int mark[5][5]={0}; typedef struct{ int x; int y; }offset; offset direct[8] = {-1,0, -1,-1, 0,-1, 1,-1, 1,0, 1,1, 0,1, -1,1};
【数据结构】栈 实现迷宫算法
man_zuo的博客
09-06 4876
#include&lt;stdio.h&gt; #include&lt;stdlib.h&gt; #include&lt;string.h&gt; #include&lt;iostream&gt; using namespace std; #define STACK_INIT_SIZE 100 #define STACKINCREMENT 10 #define TURE 1 #define FA...
C语言——迷宫问题的非递归解法
weixin_44040023的博客
11-25 3166
#include<stdio.h> #include<stdlib.h> void MazeMap(); int **InitMaze(); int **InitBook(); int **CreatElem(); void PrintMaze(int **array); void FreeMaze(int **array); int m_row; int m_c...
【模拟B卷】5.迷宫问题求解
Read by heart
06-02 368
【反思】 1.巩固复习了回溯法 2.在写卷子的过程中没能解决路径输出的问题，此题有两种输出方式： 用栈将路径存储起来，当遇到终点的时候统一输出 将走过的足迹做标记，如标记为6，当遇到终点的时候将整个迷宫矩阵打印出来 3.如果还想要输出最短路径，可以每条路径及其长度存起来，在所有递归结束时再输出路径 【之前答案错误原因分析】 void MazePath(int i, int j)//输...
迷宫问题 C语言 超详细具体解题过程 地下迷宫
fengliang_v的博客
07-28 3286
牛客网上的迷宫问题没怎么看到c语言的解答版本也是数据结构栈的一个实际应用场景，值得学习 本篇文章主要解题思路在注释上，跟着代码一步步下去，再结合注释，应该不是很难理解。
迷宫问题c语言 深度优先搜索
07-23
在这个问题中，我们将重点讨论如何使用C语言实现深度优先搜索（DFS）来解决迷宫问题。深度优先搜索是一种用于遍历或搜索树或图的算法，其基本思想是尽可能深地探索图的分支，直到达到目标节点或者回溯到一个没有被...
深度优先搜索迷宫问题c语言,使用栈解决迷宫问题(深度优先遍历)
weixin_30086041的博客
05-23 1040
问题描述：有如图所示迷宫，设计一个算法，找出一条从入口到出口的路径。思路分析：我们使用一个二维数组模拟迷宫，并新建一个栈来保存从入口通往出口的路径。然后以入口节点为基准节点依次向四周探测，如果探测到新的活节点，就将新探测到的活节点压入栈中，并以此新节点为基准节点继续向四周探测，直到找出迷宫出口。如果某基准节点四周不存在活节点，则认为此基准节点为死节点，将其从栈中弹出，返回上次基准节点继续探测(为避...
迷宫问题 c语言
06-12
在C语言中解决迷宫问题可以提供对计算机底层逻辑和算法实现的深刻理解。本文将深入探讨如何使用C语言来解决迷宫问题，并结合数据结构的知识进行详细阐述。 首先，我们要明确迷宫问题的基本概念。一个迷宫可以被抽象...
(完整word版)数据结构栈求解迷宫问题C语言版.doc
10-24
数据结构栈求解迷宫问题C语言版 在计算机科学中，迷宫问题是一个经典的算法问题，旨在寻找从迷宫的起点到终点的路径。为了解决这个问题，我们可以使用栈数据结构来存储路径，并使用递归或迭代的方法来寻找路径。在...
算法练习题13——除自身以外数组的乘积（动态规划）
hello77的blogggg 祝你得偿所愿
09-04 902
给你一个整数数组nums，返回 数组answer，其中answer[i]等于nums中除nums[i]之外其余各元素的乘积。
【大数据分析与挖掘算法】matlab实现——Apriori关联规则算法
Robbi_的博客
09-04 690
四、实验结果。
C语言：刷题笔记
weixin_45930573的博客
09-04 416
c语言刷题记录
树状数组记录
最新发布
volcan的博客
09-06 626
树状数组（Fenwick Tree）是一种用于维护数组前缀和的数据结构，支持高效的单点更新和区间查询操作。它的查询和更新时间复杂度为Ologn，适用于需要频繁更新和查询的场景。
力扣刷题--1534. 统计好三元组【简单】
m0_75266675的博客
09-04 381
力扣刷题--1534. 统计好三元组【简单】
【算法】单词出现次数和位置统计
Hanbuhuic的博客
09-04 389
编写一个程序，用于统计一个给定单词在一段文本中出现的次数以及第一次出现的位置。如果单词在文本中出现，则输出出现次数和第一次出现的位置（位置从0开始计算）。如果单词没有出现，则输出-1。
【滑动窗口】将 x 减到 0 的最小操作数
qq_42150700的博客
09-03 1141
当然也是没有必要的, 因为你要求区间里面的和至少要 target. 你刚刚区间, 就恰好是 >= target 的边界. 也就是说, 左边的值应该都是 <= target 的, 也就是下面这个图蓝色区间的和, 肯定是小于 target 的. 因为是正好加了右侧指针的值才 >= target 停下的。更新结果: 结果的更新, 可以说是最好写的一个部分, 你要什么, 你就在什么时候更新. 我们要的是 sum = target 的长度, 那我们就在 sum = target 的时候更新长度不就行了?
专题一_双指针_算法专题详细总结
2301_80636070的博客
09-06 917
利用双指针，cur=0，dest=-1，只要nums[cur]==0 dest就走两格；否则 dest走一格；但是无论怎么样cur都走一格。直到dest到达结尾处n-1 停止，即 判断dest>=n-1 处 break；
[ C++ ] 一文复习（基础语法，语言特性，STL回顾）
2301_79175236的博客
09-04 1071
C++复习参考文，待完善
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值