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 C++14 (GCC 5.4.1) (judge verdict: Wrong Answer)

#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for(int i=(a);i<(b);++i)
#define rep(i, n) FOR(i, 0, n)
#define whole(x) (x).begin(),(x).end()
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end())
using ll = long long;
using P = pair<int, int>;
const int mod = 1000000007;

vector<int> to[200005];
//int root[200005];
int depth[200005];

void dfs(int v, int p=-1) {
    if (p==-1) depth[v] = 0;
    else {
        depth[v] = depth[p]+1;
    }
    for(int e: to[v]) {
        if(e==p) continue;
        dfs(e, v);
    }
    
}

int main(){
    int n;
    cin >> n;
    vector<int> p(n);
    rep(i, n-1) {
        int a, b;
        cin >> a >> b;
        a--; b--;
        if (a>b) swap(a, b);
        to[a].push_back(b);
        to[b].push_back(a);
    }
    dfs(0, -1);
    int odd = 0;
    int even = 0;
    rep(i, n) {
        if (depth[i]%2) odd++;
        else even++;
    }
    int mod3[3];
    rep(i, 3) {
        if (n%3==0) {
            mod3[0] = n/3;
            mod3[1] = n/3;
            mod3[2] = n/3;
        }
        else if (n%3==1) {
            mod3[0] = n/3;
            mod3[1] = n/3+1;
            mod3[2] = n/3+1;
        }
        else {
            mod3[0] = n/3;
            mod3[1] = n/3+1;
            mod3[2] = n/3+1;
        }
    }
    if (max(odd, even)>(mod3[0]+mod3[1])) {
        cout << "-1" << endl;
        return 0;
    }
    
    vector<int> ans(n);
    queue<int> res[3];
    rep(i, n) {
        int v = (i+1)%3;
        res[v].push(i+1);
    }
    if (even>odd) {
        rep(i, n) {
            depth[i]++;
        }
    }
    rep(i, n) {
        if(depth[i]%2) {
            if (!res[1].empty()) {
                ans[i] = res[1].front();
                res[1].pop();
            }
            else {
                ans[i] = res[0].front();
                res[0].pop();
            }
        }
        else {
            if (!res[2].empty()) {
                ans[i] = res[2].front();
                res[2].pop();
            }
            else {
                ans[i] = res[0].front();
                res[0].pop();
            }
        }
        cout << ans[i] << " ";
    }
    cout << endl;
    
    return 0;
}