[Swift]LeetCode403. 青蛙过河 | Frog Jump

原文地址：https://www.cnblogs.com/strengthen/p/10311244.html 

A frog is crossing a river. The river is divided into x units and at each unit there may or may not exist a stone. The frog can jump on a stone, but it must not jump into the water.

Given a list of stones' positions (in units) in sorted ascending order, determine if the frog is able to cross the river by landing on the last stone. Initially, the frog is on the first stone and assume the first jump must be 1 unit.

If the frog's last jump was k units, then its next jump must be either k - 1, k, or k + 1 units. Note that the frog can only jump in the forward direction.

Note:

• The number of stones is ≥ 2 and is < 1,100.
• Each stone's position will be a non-negative integer < 231.
• The first stone's position is always 0. 

Example 1:

[0,1,3,5,6,8,12,17]

There are a total of 8 stones.
The first stone at the 0th unit, second stone at the 1st unit,
third stone at the 3rd unit, and so on...
The last stone at the 17th unit.

Return true. The frog can jump to the last stone by jumping 
1 unit to the 2nd stone, then 2 units to the 3rd stone, then 
2 units to the 4th stone, then 3 units to the 6th stone, 
4 units to the 7th stone, and 5 units to the 8th stone.

Example 2:

[0,1,2,3,4,8,9,11]

Return false. There is no way to jump to the last stone as 
the gap between the 5th and 6th stone is too large.

---

一只青蛙想要过河。 假定河流被等分为 x 个单元格，并且在每一个单元格内都有可能放有一石子（也有可能没有）。 青蛙可以跳上石头，但是不可以跳入水中。

给定石子的位置列表（用单元格序号升序表示）， 请判定青蛙能否成功过河（即能否在最后一步跳至最后一个石子上）。 开始时， 青蛙默认已站在第一个石子上，并可以假定它第一步只能跳跃一个单位（即只能从单元格1跳至单元格2）。

如果青蛙上一步跳跃了 k 个单位，那么它接下来的跳跃距离只能选择为 k - 1、k 或 k + 1个单位。 另请注意，青蛙只能向前方（终点的方向）跳跃。

请注意：

• 石子的数量 ≥ 2 且 < 1100；
• 每一个石子的位置序号都是一个非负整数，且其 < 231；
• 第一个石子的位置永远是0。

示例 1:

[0,1,3,5,6,8,12,17]

总共有8个石子。
第一个石子处于序号为0的单元格的位置, 第二个石子处于序号为1的单元格的位置,
第三个石子在序号为3的单元格的位置， 以此定义整个数组...
最后一个石子处于序号为17的单元格的位置。

返回 true。即青蛙可以成功过河，按照如下方案跳跃： 
跳1个单位到第2块石子, 然后跳2个单位到第3块石子, 接着 
跳2个单位到第4块石子, 然后跳3个单位到第6块石子, 
跳4个单位到第7块石子, 最后，跳5个单位到第8个石子（即最后一块石子）。

示例 2:

[0,1,2,3,4,8,9,11]

返回 false。青蛙没有办法过河。 
这是因为第5和第6个石子之间的间距太大，没有可选的方案供青蛙跳跃过去。

---

64ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        if stones.count == 0 {
            return false
        }
        let n = stones.count
        if n == 1 {
            return true
        }
        if stones[1] != 1 {
            return false
        }
        if n == 2 {
            return true
        }
        let last = stones.last!
        var hs = Set<Int>()
        for i in 0..<n {
            if i > 3 && stones[i] > stones[i - 1] * 2 {
                return false
            }
            hs.insert(stones[i])
        }
        return canReach(hs, last, 1, 1)
    }

    fileprivate func canReach(_ hs: Set<Int>, _ last: Int, _ pos: Int, _ jump: Int) -> Bool {
        if pos + jump - 1 == last || pos + jump == last || pos + jump + 1 == last {
            return true
        }
        if hs.contains(pos + jump + 1) {
            if canReach(hs, last, pos + jump + 1, jump + 1) {
                return true
            }
        }
        if hs.contains(pos + jump) {
            if canReach(hs, last, pos + jump, jump) {
                return true
            }
        }
        if jump > 1 && hs.contains(pos + jump - 1) {
            if canReach(hs, last, pos + jump - 1, jump - 1) {
                return true
            }
        }
        return false
    }
}

