Petya organized a strange birthday party. He invited $n$ friends and assigned an integer $k_i$ to the $i$-th of them. Now Petya would like to give a present to each of them. In the nearby shop there are $m$ unique presents available, the $j$-th present costs $c_j$ dollars ($1 \le c_1 \le c_2 \le \ldots \le c_m$). It's not allowed to buy a single present more than once.

For the $i$-th friend Petya can either buy them a present $j \le k_i$, which costs $c_j$ dollars, or just give them $c_{k_i}$ dollars directly.

Help Petya determine the minimum total cost of hosting his party.


-----Input-----

The first input line contains a single integer $t$ ($1 \leq t \leq 10^3$) — the number of test cases.

The first line of each test case contains two integers $n$ and $m$ ($1 \leq n, m \leq 3 \cdot 10^5$) — the number of friends, and the number of unique presents available.

The following line contains $n$ integers $k_1, k_2, \ldots, k_n$ ($1 \leq k_i \leq m$), assigned by Petya to his friends.

The next line contains $m$ integers $c_1, c_2, \ldots, c_m$ ($1 \le c_1 \le c_2 \le \ldots \le c_m \le 10^9$) — the prices of the presents.

It is guaranteed that sum of values $n$ over all test cases does not exceed $3 \cdot 10^5$, and the sum of values $m$ over all test cases does not exceed $3 \cdot 10^5$.


-----Output-----

For each test case output a single integer — the minimum cost of the party.


-----Examples-----

Input
2
5 4
2 3 4 3 2
3 5 12 20
5 5
5 4 3 2 1
10 40 90 160 250
Output
30
190
Input
1
1 1
1
1
Output
1


-----Note-----

In the first example, there are two test cases. In the first one, Petya has $5$ friends and $4$ available presents. Petya can spend only $30$ dollars if he gives

$5$ dollars to the first friend.

A present that costs $12$ dollars to the second friend.

A present that costs $5$ dollars to the third friend.

A present that costs $3$ dollars to the fourth friend.

$5$ dollars to the fifth friend.

In the second one, Petya has $5$ and $5$ available presents. Petya can spend only $190$ dollars if he gives

A present that costs $10$ dollars to the first friend.

A present that costs $40$ dollars to the second friend.

$90$ dollars to the third friend.

$40$ dollars to the fourth friend.

$10$ dollars to the fifth friend.

Difficulty: EASY

Solutions:
from collections import OrderedDict
for i in range(int(input())):
	(n, m) = map(int, input().split())
	(a, c) = ([*map(int, input().split())], [*map(int, input().split())])
	a = sorted(a)[::-1]
	d = OrderedDict()
	for i in a:
		d[i] = d.get(i, 0) + 1
	j = 0
	cnt = 0
	ans = 0
	for (key, value) in d.items():
		while cnt < key and value > 0:
			cnt += 1
			value -= 1
		ans += value * c[key - 1]
	for i in range(cnt):
		ans += c[i]
	print(ans)


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	lstn = list(map(int, input().split()))
	lstm = list(map(int, input().split()))
	lstn.sort(reverse=True)
	pointer = 0
	c = 0
	for j in lstn:
		if pointer <= j:
			a = lstm[j - 1]
			b = lstm[pointer]
			if b < a:
				c += b
				pointer += 1
			else:
				c += a
		else:
			c += lstm[j - 1]
	print(c)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = sorted(list(map(int, input().split())), reverse=True)
	c = list(map(int, input().split()))
	x = 0
	y = 0
	i = 0
	while i < n and y + 1 < k[i] and (y < m):
		x += c[y]
		y += 1
		i += 1
	while i < n:
		x += c[k[i] - 1]
		i += 1
	print(x)


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	friends = sorted(list(map(int, input().split())))
	gifts = list(map(int, input().split()))
	initial = n
	ans = 0
	for i in friends:
		if i > initial:
			break
		else:
			ans += gifts[i - 1]
			initial -= 1
	ans += sum(gifts[:initial])
	print(ans)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	gc = 0
	cost = 0
	k = [int(i) for i in input().split()]
	c = [int(i) for i in input().split()]
	k = sorted(k)[::-1]
	for i in k:
		if c[gc] < c[i - 1] and gc <= i - 1:
			cost += c[gc]
			gc += 1
		else:
			cost += c[i - 1]
	print(cost)


from math import ceil
for _ in range(int(input())):
	(n, m) = list(map(int, input().split()))
	arr = list(map(int, input().split()))
	cost = list(map(int, input().split()))
	arr.sort(reverse=True)
	Sum = 0
	j = 0
	for i in range(n):
		if cost[j] < cost[arr[i] - 1]:
			Sum += cost[j]
			j += 1
		else:
			Sum += cost[arr[i] - 1]
	print(Sum)


t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split(' ')))
	friends = list(map(int, input().split(' ')))
	presents = list(map(int, input().split(' ')))
	friends.sort(reverse=True)
	res = 0
	i = 0
	for x in friends:
		if x > i + 1:
			res += presents[i]
			i += 1
		else:
			res += presents[x - 1]
	print(res)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	guest = list(map(int, input().split()))
	guest.sort(reverse=True)
	gift = list(map(int, input().split()))
	ans = 0
	j = 0
	for i in guest:
		if j < i:
			ans += gift[j]
			j += 1
		else:
			ans += gift[i - 1]
	print(ans)


t = int(input())
res = ''
for _ in range(t):
	(n, m) = [int(v) for v in input().strip().split(' ')]
	k = [int(v) - 1 for v in input().strip().split(' ')]
	c = [int(v) for v in input().strip().split(' ')]
	k = sorted(k, reverse=True)
	j = 0
	sum = 0
	for i in k:
		if j < i:
			sum += c[j]
			j += 1
		else:
			sum += c[i]
	res = res + '{}\n'.format(sum)
print(res)


ll = lambda : map(int, input().split())
t = lambda : int(input())
ss = lambda : input()
from collections import Counter
from math import inf, ceil
for _ in range(t()):
	(n, m) = ll()
	a = list(ll())
	b = list(ll())
	s1 = 0
	v = [1] * m
	a.sort(reverse=1)
	j = 0
	for i in range(n):
		if b[a[i] - 1] >= b[j] and j <= a[i] - 1:
			s1 += b[j]
			if j + 1 < m:
				j += 1
		else:
			s1 += b[a[i] - 1]
	print(s1)


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	l1 = list(map(int, input().split()))
	l2 = list(map(int, input().split()))
	l1.sort(reverse=True)
	sum1 = 0
	for j in range(n):
		if j < m and l1[j] >= j + 1:
			sum1 = sum1 + l2[j]
		else:
			sum1 = sum1 + l2[l1[j] - 1]
	print(sum1)


