Does a directed graph contain a cycle?

import sys

def has_directed_cycle(n, edges):
    sys.setrecursionlimit(10000)
    adj = [[] for _ in range(n)]
    for u, v in edges:
        adj[u].append(v)
    WHITE, GREY, BLACK = 0, 1, 2
    colour = [WHITE] * n

    def visit(u):
        colour[u] = GREY                 # u is on the current path
        for v in adj[u]:
            if colour[v] == GREY:
                return True              # back along the path: a cycle
            if colour[v] == WHITE and visit(v):
                return True
        colour[u] = BLACK                # finished, and no cycle through it
        return False

    return any(colour[s] == WHITE and visit(s) for s in range(n))

#include <functional>
#include <vector>

bool solve(int n, const std::vector<std::vector<int>>& edges) {
    std::vector<std::vector<int>> adj(n);
    for (const auto& e : edges) adj[e[0]].push_back(e[1]);
    enum { WHITE, GREY, BLACK };
    std::vector<int> colour(n, WHITE);
    std::function<bool(int)> visit = [&](int u) {
        colour[u] = GREY;                       // u is on the current path
        for (int v : adj[u]) {
            if (colour[v] == GREY) return true;                  // a cycle
            if (colour[v] == WHITE && visit(v)) return true;
        }
        colour[u] = BLACK;                      // finished
        return false;
    };
    for (int s = 0; s < n; ++s)
        if (colour[s] == WHITE && visit(s)) return true;
    return false;
}

import java.util.*;

class Solution {
    private List<List<Integer>> adj;
    private int[] colour;                       // 0 white, 1 grey, 2 black

    public boolean hasDirectedCycle(int n, int[][] edges) {
        adj = new ArrayList<>();
        for (int i = 0; i < n; i++) adj.add(new ArrayList<>());
        for (int[] e : edges) adj.get(e[0]).add(e[1]);
        colour = new int[n];
        for (int s = 0; s < n; s++)
            if (colour[s] == 0 && visit(s)) return true;
        return false;
    }

    private boolean visit(int u) {
        colour[u] = 1;                          // u is on the current path
        for (int v : adj.get(u)) {
            if (colour[v] == 1) return true;    // a cycle
            if (colour[v] == 0 && visit(v)) return true;
        }
        colour[u] = 2;                          // finished
        return false;
    }
}

function hasDirectedCycle(n, edges) {
  const adj = Array.from({ length: n }, () => []);
  for (const [u, v] of edges) adj[u].push(v);
  const WHITE = 0, GREY = 1, BLACK = 2;
  const colour = new Array(n).fill(WHITE);
  const visit = u => {
    colour[u] = GREY;                    // u is on the current path
    for (const v of adj[u]) {
      if (colour[v] === GREY) return true;              // a cycle
      if (colour[v] === WHITE && visit(v)) return true;
    }
    colour[u] = BLACK;                   // finished, and no cycle through it
    return false;
  };
  for (let s = 0; s < n; s++) if (colour[s] === WHITE && visit(s)) return true;
  return false;
}

fn solve(n: i64, edges: &[[i64; 2]]) -> bool {
    let n = n as usize;
    let mut adj = vec![Vec::new(); n];
    for e in edges {
        adj[e[0] as usize].push(e[1] as usize);
    }
    // 0 white, 1 grey (on the current path), 2 black (finished)
    fn visit(u: usize, adj: &[Vec<usize>], colour: &mut Vec<u8>) -> bool {
        colour[u] = 1;
        for &v in &adj[u] {
            if colour[v] == 1 {
                return true;                    // a cycle
            }
            if colour[v] == 0 && visit(v, adj, colour) {
                return true;
            }
        }
        colour[u] = 2;
        false
    }
    let mut colour = vec![0u8; n];
    (0..n).any(|s| colour[s] == 0 && visit(s, &adj, &mut colour))
}

import qualified Data.Map.Strict as M

data Colour = Grey | Black deriving Eq

solve :: Int -> [[Int]] -> Bool
solve n edges = go [0 .. n - 1] M.empty
  where
    adj = M.fromListWith (flip (++)) [(u, [v]) | [u, v] <- edges]
    -- colours absent from the map are white
    go [] _ = False
    go (s : rest) col
      | M.member s col = go rest col
      | otherwise = case visit s col of
          Nothing -> True
          Just col' -> go rest col'
    -- Nothing means a cycle; Just carries the colours on
    visit u col = fmap (M.insert u Black) (foldr step (Just (M.insert u Grey col)) (reverse (M.findWithDefault [] u adj)))
      where
        step _ Nothing = Nothing
        step v (Just c) = case M.lookup v c of
          Just Grey -> Nothing
          Just Black -> Just c
          Nothing -> visit v c