Problem:
Score : 1100 points

Problem Statement

You are given a directed graph with N vertices and M edges.
The vertices are numbered 1, 2, ..., N, and the edges are numbered 1, 2, ..., M.
Edge i points from Vertex a_i to Vertex b_i.

For each edge, determine whether the reversion of that edge would change the number of the strongly connected components in the graph.

Here, the reversion of Edge i means deleting Edge i and then adding a new edge that points from Vertex b_i to Vertex a_i.

Constraints

2 \leq N \leq 1000

1 \leq M \leq 200,000

1 \leq a_i, b_i \leq N

a_i \neq b_i

If i \neq j, then a_i \neq a_j or b_i \neq b_j.

Input

Input is given from Standard Input in the following format:

N M
a_1 b_1
a_2 b_2
:
a_M b_M

Output

Print M lines. In the i-th line, if the reversion of Edge i would change the number of the strongly connected components in the graph, print diff; if it would not, print same.

Sample Input 1

3 3
1 2
1 3
2 3

Sample Output 1

same
diff
same

The number of the strongly connected components is 3 without reversion of edges, but it will become 1 if Edge 2 is reversed.

Sample Input 2

2 2
1 2
2 1

Sample Output 2

diff
diff

Reversion of an edge may result in multiple edges in the graph.

Sample Input 3

5 9
3 2
3 1
4 1
4 2
3 5
5 3
3 4
1 2
2 5

Sample Output 3

same
same
same
same
same
diff
diff
diff
diff

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

use proconio::{input, marker::Usize1};

fn main() {
    input!(n: usize, m: usize, ab: [(Usize1, Usize1); m]);
    let mut g = vec![vec![]; n];
    ab.iter().for_each(|&(a, b)| g[a].push(b));

    let mut min_reachable = vec![vec![None; n]; n];
    let mut max_reachable = vec![vec![None; n]; n];
    for a in 0..n {
        fn search(i: usize, a: usize, ckd: &mut [Option<usize>], g: &[Vec<usize>]) {
            let c = g[a][i];
            if ckd[c].is_some() {
                return;
            }
            let mut que = std::collections::VecDeque::from(vec![c]);
            ckd[c] = Some(i);
            while let Some(x) = que.pop_front() {
                for y in g[x].iter().copied().filter(|&y| y != a) {
                    if ckd[y].is_some() {
                        continue;
                    }
                    ckd[y] = Some(i);
                    que.push_back(y);
                }
            }
        }
        for i in 0..g[a].len() {
            search(i, a, &mut min_reachable[a], &g);
        }
        for i in (0..g[a].len()).rev() {
            search(i, a, &mut max_reachable[a], &g);
        }
    }

    for (a, b) in ab {
        let a_to_b = min_reachable[a][b] != max_reachable[a][b];
        let b_to_a = min_reachable[b][a].is_some();
        println!("{}", if a_to_b == b_to_a { "same" } else { "diff" });
    }
}