```go
package main

import (
	"bufio"
	"fmt"
	"os"
)

type Node struct {
	maxv int
	pos  int
}

var (
	n        int
	adj      [][]int
	depth    []int
	sz       []int
	dominant []int
	tree     []Node
	N        int
)

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func build(idx, l, r int) {
	if l == r {
		tree[idx] = Node{0, l}
		return
	}
	mid := (l + r) / 2
	build(2*idx, l, mid)
	build(2*idx+1, mid+1, r)
	left := tree[2*idx]
	right := tree[2*idx+1]
	if left.maxv > right.maxv {
		tree[idx] = left
	} else if left.maxv < right.maxv {
		tree[idx] = right
	} else {
		tree[idx] = Node{left.maxv, min(left.pos, right.pos)}
	}
}

func update(idx, l, r, p, delta int) {
	if l == r {
		tree[idx].maxv += delta
		return
	}
	mid := (l + r) / 2
	if p <= mid {
		update(2*idx, l, mid, p, delta)
	} else {
		update(2*idx+1, mid+1, r, p, delta)
	}
	left := tree[2*idx]
	right := tree[2*idx+1]
	if left.maxv > right.maxv {
		tree[idx] = left
	} else if left.maxv < right.maxv {
		tree[idx] = right
	} else {
		tree[idx] = Node{left.maxv, min(left.pos, right.pos)}
	}
}

func add_node(u int) {
	update(1, 0, N, depth[u], 1)
}

func remove_node(u int) {
	update(1, 0, N, depth[u], -1)
}

func add_subtree(u, par int) {
	add_node(u)
	for _, v := range adj[u] {
		if v != par {
			add_subtree(v, u)
		}
	}
}

func remove_subtree(u, par int) {
	remove_node(u)
	for _, v := range adj[u] {
		if v != par {
			remove_subtree(v, u)
		}
	}
}

func dfs_size(u, p int) {
	sz[u] = 1
	if u == 1 {
		depth[u] = 0
	} else {
		depth[u] = depth[p] + 1
	}
	for _, v := range adj[u] {
		if v != p {
			dfs_size(v, u)
			sz[u] += sz[v]
		}
	}
}

func dfs_keep(u, par int, keep bool) {
	heavy := -1
	max_cs := -1
	for _, v := range adj[u] {
		if v != par && sz[v] > max_cs {
			max_cs = sz[v]
			heavy = v
		}
	}
	for _, v := range adj[u] {
		if v != par && v != heavy {
			dfs_keep(v, u, false)
		}
	}
	if heavy != -1 {
		dfs_keep(heavy, u, true)
	}
	for _, v := range adj[u] {
		if v != par && v != heavy {
			add_subtree(v, u)
		}
	}
	add_node(u)
	dom := tree[1].pos - depth[u]
	dominant[u] = dom
	if !keep {
		remove_subtree(u, par)
	}
}

func main() {
	in := bufio.NewReader(os.Stdin)
	fmt.Fscan(in, &n)
	adj = make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		var x, y int
		fmt.Fscan(in, &x, &y)
		adj[x] = append(adj[x], y)
		adj[y] = append(adj[y], x)
	}
	depth = make([]int, n+1)
	sz = make([]int, n+1)
	dominant = make([]int, n+1)
	dfs_size(1, 0)
	N = n
	tree = make([]Node, 4*(N+1))
	build(1, 0, N)
	dfs_keep(1, 0, true)
	out := bufio.NewWriter(os.Stdout)
	for i := 1; i <= n; i++ {
		fmt.Fprint(out, dominant[i], " ")
	}
	fmt.Fprintln(out)
	out.Flush()
}
```