대학원생이 쉽게 설명해보기

from collections import deque

M, N = map(int, input().split())
tots = [list(map(int, input().split())) for _ in range(N)]
queue = deque() # 꼭 deque를 쓰지 않아도 됨

for i in range(N):
    for j in range(M):
        if tots[i][j] == 1:
            queue.append([i, j])
            
dx = [1, -1, 0, 0]
dy = [0, 0, 1, -1]

# 여기부터 bfs
while queue:
    row, col = queue.popleft()
    
    for k in range(4):
        _row = row + dy[k]
        _col = col + dx[k]
        
        # 안익은게 있다면, 익은 것으로 바꿔준다.
        if 0 <= _row < N and 0 <= _col < M and tots[_row][_col] == 0:
            tots[_row][_col] = tots[row][col] + 1
            queue.append([_row, _col])
# bfs 끝------

# -1이 존재해서 -2 값으로 비교
result = -2
# 안익은게 있는지 체크
check_tot = False

for i in tots:
    for j in i:
        if(j == 0):
            check_tot = True
        result = max(result, j)
        
if check_tot:
    print(-1)
elif result == -1:
    print(0)
else:
    print(result - 1)

import sys

input = sys.stdin.readline

N = int(input())
conn_num = int(input())

networks = [[0] * (N + 1) for _ in range(N+1)]

for _ in range(conn_num):
    a, b = map(int, input().split())
    networks[a][b] = 1; networks[b][a] = 1
    
def dfs(current_node, networks, foot_print):
    foot_print += [current_node]
    
    for search_node in range(len(networks[current_node])):
        if networks[current_node][search_node] and search_node not in foot_print:
            foot_print = dfs(search_node, networks, foot_print)
            
    return foot_print

result = dfs(1, networks, [])

print(len(result) - 1)

M, M = map(int, input().split())
heights = list(map(int, input().split()))

min_height, max_height = 1, max(heights)
H = 0

while(min_height <= max_height):
    mean_height = (min_height + max_height) // 2
    
    cut_num = 0
    for height in heights:
        if(height > mean_height):
            cut_num += (height - mean_height)
            
    # 가져가려고 하느 나무의 길이를 충족했다면,
    # 나무를 아끼기 위해 한번 더 조사한다.
    if(cut_num >= M):
        H = mean_height
        min_height = mean_height + 1
        
    # 가져가려고 하는 나무의 길이를 충족하지 못한다면,
    # 최대 길이를 낮춘다.
    elif(cut_num < M):
        max_height = mean_height - 1
        
print(H)

pypy3로 제출하여 통과하였음. 랜선 자르기를 풀었다면, 쉽게 풀 수 있음.

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

# 랜선의 최솟값은 1, 최댓값은 주어진 랜선 길이의 max 값
min_length = 1; max_length = max(lengths)
result = 0

while(min_length <= max_length):
    mean_length = (min_length + max_length) // 2
    
    cut_num = 0
    for length in lengths:
        cut_num += length // mean_length
    
    # 잘라진 랜선 개수가 N보다 많으면,
    # mean_length 밑에 존재하는 길이는 볼 필요가 없음.
    if(cut_num >= N):
        result = mean_length
        min_length = mean_length + 1

    # 잘라진 랜선 개수가 부족하다면,
    # mean_length 위에 존재하는 길이로는 조건을 만족할 수 없음.
    elif(cut_num < N):
        max_length = mean_length - 1
    
print(result)

1. 시간 초과

def iter_check(check_num, index, start, end):
    left_cnt = 0; right_cnt = 0
    left_index = 1; right_index = 1

    # 왼쪽에 숫자가 몇개 있는지
    while(start <= index - left_index):
        if(sorted_card_nums[index - left_index] == check_num):
            left_cnt += 1; left_index += 1
        else:
            break
            
    # 오른쪽에 숫자가 몇개 있는지    
    while(index + right_index <= end):
        if(sorted_card_nums[index + right_index] == check_num):
            right_cnt += 1; right_index += 1
        else:
            break
        
    # +1은 자기 자신을 의미함
    return left_cnt + right_cnt + 1

def solve(check_num, start, end):
    if(start > end):
        return 0
    
    index = (start + end) // 2
    
    # 이분 탐색
    if(sorted_card_nums[index] == check_num):
        return iter_check(check_num, index, start, end)
    elif(sorted_card_nums[index] > check_num):
        return solve(check_num, start, index - 1)
    else:
        return solve(check_num, index + 1, end)

import sys
input = sys.stdin.readline
    
N = int(input())
card_nums = list(map(int, input().split()))
sorted_card_nums = sorted(card_nums)

M = int(input())
target_list = list(map(int, input().split()))

results = []
start = 0
end = len(sorted_card_nums) - 1
    
for target in target_list:
    results.append(solve(target, start, end))
    
print(*results)

2. 자주 쓰는 딕셔너리 방법
(검색해보니 이 방법이랑 Counter 모듈이 쓰이고 있음)

import sys
input = sys.stdin.readline
    
N = int(input())
card_nums = list(map(int, input().split()))

M = int(input())
target_list = list(map(int, input().split()))

dicts = {}

for check_num in card_nums:
    if(check_num in dicts):
        dicts[check_num] += 1
    else:
        dicts[check_num] = 1
        
# ' '을 사이에 두고 반복하는 문자를 붙임
print(' '.join(str(dicts[target]) if target in dicts else '0' for target in target_list))

# ---------------------------------------
# result = ''

# for target in target_list:
#     if(target in dicts):
#         result += str(dicts[target])
#         result += ' '
#     else:
#         result += '0 '

# print(result[:-1])