Problem:
Strongly Connected Components

A direced graph is strongly connected if every two nodes are reachable from each other. In a strongly connected component of a directed graph, every two nodes of the component are mutually reachable.

Input

A directed graph G(V, E) and a sequence of queries where each query contains a pair of nodes u and v.

|V| |E|
s0 t0
s1 t1
:
s|E|-1 t|E|-1
Q
u0 v0
u1 v1
:
uQ-1 vQ-1

|V| is the number of nodes and |E| is the number of edges in the graph. The graph nodes are named with the numbers 0, 1,..., |V|-1 respectively.

si and ti represent source and target nodes of i-th edge (directed).

ui and vi represent a pair of nodes given as the i-th query.

Output

For each query, pinrt "1" if the given nodes belong to the same strongly connected component, "0" otherwise.

Constraints

1 ≤ |V| ≤ 10,000

0 ≤ |E| ≤ 30,000

1 ≤ Q ≤ 100,000

Sample Input 1

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

Sample Output 1

1
0
1
1

Solution in Rust (judge verdict: Accepted)

pub mod spaghetti_source {

pub mod graph {

    pub mod articulation_point {
        use super::{Edge, Graph};
        use std::cmp::{max, min, Ordering};
        use std::collections::{BTreeSet, VecDeque};
        pub fn articulation_point(g: &Graph) -> (Vec<usize>, Vec<EdgeSet>) {
            let n = g.len();
            let mut low = vec![0 ; n];
            let mut num = vec![0 ; n];
            let mut art = BTreeSet::new();
            let mut bcomp = Vec::new();
            let mut s = VecDeque::new();
            for u in 0..n {
                if num[u] == 0 {
                    let mut time = 0;
                    visit(g, u, &mut art, &mut bcomp, &mut s, &mut num,
                          &mut low, &mut time);
                }
            }
            (art.into_iter().collect(), bcomp)
        }
        fn visit(g: &Graph, v: usize, art: &mut BTreeSet<usize>,
                 bcomp: &mut Vec<EdgeSet>, s: &mut VecDeque<Edge>,
                 num: &mut Vec<i32>, low: &mut Vec<i32>, time: &mut i32) {
            *time += 1;
            low[v] = *time;
            num[v] = *time;
            for e in &g[v] {
                let w = e.dst;
                if num[w] < num[v] { s.push_back(e.clone()); }
                if num[w] == 0 {
                    visit(g, w, art, bcomp, s, num, low, time);
                    low[v] = min(low[v], low[w]);
                    if (num[v] == 1 && num[w] != 2) ||
                           (num[v] != 1 && low[w] >= num[v]) {
                        art.insert(v);
                    }
                    if low[w] >= num[v] {
                        bcomp.push(EdgeSet::new());
                        while let Some(f) = s.pop_back() {
                            let n = bcomp.len();
                            let end = f.src == v && f.dst == w;
                            bcomp[n - 1].insert(UndirectEdge(f));
                            if end { break ; }
                        }
                    }
                } else { low[v] = min(low[v], num[w]); }
            }
        }
        pub type EdgeSet = BTreeSet<UndirectEdge>;
        #[derive(Eq, PartialEq, Debug)]
        pub struct UndirectEdge(Edge);
        impl UndirectEdge {
            pub fn min_v(&self) -> usize { min(self.0.src, self.0.dst) }
            pub fn max_v(&self) -> usize { max(self.0.src, self.0.dst) }
        }
        impl Ord for UndirectEdge {
            fn cmp(&self, other: &UndirectEdge) -> Ordering {
                self.min_v().cmp(&other.min_v()).then_with(||
                                                               self.max_v().cmp(&other.max_v()))
            }
        }
        impl PartialOrd for UndirectEdge {
            fn partial_cmp(&self, other: &UndirectEdge) -> Option<Ordering> {
                Some(self.cmp(other))
            }
        }
    }
    pub mod bridge {
        use super::{Edge, Graph};
        use std::collections::VecDeque;
        pub fn bridge(g: &Graph) -> (Vec<Edge>, Vec<Vec<usize>>) {
            let n = g.len();
            let mut num = vec![0 ; n];
            let mut in_stq = vec![false ; n];
            let mut roots = VecDeque::new();
            let mut stq = VecDeque::new();
            let mut time = 0;
            let mut brdg = VecDeque::new();
            let mut tecomp = Vec::new();
            for u in 0..n {
                if num[u] == 0 {
                    visit(g, u, n, &mut brdg, &mut tecomp, &mut roots,
                          &mut stq, &mut in_stq, &mut num, &mut time);
                    brdg.pop_back();
                }
            }
            (brdg.into_iter().collect(), tecomp)
        }
        fn visit(g: &Graph, v: usize, u: usize, brdg: &mut VecDeque<Edge>,
                 tecomp: &mut Vec<Vec<usize>>, roots: &mut VecDeque<usize>,
                 stq: &mut VecDeque<usize>, in_stq: &mut Vec<bool>,
                 num: &mut Vec<usize>, time: &mut usize) {
            *time += 1;
            num[v] = *time;
            stq.push_back(v);
            in_stq[v] = true;
            roots.push_back(v);
            for e in &g[v] {
                let w = e.dst;
                if num[w] == 0 {
                    visit(g, w, v, brdg, tecomp, roots, stq, in_stq, num,
                          time);
                } else if u != w && in_stq[w] {
                    while num[*roots.back().unwrap()] > num[w] {
                        roots.pop_back();
                    }
                }
            }
            if v == *roots.back().unwrap() {
                brdg.push_back(Edge{src: u, dst: v, weight: 0,});
                tecomp.push(Vec::new());
                loop  {
                    let w = stq.pop_back().unwrap();
                    in_stq[w] = false;
                    let n = tecomp.len();
                    tecomp[n - 1].push(w);
                    if v == w { break ; }
                }
                roots.pop_back();
            }
        }
    }
    pub mod strongly_connected_components {
        use super::Graph;
        use std::cmp::min;
        use std::collections::VecDeque;
        fn visit(g: &Graph, v: usize, scc: &mut Vec<Vec<usize>>,
                 stk: &mut VecDeque<usize>, in_stk: &mut Vec<bool>,
                 low: &mut Vec<usize>, num: &mut Vec<usize>,
                 time: &mut usize) {
            *time += 1;
            low[v] = *time;
            num[v] = *time;
            stk.push_back(v);
            in_stk[v] = true;
            for e in &g[v] {
                let w = e.dst;
                if num[w] == 0 {
                    visit(g, w, scc, stk, in_stk, low, num, time);
                    low[v] = min(low[v], low[w]);
                } else if in_stk[w] { low[v] = min(low[v], num[w]); }
            }
            if low[v] == num[v] {
                scc.push(Vec::new());
                loop  {
                    let w = stk.pop_back().unwrap();
                    in_stk[w] = false;
                    let n = scc.len();
                    scc[n - 1].push(w);
                    if v == w { break ; }
                }
            }
        }
        pub fn strongly_connected_component(g: &Graph) -> Vec<Vec<usize>> {
            let n = g.len();
            let mut scc = Vec::new();
            let mut num = vec![0 ; n];
            let mut low = vec![0 ; n];
            let mut stk = VecDeque::new();
            let mut in_stk = vec![false ; n];
            let mut time = 0;
            for u in 0..n {
                if num[u] == 0 {
                    visit(g, u, &mut scc, &mut stk, &mut in_stk, &mut low,
                          &mut num, &mut time);
                }
            }
            scc
        }
    }
    use std::cmp::Ordering;
    pub type Weight = i32;
    #[derive(Eq, PartialEq, Debug, Clone)]
    pub struct Edge {
        pub src: usize,
        pub dst: usize,
        pub weight: Weight,
    }
    impl Ord for Edge {
        fn cmp(&self, other: &Edge) -> Ordering {
            self.weight.cmp(&other.weight).reverse().then_with(||
                                                                   self.src.cmp(&other.src)).then_with(||
                                                                                                           self.dst.cmp(&other.dst))
        }
    }
    impl PartialOrd for Edge {
        fn partial_cmp(&self, other: &Edge) -> Option<Ordering> {
            Some(self.cmp(other))
        }
    }
    pub type Edges = Vec<Edge>;
    pub type Graph = Vec<Edges>;
    pub type Array = Vec<Weight>;
    pub type Matrix = Vec<Array>;
}
#[cfg(test)]
mod tests {
    #[test]
    fn it_works() { assert_eq!(2 + 2 , 4); }
}
}


