```go
package main

import (
	"bufio"
	"io"
	"os"
	"strconv"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt() int {
	i := fs.idx
	for i < fs.n && (fs.data[i] < '0' || fs.data[i] > '9') {
		i++
	}
	val := 0
	for i < fs.n && fs.data[i] >= '0' && fs.data[i] <= '9' {
		val = val*10 + int(fs.data[i]-'0')
		i++
	}
	fs.idx = i
	return val
}

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

	t := fs.NextInt()
	for ; t > 0; t-- {
		n := fs.NextInt()
		m := fs.NextInt()

		a := make([]int, n)
		for i := 0; i < n; i++ {
			a[i] = fs.NextInt()
		}

		b := make([]int, m+1)
		indeg := make([]int, m+1)
		head := make([]int, m+1)
		nextEdge := make([]int, m+1)

		for i := 1; i <= m; i++ {
			v := fs.NextInt()
			b[i] = v
			indeg[v]++
			nextEdge[i] = head[v]
			head[v] = i
		}

		queue := make([]int, m)
		qh, qt := 0, 0
		for i := 1; i <= m; i++ {
			if indeg[i] == 0 {
				queue[qt] = i
				qt++
			}
		}
		for qh < qt {
			u := queue[qh]
			qh++
			v := b[u]
			indeg[v]--
			if indeg[v] == 0 {
				queue[qt] = v
				qt++
			}
		}

		inCycle := make([]bool, m+1)
		for i := 1; i <= m; i++ {
			if indeg[i] > 0 {
				inCycle[i] = true
			}
		}

		comp := make([]int, m+1)
		depth := make([]int, m+1)
		root := make([]int, m+1)
		pos := make([]int, m+1)
		tin := make([]int, m+1)
		tout := make([]int, m+1)
		cycleLen := make([]int, 1, m+1)

		stackNode := queue
		stackEdge := indeg
		compCnt := 0
		timer := 0

		for i := 1; i <= m; i++ {
			if !inCycle[i] || comp[i] != 0 {
				continue
			}

			compCnt++

			clen := 1
			cur := b[i]
			for cur != i {
				clen++
				cur = b[cur]
			}
			cycleLen = append(cycleLen, clen)

			cur = i
			p := 0
			for {
				comp[cur] = compCnt
				root[cur] = cur
				pos[cur] = p
				p++
				cur = b[cur]
				if cur == i {
					break
				}
			}

			cur = i
			for {
				c := cur
				timer++
				tin[c] = timer

				top := 1
				stackNode[0] = c
				stackEdge[0] = head[c]

				for top > 0 {
					u := stackNode[top-1]
					e := stackEdge[top-1]

					for e != 0 && inCycle[e] {
						e = nextEdge[e]
					}

					if e == 0 {
						tout[u] = timer
						top--
						continue
					}

					stackEdge[top-1] = nextEdge[e]
					v := e
					comp[v] = comp[u]
					root[v] = root[u]
					depth[v] = depth[u] + 1
					timer++
					tin[v] = timer
					stackNode[top] = v
					stackEdge[top] = head[v]
					top++
				}

				cur = b[cur]
				if cur == i {
					break
				}
			}
		}

		check := func(K int) bool {
			ptr := 0
			for y := 1; y <= m && ptr < n; y++ {
				cyComp := comp[y]

				if inCycle[y] {
					py := pos[y]
					clen := cycleLen[cyComp]
					for ptr < n {
						x := a[ptr]
						if comp[x] != cyComp {
							break
						}
						d := depth[x]
						diff := py - pos[root[x]]
						if diff < 0 {
							diff += clen
						}
						d += diff
						if d > K {
							break
						}
						ptr++
					}
				} else {
					ry := root[y]
					dy := depth[y]
					ly := tin[y]
					ry2 := tout[y]
					for ptr < n {
						x := a[ptr]
						if comp[x] != cyComp || root[x] != ry || depth[x] < dy {
							break
						}
						tx := tin[x]
						if tx < ly || tx > ry2 {
							break
						}
						if depth[x]-dy > K {
							break
						}
						ptr++
					}
				}
			}
			return ptr == n
		}

		ans := -1
		if check(m - 1) {
			l, r := 0, m-1
			for l < r {
				mid := (l + r) >> 1
				if check(mid) {
					r = mid
				} else {
					l = mid + 1
				}
			}
			ans = l
		}

		out.WriteString(strconv.Itoa(ans))
		out.WriteByte('\n')
	}
}
```