---

108ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {        
        guard stones.count > 1 else {
            return true
        }
        
        var memo = [Int: Int]()
        
        for i in 0..<stones.count {
            if i > 3 && stones[i] > stones[i - 1] * 2 {
                return false
            }
            memo[stones[i]] = i
        }
        
        var deadEnd = [[Bool]](repeating:[Bool](repeating:false, count:stones.count + 1), count: stones.count + 1)
        

        
        func jump(index:Int, preStep:Int) -> Bool {
            if index == stones.count - 1 {
                return true
            }
            
            if deadEnd[index][preStep] == true {
                return false
            }
            
            if let nIndex = memo[stones[index] + preStep - 1], nIndex > index{
                if jump(index:nIndex ,preStep:preStep - 1) {
                    return true
                } else {
                    deadEnd[nIndex][preStep - 1] = true
                }
            }
            
            if let nIndex = memo[stones[index] + preStep], nIndex > index {
                if jump(index:nIndex,preStep:preStep) {
                    return true
                } else {
                    deadEnd[nIndex][preStep] = true
                }
            }
            
            if let nIndex = memo[stones[index] + preStep + 1], nIndex > index {
                if jump(index:nIndex,preStep:preStep + 1) {
                    return true
                } else {
                    deadEnd[nIndex][preStep + 1] = true
                }
            }
            
            return false
        }
        
        return jump(index:0, preStep: 0)
    }
}

---

164ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        var dp = [String : Bool]()
        var map = [Int: Int]()
        for i in 0..<stones.count {
            map[stones[i]] = i
        }
        return canCross(stones, map, from: 0, jump: 1, &dp)
    }
    
    func canCross(_ stones: [Int], _ map: [Int: Int], from i: Int, jump k: Int, _ dp: inout [String: Bool]) -> Bool {        
        let key = "(i)(k)"
        if let res = dp[key] {
            return res
        }
        
        if i == stones.count-1 {
            dp[key] = true
            return true
        }
        
        if k <= 0 { return false }

        guard let j = map[stones[i] + k] else  {
            dp[key] = false
            return false
        }
        
        let res = canCross(stones, map, from: j, jump: k-1, &dp) 
            || canCross(stones, map, from: j, jump: k, &dp)
            || canCross(stones, map, from: j, jump: k+1, &dp)
        dp[key] = res
        return res
    }
}

---

256ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        let set = Set(stones)
        var cache = [String: Bool]()
        return helper(set, 0, 0, stones.last!, &cache)
    }
    
    func helper(_ set: Set<Int>, _ i: Int, _ lastJump: Int, _ last: Int, _ cache: inout [String: Bool]) -> Bool {
        if i == last { return true }
        if let r = cache["(i)-(lastJump)"] { return r }
        let possibleJumps = Array(max(lastJump-1, 1)...max(lastJump+1, 1))
        for j in possibleJumps {
            if set.contains(i+j) {
                if helper(set, i+j , j, last, &cache) {
                    return true
                }
            }
        }
        cache["(i)-(lastJump)"] = false
        return false
    }
}

---

428ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        //[stone,possibleStep]
        if stones.count == 2 {
            return stones[1] == 1
        }
        var dp = Dictionary<Int,Set<Int>>()
        dp[0] = Set<Int>()
        dp[0]!.insert(1)
        for i in 1..<stones.count{
            dp[stones[i]] = Set<Int>()
        }
        let stonesLastIndex = stones.count - 1
        for i in 0...stonesLastIndex {
            let stone = stones[i]
            if let steps = dp[stone] as Set<Int>?{
                for step in steps {
                    let reach = step + stone
                    if reach == stones[stonesLastIndex]{
                        return true
                    }
                    if var newStoneSet = dp[reach]{
                        newStoneSet.insert(step)
                        if step - 1 > 0{
                            newStoneSet.insert(step - 1)
                        }
                        newStoneSet.insert(step + 1)
                        dp[reach] = newStoneSet

                    }
                }
            }
        }
        return false
    }
}

---

432ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        var m:[Int:Set<Int>] = [Int:Set<Int>]()
        var dp:[Int] = [Int](repeating:0,count:stones.count)
        var set:Set<Int> = [0]
        m[0] = set
        var k:Int = 0
        for i in 1..<stones.count
        {
            while(dp[k] + 1 < stones[i] - stones[k])
            {
                k += 1
            }
            for j in k..<i
            {
                var t:Int = stones[i] - stones[j]
                if m[j] != nil && (m[j]!.contains(t - 1) || m[j]!.contains(t) || m[j]!.contains(t + 1))
                {
                    if m[i] == nil
                    {
                        var set2:Set<Int> = [t]
                        m[i] = set2
                    }
                    else
                    {
                        m[i]!.insert(t)
                    }
                    
                    dp[i] = max(dp[i], t)
                }
            }
        }
        return dp.last! > 0
    }
}

---

528ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        var result = [Int: Set<Int>]()
        for stone in stones {
            result[stone] = Set<Int>()
        }
        result[0]!.insert(0)
        for stone in stones {
            for step in result[stone]! {
                for newStep in step - 1...step + 1 {
                    if newStep > 0 && result[stone + newStep] != nil {
                        result[stone + newStep]!.insert(newStep)
                    }
                }
            }
        }
        return result[stones.last!]!.count > 0
    }
}

---

536ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        guard !stones.isEmpty else {
            return false
        }

        let stonesSet = Set(stones)
        var dict = [Int: Set<Int>]()
        dict[0] = [0]

        for stone in stones {
            if let steps = dict[stone] {
                for step in steps {
                    for possible in (step - 1)...(step + 1) {
                        if possible > 0 {
                            let nextLocation = stone + possible
                            if stonesSet.contains(nextLocation) {
                                if var locationSteps = dict[nextLocation] {
                                    locationSteps.insert(possible)
                                    dict[nextLocation] = locationSteps
                                } else {
                                    dict[nextLocation] = [possible]
                                }
                            }
                        }
                    }
                }
            }
        }

        let last = stones.last!
        return dict[last] != nil
    }
}

---

564ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        var map: [Int: Set<Int>] = [:]
        
        // stores possible steps to get to this stone
        for stone in stones {
            map[stone] = Set<Int>()
        }
        map[0]?.insert(0)
        for stone in stones {
            for k in map[stone]! {
                for step in k-1...k+1 {
                    let newDest = stone + step
                    if step > 0 && map.keys.contains(newDest) {
                        map[newDest]!.insert(step)
                    }
                }
            }
        }
        return !map[stones.last!]!.isEmpty
    }
}

---

704ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        // Key is stone and array is possible steps to reach stone
        var map = [Int: Set<Int>]() 
        
        // fill all the stone as key to map
        for stone in stones {
            map[stone] = Set<Int>()
        }
        
        // Initialize the first first index of map with "0"
        map[0] = [0]
        
        // Loop through each stone and fill the map with threee possible values        
        for stone in stones {
           if let stonesArray = map[stone] {
            for possibleWay in stonesArray {
                
                for step in (possibleWay - 1 ... possibleWay + 1) {
                    
                    if let value = map[stone + step] {
                        var steps = value
                        steps.insert(step)
                        map[stone + step] = steps
                    }
                }
             }
        }
        }
        if let lastValues = map[stones[stones.count - 1]] {
                return lastValues.count > 0
            }
        return false
    }
}

---

820ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        var jump:[Int:Set<Int>] = [0:[1], 1:[1,2]]
        for i in 0..<stones.count{  
            if jump[stones[i]] == nil{
                continue
            }
            let steps = jump[stones[i]]!
            for step in steps{
                if stones[i] + step == stones.last{
                    return true
                }
                jump[stones[i]+step] = jump[stones[i]+step] ?? [step]
                if step-1 > 0{
                    jump[stones[i]+step]?.insert(step-1)
                }
                jump[stones[i]+step]?.insert(step)
                jump[stones[i]+step]?.insert(step+1)
                
            }
        }
        return false
    }
}

---

848ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        var map: [Int: Set<Int>] = [:]
        
        // stores possible steps to get to this stone
        for stone in stones {
            map[stone] = Set<Int>()
        }
        map[0]?.insert(0)
        for stone in stones {
            if stone == stones.last { return !map[stone]!.isEmpty }
            for k in map[stone]! {
                for step in k-1...k+1 {
                    let newDest = stone + step
                    if step > 0 && map.keys.contains(newDest) {
                        map[newDest]!.insert(step)
                    }
                }
            }
        }
        return false
    }
}

---

1028ms