for _ in '.' * int(input()):
	(n, m) = map(int, input().split())
	integers = list(map(int, input().split()))
	prize = list(map(int, input().split()))
	cost = 0
	pointer = 0
	integers.sort(reverse=True)
	for i in integers:
		i = i - 1
		if prize[i] > prize[pointer]:
			cost += prize[pointer]
			pointer += 1
		else:
			cost += prize[i]
	print(cost)


import copy

def get_result(x: int, curr_index: int):
	res = list_gifts[list_friend[x] - 1]
	if list_gifts[curr_index] < res:
		res = list_gifts[curr_index]
		curr_index += 1
	return (res, curr_index)
t = int(input())
while t > 0:
	total_score = 0
	used_index = 0
	(n, m) = map(int, input().split())
	list_friend = list(map(int, input().split()))
	list_gifts = list(map(int, input().split()))
	list_friend.sort(reverse=True)
	for i in range(0, n):
		(temp_score, used_index) = get_result(i, used_index)
		total_score += temp_score
	print(total_score)
	t -= 1


import io
import os
from collections import Counter, defaultdict, deque
from heapq import heapify, heappop

def solve(N, M, K, C):
	freq = Counter(C)
	heap = []
	for k in K:
		heap.append(-C[k - 1])
	heapify(heap)
	total = -sum(heap)
	for c in sorted(freq.keys()):
		num = freq[c]
		while num > 0 and heap and (c < -heap[0]):
			neg = heappop(heap)
			total += neg
			total += c
			num -= 1
	return total
input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline
TC = int(input())
for tc in range(1, TC + 1):
	(N, M) = [int(x) for x in input().split()]
	K = [int(x) for x in input().split()]
	C = [int(x) for x in input().split()]
	ans = solve(N, M, K, C)
	print(ans)


import math

def solve(k, g):
	c = [0] * (len(g) + 1)
	for i in range(1, len(c)):
		c[i] = g[i - 1]
	k.sort(reverse=True)
	j = 1
	amt = 0
	for i in k:
		if c[i] <= c[j]:
			amt += c[i]
		else:
			amt += c[j]
			j += 1
	return amt
t = int(input(''))
ans = []
while t > 0:
	n = list(map(int, input('').split(' ')))
	a = list(map(int, input('').split(' ')))
	a2 = list(map(int, input('').split(' ')))
	ans.append(solve(a, a2))
	t -= 1
for i in ans:
	print(i)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	f = list(map(int, input().split()))
	c = list(map(int, input().split()))
	f.sort(reverse=True)
	ans = 0
	for i in range(n):
		if f[i] - 1 >= i and i < m:
			ans += c[i]
		else:
			ans += c[f[i] - 1]
	print(ans)


import math as mt
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	l = list(map(int, input().split()))
	cost = list(map(int, input().split()))
	l.sort(reverse=True)
	j = 1
	total_cost = 0
	for i in range(n):
		if l[i] >= j:
			total_cost += cost[j - 1]
			j += 1
		else:
			total_cost += cost[l[i] - 1]
	print(total_cost)


t = int(input())
while t > 0:
	t -= 1
	(n, m) = map(int, input().split())
	k = [a for a in map(int, input().split())]
	c = [a for a in map(int, input().split())]
	C = c.copy()
	k.sort()
	k.reverse()
	c.reverse()
	tot = 0
	for a in k:
		if len(c) == 0 or c[-1] >= C[a - 1]:
			tot += C[a - 1]
		else:
			tot += c.pop()
	print(tot)


import math

def gcd(a, b):
	if a == 0:
		return b
	return gcd(b % a, a)

def lcm(a, b):
	return a * b // gcd(a, b)

def calc(q, x):
	ans = 0
	while q % x == 0:
		ans += 1
		q = q // x
	return ans
for _ in range(int(input())):
	(n, x) = map(int, input().split())
	a = list(map(int, input().split()))
	c = list(map(int, input().split()))
	a.sort(reverse=True)
	ans = 0
	j = 0
	for i in range(n):
		if a[i] - 1 > j:
			ans += c[j]
			j += 1
		else:
			ans += c[a[i] - 1]
	print(ans)


from math import *
from collections import Counter, defaultdict
from sys import stdin, stdout
input = stdin.readline
I = lambda : int(input())
M = lambda : map(int, input().split())
LI = lambda : list(map(int, input().split()))
for _ in range(I()):
	(n, x) = M()
	a = LI()
	b = LI()
	c = sorted(a)
	c.reverse()
	ans = 0
	d = 0
	for i in range(n):
		if b[d] >= b[c[i] - 1]:
			ans += b[c[i] - 1]
		else:
			ans += b[d]
			d += 1
	print(ans)


import sys
from sys import stdin
tt = int(stdin.readline())
for loop in range(tt):
	(n, m) = map(int, stdin.readline().split())
	k = list(map(int, stdin.readline().split()))
	c = list(map(int, stdin.readline().split()))
	k.sort()
	k.reverse()
	for i in range(n):
		k[i] -= 1
	ind = 0
	ans = 0
	for i in range(n):
		if ind < k[i]:
			ans += c[ind]
			ind += 1
		else:
			ans += c[k[i]]
	print(ans)


import os, sys
from io import BytesIO, IOBase

def main():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		k = sorted(map(int, input().split()), reverse=1)
		c = list(map(int, input().split()))
		j = 0
		ans = 0
		for i in range(n):
			if j < k[i] - 1:
				ans += c[j]
				j += 1
			else:
				ans += c[k[i] - 1]
		print(ans)
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
main()


