```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var t int
	if _, err := fmt.Fscan(in, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		var n int
		fmt.Fscan(in, &n)

		adj := make([][]int, n+1)
		for i := 0; i < n-1; i++ {
			var u, v int
			fmt.Fscan(in, &u, &v)
			adj[u] = append(adj[u], v)
			adj[v] = append(adj[v], u)
		}

		dist := make([]int, (n+1)*(n+1))
		for i := 0; i < len(dist); i++ {
			dist[i] = -1
		}

		for i := 1; i <= n; i++ {
			idx := i * (n + 1)
			dist[idx+i] = 0
			q := []int{i}
			for len(q) > 0 {
				curr := q[0]
				q = q[1:]
				currDist := dist[idx+curr]
				for _, nxt := range adj[curr] {
					if dist[idx+nxt] == -1 {
						dist[idx+nxt] = currDist + 1
						q = append(q, nxt)
					}
				}
			}
		}

		dMax := 0
		dIdx := 1 * (n + 1)
		for i := 1; i <= n; i++ {
			if dist[dIdx+i] > dMax {
				dMax = dist[dIdx+i]
			}
		}

		nodesByD := make([][]int, dMax+1)
		for i := 1; i <= n; i++ {
			d := dist[dIdx+i]
			nodesByD[d] = append(nodesByD[d], i)
		}

		ans := make([]int, n+1)
		for i := 1; i <= n; i++ {
			ans[i] = dMax
		}

		A, B := -1, -1
		diam := 0

		for k := dMax - 1; k >= 0; k-- {
			for _, u := range nodesByD[k+1] {
				if A == -1 {
					A, B = u, u
					diam = 0
				} else {
					d1 := dist[A*(n+1)+u]
					d2 := dist[B*(n+1)+u]
					if d1 > diam || d2 > diam {
						if d1 > d2 {
							diam = d1
							B = u
						} else {
							diam = d2
							A = u
						}
					}
				}
			}

			mk := k - (diam+1)/2
			limit := mk
			if limit > n {
				limit = n
			}
			for x := 1; x <= limit; x++ {
				if k < ans[x] {
					ans[x] = k
				}
			}
		}

		for x := 1; x <= n; x++ {
			if x > 1 {
				fmt.Fprint(out, " ")
			}
			fmt.Fprint(out, ans[x])
		}
		fmt.Fprintln(out)
	}
}
```