3.2迷宫求解

已于 2023-06-30 22:09:02 修改
阅读量234 收藏
点赞数
文章标签： 算法
于 2023-06-30 15:53:18 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangbiaoxiaoming/article/details/131478325
版权
文章提供了一个使用Java编写的控制台迷宫游戏，玩家可以通过输入坐标来探索迷宫。同时，还展示了C语言实现的迷宫路径搜索算法，该算法通过栈来暴力寻找从起点到终点的路径。迷宫由二维数组表示，墙壁和可行走区域有特殊标记。
摘要由CSDN通过智能技术生成

首先我没 看懂数据结构书上写得迷宫 求解 不过 不重要了

迷宫求解 需要先有个 迷宫 游戏
以下 是 Java写的 控制台迷宫游戏

import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MazeGameJ {
    public static void main(String[] args) {
        //地图模拟
        //二维数组 0表示墙  1 表示可以走
        //(1,1)表示起点  （8，8）表示终点
        int[][] ints = new int[10][10];

        //记录走过的位置
        //0 位置存储 棋盘横坐标
        //1 位置存储棋盘纵坐标
        int[][] run_point = new int[100][2];
        run_point[0][0]=1;
        run_point[0][1]=1;

        //初始化地图
        init(ints);

        //开始游戏
        run(ints,run_point);

//        show(ints);

    }

    public  static  void  init(int[][]ints){
        //四周墙
        for (int i = 0; i <10 ; i++) {
            ints[0][i] = 1;
            ints[9][i] = 1;
            ints[i][0] = 1;
            ints[i][9] = 1;
        }

        //中间墙
        ints[8][1]=1;
        ints[4][2]=1;
        ints[6][2]=1;
        ints[7][2]=1;
        ints[1][3]=1;
        ints[2][3]=1;
        ints[4][3]=1;
        ints[7][3]=1;
        ints[4][4]=1;
        ints[5][4]=1;
        ints[7][4]=1;
        ints[7][5]=1;
        ints[3][6]=1;
        ints[6][6]=1;
        ints[7][6]=1;
        ints[2][7]=1;
        ints[7][7]=1;
        ints[3][3]=1;
        ints[4][6]=1;
        ints[5][6]=1;
        ints[2][5]=1;

    }
    public static void  show(int[][] ints,int[][] run_point,int step){
        for (int i = 0; i <= step; i++) {
            ints[run_point[step][0]][run_point[step][1]]=2;
        }

        for (int i = 0; i <10 ; i++) {
            for (int j = 0; j <10 ; j++) {
                if(ints[i][j]==0){
                    System.out.format("\33[32;1m");
                    System.out.print("A");
                    System.out.print(" ");
                }else if(ints[i][j]==2){
                    System.out.format("\33[0m");
                    System.out.print("B");
                    System.out.print(" ");
                }else {
                    System.out.format("\33[31;1m");
                    System.out.print("#");
                    System.out.print(" ");
                }
            }
            System.out.println();
        }
    }
    public  static  void  run(int[][] ints,int[][] run_point){
        int step =0;
        show(ints,run_point,step);
        Scanner scanner = new Scanner(System.in);
        while (true){
            //步数
            System.out.format("\33[0m");
            System.out.print("请输入一个坐标:\n");
            String s = scanner.nextLine();
            //输入合法性a,b
            Pattern pattern = Pattern.compile("[1-8],[1-8]");
            Matcher matcher = pattern.matcher(s);
            if(matcher.matches()){
                String[] split = s.split(",");
                //位置连续性检查
                if((run_point[step][0]+1==Integer.parseInt(split[0])&&run_point[step][1] ==Integer.parseInt(split[1]))
                        || (run_point[step][0]==Integer.parseInt(split[0])&&run_point[step][1]+1 ==Integer.parseInt(split[1]))
                        || (run_point[step][0]-1==Integer.parseInt(split[0])&&run_point[step][1]==Integer.parseInt(split[1]))
                        || (run_point[step][0]==Integer.parseInt(split[0])&&run_point[step][1]-1 ==Integer.parseInt(split[1]))
                ){
                    //判断是否不能走
                    if (ints[Integer.parseInt(split[0])][Integer.parseInt(split[1])]==0) {

                        //判断胜利结束
                        if (Integer.parseInt(split[0])==8&&Integer.parseInt(split[1])==8) {
                            step++;
                            run_point[step][0] = Integer.parseInt(split[0]);
                            run_point[step][1] = Integer.parseInt(split[1]);
                            System.out.print("\033[H\033[2J");
                            System.out.flush();
                            show(ints,run_point,step);
                            System.out.println("恭喜你!通关了!");
                            System.exit(1);
                        }
                        step++;
                        run_point[step][0] = Integer.parseInt(split[0]);
                        run_point[step][1] = Integer.parseInt(split[1]);
                    }else {
                        System.out.println("游戏结束!");
                        System.exit(1);
                    }

                }else {
                    System.out.println("输入不合法请重新输入");
                }


            }else {
                System.out.println("输入不合法请重新输入");
            }

            //显示
            System.out.print("\033[H\033[2J");
            System.out.flush();
        
            show(ints,run_point,step);

        }

    }

}

