用栈实现迷宫求解

本专题属于数据结构:栈部分;
本程序用于二维层面寻找可通过路径,以1和0区分是否,可通过。寻找路径,需要考虑走过的四个方向,或是8个方向。在对已经走过的地方,进行标注,防止在某一处重复检索。
具体实现直接看程序

#include<iostream>
#include<stack>

using namespace std;

class point
{
public:
	int x;
	int y;

	point(int x, int y)
	{
		this->x = x;
		this->y = y;
	}
    point()
    {
        x = y = 0;
    }
};

point change(int i, point& m)//四个方向进行改变
{
    switch (i)
    {
    case 1:
        return point(m.x + 1, m.y);
    case 2:
        return point(m.x, m.y + 1);
    case 3:
        return point(m.x - 1, m.y);
    case 4:
        return point(m.x, m.y - 1);
    }
}

int check(point& m,int map[15][15])//用来检查该点是否可通行,或者是否到了终点
{
    if (map[m.x][m.y] == 3)
        return 1;
    if (map[m.x][m.y] == 0)
    {
        return -1;
    }
    else return 0;
}

void Getpath(stack<point>& m, int map[15][15])
{
    int temp = 0;
    point a;
    cout << "路径是:" << endl;
    int i;
    while (temp != 1)
    {

        for (i = 1; i <= 4; i++)
        {
            a = change(i, m.top());
            temp = check(a, map);
            if (temp == 1 || temp == -1)
            {
                m.push(a);
                map[a.x][a.y] = 4;//对走过的点进行标记
                break;
            }
        }
        if (i == 5) m.pop();
    }
    
}

int main()
{
	stack<point> m;
	//零不可走,1可走,3为终点
    int map[15][15] = { { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
                        { 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 },
                        { 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 1 },
                        { 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1 },
                        { 1, 1, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1 },
                        { 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1 },
                        { 1, 1, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 1, 1, 1 },
                        { 1, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1 },
                        { 1, 1, 1, 1, 0, 1, 0, 1, 1, 1, 0, 1, 1, 1, 1 },
                        { 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
                        { 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1 },
                        { 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 1 },
                        { 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 1, 0, 1, 1, 1 },
                        { 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 1 },
                        { 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 } };
    point n(4, 2);
    m.push(point(1,1));
    Getpath(m, map);
    while(!m.empty())
    {
        point a;
        a = m.top();
        m.pop();
        cout << "("<<a.x<<","<< a.y<<")"<<endl;
    }
    
}

欢迎关注公众号:一起自学计算机技术啊(微信栏搜索→公众号→一起自学计算机技术啊),里面有数百本计算机方面的书籍以及数学建模的资料,
公众号二维码

在这里插入图片描述

  • 0
    点赞
  • 3
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
求解算法? 可以使用深度优先搜索算法(DFS)来求解迷宫。具体实现方法是使用栈来保存走过的路径,当搜索到终点时,中的路径就是一条正确的路径。以下是 Python 实现迷宫求解的示例代码: ```python # 定义迷宫 maze = [[0, 0, 0, 0, 0, 0, 0, 0], [0, 1, 1, 0, 1, 1, 1, 0], [0, 1, 0, 0, 0, 1, 0, 0], [0, 1, 1, 1, 1, 1, 0, 1], [0, 1, 0, 0, 0, 1, 0, 0], [0, 1, 1, 0, 1, 1, 1, 0], [0, 0, 0, 0, 0, 0, 0, 0]] # 定义节点 class StackNode: def __init__(self, x, y, next=None): self.x = x self.y = y self.next = next # 定义 class Stack: def __init__(self): self.head = None def push(self, x, y): node = StackNode(x, y, self.head) self.head = node def pop(self): if self.head is None: return None node = self.head self.head = node.next return node def is_empty(self): return self.head is None # 定义迷宫求解函数 def solve_maze(maze): start_x, start_y = 1, 1 # 起点 end_x, end_y = 5, 6 # 终点 stack = Stack() stack.push(start_x, start_y) directions = [(0, 1), (1, 0), (0, -1), (-1, 0)] # 右下左上 while not stack.is_empty(): node = stack.pop() x, y = node.x, node.y for dx, dy in directions: nx, ny = x + dx, y + dy if maze[nx][ny] == 0: # 未走过的路径 stack.push(nx, ny) maze[nx][ny] = maze[x][y] + 1 # 记录步数 if nx == end_x and ny == end_y: # 到达终点 return maze[nx][ny] return None # 没有找到正确路径 # 输出迷宫求解结果 steps = solve_maze(maze) if steps is None: print("没有找到正确路径") else: print(steps) ``` 这段代码中,我们首先定义了一个迷宫,使用 0 表示通路,使用 1 表示墙,然后定义了一个节点和一个数据结构节点保存迷宫中的一个位置,用于保存路径。在迷宫求解函数中,我们首先将起点入,然后使用深度优先搜索算法不断向前寻找可走的路径,直到找到终点或者为空时停止。当搜索到一个节点时,我们将其未走过的路径入,并记录到达该节点时的步数。如果最终能够到达终点,则返回到达终点的步数。如果没有找到正确的路径,则返回 None。

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

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

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

打赏作者

We Fab

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

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

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

打赏作者

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

抵扣说明:

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

余额充值