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 Kotlin (1.0.0) (judge verdict: Wrong Answer)

fun main(args: Array<String>) {
    val N = readInputLine().toInt()
    val edges = Array(N + 1) { mutableListOf<Int>() }

    repeat(N - 1) {
        val (a, b) = readInputLine().split(" ").map { it.toInt() }
        edges[a].add(b)
        edges[b].add(a)
    }

    val redNodes = mutableListOf<Int>()
    val blueNodes = mutableListOf<Int>()

    fun dfs(isRed: Boolean, node: Int, parent: Int) {
        if (isRed) {
            redNodes.add(node)
        } else {
            blueNodes.add(node)
        }

        for (e in edges[node]) {
            if (e == parent) {
                continue
            }
            dfs(!isRed, e, node)
        }
    }

    dfs(false, 1, 0)

    val ans = IntArray(N)

    when {
        redNodes.size > N / 3 && blueNodes.size > N / 3 -> {
            var oneNodeCnt = 0
            var twoNodeCnt = 0
            var threeNodeCnt = 0
            for (r in redNodes) {
                if (oneNodeCnt * 3 < N) {
                    ans[oneNodeCnt * 3] = r
                    oneNodeCnt++
                } else {
                    ans[threeNodeCnt * 3 + 2] = r
                    threeNodeCnt++
                }
            }
            for (b in blueNodes) {
                if (twoNodeCnt * 3 + 1 < N) {
                    ans[twoNodeCnt * 3 + 1] = b
                    twoNodeCnt++
                } else {
                    ans[threeNodeCnt * 3 + 2] = b
                    threeNodeCnt++
                }
            }
        }
        redNodes.size <= N / 3 -> {
            var threeNodeCnt = 0
            var otherNodeCnt = 0
            for (r in redNodes) {
                ans[threeNodeCnt * 3 + 2] = r
                threeNodeCnt++
            }
            for (b in blueNodes) {
                if (threeNodeCnt * 3 + 2 < N) {
                    ans[threeNodeCnt * 3 + 2] = b
                    threeNodeCnt++
                } else {
                    ans[otherNodeCnt / 2 * 3 + otherNodeCnt % 2] = b
                    otherNodeCnt++
                }
            }
        }
        else -> {
            var threeNodeCnt = 0
            var otherNodeCnt = 0
            for (b in blueNodes) {
                ans[threeNodeCnt * 3 + 2] = b
                threeNodeCnt++
            }
            for (r in redNodes) {
                if (threeNodeCnt * 3 + 2 < N) {
                    ans[threeNodeCnt * 3 + 2] = r
                    threeNodeCnt++
                } else {
                    ans[otherNodeCnt / 2 * 3 + otherNodeCnt % 2] = r
                    otherNodeCnt++
                }
            }
        }
    }

    println(ans.joinToString(" "))
}

fun readInputLine(): String {
    return readLine()!!
}