zoukankan      html  css  js  c++  java
  • 490. The Maze

    package LeetCode_490
    
    import java.util.*
    import kotlin.collections.HashSet
    
    /**
     * 490. The Maze
     * (Prime)
     * https://www.lintcode.com/problem/the-maze/description
     * 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:
    map =
    [
    [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]
    ]
    start = [0,4]
    end = [3,2]
    Output:
    false
     * */
    class Solution {
        /*
        * solution:BFS, let the node go through one direction to end and check if can reach destination,
        * Time complexity:O(mn), Space complexity:O(mn)
        * */
        fun hasPath(maze: Array<IntArray>, start: IntArray?, destination: IntArray?): Boolean {
            if (maze == null || start == null || destination == null) {
                return false
            }
            if (maze.isEmpty() || start.isEmpty() || destination.isEmpty()) {
                return false
            }
            val visited = HashSet<String>()
            val directions = intArrayOf(0, 1, 0, -1, 0)
            val queue = LinkedList<Pair<Int, Int>>()
            queue.offer(Pair(start[0], start[1]))
            visited.add("${start[0]}-${start[1]}")
            while (queue.isNotEmpty()) {
                val cur = queue.pop()
                val x = cur.first
                val y = cur.second
                //check if reach to the destination
                if (x == destination[0] && y == destination[1]) {
                    return true
                }
                //check 4 directions
                for (d in 0 until 4) {
                    var newX = x + directions[d]
                    var newY = y + directions[d + 1]
                    //go through one direction to the end
                    while (isValidPath(newX, newY, maze)) {
                        newX += directions[d]
                        newY += directions[d + 1]
                    }
                    //move back a step
                    newX -= directions[d]
                    newY -= directions[d + 1]
                    //put into queue to check in next level
                    if (!visited.contains("$newX-$newY")) {
                        visited.add("$newX-$newY")
                        queue.offer(Pair(newX, newY))
                    }
                }
            }
            return false
        }
    
        private fun isValidPath(x: Int, y: Int, maze: Array<IntArray>): Boolean {
            if (x >= 0 && x < maze.size && y >= 0 && y < maze[0].size && maze[x][y] == 0) {
                return true
            }
            return false
        }
    }
  • 相关阅读:
    Linux内核中锁机制之RCU、大内核锁
    Linux内核中锁机制之完成量、互斥量
    Linux内核中锁机制之信号量、读写信号量
    Linux内核中锁机制之内存屏障、读写自旋锁及顺序锁
    Linux内核中锁机制之原子操作、自旋锁
    Linux内核jiffies简介
    pdflush机制
    ext2文件系统
    从ext2文件系统上读出超级块
    ext2磁盘布局
  • 原文地址:https://www.cnblogs.com/johnnyzhao/p/13800364.html
Copyright © 2011-2022 走看看