import math
t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	k.sort(reverse=True)
	cost = 0
	for i in range(n):
		if i + 1 <= k[i]:
			cost += c[i]
		else:
			cost += c[k[i] - 1]
	print(cost)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	s = sorted(list(map(int, input().split())), reverse=True)
	p = list(map(int, input().split()))
	ans = 0
	for i in range(n):
		if i + 1 < s[i]:
			ans += p[i]
		else:
			ans += p[s[i] - 1]
	print(ans)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = [int(x) for x in input().split()][:n]
	c = [int(x) for x in input().split()][:m]
	a = c
	sum = 0
	k.sort(reverse=True)
	for i in range(n):
		if k[i] >= i + 1:
			sum += c[i]
		else:
			sum += c[k[i] - 1]
	print(sum)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = sorted(map(int, input().split()), reverse=True)
	c = list(map(int, input().split()))
	cheapest_present = 0
	cost = 0
	for i in range(n):
		if cheapest_present < m:
			if c[cheapest_present] < c[k[i] - 1]:
				cost += c[cheapest_present]
				cheapest_present += 1
			else:
				cost += c[k[i] - 1]
		else:
			cost += c[k[i] - 1]
	print(cost)


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	a = [int(i) for i in input().split()]
	c = [int(i) for i in input().split()]
	a.sort()
	a = a[::-1]
	x = 0
	s = 0
	for i in a:
		if x < i:
			s += c[x]
			x += 1
		else:
			s += c[i - 1]
	print(s)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = list(map(int, input().split()))
	c = list(map(int, input().split()))
	look = [0] * m
	for e in a:
		look[e - 1] += 1
	c_asc = [(i, c[i]) for i in range(m)]
	c_asc.sort(key=lambda x: x[1])
	i = 0
	ans = 0
	j = m - 1
	while j >= 0:
		if c_asc[i][0] <= j and c_asc[i][1] < c_asc[j][1] and (look[j] > 0):
			ans += c_asc[i][1]
			i += 1
			look[j] -= 1
			j = j - 1 if look[j] == 0 else j
		else:
			ans += c_asc[j][1] * look[j]
			j -= 1
	print(ans)


import sys, os, io
input = sys.stdin.readline
T = int(input())
ans = [0] * T
for t in range(T):
	(N, M) = map(int, input().split())
	K = list(map(int, input().split()))
	C = list(map(int, input().split()))
	C.sort()
	K.sort(reverse=True)
	present = 0
	for k in K:
		if k - 1 > present:
			ans[t] += C[present]
			present += 1
		else:
			ans[t] += C[k - 1]
print(*ans, sep='\n')


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k_num = list(map(int, input().split()))
	k_num = sorted(k_num, reverse=True)
	price_gift = list(map(int, input().split()))
	res = 0
	j = 0
	for i in k_num:
		if j < i:
			res += price_gift[j]
			j += 1
		else:
			res += price_gift[i - 1]
	print(res)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	costs = list(map(int, input().split()))
	k.sort(reverse=True)
	dp = [0] * n
	j = 0
	for i in range(n):
		if costs[j] < costs[k[i] - 1]:
			dp[i] = costs[j]
			j += 1
		else:
			dp[i] = costs[k[i] - 1]
	print(sum(dp))


import sys
input = sys.stdin.buffer.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	k_sort = [[] for i in range(m)]
	for i in range(n):
		k_sort[k[i] - 1].append(i)
	res = 0
	pos = 0
	for i in range(m - 1, -1, -1):
		for j in k_sort[i]:
			if pos < i:
				res += c[pos]
				pos += 1
			else:
				res += c[i]
	print(res)


R = lambda : list(map(int, input().split()))
for _ in ' ' * int(input()):
	(n, m) = R()
	k = sorted(R())[::-1]
	c = R()
	sp = 0
	pr = 1
	for i in range(n):
		if k[i] > pr:
			sp += c[pr - 1]
			pr += 1
		else:
			sp += c[k[i] - 1]
	print(sp)


for i in range(int(input())):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	k.sort(reverse=True)
	b = 0
	for i in range(n):
		if i + 1 <= k[i]:
			b += c[i]
		else:
			b += c[k[i] - 1]
	print(b)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	f = list(map(int, input().split()))
	g = list(map(int, input().split()))
	f = sorted(f, reverse=True)
	t = sorted(g)
	s = 0
	j = 0
	for i in f:
		if g[i - 1] <= t[j]:
			s += g[i - 1]
		else:
			s += t[j]
			j += 1
	print(s)


import sys
import sys
input = sys.stdin.readline
for ad in range(int(input())):
	ans = 0
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	k.sort()
	k.reverse()
	z = 0
	for i in range(n):
		if z < k[i]:
			ans += c[z]
			z += 1
		else:
			ans += c[k[i] - 1]
	print(ans)


def solve(n, m, ks, cs):
	if n < m:
		cs = cs[:n]
	gift_i = 0
	cost = 0
	ks.sort(key=lambda x: -1 * x)
	for k in ks:
		if gift_i < k - 1:
			cost += cs[gift_i]
			gift_i += 1
		else:
			cost += cs[k - 1]
	return cost
T = int(input())
for _ in range(T):
	(n, m) = map(int, input().split())
	ks = list(map(int, input().split()))
	cs = list(map(int, input().split()))
	print(solve(n, m, ks, cs))


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	K = [int(k) for k in input().split()]
	K.sort(reverse=True)
	C = [int(c) for c in input().split()]
	(s, p) = (0, 0)
	for k in K:
		if k - 1 > p:
			s += C[p]
			p += 1
		else:
			s += C[k - 1]
	print(s)


for _ in range(int(input())):
	(g, d) = input().split()
	a = [int(i) for i in input().split()]
	b = [int(i) for i in input().split()]
	chk = [0] * len(b)
	t = sorted(a, reverse=True)
	s = 0
	j = 0
	for i in range(len(t)):
		f = 0
		if b[j] < b[t[i] - 1]:
			s += b[j]
			j += 1
		else:
			s += b[t[i] - 1]
	print(s)


def solve(n, m, k, c):
	ans = 0
	last = 1
	for i in range(1, n + 1):
		if c[last] < c[k[i]]:
			ans += c[last]
			last = i + 1
		else:
			ans += c[k[i]]
	return ans
for t in range(int(input())):
	(n, m) = map(int, input().split())
	k = [0] + sorted(map(int, input().split()), reverse=True)
	c = [0] + list(map(int, input().split()))
	print(solve(n, m, k, c))


for u in range(int(input())):
	(n, m) = map(int, input().split())
	l = list(map(int, input().split()))
	d = list(map(int, input().split()))
	l.sort(reverse=True)
	(s, j) = (0, 0)
	for i in l:
		if j < i:
			s += d[j]
			j += 1
		else:
			s += d[i - 1]
	print(s)


N = int(input())
while N:
	N -= 1
	input()
	a = [int(x) - 1 for x in input().split(' ')]
	b = [int(x) for x in input().split(' ')]
	a = sorted(a, reverse=True)
	res = 0
	j = 0
	for (i, x) in enumerate(a):
		if j == len(b) or b[a[i]] < b[j]:
			res += b[a[i]]
		else:
			res += b[j]
			j += 1
	print(res)


import sys
sys.setrecursionlimit(1000000)
from collections import defaultdict, deque, Counter
from itertools import permutations
from math import sqrt, gcd, pi, factorial
from functools import reduce
from sys import stdin
from bisect import bisect_right, bisect_left
from copy import copy

