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 Rust (1.42.0) (judge verdict: Accepted)

use proconio::input;

type Graph = Vec<Vec<usize>>;

fn dfs(v:usize,pre:usize,g:&Graph,sz:&mut Vec<usize>){
    for &to in &g[v] {
        if to==pre {
            continue;
        }
        sz[to] = sz[v]+1;
        dfs(to,v,&g,sz);
    }
}


fn main() {
    input!{
        n:usize,
        ab:[(usize,usize);n-1]
    };

    let mut g = vec![Vec::<usize>::new();n];
    for (a,b) in ab {
        g[a-1].push(b-1);
        g[b-1].push(a-1);
    }

    let mut sz = vec![0;n];
    dfs(0,n,&g,&mut sz);

    let mut oddcnt = 0;
    for &s in &sz {
        if s%2==1 {
            oddcnt+=1;
        }
    }
    let evcnt = n - oddcnt;

    let unb = |b:usize| {
        let mut rest_1 = (n+2)/3;
        let mut rest_2 = (n+1)/3;
        let mut ans = vec![0;n];
        for i in 0..n {
            if sz[i]%2==b {
                ans[i] = 3;
            }
            else {
                if rest_1>0 {
                    ans[i] = 1;
                    rest_1 -=1;
                }
                else if rest_2>0{
                    ans[i] = 2;
                    rest_2  -= 1;
                }
                else{
                    ans[i] = 3;
                }
            }
        }
        ans
    };
    let bal=||{
        let mut rest_1 = (n+2)/3;
        let mut rest_2 = (n+1)/3;
        let mut ans = vec![0;n];
        for i in 0..n {
            if sz[i]%2==0 {
                if rest_1>0 {
                    rest_1-=1;
                    ans[i] = 1;
                }
                else{
                    ans[i] = 3;
                }
            }
            else {
                if rest_2>0 {
                    rest_2-=1;
                    ans[i] = 2;
                }
                else{
                    ans[i] = 3;
                }
            }
        }
        ans
    };
    let transform = |ans:&mut Vec<usize>|  {
        let mut ary = [3,1,2];
        for x in ans {
            *x = ary[*x%3];
            ary[*x%3]+=3;
        }
    };

    let mut ans = 
        if oddcnt<=n/3 {
            unb(1)
        }
        else if evcnt<=n/3 {
            unb(0)
        }
        else{
            bal()
        };

    transform(&mut ans);
    
    println!("{}",ans.iter().map(|&x|x.to_string()).collect::<Vec<String>>().join(" "));
    
}