Problem:
 Score: 500 points    Problem Statement  Takahashi will take part in an eating contest. Teams of N members will compete in this contest, and Takahashi's team consists of N players numbered 1 through N from youngest to oldest. The consumption coefficient of Member i is A_i .  In the contest, N foods numbered 1 through N will be presented, and the difficulty of Food i is F_i . The details of the contest are as follows:   A team should assign one member to each food, and should not assign the same member to multiple foods.  It will take x \times y seconds for a member to finish the food, where x is the consumption coefficient of the member and y is the difficulty of the dish.  The score of a team is the longest time it takes for an individual member to finish the food.   Before the contest, Takahashi's team decided to do some training. In one set of training, a member can reduce his/her consumption coefficient by 1 , as long as it does not go below 0 . However, for financial reasons, the N members can do at most K sets of training in total.  What is the minimum possible score of the team, achieved by choosing the amounts of members' training and allocating the dishes optimally?      Constraints   All values in input are integers.  1 \leq N \leq 2 \times 10^5  0 \leq K \leq 10^{18}  1 \leq A_i \leq 10^6\ (1 \leq i \leq N)  1 \leq F_i \leq 10^6\ (1 \leq i \leq N)         Input  Input is given from Standard Input in the following format:  N  K  A_1  A_2  ...  A_N  F_1  F_2  ...  F_N       Output  Print the minimum possible score of the team.        Sample Input 1 3 5
4 2 1
2 3 1      Sample Output 1 2  They can achieve the score of 2 , as follows:   Member 1 does 4 sets of training and eats Food 2 in (4-4) \times 3 = 0 seconds.  Member 2 does 1 set of training and eats Food 3 in (2-1) \times 1 = 1 second.  Member 3 does 0 sets of training and eats Food 1 in (1-0) \times 2 = 2 seconds.   They cannot achieve a score of less than 2 , so the answer is 2 .       Sample Input 2 3 8
4 2 1
2 3 1      Sample Output 2 0  They can choose not to do exactly K sets of training.       Sample Input 3 11 14
3 1 4 1 5 9 2 6 5 3 5
8 9 7 9 3 2 3 8 4 6 2      Sample Output 3 12

Solution (Python):
import subprocess
import gzip, base64, os
import stat

gz = b'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'
bin = gzip.decompress(base64.b64decode(gz))
p = os.path.dirname(__file__)
pymain = os.path.join(p, "a.out")
with open(pymain, "wb") as f:
    f.write(bin)