def solve(n, m, k, c):
	k = sorted(k)
	cnts = [1 for _ in range(m)]
	for i in range(n):
		cnts[k[i] - 1] += 1
	s = 0
	ret = 0
	for i in range(m):
		if s + cnts[i] < n:
			s += cnts[i]
			ret += c[i] * cnts[i]
		else:
			ret += c[i] * (n - s)
			break
	return ret
t = int(input())
anss = [0 for _ in range(t)]
for i in range(t):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	anss[i] = solve(n, m, k, c)
for ans in anss:
	print(ans)


test_cases = int(input())
for i in range(test_cases):
	used_presents = 0
	cost = 0
	x = input()
	friends = [int(x) for x in input().split()]
	presents = [int(x) for x in input().split()]
	friends.sort(reverse=True)
	for friend in friends:
		friend -= 1
		if presents[friend] > presents[used_presents]:
			cost += presents[used_presents]
			used_presents += 1
		else:
			cost += presents[friend]
	print(cost)


from os import path
import sys, time
from math import ceil, floor, gcd, log, log2, factorial
from collections import defaultdict, Counter, OrderedDict, deque
from functools import reduce
from operator import mul
maxx = float('inf')
I = lambda : int(sys.stdin.buffer.readline())
tup = lambda : map(int, sys.stdin.buffer.readline().split())
lint = lambda : [int(x) for x in sys.stdin.buffer.readline().split()]
S = lambda : sys.stdin.readline().strip('\n')
grid = lambda r: [lint() for i in range(r)]
stpr = lambda x: sys.stdout.write(f'{x}' + '\n')
star = lambda x: print(' '.join(map(str, x)))
localsys = 0
start_time = time.time()
if path.exists('input.txt'):
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
for _ in range(I()):
	(n, k) = tup()
	(A, B, ans) = (sorted(map(lambda x: x - 1, lint()), reverse=True), lint(), 0)
	for i in range(n):
		if i < A[i]:
			ans += min(B[A[i]], B[i])
		else:
			ans += B[A[i]]
	print(ans)
if localsys:
	print('\n\nTime Elased :', time.time() - start_time, 'seconds')


def ans(arr, cost):
	arr.sort()
	total = j = 0
	for i in range(len(arr) - 1, -1, -1):
		if j < arr[i] - 1 and cost[j] < cost[arr[i] - 1]:
			total += cost[j]
			j += 1
		else:
			total += cost[arr[i] - 1]
	print(total)
t = int(input())
for i in range(t):
	x = input()
	arr1 = list(map(int, input().split(' ')))
	arr2 = list(map(int, input().split(' ')))
	ans(arr1, arr2)


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	ans = 0
	a = 0
	k.sort()
	k.reverse()
	for i in k:
		if a == len(c) or c[a] > c[i - 1]:
			ans += c[i - 1]
		else:
			ans += c[a]
			a += 1
	print(ans)


import sys

def strangeBdayParty():
	for _ in range(int(input())):
		(n, m) = map(int, input().split())
		k = [int(i) for i in input().split()]
		c = [int(i) for i in input().split()]
		(ans, base) = (0, 0)
		k.sort(reverse=True)
		for i in k:
			if i - 1 > base:
				ans += c[base]
				base += 1
			else:
				ans += c[i - 1]
		print(ans)

def main():
	strangeBdayParty()
main()


t = int(input())
for i in range(t):
	nAndm = list(input().split(' '))
	n = int(nAndm[0])
	m = int(nAndm[1])
	nNumbers = list(input().split(' '))
	nNumbersInt = [int(k) for k in nNumbers]
	mgifts = list(input().split(' '))
	mgiftsInt = [int(j) for j in mgifts]
	nNumbersInt.sort(reverse=True)
	cost = 0
	for j in range(n):
		if nNumbersInt[j] > j:
			cost = cost + mgiftsInt[j]
		else:
			cost = cost + mgiftsInt[nNumbersInt[j] - 1]
	print(cost)


t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	k.sort(reverse=True)
	c.sort()
	s = set()
	j = 0
	sum = 0
	for i in range(n):
		if c[k[i] - 1] > c[j]:
			sum += c[j]
			s.add(c[j])
			j = j + 1
		elif c[k[i] - 1] <= c[j]:
			sum += c[k[i] - 1]
	print(sum)


t = int(input())
for i in range(t):
	(n, x) = map(int, input().split())
	list1 = list(map(int, input().split()))
	list2 = list(map(int, input().split()))
	list1.sort(reverse=True)
	num = 0
	for i in range(n):
		if list1[i] >= i + 1:
			num += list2[i]
		else:
			num += list2[list1[i] - 1]
	print(num)


t = int(input())
for _ in range(t):
	(n, m) = tuple(map(int, input().split()))
	klist = list(map(int, input().split()))
	jlist = list(map(int, input().split()))
	klist.sort(reverse=True)
	s = 0
	i = 0
	for k in klist:
		if jlist != []:
			if jlist[i] < jlist[k - 1]:
				s = s + jlist[i]
				i = i + 1
			else:
				s = s + jlist[k - 1]
		else:
			s = s + jlist[k - 1]
	print(s)


from sys import stdin
for _ in range(int(stdin.readline())):
	(n, m) = list(map(int, stdin.readline().split()))
	k = sorted(list(map(int, stdin.readline().split())), reverse=True)
	c = list(map(int, stdin.readline().split()))
	res = 0
	j = 0
	for i in k:
		if c[i - 1] > c[j]:
			res += c[j]
			j += 1
		else:
			res += c[i - 1]
	print(res)


for i in range(int(input())):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	k.sort()
	k = k[::-1]
	present = 0
	ans = 0
	for j in range(n):
		if present < m and c[k[j] - 1] > c[present]:
			ans += c[present]
			present += 1
		else:
			ans += c[k[j] - 1]
	print(ans)


casos = int(input())
for i in range(casos):
	(n, m) = input().split()
	(n, m) = (int(n), int(m))
	k = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	total = 0
	l = 1
	k = reversed(sorted(k))
	c.insert(0, 666)
	for ki in k:
		if c[ki] > c[l] and l < ki:
			total = total + c[l]
			l = l + 1
		else:
			total = total + c[ki]
	print(total)


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):

	def __init__(self, file):
		self.newlines = 0
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline()

def RL():
	return map(int, sys.stdin.readline().split())

def RLL():
	return list(map(int, sys.stdin.readline().split()))

