Problem:
Problem B: Family Tree

A professor of anthropology was interested in people living in isolated islands and their history.
He collected their family trees to conduct some anthropological experiment. For the experiment,
he needed to process the family trees with a computer. For that purpose he translated them
into text files. The following is an example of a text file representing a family tree.

John
Robert
Frank
Andrew
Nancy
David

Each line contains the given name of a person. The name in the first line is the oldest ancestor
in this family tree. The family tree contains only the descendants of the oldest ancestor. Their
husbands and wives are not shown in the family tree. The children of a person are indented
with one more space than the parent. For example, Robert and Nancy are the children of John,
and Frank and Andrew are the children of Robert. David is indented with one more space than
Robert, but he is not a child of Robert, but of Nancy. To represent a family tree in this way,
the professor excluded some people from the family trees so that no one had both parents in a
family tree.

For the experiment, the professor also collected documents of the families and extracted the
set of statements about relations of two persons in each family tree. The following are some
examples of statements about the family above.

John is the parent of Robert.
Robert is a sibling of Nancy.
David is a descendant of Robert.

For the experiment, he needs to check whether each statement is true or not. For example, the
first two statements above are true and the last statement is false. Since this task is tedious, he
would like to check it by a computer program.

Input

The input contains several data sets. Each data set consists of a family tree and a set of
statements. The first line of each data set contains two integers n (0 < n < 1000) and m (0 < m < 1000) which represent the number of names in the family tree and the number of
statements, respectively. Each line of the input has less than 70 characters.

As a name, we consider any character string consisting of only alphabetic characters. The names
in a family tree have less than 20 characters. The name in the first line of the family tree has
no leading spaces. The other names in the family tree are indented with at least one space, i.e.,
they are descendants of the person in the first line. You can assume that if a name in the family
tree is indented with k spaces, the name in the next line is indented with at most k + 1 spaces.
This guarantees that each person except the oldest ancestor has his or her parent in the family
tree. No name appears twice in the same family tree. Each line of the family tree contains no
redundant spaces at the end.

Each statement occupies one line and is written in one of the following formats, where X and
Y are different names in the family tree.

X is a child of Y.
X is the parent of Y.
X is a sibling of Y.
X is a descendant of Y.
X is an ancestor of Y.

Names not appearing in the family tree are never used in the statements. Consecutive words in
a statement are separated by a single space. Each statement contains no redundant spaces at
the beginning and at the end of the line.

The end of the input is indicated by two zeros.

Output

For each statement in a data set, your program should output one line containing True or False.
The first letter of True or False in the output must be a capital. The output for each data set
should be followed by an empty line.

Sample Input

6 5
John
Robert
Frank
Andrew
Nancy
David
Robert is a child of John.
Robert is an ancestor of Andrew.
Robert is a sibling of Nancy.
Nancy is the parent of Frank.
John is a descendant of Andrew.
2 1
abc
xyz
xyz is a child of abc.
0 0

Output for the Sample Input

True
True
True
False
False

True

Solution in Ruby (judge verdict: Wrong Answer)

require 'set'

class Graph
	def initialize
		@nodes = Set.new
		@edges = Set.new
	end

	def add_node(label = nil)
		Node.new(label)
	end

	def add_edge(u, v)
		e = Edge.new(u, v)
		u.outgoings << e
		v.incomings << e
		e
	end
	
	def del_edge(e)
		u, v = e.from, e.to
		u.outgoings.delete(e)
		v.incomings.delete(e)
		e
	end

	class Node
		def initialize(label)
			@label = label
			@outgoings = Set.new
			@incomings = Set.new
		end
		
		def to_s
			@label
		end
		attr_accessor :incomings, :outgoings
		attr_reader :label
	end

	class Edge
		def initialize(u, v)
			@from = u	
			@to = v
		end
		attr_reader :from, :to
	end

	def Graph::get_path_bfs(s, t)
		path_edge = {}
		reached = Set[s]
		queue = [s]
		while !queue.empty? 
			u = queue.shift
			u.outgoings.each{|e|
				v = e.to
				next if reached.include?(v)	
				reached << v
				queue << v
				path_edge[v] = e

				if v == t
					path = []
					while e = path_edge[v]
						path.unshift e
						v = e.from
					end
					return path
				end
			}
		end	
		return nil
	end

	def Graph::get_path_dfs(s, t, reached = Set.new)
		reached << s	
		s.outgoings.each{|e|
			v = e.to
			next if reached.include?(v)
			return [e] if v == t
			
			path = get_path_dfs(v, t, reached) 
			return [e] + path if path
		}
		nil
	end

	def make_layer_graph(s, t) #nodes:copy, edges:alias
		lg = Graph.new
		correspond = {}

		path_edge = {}
		reached = Set[s]
		current_queue = [s]

		correspond[s] = lg.add_node

		while 0
			next_queue = []
			while !current_queue.empty? 
				u = current_queue.shift
				u.outgoings.each{|e|
					v = e.to
					next if reached.include?(v)

					correspond[v] ||= lg.add_node 
					correspond[e] = lg.add_edge(correspond[u], correspond[v])

					next_queue << v unless reached.include?(v)	
				}
			end	

			break if next_queue.empty?
			next_queue.each{|v| reached << v}
			current_queue = next_queue
		end

		nil
	end
end

def get_integers
	gets.split(" ").map(&:to_i)
end

n, m = get_integers
loop {

	g = Graph.new

	indent = -1
	stack = []
	name_to_node = {}
	n.times {
		gets =~ /^(\s*)(\w+)$/
		indent = $1.size
		stack.pop until stack.size <= indent
		v = g.add_node($2)
		g.add_edge(stack.last, v) if stack.size > 0
		stack << v
		name_to_node[v.label] = v
	}

	m.times {
		gets =~ /^(\w+) is \w+ (\w+) of (\w+)\.$/
		u = name_to_node[$1]
		relation = $2
		v = name_to_node[$3]
		
		bool = false
		case relation
		when "descendant"
			bool = Graph::get_path_bfs(v, u)
		when "ancestor"
			bool = Graph::get_path_bfs(u, v)
		when "child"
			bool = !u.incomings.empty? && u.incomings.all?{|e| e.from == v}
		when "parent"
			bool = !v.incomings.empty? && v.incomings.all?{|e| e.from == u}
		when "sibling"
			bool = u.incomings == v.incomings
		end
		puts bool ? "True" : "False"
	}

	n, m = get_integers
	break if n == 0
	puts
}