然后求解 下面是 求解 c代码

#include <stdio.h> 

typedef  int PosTyoe[2];

typedef int MazeType[10][10];
typedef int Status;

typedef struct {

 //   int ord; //通道块在路径上的顺序
	PosTyoe seat; //通道块在迷宫中的坐标位置
//	int di; //从通道走向下一通道的方向
}SElemType; //栈的元素类型

Status MazePath(MazeType maze,PosTyoe start,PosTyoe end) {
	//利用栈 暴力寻找迷宫出路 
	//策略 下 右 上 左 的顺序

	//创建一个栈  将 初始位置 放在栈里
	//用数组模拟栈
	int i;
	SElemType  IninStack__ [1000];

	//栈顶位置
	i = 0;
	//将初始位置 放在栈里
	IninStack__[i].seat[0] = start[0];
	IninStack__[i].seat[1] = start[1];
	maze[IninStack__[i].seat[0]][IninStack__[i].seat[1]] = 1;
	++i;

	//开始寻找 
	while (i)
	{	

		//判断是否已经到达终点
		if (IninStack__[i - 1].seat[0] + 1 == end[0] && IninStack__[i - 1].seat[1] == end[1]) {
			IninStack__[i].seat[0] = IninStack__[i - 1].seat[0] + 1;
			IninStack__[i].seat[1] = IninStack__[i - 1].seat[1];
			++i;
			break;
		}

		//判断是否已经到达终点
		if (IninStack__[i - 1].seat[0]  == end[0] && IninStack__[i - 1].seat[1]+1 == end[1]) {
			IninStack__[i].seat[0] = IninStack__[i - 1].seat[0];
			IninStack__[i].seat[1] = IninStack__[i - 1].seat[1]+1;
			++i;
			break;
		}



		//先往下寻找 maze的 i+1
		if (maze[IninStack__[i-1].seat[0] + 1][IninStack__[i-1].seat[1]] != 1) {
			//如果不是0,表示能通过
					//这时候就将这个 位置进栈
					IninStack__[i].seat[0] = IninStack__[i - 1].seat[0] + 1;
					IninStack__[i].seat[1] = IninStack__[i - 1].seat[1];
					//将走过的位置设置为墙 不能 往回走
					maze[IninStack__[i - 1].seat[0] + 1][IninStack__[i - 1].seat[1]] = 1;
					++i;
					continue;
	
	

		}
		//尝试往右走
		if (maze[IninStack__[i-1].seat[0] ][IninStack__[i-1].seat[1]+1] != 1)
		{
			    //如果不是0,表示能通过}
               //这时候就将这个 位置进栈
				IninStack__[i].seat[0] = IninStack__[i - 1].seat[0];
				IninStack__[i].seat[1] = IninStack__[i - 1].seat[1] + 1;
				//将走过的位置设置为墙 不能 往回走
				maze[IninStack__[i - 1].seat[0]][IninStack__[i - 1].seat[1] + 1] = 1;
				++i;

				continue;
			

		}

		//尝试往上走
		if (maze[IninStack__[i - 1].seat[0]-1][IninStack__[i - 1].seat[1]] != 1)
		{	

			//如果不是0,表示能通过
				//没走过就可以走
			//这时候就将这个 位置进栈
				IninStack__[i].seat[0] = IninStack__[i - 1].seat[0]-1;
				IninStack__[i].seat[1] = IninStack__[i - 1].seat[1];
				//将走过的位置设置为墙 不能 往回走
				maze[IninStack__[i - 1].seat[0] - 1][IninStack__[i - 1].seat[1]] = 1;
				++i;
				continue;

		}

		//尝试往左走
		if (maze[IninStack__[i - 1].seat[0] ][IninStack__[i - 1].seat[1]-1] != 1)
		{
			//如果不是0,表示能通过
			//这时候就将这个 位置进栈
				IninStack__[i].seat[0] = IninStack__[i - 1].seat[0];
				IninStack__[i].seat[1] = IninStack__[i - 1].seat[1]-1;
				//将走过的位置设置为墙 不能 往回走
				maze[IninStack__[i - 1].seat[0]][IninStack__[i - 1].seat[1] - 1] = 1;
				++i;
				continue;
			

		}

		//如果都没有走通
		//标记自己所在点为不通，将自己出栈
		maze[IninStack__[i - 1].seat[0]][IninStack__[i - 1].seat[1]] = 1;
		--i;

	}

	if (!i) {
		printf("此迷宫没有解\n");
		return 0;
	}

	int j;
	for (j = 1; j < i; j++) {
		printf("%d,%d\n",IninStack__[j].seat[0], IninStack__[j].seat[1]);
	}
	return 0;

}


