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 Ruby (judge verdict: Wrong Answer)

class Node
  attr_accessor :post, :visited, :child, :parent, :group
  def initialize
    @post = nil
    @visited = false
    @child = []
    @parent = []
    @group = nil
  end
end

def dfs(g)
  arr = []
  v = g.size
  t = 1
  v.times{|i|
    next if g[i].visited
    stack = []
    g[i].visited = true

    stack << i
    while stack.size > 0
      u = stack[-1]
      flag = true
      g[u].child.each{|x|
        if g[x].visited == false
          g[x].visited = true
          stack << x
          flag = false
        end
      }
      if flag == true
        g[u].post = t
        arr.unshift(u)
        t += 1
        stack.pop
      end
    end
  }
  return arr
end

def scc_decomposition(arr, g)
  arr.each{|i|
    next unless g[i].visited
    stack = []
    g[i].visited = false
    g[i].group = i
    stack << i
    while stack.size > 0
      u = stack[-1]
      flag = true
      g[u].parent.each{|x|
        if g[x].visited == true
          g[x].visited = false
          g[x].group = i
          stack << x
          flag = false
        end
      }
      if flag == true
        stack.pop
      end
    end
  }
end

v, e = gets.split.map(&:to_i)
graph = Array.new(v){Node.new}
e.times{
  s, t = gets.split.map(&:to_i)
  graph[s].child << t
  graph[t].parent << s
}

arr = dfs(graph)
scc_decomposition(arr, graph)

# v.times{|i|
#   p graph[i]
# }

q = gets.to_i
q.times{
  u, v = gets.split.map(&:to_i)
  if graph[u].group == graph[v].group
    puts 1
  else
    puts 0
  end
}