```go
package main

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

func main() {
	reader := bufio.NewReader(os.Stdin)
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	var t int
	fmt.Fscan(reader, &t)

	for ; t > 0; t-- {
		var n, m int
		fmt.Fscan(reader, &n, &m)

		a := make([]int, n)
		for i := 0; i < n; i++ {
			fmt.Fscan(reader, &a[i])
		}

		// Sort a in ascending order to greedily pick opponents to beat with minimum cost
		sort.Ints(a)

		// Determine which opponents you can beat
		// You want to maximize wins, so pick opponents with smallest a_i first
		// But also, to minimize place, we want to maximize our wins

		// Actually, we need to find the best set of opponents to beat
		// to minimize our place.

		// Let's think: if we beat opponents with indices in set S (0-indexed after sort),
		// our wins = |S|
		// 
		// For opponent i (1-indexed in original), wins = i-1 (beats all j < i) + (1 if i beats you else 0)
		// 
		// After sorting a[], if we decide to beat k opponents,
		// we should beat the k opponents with smallest a values.
		// But which opponents (by their original index) we beat matters for their win counts.
		//
		// Wait - opponent i beats you if a[i-1] > preparation, i.e., if we don't prepare for them.
		// The opponents are numbered 1..n, opponent i beats opponent j iff i > j.
		// 
		// Opponent i's wins:
		// - Against other opponents: wins against all j < i, so (i-1) wins from inter-opponent games
		// - Against you: wins if you didn't prepare for them (a[i-1] > budget for that match)
		//
		// Our wins: number of opponents we prepared for and beat.
		//
		// To minimize our place, we want to minimize the number of participants with strictly more wins than us.
		//
		// Strategy: Try all possible sets of opponents to beat.
		// For a fixed number of wins k (we beat k opponents),
		// we should beat the k opponents with smallest a_i (greedy).
		// Then check how many total participants have strictly more wins than us.

		// Sort a to pick greedily
		// After sorting, if we beat the k opponents with smallest a values,
		// we need to figure out which original indices those correspond to.
		// 
		// The issue: opponent i's wins depend on their original index (i-1 inter-opponent wins).
		// We need to know, for each opponent, how many wins they have.

		// Let's work with original indices.
		// Create pairs (a[i], original_index = i+1) for i in 0..n-1
		// Sort by a[i] ascending.

		type Opponent struct {
			cost  int
			index int // 1-indexed
		}
		opponents := make([]Opponent, n)
		for i := 0; i < n; i++ {
			opponents[i] = Opponent{a[i], i + 1}
		}
		sort.Slice(opponents, func(i, j int) bool {
			return opponents[i].cost < opponents[j].cost
		})

		// Prefix sums of costs
		prefixCost := make([]int, n+1)
		for i := 0; i < n; i++ {
			prefixCost[i+1] = prefixCost[i] + opponents[i].cost
		}

		// For a given k (number of opponents we beat), we pick the first k in sorted order
		// (smallest costs). We beat opponents: opponents[0], ..., opponents[k-1]
		// We lose to: opponents[k], ..., opponents[n-1]

		// Our wins = k
		// 
		// Opponent with original index idx:
		// - inter-opponent wins = idx - 1
		// - beats us: if we don't prepare for them (i.e., they're in the "lose" group)
		// - total wins = (idx - 1) + (1 if they beat us else 0)
		//
		// We want: number of opponents with total wins > k, then our place = that count + 1.
		// (We count ourselves too, but only opponents can have more wins than us among the n+1 participants)
		// Actually place = (number of participants with strictly more wins than us) + 1
		// Other participants = opponents 1..n
		// Participant with more wins than us = opponent i with wins > k

		// For each k from 0 to max possible:
		// Find min place

		// For fixed k, we beat opponents[0..k-1] (by sorted cost order).
		// The opponents we beat have original indices: beat_set = {opponents[0].index, ..., opponents[k-1].index}
		// 
		// Opponent i (original index idx):
		// if idx in beat_set: wins = idx - 1 (we beat them, so they don't get a win against us)
		// if idx not in beat_set: wins = idx - 1 + 1 = idx
		//
		// Number of opponents with wins > k:
		// = |{idx in beat_set : idx - 1 > k}| + |{idx not in beat_set : idx > k}|

		// To efficiently compute this for all k, let's precompute.

		// Let beat[k] = set of indices when we pick k cheapest opponents
		// beat_indices[0..k-1] = opponents[0..k-1].index (sorted by cost)

		// For fixed k:
		// Group 1 (beaten by us): indices opponents[0..k-1].index
		//   contribute if idx - 1 > k, i.e., idx > k+1, i.e., idx >= k+2
		// Group 2 (beat us): indices opponents[k..n-1].index  
		//   contribute if idx > k

		// Let's define:
		// For group 1: count of opponents[0..k-1] with index >= k+2
		// For group 2: count of opponents[k..n-1] with index > k

		// We can precompute sorted indices for prefix and suffix.

		// Extract indices in order of sorting by cost:
		sortedIndices := make([]int, n)
		for i := 0; i < n; i++ {
			sortedIndices[i] = opponents[i].index
		}

		// For group 1 (prefix of size k): we need count of sortedIndices[0..k-1] with value >= k+2
		// For group 2 (suffix from k): we need count of sortedIndices[k..n-1] with value > k

		// We'll iterate k from 0 to maxK (max k where prefixCost[k] <= m)
		maxK := sort.Search(n+1, func(k int) bool {
			return prefixCost[k] > m
		}) - 1
		// maxK is the maximum number of opponents we can beat

		// For each k, compute the answer.
		// We want to minimize place = (# opponents with wins > k) + 1

		// Use a Fenwick tree or just iterate smartly.
		// n can be 5*10^5 and t up to 10^4 but sum of n is 5*10^5, so O(n log n) per test case is fine.

		// For group 2 (suffix [k..n-1]): count of sortedIndices[k..n-1] > k
		// As k increases by 1, we remove sortedIndices[k-1] from suffix and threshold increases.
		// 
		// For group 1 (prefix [0..k-1]): count of sortedIndices[0..k-1] >= k+2
		// As k increases by 1, we add sortedIndices[k-1] to prefix and threshold increases.

		// Let's use a BIT (Fenwick tree) over index values 1..n
		// BIT stores which indices are in the current set.

		bit := make([]int, n+2)
		bitUpdate := func(i, delta int) {
			for ; i <= n; i += i & (-i) {
				bit[i] += delta
			}
		}
		bitQuery := func(i int) int {
			s := 0
			for ; i > 0; i -= i & (-i) {
				s += bit[i]
			}
			return s
		}
		bitRange := func(l, r int) int {
			if l > r {
				return 0
			}
			if l == 1 {
				return bitQuery(r)
			}
			return bitQuery(r) - bitQuery(l-1)
		}

		// Reset BIT
		for i := range bit {
			bit[i] = 0
		}

		// Initialize: all indices in suffix (k=0, prefix is empty, suffix is all)
		for i := 0; i < n; i++ {
			bitUpdate(sortedIndices[i], 1)
		}

		// prefixBIT for group1
		bit2 := make([]int, n+2)
		bit2Update := func(i, delta int) {
			for ; i <= n; i += i & (-i) {
				bit2[i] += delta
			}
		}
		bit2Query := func(i int) int {
			s := 0
			for ; i > 0; i -= i & (-i) {
				s += bit2[i]
			}
			return s
		}
		bit2Range := func(l, r int) int {
			if l > r {
				return 0
			}
			if l == 1 {
				return bit2Query(r)
			}
			return bit2Query(r) - bit2Query(l-1)
		}

		bestPlace := n + 1 // worst case

		for k := 0; k <= maxK; k++ {
			// group1 (prefix [0..k-1]): count with index >= k+2
			g1 := bit2Range(k+2, n)
			// group2 (suffix [k..n-1]): count with index > k
			g2 := bitRange(k+1, n)
			totalMore := g1 + g2
			place := totalMore + 1
			if place < bestPlace {
				bestPlace = place
			}

			// Move sortedIndices[k] from suffix to prefix
			if k < n {
				bitUpdate(sortedIndices[k], -1)
				bit2Update(sortedIndices[k], 1)
			}
		}

		fmt.Fprintln(writer, bestPlace)

		// Reset bit2
		for i := 0; i < n; i++ {
			bit2Update(sortedIndices[i], -1)
		}
	}
}
```