class Solution {    
    var impossibleJumps: [Int: Set<Int>] = [:]
    func availableJumpDistance(_ lastJumpDistance: Int) -> [Int] {

        if lastJumpDistance <= 1 {
            return [1, 2]
        }        
        return [lastJumpDistance - 1, lastJumpDistance, lastJumpDistance + 1]
    }

    func availableStonePositions(_ lastJumpDistance: Int, _ lastStonePosition: Int) -> [Int] {
        
        let distances = availableJumpDistance(lastJumpDistance).map { $0 + lastStonePosition }
        return distances
        
    }

    func moveFrog(stones: [Int], lastJumpDistance: Int = 1) -> [Int] {
        guard stones.indices.contains(0) else { return [] }        
        let currentStone = stones[0]        
        let jumpableStones = availableStonePositions(lastJumpDistance, currentStone)        
        for (i, stone) in stones.enumerated() {
            if stone > jumpableStones.last ?? Int.max {
                break
            }            
            guard jumpableStones.contains(stone) else { continue }            
            let jumpDistance = stone - currentStone            
            if let memoryStone = impossibleJumps[stone] {
                if memoryStone.contains(jumpDistance) {
                    continue
                }
            }            
            let newPath = Array(stones[i...])            
            let newPathResult = moveFrog(stones: newPath, lastJumpDistance: jumpDistance)            
            if newPathResult.count == 1 {
                return newPathResult
            } else {
                if impossibleJumps[stone] == nil {
                    impossibleJumps[stone] = [jumpDistance]
                } else {
                    impossibleJumps[stone]?.insert(jumpDistance)
                }
            }            
        }
        return stones        
    }
    
    func canCross(_ stones: [Int]) -> Bool {
        var stones = stones        
        guard stones[1] == 1 else {
            return false
        }        
        stones = Array(stones[1...])
        // End prepare stones for crossing        
        var lastJumpDistance = 1        
        let result = moveFrog(stones: stones)        
        return result.count == 1
    }
}

---

1428ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
    
    guard stones.count >= 2 && stones[0] == 0 && stones[1] == 1 else { return false }
    guard checkMaxDistance(stones: stones) else { return false }
    var lists: [[Int:Bool]] = [[Int:Bool]](repeatElement([Int:Bool](), count: stones.count))
    
    func canCrossDP(k: Int, currentIndex: Int) -> Bool {
        
        if currentIndex == stones.count - 1 { return true }
        var index = currentIndex
        
        while true {
            let distanceBetween = stones[index+1] - stones[currentIndex]
            if k-1...k+1 ~= distanceBetween {
                switch distanceBetween {
                case k: if lists[index][k] == nil { lists[index][k] = canCrossDP(k: k, currentIndex: index+1) }
                case k-1: if lists[index][k-1] == nil { lists[index][k-1] = canCrossDP(k: k-1, currentIndex: index+1) }
                case k+1: if lists[index][k+1] == nil { lists[index][k+1] = canCrossDP(k: k+1, currentIndex: index+1) }
                default: break
                }
            }
            
            if lists[index][k] ?? false || lists[index][k-1] ?? false || lists[index][k+1] ?? false { return true }
            
            if index + 2 < stones.count {
                index += 1
            } else {
                return false
            }
        }
    }
    
    return canCrossDP(k: 1, currentIndex: 1)
}

func checkMaxDistance(stones: [Int]) -> Bool {
    for i in stride(from: stones.count-1, to: 1, by: -1) {
        if stones[i] - stones[i-1] > stones.count - 1 {
            return false
        }
    }
    return true
 }
}

---

1500ms

class Solution {
    func canCross(_ stones: [Int]) -> Bool {
        let len = stones.count
        var jumps = Array<(canJumpHere:Bool,kSet:Set<Int>)>.init(repeating: (false,Set<Int>()), count: len)
        jumps[0] = (true,Set.init(arrayLiteral: 1))
        
        for i in 0..<len {
            let (canJumpHere,kSet) = jumps[i]
            if(canJumpHere == false){ continue }
            for j in i+1..<len {
                //如果两个之间的间隔有k，那么代表能够跳到j上
                let step = stones[j] - stones[i]
                if(kSet.contains(step)){
                    jumps[j] = (true,jumps[j].kSet.union([step-1,step,step+1]))
                }
            }
        }
        let (canGetHere,_) = jumps[len-1]
        return canGetHere
    }
}