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)

de = false
require 'set'; require 'prime'
INF=Float::INFINITY; MOD=10**9+7
n = gets.chomp.to_i
edges = {}
(n-1).times do
  a, b = gets.chomp.split.map(&:to_i)
  edges[a] ||= []
  edges[a].push b
  edges[b] ||= []
  edges[b].push a
end
edges.default = []

edges.each do |k, vs|
  if vs.size == n - 1
    puts (1..n).to_a.join(' ')
    exit
  end
end

size1 = n / 3
size1 += 1 if n % 3 > 0
size2 = n / 3
size2 += 1 if n % 3 > 1
size3 = n / 3

q = [[1, 1]]

ans = Array.new(n+1)
visited = Set.new
until q.empty?
  node, layer = q.shift
  ans[node] = layer
  visited.add node

  layer = layer == 1 ? 2 : 1
  edges[node].each do |v|
    next if visited.include?(v)
    q.push [v, layer]
  end
end

count1 = count2 = count3 = 0

ans.shift
n.times do |i|
  if ans[i] == 1
    if count1 == size1
      ans[i] = count3 * 3 + 3
      count3 += 1
    else
      ans[i] = count1 * 3 + 1
      count1 += 1
    end
  elsif ans[i] == 2
    if count2 == size2
      ans[i] = count3 * 3 + 3
      count3 += 1
    else
      ans[i] = count2 * 3 + 2
      count2 += 1
    end
  end
  if count3 > size3
    ans = [n+100]
    break
  end
end
ans.each do |e|
  if e > n
    ans = -1
    break
  end
end

if ans != -1
  puts ans.join(' ')
  exit
end

# --------------------------------------------------------------------

count1 = count2 = count3 = 0
ans = 0

p edges.to_a.sort_by{|k,v| -v.size} if de
ans = Array.new(n+1)
edges.to_a.sort_by{|k,v| -v.size}.each do |from, tos|
  tos.each do |to|
    edges[to].each do |v| # 距離3
      next if v == from
      ans[v] = 3
      count3 += 1
      break if count3 == size3
    end
    break if count3 == size3
  end
  break if count3 == size3
end
p ans if de

q = [[1, 1]]

visited = Set.new
until q.empty?
  node, layer = q.shift
  ans[node] ||= layer
  visited.add node

  layer = layer == 1 ? 2 : 1
  edges[node].each do |v|
    next if visited.include?(v)
    q.push [v, layer]
  end
end

p ans if de

count1 = count2 = count3 = 0

ans.shift
n.times do |i|
  if ans[i] == 1
    if count1 == size1
      ans[i] = count2 * 3 + 2
      count2 += 1
    else
      ans[i] = count1 * 3 + 1
      count1 += 1
    end
  elsif ans[i] == 2
    if count2 == size2
      ans[i] = count1 * 3 + 1
      count1 += 1
    else
      ans[i] = count2 * 3 + 2
      count2 += 1
    end
  elsif ans[i] == 3
    ans[i] = count3 * 3 + 3
    count3 += 1
  end
end
ans.each do |e|
  if e > n
    ans = -1
    exit
  end
end

puts ans.join(' ')