Problem:
Score : 100 points

Problem Statement

You are given a directed graph with N vertices and M edges, not necessarily simple. The i-th edge is oriented from the vertex a_i to the vertex b_i.
Divide this graph into strongly connected components and print them in their topological order.

Constraints

1 \leq N \leq 500,000

1 \leq M \leq 500,000

0 \leq a_i, b_i < N

Input

Input is given from Standard Input in the following format:

N M
a_0 b_0
a_1 b_1
:
a_{M - 1} b_{M - 1}

Output

Print 1+K lines, where K is the number of strongly connected components.
Print K on the first line.
Print the information of each strongly connected component in next K lines in the following format, where l is the number of vertices in the strongly connected component and v_i is the index of the vertex in it.

l v_0 v_1 ... v_{l-1}

Here, for each edge (a_i, b_i), b_i should not appear in earlier line than a_i.

If there are multiple correct output, print any of them.

Sample Input 1

6 7
1 4
5 2
3 0
5 5
4 1
0 3
4 2

Sample Output 1

4
1 5
2 4 1
1 2
2 3 0

Solution in Rust (1.42.0) (judge verdict: Accepted)

#[allow(unused_imports)]
use {
    itertools::Itertools,
    proconio::{fastout, input, marker::*},
    std::cmp::*,
    std::collections::*,
    std::io::Write,
    std::ops::*,
};

#[allow(unused_macros)]
macro_rules! dbg { ($($e:expr),*) => { #[cfg(debug_assertions)] $({ let (e, mut err) = (stringify!($e), std::io::stderr()); writeln!(err, "{} = {:?}", e, $e).unwrap() })* }; }

#[fastout]
fn main() {
    input! {
        n: usize,
        m: usize,
        uv: [(usize, usize); m]
    }
    let scc = Scc::from_edges(n, &uv);
    println!("{}", scc.len());
    for s in &scc {
        println!("{} {}", s.len(), s.iter().format(" "));
    }
}

struct Scc {
    n: usize,
    to: Vec<Vec<usize>>,
    rev: Vec<Vec<usize>>,
}

impl Scc {
    fn new(n: usize) -> Self {
        Scc {
            n,
            to: vec![vec![]; n],
            rev: vec![vec![]; n],
        }
    }
    fn from_edges(n: usize, uv: &[(usize, usize)]) -> Vec<Vec<usize>> {
        let mut scc = Scc::new(n);
        for &(u, v) in uv {
            scc.add_edge(u, v);
        }
        scc.scc()
    }
    fn add_edge(&mut self, u: usize, v: usize) {
        self.to[u].push(v);
        self.rev[v].push(u);
    }
    fn dfs(&self, c: &mut usize, v: usize, visit: &mut Vec<bool>, num: &mut Vec<usize>) {
        if visit[v] {
            return;
        }
        visit[v] = true;
        for &u in self.to[v].iter() {
            if visit[u] {
                continue;
            }
            self.dfs(c, u, visit, num);
        }
        num[v] = *c;
        *c += 1;
    }
    fn scc(&self) -> Vec<Vec<usize>> {
        let mut visit = vec![false; self.n];
        let mut num = vec![0; self.n];
        {
            let mut c = 0;
            for i in 0..self.n {
                self.dfs(&mut c, i, &mut visit, &mut num);
            }
        }
        let mut num = num
            .iter()
            .enumerate()
            .map(|(i, &k)| (k, i))
            .collect::<Vec<_>>();
        num.sort();

        let mut ss = vec![];
        let mut visit = vec![false; self.n];
        for &(_, v) in num.iter().rev() {
            if visit[v] {
                continue;
            }
            let mut s = vec![];
            let mut q = std::collections::VecDeque::<usize>::new();
            q.push_back(v);
            while let Some(v) = q.pop_front() {
                if visit[v] {
                    continue;
                }
                s.push(v);
                visit[v] = true;
                for &u in self.rev[v].iter() {
                    if visit[u] {
                        continue;
                    }
                    q.push_back(u);
                }
            }
            ss.push(s);
        }
        ss
    }
}