Frog Jump

class Solution {
public:
    bool canCross(vector<int>& stones) {
        unordered_map<int, unordered_set<int>> reach;
        for (int s : stones) reach[s] = {};
        reach[0].insert(0);
        for (int s : stones) {
            for (int k : reach[s]) {
                for (int next : {k - 1, k, k + 1}) {
                    if (next > 0 && reach.count(s + next))
                        reach[s + next].insert(next);
                }
            }
        }
        return !reach[stones.back()].empty();
    }
};

func canCross(stones []int) bool {
    reach := map[int]map[int]bool{}
    for _, s := range stones {
        reach[s] = map[int]bool{}
    }
    reach[0][0] = true
    for _, s := range stones {
        for k := range reach[s] {
            for _, next := range []int{k - 1, k, k + 1} {
                if next > 0 {
                    if _, ok := reach[s+next]; ok {
                        reach[s+next][next] = true
                    }
                }
            }
        }
    }
    return len(reach[stones[len(stones)-1]]) > 0
}

from typing import List
from collections import defaultdict

class Solution:
    def canCross(self, stones: List[int]) -> bool:
        reach = defaultdict(set)
        for s in stones:
            reach[s]  # ensure key exists
        reach[0].add(0)
        stone_set = set(stones)
        for s in stones:
            for k in list(reach[s]):
                for nxt in (k - 1, k, k + 1):
                    if nxt > 0 and (s + nxt) in stone_set:
                        reach[s + nxt].add(nxt)
        return bool(reach[stones[-1]])

var canCross = function(stones) {
    const reach = new Map();
    for (const s of stones) reach.set(s, new Set());
    reach.get(0).add(0);
    for (const s of stones) {
        for (const k of reach.get(s)) {
            for (const next of [k - 1, k, k + 1]) {
                if (next > 0 && reach.has(s + next)) {
                    reach.get(s + next).add(next);
                }
            }
        }
    }
    return reach.get(stones[stones.length - 1]).size > 0;
};

class Solution {
    public boolean canCross(int[] stones) {
        Map<Integer, Set<Integer>> reach = new HashMap<>();
        for (int s : stones) reach.put(s, new HashSet<>());
        reach.get(0).add(0);
        for (int s : stones) {
            for (int k : new ArrayList<>(reach.get(s))) {
                for (int next : new int[]{k - 1, k, k + 1}) {
                    if (next > 0 && reach.containsKey(s + next)) {
                        reach.get(s + next).add(next);
                    }
                }
            }
        }
        return !reach.get(stones[stones.length - 1]).isEmpty();
    }
}

function canCross(stones: number[]): boolean {
    const reach = new Map<number, Set<number>>();
    for (const s of stones) reach.set(s, new Set<number>());
    reach.get(0)!.add(0);
    for (const s of stones) {
        for (const k of reach.get(s)!) {
            for (const next of [k - 1, k, k + 1]) {
                if (next > 0 && reach.has(s + next)) {
                    reach.get(s + next)!.add(next);
                }
            }
        }
    }
    return reach.get(stones[stones.length - 1])!.size > 0;
}