Problem:
Score : 400 points

Problem Statement

We have a tree with N vertices numbered 1 to N.
The i-th edge in the tree connects Vertex u_i and Vertex v_i, and its length is w_i.
Your objective is to paint each vertex in the tree white or black (it is fine to paint all vertices the same color) so that the following condition is satisfied:

For any two vertices painted in the same color, the distance between them is an even number.

Find a coloring of the vertices that satisfies the condition and print it. It can be proved that at least one such coloring exists under the constraints of this problem.

Constraints

All values in input are integers.

1 \leq N \leq 10^5

1 \leq u_i < v_i \leq N

1 \leq w_i \leq 10^9

Input

Input is given from Standard Input in the following format:

N
u_1 v_1 w_1
u_2 v_2 w_2
.
.
.
u_{N - 1} v_{N - 1} w_{N - 1}

Output

Print a coloring of the vertices that satisfies the condition, in N lines.
The i-th line should contain 0 if Vertex i is painted white and 1 if it is painted black.

If there are multiple colorings that satisfy the condition, any of them will be accepted.

Sample Input 1

3
1 2 2
2 3 1

Sample Output 1

0
0
1

Sample Input 2

5
2 5 2
2 3 10
1 3 8
3 4 2

Sample Output 2

1
0
1
0
1

Solution in Rust (1.42.0) (judge verdict: Accepted)

#![allow(unused_imports)]

// language: Rust(1.42.0)
// check available crates on AtCoder at "https://atcoder.jp/contests/language-test-202001"
// My Library Repositry is at "https://github.com/Loptall/prcn_lib"

/*
    青perfほしいよ〜！
*/

// from std...
use std::cmp::{
    max, min, Ordering,
    Ordering::{Equal, Greater, Less},
    Reverse,
};
use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, VecDeque};
use std::convert::TryInto;
use std::fmt;
use std::mem::swap;
use std::num::{NonZeroU32, ParseIntError};
use std::ops::{
    Add, AddAssign, BitAnd, BitAndAssign, BitOr, BitOrAssign, BitXor, BitXorAssign, Div, DivAssign,
    Index, IndexMut, Mul, MulAssign, Neg, Rem, RemAssign, Shl, ShlAssign, Shr, ShrAssign, Sub,
    SubAssign,
};
use std::process::exit;
use std::{f32, f64, i128, i16, i32, i64, i8, isize, u128, u16, u32, u64, u8, usize};

// Dep' crates are...
use itertools::*;
use itertools_num::*;
use lazy_static::lazy_static;
use maplit::{btreemap, btreeset, hashmap, hashset};
use num_bigint::{BigInt, BigUint};
use num_complex::Complex;
use num_integer::{binomial, gcd, lcm, multinomial, Integer};
use num_rational::Rational;
use num_traits::{
    clamp, one, pow, zero, Num, NumAssignOps, NumOps, One, Pow, Signed, Unsigned, Zero,
};
use permutohedron::Heap;
use proconio::{
    derive_readable, fastout, input, is_stdin_empty,
    marker::{Bytes, Chars, Isize1, Usize1},
};
use rand::random;

