[Swift]LeetCode874. 模拟行走机器人 | Walking Robot Simulation

★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★
➤微信公众号：山青咏芝（shanqingyongzhi）
➤博客园地址：山青咏芝（https://www.cnblogs.com/strengthen/）
➤GitHub地址：https://github.com/strengthen/LeetCode
➤原文地址： https://www.cnblogs.com/strengthen/p/10600487.html 
➤如果链接不是山青咏芝的博客园地址，则可能是爬取作者的文章。
➤原文已修改更新！强烈建议点击原文地址阅读！支持作者！支持原创！
★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★★

A robot on an infinite grid starts at point (0, 0) and faces north.  The robot can receive one of three possible types of commands:

• -2: turn left 90 degrees
• -1: turn right 90 degrees
• 1 <= x <= 9: move forward x units

Some of the grid squares are obstacles. 

The i-th obstacle is at grid point (obstacles[i][0], obstacles[i][1])

If the robot would try to move onto them, the robot stays on the previous grid square instead (but still continues following the rest of the route.)

Return the square of the maximum Euclidean distance that the robot will be from the origin. 

Example 1:

Input: commands = [4,-1,3], obstacles = []
Output: 25
Explanation: robot will go to (3, 4)

Example 2:

Input: commands = [4,-1,4,-2,4], obstacles = [[2,4]]
Output: 65
Explanation: robot will be stuck at (1, 4) before turning left and going to (1, 8) 

Note:

1. 0 <= commands.length <= 10000
2. 0 <= obstacles.length <= 10000
3. -30000 <= obstacle[i][0] <= 30000
4. -30000 <= obstacle[i][1] <= 30000
5. The answer is guaranteed to be less than 2 ^ 31.

---

机器人在一个无限大小的网格上行走，从点 (0, 0) 处开始出发，面向北方。该机器人可以接收以下三种类型的命令：

• -2：向左转 90 度
• -1：向右转 90 度
• 1 <= x <= 9：向前移动 x 个单位长度

在网格上有一些格子被视为障碍物。

第 i 个障碍物位于网格点  (obstacles[i][0], obstacles[i][1])

如果机器人试图走到障碍物上方，那么它将停留在障碍物的前一个网格方块上，但仍然可以继续该路线的其余部分。

返回从原点到机器人的最大欧式距离的平方。 

示例 1：

输入: commands = [4,-1,3], obstacles = []
输出: 25
解释: 机器人将会到达 (3, 4)

示例 2：

输入: commands = [4,-1,4,-2,4], obstacles = [[2,4]]
输出: 65
解释: 机器人在左转走到 (1, 8) 之前将被困在 (1, 4) 处 

提示：

1. 0 <= commands.length <= 10000
2. 0 <= obstacles.length <= 10000
3. -30000 <= obstacle[i][0] <= 30000
4. -30000 <= obstacle[i][1] <= 30000
5. 答案保证小于 2 ^ 31

---

376ms

class Solution {
    func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
        let obstacles = obstacles.reduce(into: Set<Int>()){$0.insert($1[0]*100_000+$1[1])}
        
        var x = 0; var y = 0
        var dx = 0; var dy = 1
        var maxDist = 0
        
        for command in commands {
            switch command {
            case -2:
                swap(&dx,&dy); dx = -dx; break
            case -1:
                swap(&dx,&dy); dy = -dy; break
            default:
                maxDist = max(maxDist,x*x+y*y)
                for _ in 0..<command {
                    if !obstacles.contains((x+dx)*100_000+y+dy) {
                        x += dx; y += dy
                    } else {
                        break
                    }
                }
            }
        }
        
        maxDist = max(maxDist,x*x+y*y)
        return maxDist
    }
}

---

Runtime: 424 ms

Memory Usage: 19.4 MB

class Solution {
    func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
        var set:Set<String> = Set<String>()
        for obs in obstacles
        {
            set.insert(String(obs[0]) + " " + String(obs[1]))
        }
        var dirs:[[Int]] = [[0, 1],[1, 0],[0, -1],[-1, 0]]
        var d:Int = 0
        var x:Int = 0
        var y:Int = 0
        var result:Int = 0
        for c in commands
        {
            if c == -1
            {
                d += 1
                if d == 4 
                {
                    d = 0
                }
            }
            else if c == -2
            {
                d -= 1
                if d == -1
                {
                    d = 3
                }
            }
            else
            {
                var num = c
                while(num-- > 0 && !set.contains(String(x + dirs[d][0]) + " " + String(y + dirs[d][1])))
                {
                    x += dirs[d][0]
                    y += dirs[d][1]
                }
            }
             result = max(result, x * x + y * y)
        }
        return result
    }
}

