Graphs

from collections import deque

q = deque([start])
seen = {start}                     # mark on entry, not on exit
dist = 0
while q:
    for _ in range(len(q)):        # one ring of the search: every node at distance dist
        node = q.popleft()
        if is_goal(node):
            return dist
        for nxt in neighbours(node):
            if nxt not in seen:
                seen.add(nxt)
                q.append(nxt)
    dist += 1
return -1

queue<int> q;
vector<bool> seen(n, false);
q.push(start); seen[start] = true;  // mark on entry, not on exit
for (int dist = 0; !q.empty(); ++dist) {
    for (int k = q.size(); k > 0; --k) {   // one ring: distance dist
        int node = q.front(); q.pop();
        if (isGoal(node)) return dist;
        for (int nxt : adj[node])
            if (!seen[nxt]) { seen[nxt] = true; q.push(nxt); }
    }
}
return -1;

ArrayDeque<Integer> q = new ArrayDeque<>();
boolean[] seen = new boolean[n];
q.add(start); seen[start] = true;   // mark on entry, not on exit
for (int dist = 0; !q.isEmpty(); dist++) {
    for (int k = q.size(); k > 0; k--) {   // one ring: distance dist
        int node = q.poll();
        if (isGoal(node)) return dist;
        for (int nxt : adj.get(node))
            if (!seen[nxt]) { seen[nxt] = true; q.add(nxt); }
    }
}
return -1;

const q = [start];
const seen = new Set([start]);     // mark on entry, not on exit
for (let dist = 0, head = 0; head < q.length; dist++) {
  for (let end = q.length; head < end; head++) {   // one ring: distance dist
    const node = q[head];
    if (isGoal(node)) return dist;
    for (const nxt of neighbours(node)) {
      if (!seen.has(nxt)) { seen.add(nxt); q.push(nxt); }
    }
  }
}
return -1;

let mut q = VecDeque::from([start]);
let mut seen = vec![false; n];
seen[start] = true;                     // mark on entry, not on exit
let mut dist = 0;
while !q.is_empty() {
    for _ in 0..q.len() {               // one ring: distance dist
        let node = q.pop_front().unwrap();
        if is_goal(node) { return dist; }
        for &nxt in &adj[node] {
            if !seen[nxt] { seen[nxt] = true; q.push_back(nxt); }
        }
    }
    dist += 1;
}
-1

import qualified Data.Set as S

-- Breadth-first search by rings: each step replaces the frontier by its unseen neighbours.
bfs :: Int -> Maybe Int
bfs start = go 0 [start] (S.singleton start)
  where
    go _ [] _ = Nothing
    go d frontier seen
      | any isGoal frontier = Just d
      | otherwise =
          let next = S.toList (S.fromList [n | v <- frontier, n <- neighbours v] S.\\ seen)
          in go (d + 1) next (foldr S.insert seen next)