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: Runtime Error)

class StronglyConnectedComponent
  attr_accessor :cmp
  def initialize(n)
    @v = n
    @g = Array.new(n){ Array.new }
    @rg = Array.new(n){ Array.new }
    @vs = Array.new
    @used = Array.new(n)
    @cmp = Array.new(n)
  end
  def add_edge(from, to)
    @g[from] << to
    @rg[to] << from
  end
  def dfs(v)
    @used[v] = true
    (0...@g[v].size).each do |i|
      unless @used[@g[v][i]] then dfs(@g[v][i])
      end
    end
    @vs << v
  end
  def rdfs(v, k)
    @used[v] = true
    @cmp[v] = k
    (0...@rg[v].size).each do |i|
      unless @used[@rg[v][i]] then rdfs(@rg[v][i], k)
      end
    end
  end
  def scc
    @v.times{ |i| @used[i] = false }
    @vs.clear
    @v.times{ |i| dfs(i) unless @used[i] }
    @v.times{ |i| @used[i] = false }
    k = 0
    (@vs.size-1).downto(0) do |i|
      unless @used[@vs[i]] then rdfs(@vs[i], k); k += 1
      end
    end
    return k
  end
end

n, e = gets.split.map(&:to_i)
scc = StronglyConnectedComponent.new(n)
e.times do 
  a, b = gets.split.map(&:to_i)
  scc.add_edge(a, b)
end
scc.scc
q = gets.to_i
q.times do
  a, b = gets.split.map(&:to_i)
  if scc.cmp[a] == scc.cmp[b] then p 1
  else p 0
  end
end