各种迷宫问题

最新推荐文章于 2024-05-01 20:15:53 发布
最新推荐文章于 2024-05-01 20:15:53 发布
阅读量3.9k 收藏 3
点赞数 3
分类专栏： LeetCode java 文章标签： java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_46480447/article/details/123973418
版权

迷宫游戏Ⅰ

  • 迷宫问题的解法就需要用到dfs。我们对上下左右四个方向，一个方向一个方向地尝试，如果沿着某个方向不能走到终点，我们就要原路返回，继续尝试其他方向，直到走出迷宫。这是一种最朴素的走迷宫方式，虽然效率也许比较低，但如果迷宫有解，就一定能走出终点。

    上面说的这种走法，就对应着我们要讲的dfs算法。首先找到起点s，走到每个点时，按照左、下、右、上的顺序尝试。每走到下一个点以后，我们把这个点当做起点s，继续按顺序尝试。如果某个点上下左右四个方向都尝试过，便回到走到这个点之前的点，这一步我们称之为回溯。继续尝试其他方向。直到所有点都尝试过上下左右四个方向。

    这就好比你自己去走这个迷宫，你也要一个方向一个方向的尝试着走，如果这条路不行，就回头，尝试下一条路，dfs的思想和我们直观的想法很类似。只不过，接下来我们需要用程序来完成这个过程。

  • 我们用一个二维的字符数组来表示迷宫，其中字符’S’表示起点，字符’T’表示终点，字符’*‘表示墙壁，字符’.'表示平地。你需要从S出发走到T，每次只能向上下左右相邻的位置移动，不能走出地图，也不能穿过墙壁，每个点只能通过一次。你需要输出一种从起点到终点的走法，将走过的点用’m’表示。

    输入

    5 6
....S.
.***..
.*..*.
*.***.
.T....

    输出

    ....Sm
.***.m
.*..*m
*.***m
.Tmmmm

import java.util.Scanner;

public class Main {
    static int n;
    static int m;
    static char ch[][];
    static boolean visited[][];//判断该点是否已经访问过
    static int index[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        ch = new char[n][m];
        visited = new boolean[n][m];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            String str = in.nextLine();
            ch[i] = str.toCharArray();
        }
        int x = 0, y = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                visited[i][j] = false;
                if (ch[i][j] == 'S') {
                    x = i;
                    y = j;
                }
            }
        }
        if (dfs(x, y)) {
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    ch[x][y] = 'S';
                    System.out.print(ch[i][j]);
                    if (j == m - 1) {
                        System.out.println();
                    }
                }
            }
        } else {
            System.out.println("没有找到合适的路径");
        }
    }

    public static boolean dfs(int x, int y) {
        if (ch[x][y] == 'T') {
            return true;
        }
        visited[x][y] = true;
        ch[x][y] = 'm';
        for (int i = 0; i < 4; i++) {
            int tx = x + index[i][0];
            int ty = y + index[i][1];
            if (in(tx, ty) && !visited[tx][ty] && ch[tx][ty] != '*') {
                if (dfs(tx, ty)) {
                    return true;
                }
            }
        }
        visited[x][y] = false;
        ch[x][y] = '.';
        return false;
    }

    public static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }
}

迷宫游戏Ⅱ

  • 有一个n xm的地图，地图由’.‘、’#'、'S '、‘T’这四个部分组成。’.‘表示可以通行的路，’#’表示迷宫的墙，'S’表示起始点，'T’表示终点。输出一个整数，表示从’S’到达’T’的所有方案数。

    输入

    5 5
S####
.####
.####
.####
....T

    输出

    m####
m####
m####
m####
mmmmT
 
1

import java.util.Scanner;