/*扩展Int类，实现自增++、自减--运算符*/
extension Int{
    //后缀--:先执行表达式后再自减
    static postfix func --(num:inout Int) -> Int {
        //输入输出参数num
        let temp = num
        //num减1
        num -= 1
         //返回减1前的数值
        return temp
    }
}

---

428ms

class Solution {
    func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
        var current = (0, 0)
        var directs = [(0, 1), (1, 0), (0, -1), (-1, 0) ]
        var i = 0
        var result = 0
        var obstacles = Set<[Int]>(obstacles)
        for command in commands {
            if command == -1 {
                i = (i + 1) % 4
            } else if command == -2 {
                i = (i + 3) % 4
            } else {
                for _ in 0..<command {
                    let nextStep = (current.0 + (directs[i].0 * 1), current.1 + (directs[i].1 * 1))
                    if !obstacles.contains([nextStep.0, nextStep.1]) {
                        current = nextStep
                        result = max(result, current.0 * current.0 + current.1 * current.1)
                    } else {
                        break
                    }
                }
            }
        }
        return result
    }
}

---

436ms

class Solution {
    func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
    var set = Set<[Int]>()
    for p in obstacles {
        set.insert(p)
    }
    var pos = [0, 0]
    var x = 0
    var y = 1
    var maxDis = 0
    
    for c in commands {
        //turn right 90 degree
        if c == -1 {
            if x == 0 {
                x = y
                y = 0
            }
            else {
                y = -x
                x = 0
            }
        }
        //turn left 90 degree
        else if c == -2 {
            if x == 0 {
                x = -y
                y = 0
            }
            else {
                y = x
                x = 0
            }
        }
        else {
            for _ in 0..<c {
                pos[0] += 1 * x
                pos[1] += 1 * y
                if set.contains(pos) {
                    pos[0] -= 1 * x
                    pos[1] -= 1 * y
                    break
                }
            }
        }
        maxDis = max(maxDis, pos[0] * pos[0] + pos[1] * pos[1])
    }
    return maxDis
  }
}

---

444ms

class Solution {
    func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
        var obst = Set<String>()
        for o in obstacles {
            obst.insert("(o[0])-(o[1])")
        }
        var x = 0
        var y = 0
        var res = 0
        let dirX = [0, 1, 0, -1]
        let dirY = [1, 0, -1, 0]
        var dir = 0
        for c in commands {
            if c == -2 {
                dir -= 1
                if dir < 0 { dir = 3 }
            } else if c == -1 {
                dir += 1
                dir %= 4
            } else {
                inner: for _ in 1...c {
                    let newX = x + dirX[dir]
                    let newY = y + dirY[dir]
                    if !obst.contains("(newX)-(newY)") {
                        x = newX
                        y = newY
                    } else {
                        break inner
                    }
                }
                res = max(res, x * x + y * y)
            }
        }
        return res
    }
}

---

456ms

class Solution {
    func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
        var direction = 0
        var coordinate = (0, 0)
        var result = 0
        var obstacleSet = Set<String>()
        for obstacle in obstacles {
            obstacleSet.insert("(obstacle[0]) (obstacle[1])")
        }
        
        for command in commands {
            if command == -1 {
                direction += 1
                if direction == 4 {
                    direction = 0
                }
            } else if command == -2 {
                direction -= 1
                if direction == -1 {
                    direction = 3
                }
            } else if command >= 1 && command <= 9 {
                var bestMovement = 0
                for i in 1...command {
                    var targetPoint = ""
                    if direction == 0 {
                        targetPoint = "(coordinate.0) (coordinate.1 + i)"
                    } else if direction == 1 {
                        targetPoint = "(coordinate.0 + i) (coordinate.1)"
                    } else if direction == 2 {
                        targetPoint = "(coordinate.0) (coordinate.1 - i)"
                    } else if direction == 3 {
                        targetPoint = "(coordinate.0 - i) (coordinate.1)"
                    }
                    
                    if obstacleSet.contains(targetPoint) {
                        break
                    } else {
                        bestMovement = i
                    }
                }
                
                if direction == 0 {
                    coordinate.1 += bestMovement
                } else if direction == 1 {
                    coordinate.0 += bestMovement
                } else if direction == 2 {
                    coordinate.1 -= bestMovement
                } else if direction == 3 {
                    coordinate.0 -= bestMovement
                }
                result = max(result, coordinate.0 * coordinate.0 + coordinate.1 * coordinate.1)
            }
        }
        
