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)

macro_rules! read_line_to_tuple {
    ( $( $t:ty ),* ) => {{
        let mut input = String::new();
        std::io::stdin().read_line(&mut input).unwrap();
        let mut iter = input.split_whitespace();
        ( $( iter.next().unwrap().parse::<$t>().unwrap() ),* )
    }};
}

struct Scc {
    n: usize,
    graph: Vec<Vec<usize>>,
    rev_graph: Vec<Vec<usize>>,
    post_order: Vec<usize>,
    component: Vec<usize>,
    ans: Vec<Vec<usize>>,
}

impl Scc {
    fn new(n: usize) -> Scc {
        Scc {
            n,
            graph: vec![Vec::new(); n],
            rev_graph: vec![Vec::new(); n],
            component: vec![n; n],
            post_order: Vec::with_capacity(n),
            ans: Vec::new(),
        }
    }

    fn add_edge(&mut self, from: usize, to: usize) {
        self.graph[from].push(to);
        self.rev_graph[to].push(from);
    }

    fn dfs(&mut self, from: usize) {
        self.component[from] = self.n + 1;
        for to in self.graph[from].clone() {
            if self.component[to] == self.n {
                self.dfs(to);
            }
        }
        self.post_order.push(from);
    }
    
    fn rev_dfs(&mut self, from: usize, k: usize) {
        self.component[from] = k;
        for to in self.rev_graph[from].clone() {
            if self.component[to] > self.n {
                self.rev_dfs(to, k);
            }
        }
        self.ans[k].push(from);
    }

    fn solve(&mut self) -> usize {
        for i in 0..self.n {
            if self.component[i] == self.n {
                self.dfs(i);
            }
        }

        let mut k: usize = 0;
        for i in (0..self.n).rev() {
            if self.component[self.post_order[i]] > self.n {
                self.ans.push(Vec::new());
                self.rev_dfs(self.post_order[i], k);
                k += 1;
            }
        }

        k
    }
}

fn main() {
    let (n, m) = read_line_to_tuple!(usize, usize);

    let mut scc = Scc::new(n);
    for _ in 0..m {
        let (a, b) = read_line_to_tuple!(usize, usize);
        scc.add_edge(a, b);
    }
    let k = scc.solve();

    let mut ans = Vec::with_capacity(k + 1);
    ans.push(k.to_string());
    for i in 0..k {
        ans.push(
            [scc.ans[i].len()].iter().chain(scc.ans[i].iter())
                .map(|x| x.to_string())
                .collect::<Vec<_>>()
                .join(" ")
        );
    }
    println!("{}", ans.join("\n"));
}