Count the friend groups

def count_groups(is_connected):
    n = len(is_connected)
    seen = [False] * n
    groups = 0
    for s in range(n):
        if seen[s]:
            continue
        groups += 1                     # a person in no group yet: a new group
        seen[s] = True
        stack = [s]
        while stack:
            u = stack.pop()
            for v in range(n):          # row u lists u's friends
                if is_connected[u][v] == 1 and not seen[v]:
                    seen[v] = True
                    stack.append(v)
    return groups

#include <vector>

int solve(const std::vector<std::vector<int>>& isConnected) {
    const int n = isConnected.size();
    std::vector<bool> seen(n, false);
    int groups = 0;
    for (int s = 0; s < n; ++s) {
        if (seen[s]) continue;
        ++groups;                                   // a new group
        seen[s] = true;
        std::vector<int> stack{s};
        while (!stack.empty()) {
            int u = stack.back();
            stack.pop_back();
            for (int v = 0; v < n; ++v)
                if (isConnected[u][v] == 1 && !seen[v]) { seen[v] = true; stack.push_back(v); }
        }
    }
    return groups;
}

import java.util.*;

class Solution {
    public int countGroups(int[][] isConnected) {
        int n = isConnected.length, groups = 0;
        boolean[] seen = new boolean[n];
        for (int s = 0; s < n; s++) {
            if (seen[s]) continue;
            groups++;                               // a new group
            seen[s] = true;
            ArrayDeque<Integer> stack = new ArrayDeque<>();
            stack.push(s);
            while (!stack.isEmpty()) {
                int u = stack.pop();
                for (int v = 0; v < n; v++)
                    if (isConnected[u][v] == 1 && !seen[v]) { seen[v] = true; stack.push(v); }
            }
        }
        return groups;
    }
}

function countGroups(isConnected) {
  const n = isConnected.length, seen = new Array(n).fill(false);
  let groups = 0;
  for (let s = 0; s < n; s++) {
    if (seen[s]) continue;
    groups++;                           // a new group
    seen[s] = true;
    const stack = [s];
    while (stack.length) {
      const u = stack.pop();
      for (let v = 0; v < n; v++) if (isConnected[u][v] === 1 && !seen[v]) { seen[v] = true; stack.push(v); }
    }
  }
  return groups;
}

fn solve<const N: usize>(is_connected: &[[i64; N]]) -> i64 {
    let mut seen = [false; N];
    let mut groups = 0;
    for s in 0..N {
        if seen[s] {
            continue;
        }
        groups += 1;                                // a new group
        seen[s] = true;
        let mut stack = vec![s];
        while let Some(u) = stack.pop() {
            for v in 0..N {
                if is_connected[u][v] == 1 && !seen[v] {
                    seen[v] = true;
                    stack.push(v);
                }
            }
        }
    }
    groups
}

import qualified Data.Set as S

solve :: [[Int]] -> Int
solve m = go [0 .. n - 1] S.empty 0
  where
    n = length m
    friends u = [v | (v, 1) <- zip [0 ..] (m !! u)]
    go [] _ groups = groups
    go (s : rest) seen groups
      | S.member s seen = go rest seen groups
      | otherwise = go rest (mark [s] (S.insert s seen)) (groups + 1)   -- a new group
    mark [] seen = seen
    mark (u : st) seen =
      let new = [v | v <- friends u, not (S.member v seen)]
      in mark (new ++ st) (foldr S.insert seen new)