def N():
	return int(input())

def S():
	return input().strip()

def print_list(l):
	print(' '.join(map(str, l)))
for _ in range(N()):
	(n, m) = RL()
	a = [0] + sorted(RLL(), reverse=True)
	b = [0] + RLL()
	res = 0
	now = 1
	for k in a:
		if now < k:
			res += b[now]
			now += 1
		else:
			res += b[k]
	print(res)


def solver(inputs, friends, gifts):
	cost = 0
	gift_index = 0
	friends.sort(reverse=True)
	for y in range(inputs[0]):
		if friends[y] > gift_index:
			cost = cost + gifts[gift_index]
			gift_index = gift_index + 1
		else:
			cost = cost + gifts[friends[y] - 1]
	return cost
n = int(input())
for x in range(n):
	inputs = input().split(' ')
	inputs = [int(i) for i in inputs]
	friends = input().split(' ')
	friends = [int(i) for i in friends]
	gifts = input().split(' ')
	gifts = [int(i) for i in gifts]
	print(solver(inputs, friends, gifts))


import sys
input = sys.stdin.readline
t = int(input())
for tests in range(t):
	(n, m) = map(int, input().split())
	K = sorted(map(int, input().split()), reverse=True)
	C = list(map(int, input().split()))
	ind = 0
	ANS = 0
	for k in K:
		k -= 1
		if ind < k:
			ANS += C[ind]
			ind += 1
		else:
			ANS += C[k]
	print(ANS)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = sorted(list(map(int, input().split())), reverse=True)
	c = list(map(int, input().split()))
	s = 0
	ans = 0
	for x in k:
		if c[s] < c[x - 1]:
			ans += c[s]
			s += 1
		else:
			ans += c[x - 1]
	print(ans)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = sorted([int(i) for i in input().split()])
	c = [''] + [int(i) for i in input().split()]
	(i, res) = (1, 0)
	for ind in k[::-1]:
		if ind >= i:
			res += c[i]
			i += 1
		else:
			res += c[ind]
	print(res)


from collections import Counter
t = int(input())
while t > 0:
	t -= 1
	(n, m) = (int(i) for i in input().split())
	p = [int(i) for i in input().split()]
	k = [int(i) for i in input().split()]
	c = ans = 0
	for i in sorted(p, reverse=True):
		if c < i:
			ans += k[c]
			c += 1
		else:
			ans += k[i - 1]
	print(ans)


from sys import stdin
input = stdin.readline
for i in range(int(input())):
	(n, m) = map(int, input().split())
	t = sorted(list(map(int, input().split())), reverse=True)
	t1 = list(map(int, input().split()))
	b = []
	for i in t:
		b.append(t1[i - 1])
	for i in range(n):
		if t1[i] < b[i]:
			b[i] = t1[i]
		else:
			break
		if i == m:
			break
	print(sum(b))


for _ in range(int(input())):
	(n, x) = map(int, input().split())
	k = [int(i) for i in input().split()]
	c = [int(i) for i in input().split()]
	k.sort(reverse=True)
	ans = 0
	a1 = 0
	for i in range(n):
		if a1 < k[i]:
			ans += c[a1]
			a1 += 1
		else:
			ans += c[k[i] - 1]
	print(ans)


t = int(input())
for j in range(t):
	(n, m) = map(int, input().split())
	k = [i for i in map(int, input().split())]
	c = [i for i in map(int, input().split())]
	k.sort(reverse=True)
	rez = 0
	nom = 0
	for i in range(n):
		if nom < m and k[i] > nom:
			rez = rez + c[nom]
			nom = nom + 1
		else:
			rez = rez + c[k[i] - 1]
	print(rez)


for _ in range(int(input())):
	(n, m) = map(int, input().split())
	ks = [int(x) - 1 for x in input().split()]
	cs = [int(x) for x in input().split()]
	ks.sort(reverse=True)
	t = 0
	for (i, k) in enumerate(ks):
		t += cs[min(i, k)]
	print(t)


for test in range(int(input())):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = [0] + list(map(int, input().split()))
	k.sort(reverse=True)
	ans = 0
	i = 0
	j = 1
	while i < len(k) and c[k[i]] > c[j]:
		ans += c[j]
		i += 1
		j += 1
	while i < len(k):
		ans += c[k[i]]
		i += 1
	print(ans)


def solve(k, c):
	k = sorted(k)[::-1]
	n = len(k)
	m = len(c)
	ans = 0
	for i in range(n):
		if i < m:
			ans += min(c[i], c[k[i] - 1])
		else:
			ans += c[k[i] - 1]
	return ans
t = int(input())
while t:
	t -= 1
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	print(solve(k, c))


import math
for t in range(int(input())):
	(n, m) = map(int, input().split())
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	a.sort()
	i = 0
	ans = 0
	for j in range(n - 1, -1, -1):
		if b[i] >= b[a[j] - 1]:
			ans += b[a[j] - 1]
		else:
			ans += b[i]
			i += 1
	print(ans)


def solve(n, m, guests, presents):
	guests.sort(reverse=True)
	guestsIndex = 0
	presentsIndex = 0
	ans = 0
	while guestsIndex < n and presentsIndex < m:
		if presents[presentsIndex] < presents[guests[guestsIndex] - 1]:
			ans += presents[presentsIndex]
			presentsIndex += 1
		else:
			ans += presents[guests[guestsIndex] - 1]
		guestsIndex += 1
	while guestsIndex < n:
		ans += presents[guests[guestsIndex] - 1]
	return ans
for x in range(int(input())):
	(n, m) = list(map(int, input().split()))
	guests = list(map(int, input().split()))
	presents = list(map(int, input().split()))
	print(solve(n, m, guests, presents))


import re
t = int(input())
for i in range(t):
	(n, m) = map(int, input().split())
	k_list = list(map(int, input().split()))
	c_list = list(map(int, input().split()))
	k_list.sort(reverse=True)
	pointer = 1
	result = 0
	for k in k_list:
		if pointer > k:
			result += c_list[k - 1]
			continue
		if pointer < m and c_list[pointer - 1] < c_list[k - 1]:
			result += c_list[pointer - 1]
			pointer += 1
			continue
		result += c_list[k - 1]
	print(result)


t = int(input())
for q in range(t):
	n = [int(x) for x in input().split()]
	(len_k, len_c) = (n[0], n[1])
	k = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	k = sorted(k)
	s = 0
	for i in k:
		s += c[i - 1]
	g = 0
	min_score = s
	flag = 1
	gift_val = len_c
	for i in range(len_c):
		if i > len_k - 1:
			break
		if gift_val == 0:
			break
		else:
			gift_val = min(k[-i - 1] - 1, gift_val - 1)
		s -= c[k[-i - 1] - 1]
		g += c[i]
		score = s + g
		if min_score > score:
			min_score = score
	print(min_score)


