490. The Maze

本文探讨了一种特殊迷宫寻路问题,通过球在迷宫中滚动直至遇到墙壁停止的规则,利用深度优先搜索算法(DFS)判断球是否能从起点到达终点。文章详细解释了算法实现过程及代码细节。

摘要生成于 C知道 ,由 DeepSeek-R1 满血版支持, 前往体验 >

####问题描述
There is a ball in a maze with empty spaces and walls. The ball can go through empty spaces by rolling up, down, left or right, but it won’t stop rolling until hitting a wall. When the ball stops, it could choose the next direction.

Given the ball’s start position, the destination and the maze, determine whether the ball could stop at the destination.

The maze is represented by a binary 2D array. 1 means the wall and 0 means the empty space. You may assume that the borders of the maze are all walls. The start and destination coordinates are represented by row and column indexes.

Example 1:

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (4, 4)

Output: true

Explanation: One possible way is : left -> down -> left -> down -> right -> down -> right.

Example 2:

Input 1: a maze represented by a 2D array

0 0 1 0 0
0 0 0 0 0
0 0 0 1 0
1 1 0 1 1
0 0 0 0 0

Input 2: start coordinate (rowStart, colStart) = (0, 4)
Input 3: destination coordinate (rowDest, colDest) = (3, 2)

Output: false

Explanation: There is no way for the ball to stop at the destination.

Note:

There is only one ball and one destination in the maze.
Both the ball and the destination exist on an empty space, and they will not be at the same position initially.
The given maze does not contain border (like the red rectangle in the example pictures), but you could assume the border of the maze are all walls.
The maze contains at least 2 empty spaces, and both the width and height of the maze won’t exceed 100.

题目链接:

####思路分析
给一二维数组表示一个迷宫,球只有碰到墙壁之后才会停下,问球能否到达终点。

For this question, it is a variation of ordinary dfs problem. Because in this question, the ball could move forward through multiple cells not one.
####代码

class Solution {
    private int[][] dirs = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    public boolean hasPath(int[][] maze, int[] start, int[] destination) {
        if (maze.length == 0 || maze[0].length ==  0){
            return false;
        }
        return dfs(maze, start, destination, new boolean[maze.length][maze[0].length]);
    }
    
    private boolean dfs(int[][] maze, int[] current, int[] destination, boolean[][] visited){
        int x = current[0];
        int y = current[1];
        if (x == destination[0] && y == destination[1]){
            return true;
        }
        if (x < 0 || y < 0 || x >= maze.length || y >= maze[0].length || visited[x][y]){
            return false;
        }
        visited[x][y] = true;
        for (int[] dir : dirs){
            int xx = x, yy = y;
            while (xx >= 0 && xx < maze.length && yy >= 0 && yy < maze[0].length && maze[xx][yy] == 0 ){
                xx += dir[0];
                yy += dir[1];
            }
            //retrive one step for the while loop is moving forward one cell.
            if (dfs(maze, new int[]{xx - dir[0], yy - dir[1]}, destination, visited)){
                return true;
            }
        }
        return false;
    }
}

时间复杂度: O ( n ) O(n) O(n)
空间复杂度: O ( n ) O(n) O(n)


