```go
package main

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

var reader *bufio.Reader
var writer *bufio.Writer

func scanInt() int {
	var x int
	var c byte
	for {
		c, _ = reader.ReadByte()
		if c >= '0' && c <= '9' {
			x = int(c - '0')
			break
		}
	}
	for {
		c, _ = reader.ReadByte()
		if c >= '0' && c <= '9' {
			x = x*10 + int(c-'0')
		} else {
			break
		}
	}
	return x
}

func printInt(x int64) {
	fmt.Fprintf(writer, "%d\n", x)
}

type BIT struct {
	tree []int
	size int
}

func newBIT(n int) *BIT {
	return &BIT{
		tree: make([]int, n+1),
		size: n,
	}
}

func (b *BIT) update(idx, val int) {
	for idx <= b.size {
		b.tree[idx] += val
		idx += idx & -idx
	}
}

func (b *BIT) query(idx int) int {
	sum := 0
	for idx > 0 {
		sum += b.tree[idx]
		idx -= idx & -idx
	}
	return sum
}

func (b *BIT) clear() {
	for i := range b.tree {
		b.tree[i] = 0
	}
}

type Task struct {
	bl, br int
	al, ar int
}

func solve() {
	n := scanInt()
	m := scanInt()

	a := make([]int, n)
	for i := 0; i < n; i++ {
		a[i] = scanInt()
	}
	b := make([]int, m)
	for i := 0; i < m; i++ {
		b[i] = scanInt()
	}

	sort.Ints(b)

	vals := make([]int, 0, n+m)
	vals = append(vals, a...)
	vals = append(vals, b...)
	sort.Ints(vals)

	uniqueVals := make([]int, 0, len(vals))
	if len(vals) > 0 {
		uniqueVals = append(uniqueVals, vals[0])
		for i := 1; i < len(vals); i++ {
			if vals[i] != vals[i-1] {
				uniqueVals = append(uniqueVals, vals[i])
			}
		}
	}

	getRank := func(val int) int {
		idx := sort.Search(len(uniqueVals), func(i int) bool {
			return uniqueVals[i] >= val
		})
		return idx + 1
	}

	ra := make([]int, n)
	for i, v := range a {
		ra[i] = getRank(v)
	}
	rb := make([]int, m)
	for i, v := range b {
		rb[i] = getRank(v)
	}

	bitSize := len(uniqueVals)
	bit := newBIT(bitSize)

	var currentInv int64
	for i := n - 1; i >= 0; i-- {
		currentInv += int64(bit.query(ra[i] - 1))
		bit.update(ra[i], 1)
	}

	totalSmaller := make([]int, m)
	for i := 0; i < m; i++ {
		totalSmaller[i] = bit.query(rb[i] - 1)
	}

	var minCrossInv int64
	tasks := []Task{{0, m - 1, 0, n}}

	for len(tasks) > 0 {
		var nextTasks []Task
		bit.clear()
		currA := 0

		for _, t := range tasks {
			mid := (t.bl + t.br) / 2
			val := rb[mid]

			for currA < t.al {
				bit.update(ra[currA], 1)
				currA++
			}

			smallerInPrefix := bit.query(val - 1)
			greaterInPrefix := currA - bit.query(val)

			cost := int64(totalSmaller[mid]) + int64(greaterInPrefix) - int64(smallerInPrefix)

			bestCost := cost
			bestPos := t.al
			scanCost := cost

			for k := t.al; k < t.ar; k++ {
				if ra[k] < val {
					scanCost--
				} else if ra[k] > val {
					scanCost++
				}
				if scanCost < bestCost {
					bestCost = scanCost
					bestPos = k + 1
				}
			}

			minCrossInv += bestCost

			if t.bl < mid {
				nextTasks = append(nextTasks, Task{t.bl, mid - 1, t.al, bestPos})
			}
			if mid < t.br {
				nextTasks = append(nextTasks, Task{mid + 1, t.br, bestPos, t.ar})
			}
		}
		tasks = nextTasks
	}

	printInt(currentInv + minCrossInv)
}

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

	t := scanInt()
	for i := 0; i < t; i++ {
		solve()
	}
}
```