import math
from collections import Counter

def strange_birthday_party(friends, presents):
	count = 0
	cost = 0
	friend_counter = Counter(friends)
	use_present = True
	buy_present = 0
	for index in sorted(friend_counter.keys(), reverse=True):
		value = friend_counter[index]
		if use_present and index > count:
			count += value
			buy_present = count
			if count >= index:
				use_present = False
				cost += presents[index - 1] * (count - index)
				buy_present = index
		else:
			cost += presents[index - 1] * value
	return cost + sum(presents[:buy_present])
num_test = int(input())
for i in range(num_test):
	(n, m) = [int(i) for i in input().split()]
	friends = [int(i) for i in input().split()]
	presents = [int(i) for i in input().split()]
	print(strange_birthday_party(friends, presents))


task_number = int(input())
for _ in range(task_number):
	(n, m) = map(int, input().split())
	K = [int(x) - 1 for x in input().split()]
	C = [int(x) for x in input().split()]
	result = 0
	p_index = 0
	K.sort(reverse=True)
	for k in K:
		if p_index < k:
			result += C[p_index]
			p_index += 1
		else:
			result += C[k]
	print(result)


for l in range(int(input())):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	rev_sorted_k = k
	rev_sorted_k.sort(reverse=True)
	c = list(map(int, input().split()))
	c_copy = c
	cost = 0
	r = 0
	for i in rev_sorted_k:
		a = c[i - 1]
		if r < m:
			b = c_copy[r]
			if a >= b:
				cost += b
				r += 1
			else:
				cost += a
		else:
			cost += c[i - 1]
	print(cost)


t = int(input())
for i in range(t):
	(n, m) = list(map(int, input().split()))
	l1 = [int(i) for i in input().split()]
	l2 = [int(i) for i in input().split()]
	l1.sort(reverse=True)
	ans = 0
	for i in range(n):
		if i + 1 < l1[i]:
			ans = ans + l2[i]
		else:
			ans = ans + l2[l1[i] - 1]
	print(ans)


T = int(input())
for _ in range(T):
	(M, N) = map(int, input().split())
	nums = list(map(int, input().split()))
	P = list(map(int, input().split()))
	nums.sort(reverse=True)
	ans = 0
	idx = 0
	for i in range(len(nums)):
		if idx >= len(P) or P[nums[i] - 1] < P[idx]:
			ans += P[nums[i] - 1]
		else:
			ans += P[idx]
			idx += 1
	print(ans)


import sys
input = sys.stdin.readline
T = int(input())
for t in range(T):
	(n, m) = map(int, input().split())
	inds_cost = list(map(int, input().split()))
	costs = list(map(int, input().split()))
	up_to_costs = [costs[pos - 1] for pos in inds_cost]
	sol = 0
	start = 10 ** 10
	up_to_costs.sort(reverse=True)
	for i in range(min(m, n)):
		if up_to_costs[i] > costs[i]:
			sol += costs[i]
		else:
			start = i
			break
	sol += sum(up_to_costs[start:])
	print(sol)


from sys import stdin, stdout
input = stdin.readline
from collections import defaultdict as dd
import math

def geti():
	return map(int, input().strip().split())

def getl():
	return list(map(int, input().strip().split()))

def getis():
	return map(str, input().strip().split())

def getls():
	return list(map(str, input().strip().split()))

def gets():
	return input().strip()

def geta():
	return int(input())

def print_s(s):
	stdout.write(s + '\n')

def solve():
	for _ in range(geta()):
		(n, m) = geti()
		a = getl()
		cost = getl()
		a.sort(reverse=True)
		j = 0
		ans = 0
		for i in range(n):
			if a[i] >= j + 1 and j < n:
				ans += cost[j]
				j += 1
			else:
				ans += cost[a[i] - 1]
		print(ans)
solve()


t = int(input())

def f(n, k, m, c):
	k.sort()
	k = k[::-1]
	x = 0
	summ = 0
	for i in range(n):
		if c[x] < c[k[i] - 1]:
			summ += c[x]
			x += 1
			srop = 0
		else:
			summ += c[k[i] - 1]
	return summ
for i in range(t):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	print(f(n, k, m, c))


list_ans = []
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	list1 = list(map(int, input().split()))
	list2 = list(map(int, input().split()))
	list1.sort(reverse=True)
	ans = 0
	a = 0
	for x in list1:
		if x > a:
			ans += list2[a]
			a += 1
		else:
			ans += list2[x - 1]
	list_ans.append(ans)
print(*list_ans, sep='\n')


for k in range(int(input())):
	(n, m) = list(map(int, input().split()))
	kls = list(map(int, input().split()))
	pls = list(map(int, input().split()))
	kls = sorted(kls, reverse=True)
	ans = 0
	j = 0
	for i in range(n):
		num = kls[i] - 1
		money = pls[num]
		if j < m:
			gift = pls[j]
		else:
			gift = 1e+99
		if money <= gift:
			ans += money
		else:
			ans += gift
			j += 1
	print(ans)


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	k = [*map(int, input().split())]
	c = [*map(int, input().split())]
	c_cons = [False] * len(c)
	k.sort(reverse=True)
	next_g_ind = 0
	biggest_g_ind = k[0]
	total_cost = 0
	for x in k:
		if next_g_ind <= x - 1 and (not c_cons[next_g_ind]):
			c_cons[next_g_ind] = True
			total_cost += c[next_g_ind]
			next_g_ind += 1
		else:
			total_cost += c[x - 1]
	print(total_cost)


for test_num in range(int(input())):
	(f, m) = input().split()
	f_list = list(map(int, input().split()))
	m_list = list(map(int, input().split()))
	f_list.sort()
	f_list.reverse()
	money = 0
	present = 0
	for i in f_list:
		if present < i:
			money += m_list[present]
			present += 1
		else:
			money += m_list[i - 1]
	print(money)


t = int(input())
for _ in range(t):
	(n, x) = list(map(int, input().split()))
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	k.sort(reverse=True)
	k = [i - 1 for i in k]
	ans = 0
	j = 0
	for i in range(len(k)):
		if k[i] >= j:
			ans += c[j]
			j += 1
		else:
			ans += c[k[i]]
	print(ans)


from sys import stdin
stdin.readline

def mp():
	return list(map(int, stdin.readline().strip().split()))

