#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <map>
#include <numeric>
using namespace std;
#define MAX 1000100
vector<int> adj[MAX];
int cnt[MAX];
char res[MAX];
int n;
void dfsPrepare(int u, int par) {
cnt[u] = 1;
for (int v : adj[u]) {
if (v != par) {
dfsPrepare(v, u);
cnt[u] += cnt[v];
}
}
}
void dfsTrace(int u, int par, char c) {
res[u] = c;
for (int v : adj[u]) {
if (v != par) {
dfsTrace(v, u, c);
}
}
}
bool canSplit(int r) {
vector<pair<int, int>> values;
int max_limit = n / 2;
for (int c : adj[r]) {
int branch_size;
if (cnt[c] < cnt[r]) {
branch_size = cnt[c];
}
else {
branch_size = n - cnt[r];
}
if (branch_size > max_limit) return false;
values.push_back({branch_size, c});
}
// 1. Sắp xếp giảm dần (Tham lam: Xử lý nhánh lớn trước)
sort(values.begin(), values.end(), greater<pair<int, int>>());
int sum[3] = {0, 0, 0};
pair<int, int> p[3]; // {sum, index}
// 2. Thực hiện chia tham lam (Ưu tiên nhóm CÓ TỔNG NHỎ NHẤT)
for (const auto& x : values) {
int branch_size = x.first;
int branch_root_node = x.second;
for (int i = 0; i < 3; ++i) {
p[i] = {sum[i], i};
}
// Sắp xếp TĂNG DẦN theo tổng hiện tại (Ưu tiên nhóm NHỎ NHẤT để giữ cân bằng)
sort(p, p + 3);
bool assigned = false;
// Duyệt từ nhóm nhỏ nhất đến lớn nhất
for (int i = 0; i < 3; ++i) {
int j = p[i].second;
if (sum[j] + branch_size <= max_limit) {
sum[j] += branch_size;
res[branch_root_node] = '1' + j;
assigned = true;
break;
}
}
if (!assigned) {
return false;
}
}
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
if (!(cin >> n)) return 0;
if (n == 1) {
cout << "0\n";
return 0;
}
for (int i = 0; i < n - 1; ++i) {
int u, v;
if (!(cin >> u >> v)) return 0;
adj[u].push_back(v);
adj[v].push_back(u);
}
dfsPrepare(1, 0);
for (int r = 1; r <= n; ++r) {
fill(res + 1, res + n + 1, 0);
if (canSplit(r)) {
res[r] = '0';
for (int c : adj[r]) {
dfsTrace(c, r, res[c]);
}
res[n + 1] = '\0';
cout << (res + 1) << "\n";
return 0;
}
}
cout << "-1\n";
return 0;
}
I2luY2x1ZGUgPGlvc3RyZWFtPgojaW5jbHVkZSA8dmVjdG9yPgojaW5jbHVkZSA8YWxnb3JpdGhtPgojaW5jbHVkZSA8Y21hdGg+CiNpbmNsdWRlIDxtYXA+CiNpbmNsdWRlIDxudW1lcmljPgoKdXNpbmcgbmFtZXNwYWNlIHN0ZDsKCiNkZWZpbmUgTUFYIDEwMDAxMDAKCnZlY3RvcjxpbnQ+IGFkaltNQVhdOwppbnQgY250W01BWF07IApjaGFyIHJlc1tNQVhdOyAKaW50IG47IAoKdm9pZCBkZnNQcmVwYXJlKGludCB1LCBpbnQgcGFyKSB7CiAgICBjbnRbdV0gPSAxOwogICAgZm9yIChpbnQgdiA6IGFkalt1XSkgewogICAgICAgIGlmICh2ICE9IHBhcikgewogICAgICAgICAgICBkZnNQcmVwYXJlKHYsIHUpOwogICAgICAgICAgICBjbnRbdV0gKz0gY250W3ZdOwogICAgICAgIH0KICAgIH0KfQoKdm9pZCBkZnNUcmFjZShpbnQgdSwgaW50IHBhciwgY2hhciBjKSB7CiAgICByZXNbdV0gPSBjOwogICAgZm9yIChpbnQgdiA6IGFkalt1XSkgewogICAgICAgIGlmICh2ICE9IHBhcikgewogICAgICAgICAgICBkZnNUcmFjZSh2LCB1LCBjKTsKICAgICAgICB9CiAgICB9Cn0KCmJvb2wgY2FuU3BsaXQoaW50IHIpIHsKICAgIHZlY3RvcjxwYWlyPGludCwgaW50Pj4gdmFsdWVzOyAKICAgIGludCBtYXhfbGltaXQgPSBuIC8gMjsKCiAgICBmb3IgKGludCBjIDogYWRqW3JdKSB7CiAgICAgICAgaW50IGJyYW5jaF9zaXplOwogICAgICAgIAogICAgICAgIGlmIChjbnRbY10gPCBjbnRbcl0pIHsKICAgICAgICAgICAgYnJhbmNoX3NpemUgPSBjbnRbY107CiAgICAgICAgfSAKICAgICAgICBlbHNlIHsKICAgICAgICAgICAgYnJhbmNoX3NpemUgPSBuIC0gY250W3JdOwogICAgICAgIH0KICAgICAgICAKICAgICAgICBpZiAoYnJhbmNoX3NpemUgPiBtYXhfbGltaXQpIHJldHVybiBmYWxzZTsKICAgICAgICAKICAgICAgICB2YWx1ZXMucHVzaF9iYWNrKHticmFuY2hfc2l6ZSwgY30pOwogICAgfQoKICAgIC8vIDEuIFPhuq9wIHjhur9wIGdp4bqjbSBk4bqnbiAoVGhhbSBsYW06IFjhu60gbMO9IG5ow6FuaCBs4bubbiB0csaw4bubYykKICAgIHNvcnQodmFsdWVzLmJlZ2luKCksIHZhbHVlcy5lbmQoKSwgZ3JlYXRlcjxwYWlyPGludCwgaW50Pj4oKSk7CgogICAgaW50IHN1bVszXSA9IHswLCAwLCAwfTsKICAgIHBhaXI8aW50LCBpbnQ+IHBbM107IC8vIHtzdW0sIGluZGV4fQoKICAgIC8vIDIuIFRo4buxYyBoaeG7h24gY2hpYSB0aGFtIGxhbSAoxq91IHRpw6puIG5ow7NtIEPDkyBU4buUTkcgTkjhu44gTkjhuqRUKQogICAgZm9yIChjb25zdCBhdXRvJiB4IDogdmFsdWVzKSB7CiAgICAgICAgaW50IGJyYW5jaF9zaXplID0geC5maXJzdDsKICAgICAgICBpbnQgYnJhbmNoX3Jvb3Rfbm9kZSA9IHguc2Vjb25kOwoKICAgICAgICBmb3IgKGludCBpID0gMDsgaSA8IDM7ICsraSkgewogICAgICAgICAgICBwW2ldID0ge3N1bVtpXSwgaX07CiAgICAgICAgfQogICAgICAgIC8vIFPhuq9wIHjhur9wIFTEgk5HIEThuqZOIHRoZW8gdOG7lW5nIGhp4buHbiB04bqhaSAoxq91IHRpw6puIG5ow7NtIE5I4buOIE5I4bqkVCDEkeG7gyBnaeG7ryBjw6JuIGLhurFuZykKICAgICAgICBzb3J0KHAsIHAgKyAzKTsgCiAgICAgICAgCiAgICAgICAgYm9vbCBhc3NpZ25lZCA9IGZhbHNlOwogICAgICAgIAogICAgICAgIC8vIER1eeG7h3QgdOG7qyBuaMOzbSBuaOG7jyBuaOG6pXQgxJHhur9uIGzhu5tuIG5o4bqldAogICAgICAgIGZvciAoaW50IGkgPSAwOyBpIDwgMzsgKytpKSB7CiAgICAgICAgICAgIGludCBqID0gcFtpXS5zZWNvbmQ7CiAgICAgICAgICAgIAogICAgICAgICAgICBpZiAoc3VtW2pdICsgYnJhbmNoX3NpemUgPD0gbWF4X2xpbWl0KSB7CiAgICAgICAgICAgICAgICBzdW1bal0gKz0gYnJhbmNoX3NpemU7CiAgICAgICAgICAgICAgICByZXNbYnJhbmNoX3Jvb3Rfbm9kZV0gPSAnMScgKyBqOyAKICAgICAgICAgICAgICAgIGFzc2lnbmVkID0gdHJ1ZTsKICAgICAgICAgICAgICAgIGJyZWFrOyAKICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgaWYgKCFhc3NpZ25lZCkgewogICAgICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgICAgfQogICAgfQoKICAgIHJldHVybiB0cnVlOwp9CgppbnQgbWFpbigpIHsKICAgIGlvc19iYXNlOjpzeW5jX3dpdGhfc3RkaW8oZmFsc2UpOwogICAgY2luLnRpZShOVUxMKTsKCiAgICBpZiAoIShjaW4gPj4gbikpIHJldHVybiAwOwogICAgCiAgICBpZiAobiA9PSAxKSB7CiAgICAgICAgY291dCA8PCAiMFxuIjsKICAgICAgICByZXR1cm4gMDsKICAgIH0KCiAgICBmb3IgKGludCBpID0gMDsgaSA8IG4gLSAxOyArK2kpIHsKICAgICAgICBpbnQgdSwgdjsKICAgICAgICBpZiAoIShjaW4gPj4gdSA+PiB2KSkgcmV0dXJuIDA7CiAgICAgICAgYWRqW3VdLnB1c2hfYmFjayh2KTsKICAgICAgICBhZGpbdl0ucHVzaF9iYWNrKHUpOwogICAgfQoKICAgIGRmc1ByZXBhcmUoMSwgMCk7CgogICAgZm9yIChpbnQgciA9IDE7IHIgPD0gbjsgKytyKSB7CiAgICAgICAgZmlsbChyZXMgKyAxLCByZXMgKyBuICsgMSwgMCk7IAoKICAgICAgICBpZiAoY2FuU3BsaXQocikpIHsKICAgICAgICAgICAgcmVzW3JdID0gJzAnOyAKCiAgICAgICAgICAgIGZvciAoaW50IGMgOiBhZGpbcl0pIHsKICAgICAgICAgICAgICAgIGRmc1RyYWNlKGMsIHIsIHJlc1tjXSk7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIHJlc1tuICsgMV0gPSAnXDAnOwogICAgICAgICAgICBjb3V0IDw8IChyZXMgKyAxKSA8PCAiXG4iOwogICAgICAgICAgICByZXR1cm4gMDsKICAgICAgICB9CiAgICB9CgogICAgY291dCA8PCAiLTFcbiI7IAogICAgcmV0dXJuIDA7Cn0K