反思
好的,下面是 `freegames.maze` 模块的详细注释: ```python """ freegames.maze This module provides functions to create and manipulate mazes. Functions: maze(width, height, complexity=0.75, density=0.75): Create a maze with the given dimensions and complexity/density. Classes: Maze: A maze object that can be displayed and solved using Turtle graphics. """ import random def maze(width, height, complexity=0.75, density=0.75): """ Create a maze with the given dimensions and complexity/density. Parameters: - width (int): the width of the maze in cells. - height (int): the height of the maze in cells. - complexity (float): a value between 0 and 1 that determines the amount of complexity/number of twists and turns in the maze. - density (float): a value between 0 and 1 that determines the amount of density/number of cells that are filled in the maze. Returns: - A 2D list of booleans representing the maze, where True indicates a wall and False indicates a path. """ # Determine the dimensions of the maze in cells. rows = height // 2 + 1 cols = width // 2 + 1 # Create the maze as a 2D list of booleans. maze = [[False] * cols for i in range(rows)] # Fill in the border cells as walls. for i in range(rows): maze[i][0] = maze[i][-1] = True for j in range(cols): maze[0][j] = maze[-1][j] = True # Fill in the maze with walls and paths. for i in range(1, rows - 1): for j in range(1, cols - 1): if random.random() < density: maze[i][j] = True elif i % 2 == 0 or j % 2 == 0: maze[i][j] = True # Carve out the maze starting from the center. start_x, start_y = rows // 2, cols // 2 maze[start_x][start_y] = False cells = [(start_x, start_y)] while cells: current = cells.pop(random.randint(0, len(cells) - 1)) x, y = current neighbors = [] if x > 1 and not maze[x - 2][y]: neighbors.append((x - 2, y)) if x < rows - 2 and not maze[x + 2][y]: neighbors.append((x + 2, y)) if y > 1 and not maze[x][y - 2]: neighbors.append((x, y - 2)) if y < cols - 2 and not maze[x][y + 2]: neighbors.append((x, y + 2)) if neighbors: cells.append(current) neighbor = neighbors[random.randint(0, len(neighbors) - 1)] nx, ny = neighbor if nx == x - 2: maze[x - 1][y] = False elif nx == x + 2: maze[x + 1][y] = False elif ny == y - 2: maze[x][y - 1] = False elif ny == y + 2: maze[x][y + 1] = False maze[nx][ny] = False return maze class Maze: """ A maze object that can be displayed and solved using Turtle graphics. Attributes: - maze (list): a 2D list of booleans representing the maze. - width (int): the width of the maze in cells. - height (int): the height of the maze in cells. - cell_size (int): the size of each cell in pixels. - turtle (turtle.Turtle): the turtle used to draw the maze. - screen (turtle.Screen): the screen used to display the maze. Methods: - __init__(self, maze, cell_size=10): create a new Maze object. - _draw_wall(self, row, col): draw a wall at the given cell. - _draw_path(self, row, col): draw a path at the given cell. - display(self): display the maze using Turtle graphics. - solve(self, start=(0, 0), end=None): solve the maze using the given start and end positions, and return a list of (row, col) tuples representing the solution path. """ def __init__(self, maze, cell_size=10): """ Create a new Maze object. Parameters: - maze (list): a 2D list of booleans representing the maze. - cell_size (int): the size of each cell in pixels. """ self.maze = maze self.width = len(maze[0]) self.height = len(maze) self.cell_size = cell_size self.turtle = None self.screen = None def _draw_wall(self, row, col): """ Draw a wall at the given cell. Parameters: - row (int): the row number of the cell. - col (int): the column number of the cell. """ x = col * self.cell_size y = row * self.cell_size self.turtle.goto(x, y) self.turtle.setheading(0) self.turtle.pendown() for i in range(4): self.turtle.forward(self.cell_size) self.turtle.left(90) self.turtle.penup() def _draw_path(self, row, col): """ Draw a path at the given cell. Parameters: - row (int): the row number of the cell. - col (int): the column number of the cell. """ x = col * self.cell_size + self.cell_size // 2 y = row * self.cell_size + self.cell_size // 2 self.turtle.goto(x, y) self.turtle.dot(self.cell_size // 2) def display(self): """ Display the maze using Turtle graphics. """ if not self.turtle: import turtle self.turtle = turtle.Turtle() self.turtle.hideturtle() self.turtle.speed(0) self.turtle.penup() self.turtle.setheading(0) self.turtle.goto(0, 0) self.turtle.pendown() self.turtle.color('black') self.screen = self.turtle.getscreen() self.screen.setworldcoordinates(0, 0, self.width * self.cell_size, self.height * self.cell_size) for row in range(self.height): for col in range(self.width): if self.maze[row][col]: self._draw_wall(row, col) else: self._draw_path(row, col) self.screen.exitonclick() def solve(self, start=(0, 0), end=None): """ Solve the maze using the given start and end positions, and return a list of (row, col) tuples representing the solution path. Parameters: - start (tuple): a (row, col) tuple representing the starting position. Defaults to (0, 0). - end (tuple): a (row, col) tuple representing the ending position. Defaults to the bottom-right corner of the maze. Returns: - A list of (row, col) tuples representing the solution path. """ if not end: end = (self.height - 1, self.width - 1) queue = [(start, [start])] visited = set() while queue: (row, col), path = queue.pop(0) if (row, col) == end: return path if (row, col) in visited: continue visited.add((row, col)) if row > 0 and not self.maze[row - 1][col]: queue.append(((row - 1, col), path + [(row - 1, col)])) if row < self.height - 1 and not self.maze[row + 1][col]: queue.append(((row + 1, col), path + [(row + 1, col)])) if col > 0 and not self.maze[row][col - 1]: queue.append(((row, col - 1), path + [(row, col - 1)])) if col < self.width - 1 and not self.maze[row][col + 1]: queue.append(((row, col + 1), path + [(row, col + 1)])) return None ``` 以上就是 `freegames.maze` 模块的详细注释,希望能帮助你更好地理解它的实现和使用。
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

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

抵扣说明:

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

余额充值