Can every course be finished?

from collections import deque

def can_finish(n, prereqs):
    unlocks = [[] for _ in range(n)]
    indeg = [0] * n                         # prerequisites still to take
    for a, b in prereqs:
        unlocks[b].append(a)
        indeg[a] += 1
    q = deque(i for i in range(n) if indeg[i] == 0)
    taken = 0
    while q:
        c = q.popleft()
        taken += 1
        for a in unlocks[c]:
            indeg[a] -= 1
            if indeg[a] == 0:               # its last prerequisite is done
                q.append(a)
    return taken == n                       # a cycle leaves its courses waiting for ever

#include <vector>

bool solve(int n, const std::vector<std::vector<int>>& prereqs) {
    std::vector<std::vector<int>> unlocks(n);
    std::vector<int> indeg(n, 0);                  // prerequisites still to take
    for (const auto& p : prereqs) { unlocks[p[1]].push_back(p[0]); ++indeg[p[0]]; }
    std::vector<int> q;
    for (int i = 0; i < n; ++i) if (indeg[i] == 0) q.push_back(i);
    for (size_t head = 0; head < q.size(); ++head)
        for (int a : unlocks[q[head]])
            if (--indeg[a] == 0) q.push_back(a);   // its last prerequisite is done
    return (int)q.size() == n;                     // every course was taken
}

class Solution {
    public boolean canFinish(int n, int[][] prereqs) {
        java.util.List<java.util.List<Integer>> unlocks = new java.util.ArrayList<>();
        for (int i = 0; i < n; i++) unlocks.add(new java.util.ArrayList<>());
        int[] indeg = new int[n];                  // prerequisites still to take
        for (int[] p : prereqs) { unlocks.get(p[1]).add(p[0]); indeg[p[0]]++; }
        int[] q = new int[n];
        int tail = 0;
        for (int i = 0; i < n; i++) if (indeg[i] == 0) q[tail++] = i;
        for (int head = 0; head < tail; head++)
            for (int a : unlocks.get(q[head]))
                if (--indeg[a] == 0) q[tail++] = a;   // its last prerequisite is done
        return tail == n;                          // every course was taken
    }
}

function canFinish(n, prereqs) {
  const unlocks = Array.from({ length: n }, () => []);
  const indeg = new Array(n).fill(0);          // prerequisites still to take
  for (const [a, b] of prereqs) { unlocks[b].push(a); indeg[a]++; }
  const q = [];
  for (let i = 0; i < n; i++) if (indeg[i] === 0) q.push(i);
  let head = 0;
  while (head < q.length) {
    const c = q[head++];
    for (const a of unlocks[c]) if (--indeg[a] === 0) q.push(a);
  }
  return head === n;                           // every course was taken
}

fn solve(n: i64, prereqs: &[[i64; 2]]) -> bool {
    let n = n as usize;
    let mut unlocks = vec![Vec::new(); n];
    let mut indeg = vec![0usize; n];               // prerequisites still to take
    for p in prereqs {
        unlocks[p[1] as usize].push(p[0] as usize);
        indeg[p[0] as usize] += 1;
    }
    let mut q: Vec<usize> = (0..n).filter(|&i| indeg[i] == 0).collect();
    let mut head = 0;
    while head < q.len() {
        let c = q[head];
        head += 1;
        for &a in &unlocks[c] {
            indeg[a] -= 1;
            if indeg[a] == 0 {
                q.push(a);                         // its last prerequisite is done
            }
        }
    }
    q.len() == n                                   // every course was taken
}

import Data.List (nub)
import qualified Data.Map.Strict as M

-- Kahn's algorithm: repeatedly take a course with no prerequisites left.
solve :: Int -> [[Int]] -> Bool
solve n prereqs = go [i | i <- [0 .. n - 1], M.findWithDefault 0 i indeg0 == 0] indeg0 0
  where
    unlocks = M.fromListWith (++) [(b, [a]) | [a, b] <- prereqs]
    indeg0 = M.fromListWith (+) [(a, 1 :: Int) | [a, _] <- prereqs]
    go [] _ taken = taken == n
    go (c : rest) indeg taken =
      let nexts = M.findWithDefault [] c unlocks
          indeg' = foldr (M.adjust (subtract 1)) indeg nexts
          freed = nub [a | a <- nexts, M.findWithDefault 0 a indeg' == 0, M.findWithDefault 0 a indeg > 0]
      in go (rest ++ freed) indeg' (taken + 1)