Problem:
MathJax.Hub.Config({ tex2jax: { inlineMath: [["$","$"], ["\\(","\\)"]], processEscapes: true }});

Reconstruction of a Tree

Write a program which reads two sequences of nodes obtained by the preorder tree walk and the inorder tree walk on a binary tree respectively, and prints a sequence of the nodes obtained by the postorder tree walk on the binary tree.

Input

In the first line, an integer $n$, which is the number of nodes in the binary tree, is given.

In the second line, the sequence of node IDs obtained by the preorder tree walk is given separated by space characters.

In the second line, the sequence of node IDs obtained by the inorder tree walk is given separated by space characters.

Every node has a unique ID from $1$ to $n$. Note that the root does not always correspond to $1$.

Output

Print the sequence of node IDs obtained by the postorder tree walk in a line. Put a single space character between adjacent IDs.

Constraints

$1 \leq n \leq 40$

Sample Input 1

5
1 2 3 4 5
3 2 4 1 5

Sample Output 1

3 4 2 5 1

Sample Input 2

4
1 2 3 4
1 2 3 4

Sample Output 2

4 3 2 1

Solution in Ruby (judge verdict: Accepted)

class Graph
  include Comparable
  attr_reader :id, :depth
  @@nodes = Array.new
  def initialize(id, left = nil, right = nil)
    @id = id
    @left = left == -1? nil: left
    @right = right == -1? nil: right
    @depth = -1
    @parent = -1
    @sibling = -1
    @@nodes[id] = self
  end
  
  def to_i
    return @id
  end
  
  def degree
    deg = 0
    deg += 1 if @left
    deg += 1 if @right
    return deg
  end
  
  def set_num(other)
    if @parent != -1
      if @left == other
        @parent.set_num(self) * 2
      elsif @right == other
        @parent.set_num(self) * 2 + 1
      end
    else
      1
    end
  end
  
  def num
    if @parent != -1
      @parent.set_num(self)
    else
      return 1
    end
  end
  
  def set_left(other)
    @left = other
  end
  
  def set_right(other)
    @right = other
  end
  
  def set_parent(other)
    @parent = other
  end
  
  def set_child
    @@nodes[@left].set_parent(self) if @left
    @@nodes[@right].set_parent(self) if @right
    if @left and @right
      @@nodes[@left].set_sib(@@nodes[@right])
      @@nodes[@right].set_sib(@@nodes[@left])
    end
  end
  
  def set_children
    set_child
    @@nodes[@left].set_children if @left
    @@nodes[@right].set_children if @right
  end
  
  def set_sib(other)
    @sibling = other
  end
  
  def depth
    if @parent != -1
      @parent.depth + 1
    else
      0
    end
  end
  
  def height
    left = @left? @@nodes[@left].height: -1
    right = @right? @@nodes[@right].height: -1
    if left < right
      right + 1
    else
      left + 1
    end
  end
  
  def <=>(other)
    if Graph === other
      @id <=> other.id
    else
      @id <=> other
    end
  end
  
  def type
    if @parent == -1
      return "root"
    elsif @degree == 0
      return "leaf"
    else
      return "internal node"
    end
  end
  
  def order(n)
    arr = []
    if n == 0
      preorder(arr)
      return ["Preorder", " " + arr.join(" ")]
    elsif n == 1
      inorder(arr)
      return ["Inorder", " " + arr.join(" ")]
    else
      postorder(arr)
      return ["Postorder", " " + arr.join(" ")]
    end
  end
  
  def preorder(arr)
    arr << @id
    @@nodes[@left].preorder(arr) if @left
    @@nodes[@right].preorder(arr) if @right
  end
  
  def inorder(arr)
    @@nodes[@left].inorder(arr) if @left
    arr << @id
    @@nodes[@right].inorder(arr) if @right
  end
  
  def postorder(arr)
    @@nodes[@left].postorder(arr) if @left
    @@nodes[@right].postorder(arr) if @right
    arr << @id
  end
  
  def inspect
    return [@id, num, @left, @right]
  end
  
  def to_s
    "node #{@id}: parent = #{@parent.id}, sibling = #{@sibling.id}, degree = #{degree}, depth = #{depth}, height = #{height}, #{type}"
  end
end
def f(preorder, inorder)
  root = preorder[0]
  idx = inorder.index(root)
  root.set_left(f(preorder & inorder[0...idx], inorder[0...idx])) if idx > 0
  root.set_right(f(preorder & inorder[idx + 1..-1], inorder[idx + 1 ..-1])) if idx < inorder.length - 1
  return root.to_i
end
def main
  arr = []
  gets.to_i.times do |n|
    arr << Graph.new(n + 1)
  end
  preorder = gets.split(" ").map{|item|arr[item.to_i - 1]}
  inorder = gets.split(" ").map{|item|arr[item.to_i - 1]}
  f(preorder, inorder)
  preorder[0].set_children
  arr = []
  puts preorder[0].postorder(arr).join(" ")
end
main