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;
typedef long long ll;
typedef pair<ll, ll> P;
const ll MOD = 1e9+7;
const ll INF = 1e18;
#define rep(i,m,n) for(ll i = (m); i <= (n); i++)
#define zep(i,m,n) for(ll i = (m); i < (n); i++)
#define rrep(i,m,n) for(ll i = (m); i >= (n); i--)
#define print(x) cout << (x) << endl;
#define printa(x,m,n) for(ll i = (m); i <= n; i++){cout << (x[i]) << " ";} cout<<endl;

ll n, a, b;
vector<vector<ll>> g;
vector<ll> e, o, ans;

void dfs(ll at, ll from, ll mod){

	if(mod == 0){
		e.push_back(at);
	}
	else{
		o.push_back(at);
	}
	
	zep(i, 0, g[at].size()){
		if(g[at][i] != from){
			dfs(g[at][i], at, 1-mod);
		}
	}
	return;
}

int main(){
	cin.tie(0); ios::sync_with_stdio(false);
	
	cin >> n;
	g.resize(n);
	zep(i, 0, n-1){
		cin >> a >> b;
		a--; b--;
		g[a].push_back(b);
		g[b].push_back(a);
	}
	
	dfs(0, -1, 0);
	
	ans.resize(n);
	ll a = e.size();
	ll b = o.size();
	ll x = (n+2)/3;
	ll y = (n+1)/3;
	ll z = n/3;
	if(a <= x+z){
		zep(i, 0, a){
			if(x > 0){
				ans[e[i]] = 3*x-2;
				x--;
			}
			else{
				ans[e[i]] = 3*z;
				z--;
			}
		}
		zep(i, 0, b){
			if(y > 0){
				ans[o[i]] = 3*y-1;
				y--;
			}
			else{
				ans[o[i]] = 3*z;
				z--;
			}
		}
	}
	else{
		zep(i, 0, a){
			ans[e[i]] = 3*z;
			z--;
		}
		zep(i, 0, b){
			if(x > 0){
				ans[o[i]] = 3*x-2;
				x--;
			}
			else{
				if(y > 0){
					ans[o[i]] = 3*y-1;
					y--;
				}
				else{
					ans[o[i]] = 3*z;
					z--;
				}
			}
		}
		/*if(b <= x+z){
			zep(i, 0, b){
				if(x > 0){
					ans[o[i]] = 3*x-2;
					x--;
				}
				else{
					ans[o[i]] = 3*z;
					z--;
				}
			}
			zep(i, 0, a){
				if(y > 0){
					ans[e[i]] = 3*y-1;
					y--;
				}
				else{
					ans[e[i]] = 3*z;
					z--;
				}
			}
		}
		else{
			if(a <= z){
				zep(i, 0, a){
					ans[e[i]] = 3*z;
					z--;
				}
				zep(i, 0, b){
					if(x > 0){
						ans[o[i]] = 3*x-2;
						x--;
					}
					else{
						if(y > 0){
							ans[o[i]] = 3*y-1;
							y--;
						}
						else{
							ans[o[i]] = 3*z;
							z--;
						}
					}
				}
			}
			else{
				if(b <= z){
					zep(i, 0, b){
						ans[o[i]] = 3*z;
						z--;
					}
					zep(i, 0, a){
						if(x > 0){
							ans[e[i]] = 3*x-2;
							x--;
						}
						else{
							if(y > 0){
								ans[e[i]] = 3*y-1;
								y--;
							}
							else{
								ans[e[i]] = 3*z;
								z--;
							}
						}
					}
				}
				else{
					print(-1)
				}
			}
		}*/
	}
	zep(i, 0, n){
		cout << ans[i] << " ";
	}
	cout << endl;
	return 0;
}