```go
package main

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

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var t int
	fmt.Fscan(in, &t)
	for tt := 0; tt < t; tt++ {
		var n int
		fmt.Fscan(in, &n)
		a := make([]int64, n)
		uniques := make(map[int64]bool)
		for i := 0; i < n; i++ {
			fmt.Fscan(in, &a[i])
			uniques[a[i]] = true
		}
		var mex int64 = 0
		for {
			if _, ok := uniques[mex]; !ok {
				break
			}
			mex++
		}
		m := mex
		pos_m1 := []int{}
		for i := 0; i < n; i++ {
			if a[i] == m+1 {
				pos_m1 = append(pos_m1, i)
			}
		}
		empty_s := len(pos_m1) == 0
		min_pos := make([]int, int(m))
		max_pos := make([]int, int(m))
		for i := range min_pos {
			min_pos[i] = n
			max_pos[i] = -1
		}
		low_count := 0
		for i := 0; i < n; i++ {
			if a[i] < m {
				low_count++
				x := int(a[i])
				min_pos[x] = min(min_pos[x], i)
				max_pos[x] = max(max_pos[x], i)
			}
		}
		var ans string
		if empty_s {
			if low_count == n && low_count == int(m) {
				ans = "No"
			} else {
				ans = "Yes"
			}
		} else {
			L0 := n
			R0 := -1
			for _, p := range pos_m1 {
				L0 = min(L0, p)
				R0 = max(R0, p)
			}
			left_bound := 0
			for x := 0; x < int(m); x++ {
				if max_pos[x] <= R0 && max_pos[x] >= 0 {
					left_bound = max(left_bound, min_pos[x]+1)
				}
			}
			right_bound := n - 1
			for x := 0; x < int(m); x++ {
				if min_pos[x] >= L0 && min_pos[x] < n {
					right_bound = min(right_bound, max_pos[x]-1)
				}
			}
			if left_bound <= L0 && R0 <= right_bound {
				ans = "Yes"
			} else {
				ans = "No"
			}
		}
		fmt.Println(ans)
	}
}
```