os.chmod(pymain, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
if p == "":
    pymain = "./" + pymain
subprocess.call(pymain)



'''

import numpy as np
i8 = np.int64
i4 = np.int32


def solve(A, F, K):
    min_ = 0
    max_ = 10 ** 12
    while min_ < max_:
        mid = (min_ + max_) // 2
        count = A - mid // F
        sum_ = count[count > 0].sum()
        if sum_ <= K:
            max_ = mid
        else:
            min_ = mid + 1
    return min_


def main2():
    stdin = open('/dev/stdin')
    N, K = np.fromstring(stdin.readline(), i8, -1, ' ')
    A = np.fromstring(stdin.readline(), i8, -1, ' ')
    F = np.fromstring(stdin.readline(), i8, -1, ' ')
    A = np.sort(A)[::-1]
    F = np.sort(F)
    ans = solve(A, F, K)
    print(ans)
'''

Solution (Python):
import numpy as np
N, K= map(int, input().split())
A=[int(i) for i in input().split()]
F=[int(i) for i in input().split()]

A=np.array(sorted(A, reverse=True))
F=np.array(sorted(F))

lower_bound=0
upper_bound=np.max(A*F)
K_tmp=0

while upper_bound>=lower_bound:
    mid=(lower_bound+upper_bound)//2
    K_tmp=np.sum(np.maximum(A-mid//F, 0))
    if K_tmp<=K:
        upper_bound=mid-1
    else:
        lower_bound=mid+1

print(lower_bound)

Solution (Python):
import sys
input = sys.stdin.readline
n, k = map(int, input().split())
a = sorted(list( map(int, input().split()) ))
f = sorted(list( map(int, input().split()) ), reverse=True)

lft = -1
rgt = 10**12
while rgt-lft > 1:
    mid = ( rgt+lft ) // 2
    cnt = 0

    for i, e in enumerate(a):
        cnt += max( 0, e-mid//f[i] )

    if cnt <= k:
        rgt = mid
    else:
        lft = mid

print(rgt)

Solution (Python):
N,K=map(int,input().split())

A=list(map(int,input().split()))
F=list(map(int,input().split()))

A.sort()
F.sort(reverse=True)

H=10**12
L=0

while abs(H-L)>4:
    Mid=(H+L)//2
    
    cnt=0
    for i in range(N):
        f=0
        if A[i]*F[i]>Mid:
            cnt+=(A[i]-int(Mid/F[i]))
            if cnt>K:
                f=1
                break
    if f==1:
        L=Mid
    else:
        H=Mid
for j in range(5):
    M=H-j
    cnt=0
    for i in range(N):
        if A[i]*F[i]>M:
            cnt+=(A[i]-int(M/F[i]))
            if cnt>K:
                print(M+1)
                exit()
print(0)

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = True
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]

    n, k = LMIIS()
    a = LMIIS()
    f = LMIIS()
    a.sort(reverse=True)
    f.sort()


    max_ = 10**12
    min_ = 0

    while max_ != min_ + 1:
        x = (max_ + min_) // 2
        shugyo = 0
        for i in range(n):
            shugyo += max(0, a[i] - x // f[i])

        if shugyo <= k:
            max_ = x
        else:
            min_ = x


    if x == min_:
        x += 1
    if sum(a) <= k:
        x = 0
    print(x)

if __name__ == '__main__':
    main()

Solution (Python):
N,K = map(int, input().split())
A = [int(a) for a in input().split()]
F = [int(f) for f in input().split()]

A.sort()
F.sort(reverse=True)

if K >= sum(A):
    ans = 0
else:
    u = 10**13
    l = 0
    while u-l > 1:
        x = (u+l)//2
        cnt = K
        for i in range(N):
            cnt -= max(0, A[i]-x//F[i])
        if cnt >= 0:
            u = x
        else:
            l = x
    cnt = K
    for i in range(N):
        cnt -= max(0, A[i]-l//F[i])
    if cnt >= 0:
        ans = l
    else:
        ans = u
        
print(ans)

Solution (Python):

import sys
sys.setrecursionlimit(10**6)
write = sys.stdout.write
dbg = lambda *something : print(*something) if DEBUG else 0
DEBUG = True
def main(given = sys.stdin.readline):
    input = lambda : given().rstrip()
    LMIIS = lambda : list(map(int,input().split()))
    II = lambda : int(input())
    XLMIIS = lambda x : [LMIIS() for _ in range(x)]

    n, k = LMIIS()
    aa = LMIIS()
    ff = LMIIS()
    aa.sort(reverse=True)
    ff.sort()
    a = tuple(aa)
    f = tuple(ff)


    max_ = 10**12
    min_ = 0

    while max_ != min_ + 1:
        x = (max_ + min_) // 2
        shugyo = 0
        for i in range(n):
            shugyo += max(0, a[i] - x // f[i])

        if shugyo <= k:
            max_ = x
        else:
            min_ = x


    if x == min_:
        x += 1
    if sum(a) <= k:
        x = 0
    print(x)

if __name__ == '__main__':
    main()

Solution (Python):
def isOK(mid,N,K,sort_F,sort_A):
    cnt = 0
    for i in range(N):
        cnt += max(sort_A[i] - (mid // sort_F[i]),0)
    return cnt <= K

def main():
    N, K = map(int, input().split())
    A = list(map(int, input().split()))
    F = list(map(int, input().split()))
    sort_A = sorted(A)
    sort_F = sorted(F, reverse=True)

    ng = -1
    ok = 10 ** 12 + 5
    while abs(ok - ng) > 1:
        mid = (ok + ng) // 2
        if isOK(mid,N,K,sort_F,sort_A):
            ok = mid
        else:
            ng = mid

    print(ok)



if __name__ == "__main__":
    main()

Solution (Python):
def binary_search(a, f, target, left, right):
    ans = a[-1] * f[-1]
    while left + 1 < right:
        mid = (left+right)//2
        cost = 0
        for aa,ff in zip(a,f):
            if ff > mid:
                cost += aa
            elif aa - mid // ff > 0:
                cost += aa - mid // ff
        if cost > target:
            left = mid
        else:
            right = mid
    return right

n,k = map(int,input().split())
a = sorted(map(int, input().split()), reverse=True)
f = sorted(map(int, input().split()))
target = binary_search(a,f,k,-1,max(a) * max(f))
mx = 0
cost = 0
for aa, ff in zip(a,f):
    if ff > target:
        cost += aa
        aa = 0
    elif aa - target // ff > 0:
        cost += aa - target // ff
        aa = (target // ff)
    if mx < aa * ff:
        mx = aa * ff
print(mx)

Solution (Python):
import numpy as np
I = np.array([int(_) for _ in open(0).read().split()])
N, K = I[0], I[1]
A, F = I[2:2 + N], I[2 + N:2 + 2 * N]
A = np.sort(A)
F = np.sort(F)[::-1]
lb = -1
rb = 10**13



def check(x):
    if np.sum(np.maximum(A - np.array([x]) // F, 0)) <= K:
        return 1
    else:
        return 0


while rb - lb > 1:
    mid = (rb + lb) // 2
    if check(mid):
        rb = mid
    else:
        lb = mid
print(rb)

Solution (Python):
import numpy as np

n, k = map(int, input().split())
a = list(map(int, input().split()))
f = list(map(int, input().split()))

a  = np.sort(np.array(a))
f = np.sort(np.array(f))[::-1]

l ,r = 0, 10 ** 12
while l <= r:
 x = (l + r) // 2
 if np.clip(a - x // f, 0, None).sum() <= k:
  r = x - 1
 else:
  l = x + 1
print(l)

Solution (Python):
import sys
sys.setrecursionlimit(10000000)
import heapq
import math

def main():
    N, K = map(int, input().split())
    A = [int(c) for c in input().split()]
    F = [int(c) for c in input().split()]
    
    A.sort()
    F.sort(reverse=True)

    num = 0
    sum_ = []
    for i in range(len(A)):
        sum_.append(A[i] * F[i])
    left = 0
    right = 10 ** 12
    while(num < 50):
        number = 0
        mid = (left + right) // 2
        
        for i in range(len(A)):
            if sum_[i] <= mid:
                continue
            else:
                number += math.ceil((sum_[i] - mid) / F[i])
            
        if number > K:
            
            left = mid + 1
        else:
            right = mid
        num += 1
    print(mid)
                

if __name__ == '__main__':
    main()

Solution (Python):
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)

start = -1
end = A[-1] * F[0]

def check(now):
    cnt = 0
    for a, f in zip(A, F):
        eatable = now//f
        if eatable < a:
            cnt += a - eatable
    if cnt > K:
        return False
    return True

while end > start + 1:
    now = (start + end) // 2
    if check(now):
        end = now
    else:
        start = now

print(end)

Solution (Python):
N, K = map(int, input().split())
A = list(map(int, input().split()))
F = list(map(int, input().split()))
A.sort()
F.sort(reverse=True)

start = -1
end = A[-1] * F[0]

def check(now):
    cnt = 0
    for a, f in zip(A, F):
        eatable = now//f
        if eatable < a:
            cnt += a - eatable
    if cnt > K:
        return False
    return True

while end > start + 1:
    now = (start + end) // 2
    if check(now):
        end = now
    else:
        start = now

print(end)

Solution (Python):
import sys
import math
import bisect
 
 
sys.setrecursionlimit(1000000000)
def input():
    return sys.stdin.readline().strip()
 
def iinput():
    return int(input())
 
def finput():
    return float(input())
 
def tinput():
    return input().split()
 
def rinput():
    return map(int, tinput())
 
def rlinput():
    return list(rinput())
 
def modst(a, s):
    res = 1
    while s:
        if s % 2:
            res *= a
        a *= a
        s //= 2
    return res

 
def main():
    n, k = rinput()
    a = sorted(rlinput())
    s = sorted(rlinput())
    l, res = -1, 10 ** 12
    while res - l > 1:
        m = (res + l) // 2
        q = k    
        for i in range(n):
            w = a[i] - (m // s[- i - 1])
            q -= max(0, w)
        if q < 0:
            l = m
        else:
            res = m
    print(res)        
main()