package main

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReaderSize(os.Stdin, 1<<20)}
}

func (fs *FastScanner) NextInt() int {
	sign, val := 1, 0
	c, _ := fs.r.ReadByte()
	for (c < '0' || c > '9') && c != '-' {
		c, _ = fs.r.ReadByte()
	}
	if c == '-' {
		sign = -1
		c, _ = fs.r.ReadByte()
	}
	for c >= '0' && c <= '9' {
		val = val*10 + int(c-'0')
		c, _ = fs.r.ReadByte()
	}
	return sign * val
}

type TNode struct {
	key       int
	tout      int
	pr        uint32
	left      *TNode
	right     *TNode
	subtreeSz int
}

type Treap struct {
	root *TNode
	seed uint32
}

func (t *Treap) rnd() uint32 {
	t.seed ^= t.seed << 13
	t.seed ^= t.seed >> 17
	t.seed ^= t.seed << 5
	return t.seed
}

func cnt(n *TNode) int {
	if n == nil {
		return 0
	}
	return n.subtreeSz
}

func upd(n *TNode) {
	if n != nil {
		n.subtreeSz = 1 + cnt(n.left) + cnt(n.right)
	}
}

func split(root *TNode, key int) (*TNode, *TNode) {
	if root == nil {
		return nil, nil
	}
	if key <= root.key {
		l, r := split(root.left, key)
		root.left = r
		upd(root)
		return l, root
	} else {
		l, r := split(root.right, key)
		root.right = l
		upd(root)
		return root, r
	}
}

func merge(l, r *TNode) *TNode {
	if l == nil {
		return r
	}
	if r == nil {
		return l
	}
	if l.pr > r.pr {
		l.right = merge(l.right, r)
		upd(l)
		return l
	} else {
		r.left = merge(l, r.left)
		upd(r)
		return r
	}
}

func (t *Treap) Insert(key, tout int) {
	node := &TNode{key: key, tout: tout, pr: t.rnd(), subtreeSz: 1}
	l, r := split(t.root, key)
	t.root = merge(merge(l, node), r)
}

func (t *Treap) Delete(key int) {
	t.root = t.deleteRec(t.root, key)
}

func (t *Treap) deleteRec(root *TNode, key int) *TNode {
	if root == nil {
		return nil
	}
	if key == root.key {
		return merge(root.left, root.right)
	} else if key < root.key {
		root.left = t.deleteRec(root.left, key)
	} else {
		root.right = t.deleteRec(root.right, key)
	}
	upd(root)
	return root
}

func (t *Treap) LowerBound(key int) *TNode {
	cur := t.root
	var res *TNode
	for cur != nil {
		if key <= cur.key {
			res = cur
			cur = cur.left
		} else {
			cur = cur.right
		}
	}
	return res
}

func (t *Treap) Predecessor(key int) *TNode {
	cur := t.root
	var res *TNode
	for cur != nil {
		if cur.key < key {
			res = cur
			cur = cur.right
		} else {
			cur = cur.left
		}
	}
	return res
}

func (t *Treap) Size() int {
	return cnt(t.root)
}

type Op struct {
	typ int
	key int
	old int
}

func main() {
	in := NewFastScanner()
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	t := in.NextInt()
	for ; t > 0; t-- {
		n := in.NextInt()
		aAdj := make([][]int, n+1)
		bAdj := make([][]int, n+1)
		for i := 2; i <= n; i++ {
			p := in.NextInt()
			aAdj[p] = append(aAdj[p], i)
		}
		for i := 2; i <= n; i++ {
			p := in.NextInt()
			bAdj[p] = append(bAdj[p], i)
		}

		tin := make([]int, n+1)
		tout := make([]int, n+1)
		time := 0
		stack := make([]int, 0, 2*n)
		stack = append(stack, 1)
		for len(stack) > 0 {
			u := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			if u > 0 {
				time++
				tin[u] = time
				stack = append(stack, -u)
				ch := bAdj[u]
				for i := len(ch) - 1; i >= 0; i-- {
					stack = append(stack, ch[i])
				}
			} else {
				u = -u
				tout[u] = time
			}
		}
		toutOfTin := make([]int, n+2)
		for i := 1; i <= n; i++ {
			toutOfTin[tin[i]] = tout[i]
		}

		var treap Treap
		treap.seed = 71236721
		ans := 0
		ops := make([]Op, 0, n)
		stack = stack[:0]
		stack = append(stack, 1)
		for len(stack) > 0 {
			u := stack[len(stack)-1]
			stack = stack[:len(stack)-1]
			if u > 0 {
				key := tin[u]
				to := tout[u]
				var op Op
				pred := treap.Predecessor(key)
				if pred != nil && pred.tout >= to {
					treap.Delete(pred.key)
					treap.Insert(key, to)
					op = Op{typ: 2, key: key, old: pred.key}
				} else {
					succ := treap.LowerBound(key)
					if succ != nil && succ.tout <= to {
						op = Op{typ: 0, key: key}
					} else {
						treap.Insert(key, to)
						op = Op{typ: 1, key: key}
					}
				}
				ops = append(ops, op)
				if treap.Size() > ans {
					ans = treap.Size()
				}
				stack = append(stack, -u)
				ch := aAdj[u]
				for i := len(ch) - 1; i >= 0; i-- {
					stack = append(stack, ch[i])
				}
			} else {
				u = -u
				op := ops[len(ops)-1]
				ops = ops[:len(ops)-1]
				if op.typ == 1 {
					treap.Delete(op.key)
				} else if op.typ == 2 {
					treap.Delete(op.key)
					treap.Insert(op.old, toutOfTin[op.old])
				}
			}
		}

		fmt.Fprintln(out, ans)
	}
}