def it():
	return int(stdin.readline().strip())
for _ in range(it()):
	(n, m) = mp()
	c = sorted(mp(), reverse=True)
	k = mp()
	(i, t) = (0, 0)
	ans = 0
	while i < n and t < m:
		if k[c[i] - 1] <= k[t]:
			ans += k[c[i] - 1]
			i += 1
		else:
			ans += k[t]
			t += 1
			i += 1
		if t >= m:
			j = i
			while j <= n:
				ans += k[c[j] - 1]
				j += 1
			break
	print(ans)


import sys
t = int(input())
for i in range(t):
	(n, m) = list(map(int, sys.stdin.readline().strip().split()))
	F = list(map(int, sys.stdin.readline().strip().split()))
	P = list(map(int, sys.stdin.readline().strip().split()))
	F.sort()
	cost = 0
	c_ptr = 0
	for k in range(n - 1, -1, -1):
		if c_ptr > m - 1 or P[c_ptr] > P[F[k] - 1]:
			cost += P[F[k] - 1]
		else:
			cost += P[c_ptr]
			c_ptr += 1
	print(cost)


def strangeBDParty(n: int, m: int, k: [int], c: [int]) -> int:
	k.sort(reverse=True)
	cost = l = 0
	for i in range(n):
		if l < m and c[l] < c[k[i] - 1]:
			cost += c[l]
			l += 1
		else:
			cost += c[k[i] - 1]
	return cost
rep = int(input())
for _ in range(rep):
	(n, m) = list(map(int, input().split()))
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	print(strangeBDParty(n, m, k, c))


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	k = list(sorted(map(int, input().split()), reverse=True))
	c = list(map(int, input().split()))
	friend_costs = list(map(lambda idx: c[idx - 1], k))
	npresent = 0
	sum = 0
	for i in range(n):
		if npresent < len(c) and npresent <= k[i] and (c[npresent] < friend_costs[i]):
			sum += c[npresent]
			npresent += 1
		else:
			sum += friend_costs[i]
	print(sum)


import sys
input = sys.stdin.buffer.readline

def multiLineArrayPrint(arr):
	print('\n'.join([str(x) for x in arr]))
allAns = []
t = int(input())
for _ in range(t):
	(n, m) = [int(x) for x in input().split()]
	k = [int(x) for x in input().split()]
	c = [int(x) for x in input().split()]
	k.sort(reverse=True)
	totalCost = 0
	cJ = 0
	for ki in k:
		ki -= 1
		if cJ < ki:
			totalCost += c[cJ]
			cJ += 1
		else:
			totalCost += c[ki]
	allAns.append(totalCost)
multiLineArrayPrint(allAns)


from collections import deque, defaultdict, Counter
from bisect import bisect_left, bisect_right
import heapq
import sys

def input():
	return sys.stdin.readline().rstrip()

def sol():
	(n, m) = map(int, input().split())
	idxa = list(map(int, input().split()))
	cost = list(map(int, input().split()))
	idxa.sort()
	lpos = 0
	ans = 0
	for i in range(n - 1, -1, -1):
		idx = idxa[i] - 1
		if lpos <= idx:
			ans += cost[lpos]
			lpos += 1
		else:
			ans += cost[idx]
	print(ans)
	return

def main():
	testcase = int(input())
	for i in range(testcase):
		sol()
main()


T = int(input())
for _ in range(T):
	(num_friends, num_presents) = map(int, input().split(' '))
	ks = sorted([int(k) - 1 for k in input().split(' ')])
	assert len(ks) == num_friends
	prices = list(map(int, input().split(' ')))
	assert len(prices) == num_presents
	total_cost = 0
	num_taken = 0
	for k in reversed(ks):
		direct_cost = prices[k]
		present_cost = prices[num_taken]
		if present_cost >= direct_cost:
			total_cost += direct_cost
		else:
			total_cost += present_cost
			num_taken += 1
	print(total_cost)


import sys
import math
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	a = list(map(int, input().split()))
	c = list(map(int, input().split()))
	a.sort(reverse=True)
	j = 0
	ans = 0
	for i in range(n):
		if a[i] - 1 <= j:
			ans += c[a[i] - 1]
		else:
			ans += c[j]
			j += 1
	print(ans)


import sys
input = sys.stdin.readline
for _ in range(int(input())):
	(N, M) = map(int, input().split())
	a = list(map(int, input().split()))
	c = list(map(int, input().split()))
	a.sort()
	i = 0
	res = 0
	while len(a):
		x = a.pop()
		if x > i:
			res += c[i]
			i += 1
		else:
			a.append(x)
			break
	for x in a:
		res += c[x - 1]
	print(res)


import sys
input = lambda : sys.stdin.readline().rstrip()
T = int(input())
for _ in range(T):
	(N, M) = map(int, input().split())
	A = sorted([int(a) - 1 for a in input().split()])
	B = [int(a) for a in input().split()]
	ans = 0
	i = 0
	while A:
		a = A.pop()
		if i < a:
			ans += B[i]
			i += 1
		else:
			ans += B[a]
	print(ans)


def solve():
	t = inp()
	for _ in range(t):
		(n, k) = mul()
		l = seq()
		m = seq()
		l.sort(reverse=True)
		pos = 0
		total = 0
		for j in range(n):
			if l[j] - 1 > pos:
				total += m[pos]
				pos += 1
			else:
				total += m[l[j] - 1]
		print(total)
import sys
import math
import bisect
from sys import stdin, stdout
from math import gcd, floor, sqrt, log
from collections import defaultdict as dd
from bisect import bisect_left as bl, bisect_right as br
inp = lambda : int(input())
strng = lambda : input().strip()
jn = lambda x, l: x.join(map(str, l))
strl = lambda : list(input().strip())
mul = lambda : map(int, input().strip().split())
mulf = lambda : map(float, input().strip().split())
seq = lambda : list(map(int, input().strip().split()))
ceil = lambda x: int(x) if x == int(x) else int(x) + 1
ceildiv = lambda x, d: x // d if x % d == 0 else x // d + 1
flush = lambda : stdout.flush()
stdstr = lambda : stdin.readline()
stdint = lambda : int(stdin.readline())
stdpr = lambda x: stdout.write(str(x))
solve()


t = int(input())
for _ in range(t):
	(n, m) = map(int, input().split())
	gifts = sorted(list(map(int, input().split())), reverse=True)
	cost = list(map(int, input().split()))
	res = 0
	place = 0
	for index in range(n):
		if gifts[index] - 1 < place:
			res += cost[gifts[index] - 1]
		elif gifts[index] - 1 >= place:
			res += cost[place]
			place += 1
	print(res)


