#5 Python 코딩테스트 이진 탐색

https://www.youtube.com/watch?v=94RC-DsGMLo&list=PLRx0vPvlEmdAghTr5mXQxGpHjWqSz0dgC&index=5 

이 포스팅은 위의 영상을 보고 제가 필요하다고 생각되는 부분을 정리한 포스팅입니다.

 

순차 탐색 : 리스트 안에 있는 특정한 데이터를 찾기 위해 앞에서부터 데이터를 하나씩 확인하는 방법

이진 탐색 : 정렬되어 있는 리스트에서 탐색 범위를 절반씩 좁혀가며 데이터를 탐색하는 방법

- 이진 탐색은 시작점, 끝점, 중간점을 이용하여 탐색 범위를 설정합니다.

절반씩 데이터를 쪼개서 탐색하기 때문에 O(logN)의 시간 복잡도를 가지게 됨

 

# 이진 탐색 소스코드 구현 (재귀 함수)
def binary_search_recursive(array, target, start, end):
    if start > end:
        return None
    mid = (start + end) //2
    # 찾은 경우 중간점 인덱스 반환
    if array[mid] == target:
        return mid
    # 중간점의 값보다 찾고자 하는 값이 작은 경우 왼쪽 확인
    elif array[mid] > target:
        return binary_search(array, target, start, mid - 1)
    # 중간점의 값보다 찾고자 하는 값이 큰 경우 오른쪽 확인
    else:
        return binary_search(array, target, mid + 1, end)
        
# 이진 탐색 소스코드 구현 (반복문)
def binary_search_repeat(array, target, start, end):
    while start <= end:
        mid = (start + end) //2
        # 찾은 경우 중간점 인덱스 반환
    	if array[mid] == target:
            return mid
    	# 중간점의 값보다 찾고자 하는 값이 작은 경우 왼쪽 확인
    	elif array[mid] > target:
            end = mid - 1
    	# 중간점의 값보다 찾고자 하는 값이 큰 경우 오른쪽 확인
    	else:
            start = mid +1
    return None


# n(원소의 개수)과 target(찾고자 하는 값)을 입력 받기
n, target = list(map(int, input().split()))
# 전체 원소 입력 받기
array = list(map(int, input().split()))

# 이진 탐색 수행 결과 출력
result = binary_search(array, target, 0, n - 1)
if result == None:
    print("원소가 존재하지 않습니다.")
else:
    print(result + 1)

이진 탐색 주요 라이브러리

이건 몰랐는데 꽤 유용하겠다.

값이 특정 범위에 속하는 데이터 개수 구하기

from bisect import bisect_left, bisect_right

# 값이 [left_value, right_value]인 데이터의 개수를 반환하는 함수
def count_by_range(a, left_value, right_value):
    right_index = bisect_right(a, right_value)
    left_index = bisect_left(a, left_value)
    return right_index - left_index

# 배열 선언
a = [1, 2, 3, 3, 3, 3, 4, 4, 8, 9]

# 값이 4인 데이터 개수 출력
print(count_by_range(a, 4, 4))

# 값이 [-1, 3] 범위에 있는 데이터 개수 출력
print(count_by_range(a, -1, 3))

파라메트릭 서치 (Parametric Search)

파라메트릭 서치란 최적화 문제를 결정 문제('예' 혹은 '아니오')로 바꾸어 해결하는 기법

- 예시 : 특정한 조건을 만족하는 가장 알맞은 값을 빠르게 찾는 최적화 문제

- 일반적으로 코딩 테스트에서 파라메트릭 서치 문제는 이진 탐색을 이용하여 해결할 수 있다.

 

떡볶이 떡 만들기

내 풀이

from bisect import bisect_left
N, M = map(int, input().split())
rice_cake = list(map(int,input().split()))
rice_cake.sort()
def chunk_rice(start, end, rice_cake):
    H = int((start+end)/2)
    index = bisect_left(rice_cake,H)
    result = sum(rice_cake[index:]) - (H*len(rice_cake[index:]))
    if result == M:
        return H
    elif result < M:
        return chunk_rice(start, H, rice_cake)
    elif result > M:
        if end - start ==1:
            return H
        else :
            return chunk_rice(H,end,rice_cake)
print(chunk_rice(0,rice_cake[-1],rice_cake))

답안 예시

# 떡의 개수(N) 와 요청한 떡의 길이(M)을 입력
n, m = list(map(int, input().split(' ')))
# 각 떡의 개별 높이 정보를 입력
array = list(map(int, input().split()))

# 이진 탐색을 위한 시작점과 끝점 설정
start = 0
end = max(array)

# 이진 탐색 수행 (반복적)
result = 0
while(start <= end):
    total = 0
    mid = (start + end) //2
    for x in array:
        # 잘랐을 때의 떡의 양 계산
        if x > mid:
            total += x - mid
    # 떡의 양이 부족한 경우 더 많이 자르기 (왼쪽 부분 탐색)
    if total < m:
        end = mid -1
    # 떡의 양이 충분한 경우 덜 자르기 (오른쪽 부분 탐색)
    else:
        result = mid # 최대한 덜 잘랐을 때가 정답이므로, 여기에서 result에 기록
        start = mid + 1
        
print(result)

내 코드는 sorting도 진행해야 하고 코드도 직관적이지 못한 것 같다. - bisect를 제대로 이해했다는 것에 의의를 두자.

앞으로 큰 데이터 양이 주어졌을 때 이진 탐색을 기반으로 풀이하는 생각을 해야겠다.

 

정렬된 배열에서 특정 수의 개수 구하기

이진 탐색 사용한 코드

N, x = map(int,input().split())
num_list = list(map(int,input().split()))

start = 0
end = len(num_list) - 1
left_result, right_result = -1 , -1
# left index
while(start<=end):
    mid = (start+end)//2
    if num_list[mid] == x:
        left_result = mid
        end = mid - 1
    elif num_list[mid] < x:
        start = mid + 1
    elif num_list[mid] > x:
        end = mid - 1
start = 0
end = len(num_list) - 1
# left index
while(start<=end):
    mid = (start+end)//2
    if num_list[mid] == x:
        right_result = mid
        start = mid + 1
    elif num_list[mid] < x:
        start = mid + 1
    elif num_list[mid] > x:
        end = mid - 1
if left_result == -1:
    print(-1)
else:
    print(right_result-left_result+1)

 

bisect 사용한 코드

from bisect import bisect_left, bisect_right
N, x = map(int,input().split())
num_list = list(map(int,input().split()))

def count_range(array,left_value,right_value):
    left_index = bisect_left(array,left_value)
    right_index = bisect_right(array,right_value)
    return right_index - left_index

count = count_range(num_list,x,x)
if count == 0:
    print(-1)
else :
    print(count)