BOJ_1092 배

import sys

N = int(input())
crane = list(map(int, input().split()))
M = int(input())
boxes = list(map(int, input().split()))

crane.sort(reverse=True)
boxes.sort(reverse=True)

if boxes[0] > crane[0]:
    print(-1)
    sys.exit()

# 한 크레인이 박스를 옮기는 데 걸린 최대 시간
res = 0
# 각 크레인이 박스를 옮기는 데 걸린 시간
tmp_count = [0] * N
i, j = 0, 0

while i < M:
    # 박스의 무게가 무게 제한 보다 작을 때
    if boxes[i] <= crane[j]:
        # 현재 크레인이 res만큼 박스를 옮겼으면
        if tmp_count[j] == res:
            # 다음 크레인으로 넘어간다.
            j += 1
            # 마지막 크레인이면
            if j == N:
                # 처음 크레인으로 넘어가고
                j = 0
                # res를 1 증가시킨다.
                res += 1
            continue

        # 해당 크레인으로 박스를 옮기고
        tmp_count[j] += 1
        # 다음 박스로 넘어간다
        i += 1
    # 박스의 무게가 더 무거우면
    else:
        # res를 증가시키고
        res += 1
        # 앞의 모든 크레인으로 
        for k in range(j):
            # 박스를 옮긴다.
            tmp_count[k] += 1
        # j개의 박스가 옮겨진다.
        i += j

print(res)

import sys
input = sys.stdin.readline

def solution(crane, boxes):
    res = 0

    if crane[0] < boxes[0]:
        return -1

    # 모든 크레인이 동시에 움직일 경우 최솟값
    min_count = M // N if M % N == 0 else M // N + 1
    res = min_count

    i, j, count = 0, 0, 0
    while i < M:
        # 해당 크레인이 할당량을 채울 경우
        if count >= res: 
            # 다음 크레인으로 이동한다.
            j += 1
            count = 0
        # 박스 무게가 크레인의 무게 제한보다 클 경우
        if boxes[i] > crane[j]:
            # 앞의 크레인 모두가 박스를 대신 옮기고
            i += j 
            # 목표(최대 시간)를 1 늘린다.
            res += 1
            continue
        # 현재 크레인의 할당량 1 증가
        count += 1

        # 다음 박스로 이동한다.
        i += 1  

    return res


N = int(input())
crane = list(map(int, input().split()))
M = int(input())
boxes = list(map(int, input().split()))

crane.sort(reverse=True)
boxes.sort(reverse=True)

print(solution(crane, boxes))

import sys
input = sys.stdin.readline

N = int(input())
crane = list(map(int, input().split()))
M = int(input())
box = list(map(int, input().split()))

crane.sort(reverse=True)
box.sort(reverse=True)

if box[0] > crane[0]:
    print(-1)
    sys.exit()

pos = [0] * N
moved = [False] * M
count = 0
res = 0

while count < M:
    for i, x in enumerate(crane):
        while pos[i] < M:
            if not moved[pos[i]] and x >= box[pos[i]]:
                moved[pos[i]] = True
                count += 1
                pos[i] += 1
                break
            else:
                pos[i] += 1
    res += 1

print(res)

import sys
input = sys.stdin.readline

N = int(input())
cranes = sorted(map(int, input().split()), reverse=True)
M = int(input())
boxes = sorted(map(int, input().split()), reverse=True)

if cranes[0] < boxes[0]:
    print(-1)
    sys.exit()


def move(count):
    # 크레인의 수에 count를 곱한 값이
    # 박스 수보다 적으면
    # 해당 크레인이 count 번 옮겨서는 박스를 모두 옮길 수 없기 때문에
    if N * count < M:
        # False를 반환
        return False
    # 첫 번째 크레인부터 M // count 번째 크레인까지
    for i in range(1, M // count):
        # i번째 크레인의 무게 제한이 i * count 번째 박스의 무게보다 작으면
        if boxes[i * count] > cranes[i]:
            # False를 반환
            return False
    # 그 외면 True를 반환
    return True


def binary_search(fnc, start, end):
    while start <= end:
        mid = (start + end) // 2
        if fnc(mid):
            ans = mid
            end = mid - 1
        else:
            start = mid + 1
    return ans


print(binary_search(move, 1, M))

# 풀이 1-1

N = int(input())
crane = list(map(int, input().split()))
M = int(input())
boxes = list(map(int, input().split()))

crane.sort(reverse=True)
boxes.sort(reverse=True)
count = [0 for _ in range(N)]

if boxes[0] > crane[0]:
    print(-1)

else:
    # 각 box에 대해서
    for box in boxes:
        idx = 0
        for i in range(N):
            # 박스 무게가 현재 크레인의 무게 제한보다 작거나 같고
            # 현재 크레인이 옮긴 박스의 수가 타깃 인덱스 번쨰 크레인에 비해 작으면
            if box <= crane[i] and count[idx] > count[i]:
                # 타깃 인덱스를 현재로 바꾼다.
                idx = i
            # 박스 무게가 현재 크레인의 무게 제한보다 크면
            elif box > crane[i]:
                # 크레인 탐색을 끝낸다.
                break
        # 타깃(현재) 인덱스의 크레인이 옮긴 박스의 수를 증가시킨다.
        count[idx] = count[idx] + 1

    print(max(count))

# 풀이 1-2

import sys
from heapq import heappush, heappop
input = sys.stdin.readline


def solve(cranes, boxes):
    if max(cranes) < max(boxes):
        return -1

    # 크레인이 옮긴 박스의 수도 같이 관리할 heap
    # 1-1의 count 역할
    crane_heap = []
    for box in boxes:
        # 현재 박스보다 무게 제한이 큰 크레인들을
        while cranes and cranes[-1] >= box:
            # count를 0으로 crane_heap에 넣는다.
            heappush(crane_heap, (0, cranes.pop()))
        # count가 최소이면서
        # 동일 count에서 무게 제한이 가장 작은 크레인을 pop 한 뒤
        count, crane = heappop(crane_heap)
        # count를 1 증가 시켜 다시 넣는다.
        heappush(crane_heap, (count + 1, crane))

    # crane_heap에서 최대 count 값을 갖는 원소의
    # 첫 번째 값(count)를 반환한다.
    return max(crane_heap)[0]


input()
cranes = list(map(int, input().split()))
input()
boxes = list(map(int, input().split()))

cranes.sort()
boxes.sort(reverse = True)

print(solve(cranes, boxes))