test = int(input())
while test:
	(n, o) = map(int, input().split())
	li = list(map(int, input().split()))
	li1 = list(map(int, input().split()))
	li.sort(reverse=True)
	(c, ans) = (0, 0)
	for i in li:
		if li1[c] < li1[i - 1]:
			ans += li1[c]
			c += 1
		else:
			ans += li1[i - 1]
	print(ans)
	test -= 1


t = int(input())
outputs = []
for _ in range(t):
	(n, m) = map(int, input().split())
	ks = list(map(int, input().split()))
	cs = list(map(int, input().split()))
	csbool = [True] * m
	ks.sort(reverse=True)
	cena = 0
	w = 0
	for i in range(n):
		if ks[i] - 1 > w:
			cena += cs[w]
			w += 1
		else:
			cena += cs[ks[i] - 1]
	outputs.append(cena)
for odp in outputs:
	print(odp)


from math import ceil
t = int(input())
for _ in range(t):
	(n, m) = list(map(int, input().split()))
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	v = []
	for i in k:
		v.append(c[i - 1])
	v.sort(reverse=True)
	for i in range(min(n, m)):
		if v[i] > c[i]:
			v[i] = c[i]
	print(sum(v))


gans = []
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = list(map(int, input().split()))
	c = list(map(int, input().split()))
	p = [0] * n
	k.sort()
	for i in range(n):
		p[i] = c[k[i] - 1]
	for i in range(1, n):
		p[i] += p[i - 1]
	for i in range(1, m):
		c[i] += c[i - 1]
	ans = p[-1]
	if m >= n:
		ans = min(ans, c[n - 1])
	for x in range(max(0, n - m - 1), n - 1):
		cur = p[x] + c[n - x - 2]
		ans = min(ans, cur)
	gans.append(ans)
print('\n'.join(map(str, gans)))


import sys
readline = sys.stdin.readline
T = int(readline())
Ans = [None] * T
for qu in range(T):
	(N, M) = map(int, readline().split())
	K = list(map(lambda x: int(x) - 1, readline().split()))
	K.sort(reverse=True)
	C = list(map(int, readline().split()))
	L = list(range(N))
	L.sort(key=lambda x: K[x], reverse=True)
	ans = 0
	nxt = 0
	for k in K:
		if nxt <= k:
			ans += C[nxt]
			nxt += 1
		else:
			ans += C[k]
	Ans[qu] = ans
print('\n'.join(map(str, Ans)))


for _ in range(int(input())):
	(n, m) = [int(x) for x in input().split()]
	a = list(map(int, input().split()))
	b = list(map(int, input().split()))
	a.sort()
	(j, res) = (0, 0)
	for _ in range(n - 1, -1, -1):
		if j <= a[_] - 1:
			res += b[j]
			j += 1
		else:
			res += b[a[_] - 1]
	print(res)


for testcase in range(int(input())):
	(n, m) = map(int, input().split(' '))
	k = sorted(list(map(lambda x: int(x) - 1, input().split(' '))))[::-1]
	c = list(map(int, input().split(' ')))
	suma = 0
	for i in range(len(k)):
		if i < k[i]:
			suma += c[i]
		else:
			suma += c[k[i]]
	print(suma)


t = int(input())
res = []
for i in range(t):
	(n, m) = list(map(int, input().split()))
	k = sorted(list(map(int, input().split())), reverse=True)
	c = list(map(int, input().split()))
	s = 0
	for i in range(n):
		s += c[i] if i < k[i] else c[k[i] - 1]
	res.append(s)
print(*res, sep='\n')


from math import inf

def main():
	t = int(input())
	for _ in range(t):
		(n, m) = map(int, input().split())
		ks = [int(x) for x in input().split()]
		cs = [0] + [int(x) for x in input().split()]
		ks.sort(reverse=True)
		min_sum = 0
		cur_present = 1
		for (i, k) in enumerate(ks):
			den = cs[k]
			pod = cs[cur_present] if cur_present <= m else inf
			if den > pod:
				cur_present += 1
				min_sum += pod
			else:
				min_sum += den
		print(min_sum)
main()


a = int(input())
sum2 = []
for i in range(a):
	list1 = input().split(' ')
	n = int(list1[0])
	m = int(list1[1])
	list2 = input().split(' ')
	list2 = list(map(int, list2))
	list3 = input().split(' ')
	list3 = list(map(int, list3))
	list2.sort(reverse=True)
	sum = 0
	x = 1
	for k in list2:
		if k > x:
			sum = sum + list3[x - 1]
		else:
			sum = sum + list3[k - 1]
		x = x + 1
	sum2.append(sum)
	list1.clear()
	list2.clear()
	list3.clear()
for sum3 in sum2:
	print(sum3)


import sys
input = sys.stdin.readline
getint = lambda : int(input())
getints = lambda : [int(a) for a in input().split()]

def solve():
	(n, _) = getints()
	friends = getints()
	prices = getints()
	friends = sorted(friends, reverse=True)
	i = 0
	sum = 0
	while i < n and friends[i] - 1 > i:
		sum += prices[i]
		i += 1
	while i < n:
		sum += prices[friends[i] - 1]
		i += 1
	print(sum)
t = getint()
for i in range(t):
	solve()


t = int(input())
while t > 0:
	t -= 1
	(n, m) = map(int, input().split())
	v = [int(x) for x in input().split()]
	a = [int(x) for x in input().split()]
	v.sort()
	v.reverse()
	j = 0
	cnt = 0
	for i in range(n):
		if j < m and j < v[i]:
			cnt = cnt + a[j]
			j += 1
		else:
			cnt = cnt + a[v[i] - 1]
	print(cnt)


import math, sys
from collections import defaultdict, Counter
input = sys.stdin.readline
for _ in range(int(input())):
	(n, m) = map(int, input().split())
	k = sorted(map(int, input().split()))
	c = list(map(int, input().split()))
	ans = 0
	i = 0
	while k:
		node = k.pop()
		if c[i] < c[node - 1]:
			ans += c[i]
			i += 1
		else:
			ans += c[node - 1]
	print(ans)


def main():
	for _ in range(int(input())):
		(n, m) = list(map(int, input().split()))
		k = list(map(int, input().split()))
		c = list(map(int, input().split()))
		k.sort()
		cost = 0
		j = 0
		for i in range(n):
			if k[i] + i <= n:
				cost += c[k[i] - 1]
			else:
				cost += c[j]
				j += 1
		print(cost)
main()