use spaghetti_source::graph::strongly_connected_components::strongly_connected_component;
use spaghetti_source::graph::{Edge, Edges};

fn main() {
    let (n, m) = readln();
    let mut g = vec![Edges::new(); n];
    for _ in 0..m {
        let (x, y): (usize, usize) = readln();
        g[x].push(Edge {
            src: x,
            dst: y,
            weight: 0,
        });
    }
    let cmp = strongly_connected_component(&g);
    let mut cmp_id = vec![0; n];
    for (i, xs) in cmp.into_iter().enumerate() {
        for x in xs {
            cmp_id[x] = i;
        }
    }
    let q = readln();
    for _ in 0..q {
        let (u, v): (usize, usize) = readln();
        let p = cmp_id[u];
        let q = cmp_id[v];
        let ans = if p == q { 1 } else { 0 };
        println!("{}", ans);
    }
}

pub trait FromLn {
    fn fromln(s: &str) -> Self;
}
pub fn readln<T: FromLn>() -> T {
    let mut buf = String::new();
    let _ = ::std::io::stdin().read_line(&mut buf).unwrap();
    T::fromln(buf.trim())
}
pub fn readlns<T: FromLn>(n: usize) -> Vec<T> {
    let mut vs = vec![];
    for _ in 0..n {
        vs.push(readln());
    }
    vs
}
macro_rules! fromln_primitives {
    ($($t:ty),*) => { $(
        impl FromLn for $t {
            fn fromln(s: &str) -> $t {
                s.parse().unwrap()
            }
        }
    )* }
}
fromln_primitives!(String, bool, f32, f64, isize, i8, i16, i32, i64, usize, u8, u16, u32, u64);
impl<T> FromLn for Vec<T>
where
    T: FromLn,
{
    fn fromln(s: &str) -> Vec<T> {
        s.split_whitespace().map(T::fromln).collect()
    }
}
impl FromLn for Vec<char> {
    fn fromln(s: &str) -> Vec<char> {
        s.chars().collect()
    }
}
macro_rules! fromln_tuple {
    ($($t:ident),*) => {
        impl<$($t),*> FromLn for ($($t),*) where $($t: FromLn),* {
            fn fromln(s: &str) -> ($($t),*) {
                let mut it = s.split_whitespace();
                let t = ($($t::fromln(it.next().unwrap())),*);
                assert_eq!(it.next(), None);
                t
            }
        }
    }
}
fromln_tuple!(A, B);
fromln_tuple!(A, B, C);
fromln_tuple!(A, B, C, D);
fromln_tuple!(A, B, C, D, E);
fromln_tuple!(A, B, C, D, E, F);