public class Main {
    static int n;
    static int m;
    static int count;
    static char ch[][];
    static boolean visited[][];
    static int index[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    public static void main(String[] args) {
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        ch = new char[n][m];
        visited = new boolean[n][m];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            String str = in.nextLine();
            ch[i] = str.toCharArray();
        }
        int x = 0, y = 0;
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                visited[i][j] = false;
                if (ch[i][j] == 'S') {
                    x = i;
                    y = j;
                }
            }
        }
        dfs(x, y);
        System.out.println(count);
    }
    
    public static boolean in(int x, int y) {
        return x >= 0 && x < n && y >= 0 && y < m;
    }

    public static void dfs(int x, int y) {
        if (!in(x, y) || visited[x][y] || ch[x][y] == '#') {
            return;
        }
        if (ch[x][y] == 'T') {
            count++;
            for (int i = 0; i < n; i++) {
                for (int j = 0; j < m; j++) {
                    System.out.print(ch[i][j]);
                    if (j == m - 1)
                        System.out.println();
                    if(i==n-1&&j==m-1)
                        System.out.println(" ");
                }
            }
            return;
        }
        visited[x][y] = true;
        ch[x][y] = 'm';
        for (int i = 0; i < 4; i++) {
            int tx = x + index[i][0];
            int ty = y + index[i][1];
            dfs(tx, ty);
        }
        visited[x][y] = false;
        ch[x][y] = '.';
        return;//可删除
    }
}

迷宫游戏Ⅲ

  • 有一个n xm的地图，地图由’.‘、’#‘这两个部分组成。四连通的’#'被认为是一个块，请问地图中最大的块是多少。

    输入

    3 3
##.
..#
###

    输出

    4

import java.util.Scanner;

public class Main {
    static int count;
    static int n;
    static int m;
    static boolean visited[][];
    static char ch[][];
    static int index[][] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};

    public static void main(String[] args) {
        int temp = 0;
        Scanner in = new Scanner(System.in);
        n = in.nextInt();
        m = in.nextInt();
        ch = new char[n][m];
        visited = new boolean[n][m];
        in.nextLine();
        for (int i = 0; i < n; i++) {
            String str = in.nextLine();
            ch[i] = str.toCharArray();
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                visited[i][j] = false;
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (ch[i][j] == '#' && !visited[i][j]) {
                    count = 0;
                    dfs(i, j);
                    if (count > temp) {
                        temp = count;
                    }
                }
            }
        }
        System.out.println(temp);
    }

    public static void dfs(int x, int y) {
        if (x < 0 || x >= n || y < 0 || y >= m || visited[x][y] || ch[x][y] == '.') {
            return;
        }
        visited[x][y] = true;
        count++;
        ch[x][y] = '.';
        for (int i = 0; i < 4; i++) {
            int tx = x + index[i][0];
            int ty = y + index[i][1];
            dfs(tx, ty);
        }
    }
}

水洼数

  • 有一个大小为N乘M的园子，雨后积起了水。八连通的积水被认为是连接在一起的。请求出园子里总共有多少水洼?(八连通指的是下图中相对W的*部分，W表示积水， '*'表示没有积水)

    ***

    *w*

    ***

    限制条件
    N, M <=100
    样例：

    输入

    10 12
