package main

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

var in = bufio.NewReader(os.Stdin)
var out = bufio.NewWriter(os.Stdout)

func main() {
	defer out.Flush()
	var t int
	fmt.Fscan(in, &t)
	for i := 0; i < t; i++ {
		solve()
	}
}

func solve() {
	var n, m int
	fmt.Fscan(in, &n, &m)
	a := make([]int, n)
	for i := 0; i < n; i++ {
		fmt.Fscan(in, &a[i])
	}

	
	
	
	minReq := make([]int, n+2)
	for i := 0; i <= n+1; i++ {
		minReq[i] = n + 1
	}

	for i := 0; i < m; i++ {
		var l, r int
		fmt.Fscan(in, &l, &r)
		if l < minReq[r] {
			minReq[r] = l
		}
	}

	
	
	
	
	
	for i := n; i >= 1; i-- {
		if minReq[i+1] < minReq[i] {
			minReq[i] = minReq[i+1]
		}
	}

	type pair struct {
		val, idx int
	}
	pairs := make([]pair, n)
	for i := 0; i < n; i++ {
		pairs[i] = pair{a[i], i + 1}
	}

	sort.Slice(pairs, func(i, j int) bool {
		if pairs[i].val != pairs[j].val {
			return pairs[i].val < pairs[j].val
		}
		return pairs[i].idx < pairs[j].idx
	})

	minV := n + 2
	maxU := -1
	events := make([]int, n+2)
	hasActive := false

	
	for i := 0; i < n; {
		j := i
		for j < n && pairs[j].val == pairs[i].val {
			j++
		}

		group := pairs[i:j]
		k := len(group)
		indices := make([]int, k)
		for idx := 0; idx < k; idx++ {
			indices[idx] = group[idx].idx
		}

		
		for idx := 0; idx < k-1; idx++ {
			u := indices[idx]
			v := indices[idx+1]
			
			if u >= minReq[v] {
				hasActive = true
				if v < minV {
					minV = v
				}
				if u > maxU {
					maxU = u
				}
			}
		}

		
		
		
		
		for idx := 1; idx < k; idx++ {
			v := indices[idx]
			req := minReq[v]
			if req > n {
				continue
			}

			
			pos := sort.Search(idx, func(x int) bool {
				return indices[x] >= req
			})

			if pos < idx {
				u := indices[pos]
				
				if v > events[u] {
					events[u] = v
				}
				hasActive = true
			}
		}
		i = j
	}

	if !hasActive {
		fmt.Fprintln(out, 0)
		return
	}

	
	P := make([]int, n+2)
	curr := 0
	for i := 1; i <= n; i++ {
		if events[i] > curr {
			curr = events[i]
		}
		P[i] = curr
	}

	ans := n + 1
	
	
	for L := 1; L <= minV; L++ {
		
		
		reqR := maxU
		if P[L-1] > reqR {
			reqR = P[L-1]
		}

		length := reqR - L + 1
		if length < ans {
			ans = length
		}
	}
	fmt.Fprintln(out, ans)
}