pub trait Visualize {
    fn visualize(&self, split: &str);
    fn continuous(&self) {
        self.visualize("");
    }
    fn spaces(&self) {
        self.visualize(" ");
    }
    fn lines(&self) {
        self.visualize("\n");
    }
}
macro_rules ! impl_vis_for_sized {($ ($ t : ty ) ,+ ) => {$ (impl Visualize for $ t {fn visualize (& self , _split : & str ) {print ! ("{}" , self ) ; } } ) + } ; }
impl_vis_for_sized! {usize , u8 , u16 , u32 , u64 , u128 , isize , i8 , i16 , i32 , i64 , i128 , String , & str }
impl<T: fmt::Display> Visualize for [T] {
    fn visualize(&self, split: &str) {
        print!("{}", self.iter().join(split));
    }
}
/// macro to output answer improved to println
///
/// this macro will print '\n' at the last.
///
/// # Patterns
///
/// `,`, it means one space, it formats the elements, which is before, space-split.
/// And insert a space after the prefix, unless it is at last.
///
/// `=>`, it means empty string, it formats the element, witch is before, without any split.
/// And insert nothing between two element.
///
/// `;`, it means newline(\n), it formats the element, witch is before, newline-split.
/// And insert a newline after the prefix, unless it is at last.
///
/// # Eample
///
/// ```
/// #[test]
/// fn vis_test() {
///     let a = 1;
///     let b = 2;
///     let c = 3;
///
///     let v = vec!['a', 'b', 'c'];
///
///     // single element test ...
///
///     vis!(a); // 1\n
///     vis!(a,); // 1\n
///     vis!(a =>); // 1\n
///     vis!(a;); // 1\n
///
///     println!();
///
///     vis!(a + b); // 3\n
///
///     println!();
///
///     vis!(v); // a b c\n
///     vis!(v,); // a b c\n
///     vis!(v =>); // abc\n
///     vis!(v;); // a\nb\nc\n
///
///     println!();
///
///     // multi elements connected by common operater test ...
///
///     println!();
///
///     vis!(a, b); // 1 2\n
///     vis!(a, b, c); // 1 2 3\n
///     vis!(a, b, c;); // 1 2 3\n
///
///     println!();
///
///     vis!(a => b); // 12\n
///     vis!(a => b => c); // 123\n
///     vis!(a => b => c ,); // 123\n
///
///     println!();
///
///     vis!(a; b); // 1\n2\n
///     vis!(a; b; c); // 1\n2\n3\n
///     vis!(a; b; c =>); // 1\n2\n3\n
///
///     println!();
///
///     // multi elements connected by different operater test ...
///
///     vis!(a, b; c); // 1 2\n3\n
///     vis!(a; b, c); // 1\n2 3\n
///     vis!(a => b, c); // 12 3\n
///     vis!(a; b => c); // 1\n23\n
///
///     println!();
///
///     vis!(a, v); // 1 a b c\n;
///     vis!(a, v;); // 1 a\nb\nc\n;
///     vis!(a => v =>); // 1abc\n;
///
///     println!("\d");
///     // panic!()
/// }
/// ```
#[macro_export]
macro_rules ! vis {() => {println ! () ; } ; ($ last : expr ; ) => {$ last . lines () ; vis ! () } ; ($ last : expr => ) => {$ last . continuous () ; vis ! () ; } ; ($ last : expr $ (, ) ? ) => {$ last . spaces () ; vis ! () ; } ; ($ first : expr ; $ ($ rest : tt ) * ) => {$ first . lines () ; println ! () ; vis ! ($ ($ rest ) * ) ; } ; ($ first : expr => $ ($ rest : tt ) * ) => {$ first . continuous () ; vis ! ($ ($ rest ) * ) ; } ; ($ first : expr , $ ($ rest : tt ) * ) => {$ first . spaces () ; print ! (" " ) ; vis ! ($ ($ rest ) * ) ; } ; }

pub const MOD10E9_7: usize = 1000000007;
pub const MOD99_: usize = 998244353;
pub const MAX: usize = std::usize::MAX;
pub const PI: f64 = f64::consts::PI;
pub const ASCII_A: u8 = 65;
pub const ASCII_0: u8 = 48;
pub const ADJ4: &[(isize, isize); 4] = &[(1, 0), (0, 1), (-1, 0), (0, -1)];

// code...
// #[fastout]
fn main() {
    input! {
        n: usize,
        edges: [(Usize1, Usize1, u64); n-1]
    }

    let mut g = vec![Vec::new(); n];
    for (i, j, w) in edges {
        g[i].push((j, w));
        g[j].push((i, w));
    }

    let mut color = vec![-1; n];
    color[0] = 0; // 頂点 0 を 白で塗る
    dfs(&g, &mut color, 0);
    vis!(color;);
}

fn dfs(g: &Vec<Vec<(usize, u64)>>, res: &mut Vec<i32>, cur: usize) {
    let iter = g[cur].iter().filter(|x| res[x.0] == -1).collect_vec();

    for &neib in iter {
        // dbg!(neib);
        if neib.1 & 1 != 0 {
            res[neib.0] = res[cur] ^ 1;
        } else {
            res[neib.0] = res[cur];
        }
        dfs(g, res, neib.0);
    }
}