int main() {
	MazeType maze;
	PosTyoe start;
	PosTyoe end;
	//四周墙
	int i;
	for (i = 0; i < 10; i++) {
		maze[0][i] = 1;
		maze[9][i] = 1;
		maze[i][0] = 1;
		maze[i][9] = 1;
	}
	//中间墙
	maze[8][1] = 1;
	maze[4][2] = 1;
	maze[6][2] = 1;
	maze[7][2] = 1;
	maze[1][3] = 1;
	maze[2][3] = 1;
	maze[4][3] = 1;
	maze[7][3] = 1;
	maze[4][4] = 1;
	maze[5][4] = 1;
	maze[7][4] = 1;
	maze[7][5] = 1;
	maze[3][6] = 1;
	maze[6][6] = 1;
	maze[7][6] = 1;
	maze[2][7] = 1;
	maze[7][7] = 1;
	maze[3][3] = 1;
	maze[4][6] = 1;
	maze[5][6] = 1;
	maze[2][5] = 1;

	start[0] = 1;
	start[1] = 1;

	end[0] = 8;
	end[1] = 8;

	MazePath(maze, start, end);

	return 0;
};

看效果 在这里插入图片描述

在这里插入图片描述

偶尔正经的小明
关注
迷宫游戏求解：智能体的探索之旅
AI天才研究院
05-05 165
1. 背景介绍 1.1 迷宫的魅力与挑战 迷宫，作为一种古老的智力游戏，以其错综复杂的路径和迷雾重重的氛围，吸引着无数冒险者和解谜爱好者。从古希腊神话中的克里特迷宫到现代电子游戏中的虚拟迷宫，迷宫一直是人类智慧和探索精神的试金石。然而，迷宫的复杂性也带来了巨大的挑战，如何在迷宫中找到正确的路径，成为
迷宫求解（C++）
Xppal的博客
02-07 2064
迷宫求解（C++） 此算法适用C++，使用栈求解迷宫。本文采用系统栈函数，迷宫为n行m列，并对上篇文章进行了大量改进。
迷宫自动生成求解器 数据结构课程设计
KKKKKaiX的博客
01-11 1056
通过递归回溯算法实现了一个迷宫生成器。由于实现了一个栈结构，因此该生成器可以生成任意大的迷宫而不会受系统调用栈的限制。
数据结构课程设计——迷宫问题求解
不太聪明的椰羊的博客
12-19 5413
NEFU，计算机与控制工程学院，基于C/C++的数据结构 ，课程设计，迷宫问题求解
【数据结构与算法（C语言）】栈的实际应用之二：迷宫求解（具有动画效果）
weiweiliude2的专栏
05-31 1404
C语言实现迷宫求解，实现动态路径
迷宫路径求解
yilandan0725的博客
04-20 792
一.问题描述现有一个迷宫，以S作为起点，G作为终点，#作为墙壁，. 作为可以通行的道路，求从起点到终点的路径。多条路径，分别输出。例如，输入：( 为便于观看，下图做了处理，输入 4  4 表示迷宫的长度（X轴）和宽度（Y轴）输出从S到G点的行走路径，要求不能绕圈，即走过的点不能再走。结果如下：（表示有两条路线）(1,2),(2,2),(3,2),(3,1),(3,0),(1,2),(1,3),(2...
数据结构课设：迷宫问题（队列求解）
qq_63855497的博客
09-26 2892
Step3：对队头进行东、南、西、北四个方向进行扩展，再对待扩展的结点进行判断，如果待扩展的结点不为墙，并且在当前路径中没有出现过，即为满足条件的点，可加入队列，并记录结点属性，如此即可通过队列求得所有满足条件的路径。Step2：取出队头元素，并将其从队列中删除，判断其是否为终点，如果是，则保存路径，根据pre逆向获取路径，并保存至stk数组中，以便使用。给定一个n*m的迷宫，0表示迷宫中的通路，1表示迷宫中的墙壁，给定起点和终点，求解从起点到终点的所有通路，或者没有找到通路的结论。2、可视化显示迷宫。
数据结构(3-2)--用栈实现迷宫问题的求解
合衬绅士的博客
11-19 4184
数据结构--用栈实现迷宫问题的求解前言问题概述程序思路代码实现自定义一个迷宫数据的存储结构栈的操作迷宫的操作代码汇总反思总结标志变量的使用 前言 最近保持一周三更，出十篇数据结构的博客之后会出Java的。 博客排版会逐步规范。 代码排版会沿用我自己的风格并且继续改进。代码注释会反复考虑，如果过于复杂就会分块排版代码。 这篇博客之后会上一个栈的基本操作的文件和一篇随机生成迷宫的程序博客。 后续会在...
java走迷宫穷举_迷宫问题求解之“穷举+回溯”（一）
weixin_32339855的博客
02-26 369
求迷宫从入口到出口的所有路径是一个经典的程序设计问题，求解迷宫，通常采用的是“穷举+回溯”的思想，即从入口开始，顺着某一个方向出发，若能够走通，就继续往前走；若不能走通，则退回原路，换一个方向继续向前探索，直到所有的通路都探寻为止。因此本文依据这种“穷举+回溯”的思想，设计一个求解迷宫的程序。1 问题分析为了保证在任何位置上都能够退回原路，显然需要使用一个先进后出的数据结构来保存已经探寻过的位置，...
C语言数据结构顺序栈之迷宫求解
01-15
本主题聚焦于“C语言数据结构顺序栈之迷宫求解”，这是一个结合了基本数据结构和算法的有趣应用。我们将深入探讨顺序栈、迷宫问题以及如何使用C语言实现迷宫求解算法。 顺序栈是一种线性数据结构，它的元素按照...
迷宫求解数据结构课程设计报告
11-15
　3.2 概要设计………………………………………………7 　3.3 详细设计………………………………………………7 　3.4 调试分析………………………………………………10 　3.5 测试结果……………………………………...
算法基础-链表
August的专栏
11-05 153
当链表的长度为偶数时，head找到的中点是靠后的，因为fast相对slow移动只快了1步，而head.next找到的中点是靠前的，因为fast相对slow移动快了2步。这2种方式寻找链表的结点主要区别是 当链表的长度为奇偶数时，找到链表中点的位置一个靠后，一个靠前。使用快慢指针寻找链表的中点有2种方式，分别是fast=head;当链表为奇数时 [1->2->3->4->5]当链表长度为奇数时，找到的中点2种方式是一样的。当链表为偶数时 [1->2->3->4]
算法竞赛——02基本算法
QD_Jason的博客
10-31 939
算法竞赛——02基本算法
深⼊理解指针2
ElePower9527的博客
11-01 663
指针访问数组内容时，有如下代码这⾥我们使⽤ &arr[0] 的⽅式拿到了数组第⼀个元素的地址，但是其实数组名本来就是地址，⽽且 是数组⾸元素的地址，我们来做个测试。输出结果我们发现数组名和数组⾸元素的地址打印出的结果⼀模⼀样，数组名就是数组⾸元素(第⼀个元素)的地址。注意有两个例外• sizeof(数组名)，sizeof中单独放数组名，这⾥的数组名表⽰整个数组，计算的是整个数组的⼤⼩， 单位是字节。
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
weixin_66461496的博客
11-02 999
CSP/信奥赛C++刷题训练：经典深搜例题（1）：洛谷1605 ：迷宫
【二分查找】【三种写法】——在排序数组中查找元素的第一个和最后一个位置#力扣hot100
weixin_47868976的博客
10-31 1129
给你一个按照非递减顺序排列的整数数组nums，和一个目标值target。请你找出给定目标值在数组中的开始位置和结束位置。如果数组中不存在目标值target，返回[-1, -1]。必须设计并实现时间复杂度为O(log n)的算法解决此问题。
【LeetCode】【算法】160.相交链表
最新发布
passer__jw767的博客
11-05 168
Leetcode 160. 相交链表
【算法】（Python）贪心算法
yannan20190313的博客
11-04 1569
【算法】（Python）贪心算法（最大单元数，买卖股票最佳时机，最低加油次数）
C语言实现经典迷宫求解算法
"C语言实现迷宫求解的代码示例" 在编程领域，迷宫求解是一种常见的问题，它涉及到路径搜索算法，如深度优先搜索（DFS）或广度优先搜索（BFS）。这个资源提供了一个用C语言实现迷宫求解的实例，通过使用栈来存储路径...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值