Problem:
C: 同値命題

問題

$N$ 個の命題があり, それぞれ $1, 2, \cdots,N$ という名前がついている.

また, 命題に関する情報が $M$ 個与えられる. $i$ 番目の情報は「$a_i$ $b_i$」という形式で与えられ, これは $a_i$ ならば $b_i$ であることを表す.（「ならば」は論理包含であり、推移律が成り立つ）

各命題 $i$ に対して $i$ と同値な命題を全て昇順に出力せよ.

ただし命題 $i$ と命題 $i$ は常に同値である.

命題 $X$ と命題 $Y$ が同値とは,「$X$ ならば $Y$」かつ「$Y$ ならば $X$」のことである.

制約

入力値は全て整数である.

$ 2 \leq N \leq 300$

$ 1 \leq M \leq N(N - 1)$

$ a_i \neq b_i $

$1 \leq a_i, b_i \leq N $

入力形式

入力は以下の形式で与えられる.

$N\ M$

$a_1\ b_1$

$a_2\ b_2$

$\vdots$

$a_M\ b_M$

出力

$i$ 行目には命題 $i$ と同値である命題を昇順に空白区切りですべて出力せよ. また, 各行の末尾に改行を出力せよ.

サンプル

サンプル入力 1

5 2
1 2
2 1

サンプル出力 1

1 2
1 2
3
4
5

サンプル入力 2

3 3
1 2
2 3
3 1

サンプル出力 2

1 2 3
1 2 3
1 2 3

サンプル入力 3

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

サンプル出力 3

1
2 6
3 4 5
3 4 5
3 4 5
2 6

Solution in Rust (judge verdict: Accepted)

//https://qiita.com/tanakh/items/0ba42c7ca36cd29d0ac8
macro_rules! input {
    (source = $s:expr, $($r:tt)*) => {
        let mut iter = $s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
    ($($r:tt)*) => {
        let s = {
            use std::io::Read;
            let mut s = String::new();
            std::io::stdin().read_to_string(&mut s).unwrap();
            s
        };
        let mut iter = s.split_whitespace();
        input_inner!{iter, $($r)*}
    };
}

macro_rules! input_inner {
    ($iter:expr) => {};
    ($iter:expr, ) => {};
    ($iter:expr, $var:ident : $t:tt $($r:tt)*) => {
        let $var = read_value!($iter, $t);
        input_inner!{$iter $($r)*}
    };
}

macro_rules! read_value {
    ($iter:expr, ( $($t:tt),* )) => {
        ( $(read_value!($iter, $t)),* )
    };
    ($iter:expr, [ $t:tt ; $len:expr ]) => {
        (0..$len).map(|_| read_value!($iter, $t)).collect::<Vec<_>>()
    };
    ($iter:expr, chars) => {
        read_value!($iter, String).chars().collect::<Vec<char>>()
    };
    ($iter:expr, usize1) => {
        read_value!($iter, usize) - 1
    };
    ($iter:expr, $t:ty) => {
        $iter.next().unwrap().parse::<$t>().expect("Parse error")
    };
}

//

fn run() {
    input! {
        n: usize,
        m: usize,
        e: [(usize1, usize1); m],
    }
    let inf = 301;
    let mut d = vec![vec![inf; n]; n];
    for (a, b) in e {
        d[a][b] = 1;
    }
    for i in 0..n {
        d[i][i] = 0;
    }
    for k in 0..n {
        for i in 0..n {
            for j in 0..n {
                d[i][j] = std::cmp::min(d[i][j], d[i][k] + d[k][j]);
            }
        }
    }
    let mut ans = String::new();
    for i in 0..n {
        for j in 0..n {
            if d[i][j] < inf && d[j][i] < inf {
                ans.push_str(&(j + 1).to_string());
                ans.push(' ');
            }
        }
        ans.pop();
        ans.push('\n');
    }
    print!("{}", ans);
}

fn main() {
    run();
}