Problem:
Score : 600 points

Problem Statement

We have a tree with N vertices. The vertices are numbered 1 to N, and the i-th edge connects Vertex a_i and Vertex b_i.

Takahashi loves the number 3. He is seeking a permutation p_1, p_2, \ldots , p_N of integers from 1 to N satisfying the following condition:

For every pair of vertices (i, j), if the distance between Vertex i and Vertex j is 3, the sum or product of p_i and p_j is a multiple of 3.

Here the distance between Vertex i and Vertex j is the number of edges contained in the shortest path from Vertex i to Vertex j.

Help Takahashi by finding a permutation that satisfies the condition.

Constraints

2\leq N\leq 2\times 10^5

1\leq a_i, b_i \leq N

The given graph is a tree.

Input

Input is given from Standard Input in the following format:

N
a_1 b_1
a_2 b_2
\vdots
a_{N-1} b_{N-1}

Output

If no permutation satisfies the condition, print -1.

Otherwise, print a permutation satisfying the condition, with space in between.
If there are multiple solutions, you can print any of them.

Sample Input 1

5
1 2
1 3
3 4
3 5

Sample Output 1

1 2 5 4 3

The distance between two vertices is 3 for the two pairs (2, 4) and (2, 5).

p_2 + p_4 = 6

p_2\times p_5 = 6

Thus, this permutation satisfies the condition.

Solution in Ruby (2.3.3) (judge verdict: Wrong Answer)

def change(arr, i, j)
  a = arr.index i
  b = arr.index j
  arr[a] = j
  arr[b] = i
  arr
end

n = gets.to_i
node = Array.new(n).map{|_| Array.new()}
(n-1).times do |i|
  hen = gets.chomp.split(" ", n).map(&:to_i)
  node[hen[0]-1] << hen[1]-1
  node[hen[1]-1] << hen[0]-1
end

three = Array.new()
(n-1).times do |t|
  i = n - t - 1
  node[i].each do |j|
    if j > i
      next
    end
    node[j].each do |k|
      if k > j
        next
      end
      node[k].each do |m|
        if m == j
          next
        end
        three << [m, i]
      end
    end
  end
end

arr = n.times.map{|a| a + 1}
fix = Array.new

three.each do |th|
  if (arr[th[0]] + arr[th[1]]) % 3 == 0 || (arr[th[0]] * arr[th[1]]) % 3 == 0
    fix << arr[th[0]] << arr[th[1]]
  else
    unfix = arr - fix
    find = false
    if fix.find arr[th[0]]
      unfix.each do |i|
        if (arr[th[0]] + i) % 3 == 0 || (arr[th[0]] * i) % 3 == 0
          find = true
          change(arr, i, arr[th[1]])
          break
        end
      end
    else
      unfix.each do |i|
        if (arr[th[1]] + i) % 3 == 0 || (arr[th[1]] * i) % 3 == 0
          find = true
          change(arr, i, arr[th[0]])
          break
        end
      end
    end
    if !find
      print "-1\n"
      exit
    end
    fix << arr[th[0]] << arr[th[1]]
  end
end
print "#{arr.join(" ")}\n"