Coding 공부

def check(number):
    remain_person = M

    for k in time_list:
        remain_person = remain_person - number//k
        if remain_person <=0:
            return -1
    return 1


N,M = map(int,input().split())
time_list = [int(input()) for _ in range(N)]

start = 1
end = ((M//N)+1)*max(time_list)
while start<end:
    mid = (start+end)//2
    remain_person = check(mid)

    if remain_person > 0:
        start = mid + 1
    else:
        end = mid -1
print(end)

import sys

input = sys.stdin.readline

N = int(input())


bit_cnt_list = [0]*1024
for _ in range(N):
    num = input().strip()
    temp = 0
    for bit_num in num:
        temp = temp | 2**(int(bit_num))
    bit_cnt_list[temp] += 1
result = 0
for k in range(1,1024):
    for t in range(k,1024):
        if k == t:
            if bit_cnt_list[k] >= 2:
                result = result + (bit_cnt_list[k]*(bit_cnt_list[k]-1))//2
        else:
            if bit_cnt_list[k] != 0 or bit_cnt_list[t] != 0:
                if k&t >0:
                    result = result + bit_cnt_list[k]*bit_cnt_list[t]

print(result)

T = int(input())
dp = [[0]*10 if i !=0 else [1]*10 for i in range(65)]
visited = [0]*64
visited[0] = 1
last_n = 0
for ind in range(T):
    n = int(input())
    if visited[n-1]:
        print(sum(dp[n-1]))
    else:
        for ind in range(last_n+1,n):
            for num in range(9,-1,-1):
                if num == 9:
                    dp[ind][num] = sum(dp[ind-1])
                else:
                    dp[ind][num] = dp[ind][num+1] - dp[ind-1][num+1]
        last_n = max(last_n,n-1)

        print(sum(dp[n-1]))

T = int(input())
dp = [[1]*10 if ind == 0 else [0]*10 for ind in range(64)]
result = [0]*64
result[0] = 10
for ind in range(1,64):
    for num in range(9,-1,-1):
        if num == 9:
            dp[ind][num] = result[ind-1]
        else:
            dp[ind][num] = dp[ind][num+1] - dp[ind-1][num+1]
    result[ind] = sum(dp[ind])

for _ in range(T):
    n = int(input())
    print(result[n-1])

def checkminNumber(index,open1,open2):
    if index > M-1:
        return 0 
    result = dp[index][open1][open2]
    if result != float('inf'):
        return result
    next_open = output_list[index]
    dp[index][open1][open2] = min(abs(open1 - next_open) + checkminNumber(index+1,next_open,open2), abs(open2 - next_open) + checkminNumber(index+1,open1,next_open))
    return dp[index][open1][open2]



N = int(input())

open1,open2 = list(map(int,input().split()))

M = int(input())
dp = [[[float('inf')]*(N+1) for _ in range(N+1)] for _ in range(M)]
output_list = []

for _ in range(M):
    output_list.append(int(input()))
print(checkminNumber(0,open1,open2))

import sys
import collections
input = sys.stdin.readline

def bfs1(x):
    que=collections.deque()
    que.append(x)
    temp=set()
    temp.add(x)
    while que:
        node=que.popleft()
        for i in graph1[node]:
            if i not in temp:
                temp.add(i)
                visit[x]+=1       
                que.append(i)
    return
def bfs2(x):
    que=collections.deque()
    que.append(x)
    temp=set()
    temp.add(x)
    while que:
        node=que.popleft()
        for i in graph2[node]:            
            if i not in temp:
                temp.add(i)
                visit[x]+=1       
                que.append(i)
    return
 

N,M = map(int,input().split())
arr=[list(map(int,input().split())) for i in range(M)]
graph1=[[] for i in range(N+1)]
graph2=[[] for i in range(N+1)]
for i in arr:
    graph1[i[0]].append(i[1])
    graph2[i[1]].append(i[0])
visit=[0]*(N+1)
for i in range(1,N+1):        
    bfs1(i)
    bfs2(i)

cnt=visit.count(N-1)
print(cnt)

def gcd(A,B):
    if not A%B:
        return B
    return gcd(B,A%B)


N, M = map(int,input().split())
ab = M//N
list_a = []
last_N = int(ab**(1/2))
for number_a in range(last_N,0,-1):
    if not ab%number_a:
        number_b = ab//number_a
        if gcd(number_a,number_b) == 1:
            list_a.extend([number_a,number_b])
            break
print(*[ i*N for i in list_a])

N = int(input())
K = int(input())
arr = list(map(int,input().split()))
arr.sort()
diff = [0]*N
for i in range(N-1):
    diff[i] = arr[i+1] - arr[i]

diff.sort()
print(sum(diff[:len(diff)-(K-1)]))

N = int(input())

arr = [int(input()) for _ in range(N)]

dp = [[0 for _ in range(3)] for _ in range(N)] 
if N>2:
    dp[0][1] = arr[0]
    dp[1][1] = arr[1]
    dp[1][2] = dp[0][1] + arr[1]



    for ind in range(2,N):
        
        dp[ind][0] = max(dp[ind-1][0],dp[ind][0],dp[ind-2][2],dp[ind-2][1],dp[ind-1][1])
        dp[ind][1] = max(dp[ind][1],dp[ind-1][0]+arr[ind],dp[ind-2][1]+arr[ind],dp[ind-2][2]+arr[ind],dp[ind-2][0]+arr[ind])
        dp[ind][2] = max(dp[ind][2],dp[ind-1][1]+arr[ind])
    print(max(list(map(max,dp))))
else:
    print(sum(arr))

N = int(input())

arr = [0]+[int(input()) for _ in range(N)]

dp = [0]*(N+1)

dp[1] = arr[1]

for ind in range(2,N+1):
    if ind == 2:
        dp[ind] = dp[ind-1] + arr[ind]
    else:
        dp[ind] = max(dp[ind-3]+arr[ind-1]+arr[ind],dp[ind-2]+arr[ind],dp[ind-1])

print(dp[N])