package main

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

var (
	head []int
	next []int
	to   []int
	dp0  []int
	dp1  []int
	deg  []int
	edgeCount int
	alpha     int
	found     bool
)

func dfs1(u, p int) {
	dp0[u] = 0
	dp1[u] = 1
	for e := head[u]; e != 0; e = next[e] {
		v := to[e]
		if v != p {
			dfs1(v, u)
			if dp0[v] > dp1[v] {
				dp0[u] += dp0[v]
			} else {
				dp0[u] += dp1[v]
			}
			dp1[u] += dp0[v]
		}
	}
}

func dfs2(u, p, out0, out1 int) {
	S0 := 0
	S1 := 1
	if p != 0 {
		if out0 > out1 {
			S0 += out0
		} else {
			S0 += out1
		}
		S1 += out0
	}
	for e := head[u]; e != 0; e = next[e] {
		v := to[e]
		if v != p {
			if dp0[v] > dp1[v] {
				S0 += dp0[v]
			} else {
				S0 += dp1[v]
			}
			S1 += dp0[v]
		}
	}

	if deg[u] == 1 && S0 == alpha {
		found = true
	}

	if found {
		return
	}

	for e := head[u]; e != 0; e = next[e] {
		v := to[e]
		if v != p {
			vMax := dp0[v]
			if dp1[v] > dp0[v] {
				vMax = dp1[v]
			}
			nxtOut0 := S0 - vMax
			nxtOut1 := S1 - dp0[v]
			dfs2(v, u, nxtOut0, nxtOut1)
			if found {
				return
			}
		}
	}
}

func main() {
	buf := make([]byte, 8192)
	var pos, length int
	readByte := func() byte {
		if pos >= length {
			pos = 0
			n, err := os.Stdin.Read(buf)
			if err != nil || n == 0 {
				return 0
			}
			length = n
		}
		b := buf[pos]
		pos++
		return b
	}

	nextInt := func() int {
		var res int
		b := readByte()
		for b <= ' ' {
			if b == 0 {
				return 0
			}
			b = readByte()
		}
		for b > ' ' {
			res = res*10 + int(b-'0')
			b = readByte()
		}
		return res
	}

	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	t := nextInt()
	if t == 0 {
		return
	}

	maxN := 300005
	head = make([]int, maxN)
	next = make([]int, maxN*2)
	to = make([]int, maxN*2)
	dp0 = make([]int, maxN)
	dp1 = make([]int, maxN)
	deg = make([]int, maxN)

	for tc := 0; tc < t; tc++ {
		n := nextInt()
		edgeCount = 0
		found = false

		for i := 1; i <= n; i++ {
			head[i] = 0
			deg[i] = 0
		}

		addEdge := func(u, v int) {
			edgeCount++
			to[edgeCount] = v
			next[edgeCount] = head[u]
			head[u] = edgeCount
			deg[u]++
		}

		for i := 0; i < n-1; i++ {
			u := nextInt()
			v := nextInt()
			addEdge(u, v)
			addEdge(v, u)
		}

		dfs1(1, 0)

		alpha = dp0[1]
		if dp1[1] > dp0[1] {
			alpha = dp1[1]
		}

		dfs2(1, 0, 0, 0)

		if found {
			fmt.Fprintln(writer, alpha+1)
		} else {
			fmt.Fprintln(writer, alpha)
		}
	}
}