        return result
    }
}

---

496ms

class Solution {
  func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
    let obstaSet = Set(obstacles)
    
    var maxDist = 0
    
    var pos = [0,0]
    var posI = 1
    var dir = 1
    
    for command in commands {
      if command == -2 {
        if posI == 1 {
          dir *= -1
        }
        posI ^= 1
      } else if command == -1 {
        if posI == 0 {
          dir *= -1
        }
        posI ^= 1
      } else {
        for _ in 1...command {
          pos[posI] += dir
          
          if obstaSet.contains(pos) {
            pos[posI] -= dir
            break
          }
        }
        
        maxDist = max(maxDist, pos[0] * pos[0] + pos[1] * pos[1])
      }
    }
    
    return maxDist
  }
}

---

940ms

class Solution {
    func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
        enum MoveType{
            case left
            case right
            case up
            case down
        }
        func modifi(_ type: inout MoveType, _ num: Int) {
            if num == -1 {
                switch type {
                case .down:
                    type = .left
                case .up:
                    type = .right
                case .left:
                    type = .up
                case .right:
                    type = .down
                }
            }
            if num == -2 {
                switch type {
                case .down:
                    type = .right
                case .up:
                    type = .left
                case .left:
                    type = .down
                case .right:
                    type = .up
                }
            }
        }
        var type: MoveType = .up
        var x = 0
        var y = 0
        let set: Set<String> = Set(obstacles.map({"($0[0])=($0[1])"}))
        var result = 0
        
        for i in (0..<commands.count) {
            let temp = commands[i]
            if temp == -1 || temp == -2 {
                modifi(&type, temp)
            }else {
                switch type {
                case .left:
                    for _ in (1...temp) {
                        let move = "(x - 1)=(y)"
                        if set.contains(move) {
                            break
                        }else {
                            x -= 1
                        }
                    }
                case .right:
                    for _ in (1...temp) {
                        let move = "(x + 1)=(y)"
                        if set.contains(move) {
                            break
                        }else {
                            x += 1
                        }
                    }
                case .up:
                    for _ in (1...temp) {
                        let move = "(x)=(y + 1)"
                        if set.contains(move) {
                            break
                        }else {
                            y += 1
                        }
                    }
                case .down:
                    for _ in (1...temp) {
                        let move = "(x)=(y - 1)"
                        if set.contains(move) {
                            break
                        }else {
                            y -= 1
                        }
                    }
                }
            }
            let t = x * x + y * y
            result = t > result ? t : result
        }
        return result
    }
}

---

1008ms

class Solution {
    enum Direction:Int{
        case top = 1
        case right
        case bottom
        case left
    }
    
     func robotSim(_ commands: [Int], _ obstacles: [[Int]]) -> Int {
        var newObstacles = Set(obstacles)
        var placeArray:[(Int,Int)] = []
        var currentPlace = (0,0)
        var currentDir = Direction.top
        for step in commands{
            if step == -1{
                if currentDir.rawValue + 1 > 4{
                    currentDir = .top
                }else{
                    currentDir = Direction.init(rawValue:currentDir.rawValue+1)!
                }
            }else if step == -2 {
                if currentDir.rawValue - 1 < 1{
                    currentDir = .left
                }else{
                    currentDir = Direction.init(rawValue:currentDir.rawValue-1)!
                }
            }else{
                for _ in 1...step{
                    var isbreak = false
                    switch currentDir{
                    case .top:
                        currentPlace.1 += 1
                        if newObstacles.contains([currentPlace.0,currentPlace.1]){
                            currentPlace.1 -= 1
                            isbreak = true
                        }
                    case .right:
                        currentPlace.0 += 1
                        if newObstacles.contains([currentPlace.0,currentPlace.1]){
                            currentPlace.0 -= 1
                            isbreak = true
                        }
                    case .bottom:
                        currentPlace.1 -= 1
                        if newObstacles.contains([currentPlace.0,currentPlace.1]){
                            currentPlace.1 += 1
                            isbreak = true
                        }
                    case .left:
                        currentPlace.0 -= 1
                        if newObstacles.contains([currentPlace.0,currentPlace.1]){
                            currentPlace.0 += 1
                            isbreak = true
                        }
                    }
                    if isbreak{
                        break
                    }
                }
            }
            placeArray.append(currentPlace)
        }
        
        return placeArray.map{$0.0 * $0.0 + $0.1 * $0.1}.max() ?? 0
    }
}