W********WW*
*WWW*****WWW
****WW***WW*
*********WW*
*********W**
**W******W**
*W*W*****WW*
W*W*W*****W*
*W*W******W*
**W*******W*

    输出

    3

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int N = in.nextInt();
		int M = in.nextInt();
		char ch[][] = new char[N][M];
		for (int i = 0; i < N; i++) {
			ch[i] = in.next().toCharArray();
		}

		int count = 0;
		for (int i = 0; i < N; i++) {
			for (int j = 0; j < M; j++) {
				if (ch[i][j] == 'W') {
					dfs(ch, i, j);
					count++;
				}
			}
		}
		System.out.println(count);
	}

	public static void dfs(char ch[][], int i, int j) {
        //不需要回溯
		ch[i][j] = '*';
		for (int m = -1; m <= 1; m++) {
			for (int n = -1; n <= 1; n++) {
				if (m == 0 && n == 0) {
					continue;
				}
				if (i + m >= 0 && i + m <= ch.length - 1 && j + n >= 0 && j + n <= ch[i].length - 1) {
					if (ch[i + m][j + n] == 'W') {
						dfs(ch, i + m, j + n);
					}
				}
			}
		}
	}
}
wutu0513
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
migong.rar_迷宫问题
09-21
《迷宫问题详解与递归求解》 迷宫问题是一个经典的计算机科学问题，它涉及到图论、搜索算法以及递归等多方面的知识。在这个问题中，我们通常以二维矩阵的形式来表示迷宫，其中1代表可以通行的路径，0则表示障碍物。...
迷宫问题上下左右的代码
Findprincess的博客
02-12 410
定义数组X[ ]Y,[ ],x[1]y[1]表示方向向上向上 x += X[i]; y += Y[i]; #include<bits/stdc++.h> using namespace std; int X[] = {0, -1, 1, 0, 0}; //上下左右4个方向 int Y[] = {0, 0, 0, -1, 1}; bool vis[10][10]; //标记点是否被访问过 int res = 0; void dfs(int x, int y){
迷宫问题
qq_45856596的博客
08-26 206
迷宫问题 【解法】 人的走法有上、左、下、右四个方向，在每前进一格之后就选一个方向前进，无法前 进时退回选择下一个可前进方向，如此在阵列中依序测试四个方向，直到走到出口为止，这是 递回的基本题，请直接看程式应就可以理解。 #include<stdio.h> struct note { int x; int y; int s; }; int main() { struct note que[2500]; int a[50][50] = { 0 }; int book[50][50] =
迷宫问题详解
最新发布
ccc369639963的博客
05-01 1068
迷宫问题详解 迷宫问题指的是：在给定区域内，找到一条甚至所有从某个位置到另一个位置的移动路线。举个简单的例子，如图 1 所示，在白色区域内找到一条（甚至所有）从起点到终点的路线。 图 1 迷宫问题 迷宫问题就可以采用回溯算法解决，即从起点开始，采用不断“回溯”的方式逐一试探所有的移动路线，最终找到可以到达终点的路线。 回溯算法解决迷宫问题 以图 1 所示的迷宫为例，回溯算法解决此问题的具体思路是： 从当前位置开始，分别判断是否可以向 4 个方向（上、下、左、右）移动： 选择一个方向并移动到下个位置。判断此
洗白的迷宫
yeyongsheng369的博客
07-29 312
空间限制512MB时间限制1000ms。
c语言中dfs用pos做参数,简单易懂DFS(三)dfs剪枝策略
weixin_32161697的博客
05-21 404
剪枝： 顾名思义，就是通过一些判断，砍掉搜索树上不必要的子树。有时候，我们会发现某个节点对应的子树的状态都不是我们要的结果，那么我们其实没必要对这个分支进行搜索，砍掉这个子树，就是剪枝。可行性剪枝还是上篇中提到的一道题：例1：给定n个整数，要求选出K个数，使得选出来的K个数的和为sum。所谓可行性剪枝，就是把能够想到的它不可能出现的情况给它剪掉。对于每一个数，我们有两种选择：选或不选；在这其中，我...
BFS：迷宫最短路径
m0_73731708的博客
02-22 640
我们用一个二维的字符数组来表示迷宫；其中字符 S 表示起点，字符 T 表示终点，字符 * 表示墙壁，字符 . 表示平地。你需要从S出发走到T，每次只能向上下左右相邻的位置移动，不能走出地图，也不能穿过墙壁，每个点只能通过一次。你需要编程来求解出一种从起点到终点路程最短走法。无法到达终点输出-1；输入的第一行为两个整数，表示迷宫的行数和列数，中间用空格分开。下面每行为迷宫每行的样子。BFS广度优先搜索，每次优先搜索最近的节点，与DFS一条路走到黑形成鲜明对比。
zuoye.rar_迷宫问题
09-21
在IT领域，迷宫问题是一个经典的算法问题，它通常与图论、搜索算法以及数据结构紧密相关。在“zuoye.rar_迷宫问题”这个压缩包中，我们可以期待找到一系列关于迷宫问题的实例、测试数据以及可能的解决方案，这对于...
数据结构课程设计迷宫问题.doc
12-06
数据结构课程设计迷宫问题 数据结构课程设计迷宫问题是计算机科学领域中的一种经典问题，旨在设计一个程序来解决迷宫问题。...该程序可以用于解决各种迷宫问题，并且可以输出迷宫的通路信息或没有通路的信息。
Maze-problem-data-structure.rar_迷宫问题
09-23
在IT领域，迷宫问题是一种常见的算法挑战，它涉及到路径搜索、图遍历以及数据结构的应用。本资源包" Maze-problem-data-structure.rar_迷宫问题 "包含了多个关于迷宫问题的源代码，旨在帮助深入理解和解决这类问题。...
7-1 迷宫问题 (10 分)
weixin_46623714的博客
09-04 2495
一、题目描述 小明置身于一个迷宫，请你帮小明找出从起点到终点的最短路程。 小明只能向上下左右四个方向移动。 输入格式: 第一行是两个整数n和m (1≤ m, n ≤100)，表示迷宫的长和宽。接下来是n行，每行m个数字，表示整个迷宫。空地格子用0表示，障碍物用1表示，小明所在起点用3表示，终点用4表示。 输出格式: 如果能够到达终点，输出一个整数，表示小明从起点到目的地所需的最短时间。如果不能到达终点，输出“unreachable”。 输入样例1: 5 5 1 0 1 1 1 1 0 4 1
对于迷宫问题的汇总总结
m0_56184347的博客
05-08 945
1查找出岛屿的数量 class Solution { public int numIslands(char[][] grid) { //记录下当前岛屿的数量 int m=grid.length; int n=grid[0].length; int result=0; for(int i=0;i<m;i++){ for(int j=0;j<n;j++){
有一个N*M的格子迷宫，1代表该格子为墙，不能通过，0代表可以通过，另外，在迷宫中 有一些传送门，走到传送门的入口即会自动被传送到传送门的出口（一次传送算1步）。人在迷宫中可以尝试 上下左右四个方向移
chenjiazhanxiao的博客
04-12 1万+
  #include &lt;iostream&gt; #include &lt;string&gt; #include &lt;vector&gt; #include &lt;queue&gt; #include &lt;utility&gt; #include &lt;cstdio&gt; using namespace std; const int MAX_N = 100; cons...
使用上下左右记录迷宫路径
12-01 281
#include #include  #include "queue" using namespace std; int a[400][400]; int c[40000]; char d[40000],f[40000]; queue q; int k,r; int b[4][2]={ {-1,0},{1,0},{0,-1},{0,1} }; void migong(int
地下迷宫-------上下左右移动深度递归
Magic_Coder_Yang_S_Blog
08-06 1050
题目描述: 小青蛙有一天不小心落入了一个地下迷宫,小青蛙希望用自己仅剩的体力值P跳出这个地下迷宫。为了让问题简单,假设这是一个n*m的格子迷宫,迷宫每个位置为0或者1,0代表这个位置有障碍物,小青蛙达到不了这个位置;1代表小青蛙可以达到的位置。小青蛙初始在(0,0)位置,地下迷宫的出口在(0,m-1)(保证这两个位置都是1,并且保证一定有起点到终点可达的路径),小青蛙在迷宫中水平移动一个单位距离...
Coursera 学习记录：走出迷宫（二维数组的上下左右判断以及递归调用）
AhaKnow
12-25 2133
描述 当你站在一个迷宫里的时候，往往会被错综复杂的道路弄得失去方向感，如果你能得到迷宫地图，事情就会变得非常简单。 假设你已经得到了一个n*m的迷宫的图纸，请你找出从起点到出口的最短路。 输入 第一行是两个整数n和m(1 &lt;= n,m &lt;= 100)，表示迷宫的行数和列数。 接下来n行，每行一个长为m的字符串，表示整个迷宫的布局。字符’.’表示空地，’#’表示墙，’S’表示起点...
回溯算法之迷宫问题（Maze）
热门推荐
YING—country的博客
07-22 1万+
回溯算法之迷宫问题前言算法思路一、回溯算法二、经典问题之迷宫问题（Maze）（一）问题阐述 前言     迷宫问题是回溯算法的经典问题 算法思路 一、回溯算法     回溯算法实际上是一个类似枚举的搜索尝试过程，主要是在搜素尝试过程中寻找问题的解，当发现已满足求解条件时，就“回溯”返回，尝试别的路径。     回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标，但当搜索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种不通就回退再走的技术称为回溯法，而满足回溯条件的某个状态的点称为“回
c语言数据结构迷宫问题
09-26
### 回答1： OK，我理解了，您的问题是关于C语言中数据结构的迷宫问题。 C语言中，实现迷宫问题主要涉及到两个方面：一是地图的表示方式；二是搜索算法的实现。 对于地图的表示方式，可以使用二维数组来表示。假设地图的大小为m*n，那么我们可以定义一个m行n列的二维数组，每个元素表示一个地图上的位置。如果该位置可以通行，则标识为1，否则为0。 对于搜索算法的实现，可以使用广度优先搜索（BFS）或深度优先搜索（DFS）等算法。以BFS为例，其基本思路是从起点开始搜索，将其周围的位置加入队列中，然后从队列中取出一个位置进行搜索，直到找到终点或者队列为空为止。 在实现过程中，还需要考虑如何表示队列等数据结构，如何标识已经访问过的位置等问题。 希望以上内容能够对您有所帮助。如果您有任何问题或需要进一步的帮助，请随时向我提问。 ### 回答2： 迷宫问题是指在一个二维矩阵中，通过移动来找到从起点到终点的路径。C语言是一种用于程序设计的高级编程语言，可以处理各种数据结构。在利用C语言解决迷宫问题时，我们可以使用数据结构来表示迷宫并实现路径的查找。 在C语言中，我们可以使用二维数组来表示迷宫，其中不同的值代表不同的状态，比如起点、终点、墙壁和通道等。可以使用一个结构体来表示迷宫的坐标位置。 要解决迷宫问题，可以使用递归或者回溯算法。递归算法通过不断地探索下一个可行的位置，直到找到终点或者无法继续前进时回溯到上一个位置。回溯算法则是通过记录已经尝试过的路径，在无法继续前进时回到上一个节点再进行其他尝试。 在C语言中，我们可以使用递归函数来实现迷宫问题的解决。通过将当前位置标记为已访问，在每个可行的方向上递归调用自身，直到找到终点或者无法继续前进。如果找到了终点，则递归函数返回真，并将路径输出。否则，递归函数返回假，表示无法找到合适的路径。 总结来说，C语言可以通过二维数组和结构体来表示迷宫问题。使用递归函数和回溯算法可以在迷宫中找到从起点到终点的路径。通过灵活运用C语言和数据结构，我们可以解决各种迷宫问题。 ### 回答3： 在C语言中实现迷宫问题涉及到使用数据结构来解决迷宫中的路径搜索问题。可以使用二维数组表示迷宫地图，其中0表示空地，1表示墙壁。通过使用二维数组来表示迷宫，可以方便地在程序中操作迷宫地图。 解决迷宫问题的一个常见的方法是使用深度优先搜索算法。通过递归调用函数，在每个可能的路径上继续向前探索，直到找到一条通向终点的路径或者无路可走。在搜索过程中，需要使用访问标记数组来记录已经访问过的位置，避免陷入死循环。 具体实现时，可以定义一个递归函数，该函数可以接受迷宫地图、起始位置、目标位置等参数。在函数内部，首先判断当前位置是否为终点，如果是则返回true，表示找到了一条路径。然后根据当前位置进行上、下、左、右的四个方向探索，如果该方向可以走，并且没有访问过，则递归调用函数，继续向前探索。如果四个方向都无路可走，则返回false。 在每个递归调用中，需要更新访问标记数组，并将当前位置加入到路径中。如果找到了一条通向终点的路径，则可以将路径输出或者保存下来。 总之，使用C语言数据结构解决迷宫问题，可以通过二维数组表示迷宫地图，使用深度优先搜索算法进行路径搜索，同时使用访问标记数组避免陷入死循环。这样可以找到迷宫中从起点到终点的一条路径。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值