🌱WIL

• 주어진 시간 내에 푸는 것도 중요하지만, 우선 혼자 힘으로 풀어내기 위해서 훈련을 하고 있다는 걸 기억하기!
• 이번주차 발제/과제 문제들을 아직 잘 이해하지는 못한것 같다. 풀이를 다시 정리하고 비슷한 문제를 몇번 더 풀어보면 좋을 것 같다.

🚀주간 목표 문제 수: 5개

푼 문제

• 백준 #5582. 공통 부분 문자열: DP / 골드5
• 백준 #20542. 받아쓰기: DP / 골드3
• 백준 #2776.암기왕: 그래프 / 실버4
• 백준 #1654. 랜선 자르기: 그래프 / 실버2
• 백준 #11663. 선분 위의 점: 그래프 / 실버3
• 백준 #2343. 기타 레슨: DP / 실버1

백준 #5582. 공통 부분 문자열: DP / 골드5

정리한 링크: (바로가기)

🚩제출한 코드

import sys 
input = sys.stdin.readline

S1 = list(input().strip())
S2 = list(input().strip()) 
n, m = len(S1), len(S2)

dp = [[0] * (m+1) for _ in range(n+1)]

max_len = 0

for i in range(1, n+1):
    for j in range(1, m+1):
        # 문자열 S1과 S2의 현재 위치의 문자를 비교
        if S1[i-1] == S2[j-1]:
            dp[i][j] = dp[i-1][j-1] + 1 # 이전 공통 부분 문자열에 현재 문자를 추가하여 길이를 연장 
            max_len = max(max_len, dp[i][j])
        else:
            dp[i][j] = 0 # 다르면 공통 부분 문자열이 끊어짐 

print(max_len)

백준 #20542. 받아쓰기: DP / 골드3

정리한 링크: (바로가기)

🚩제출한 코드

n, m = map(int, input().split())
answer = input().strip()
correct = input().strip()

def calculate_score(n, m, answer, correct):
    # DP 테이블 초기화
    prev = list(range(m + 1))
    curr = [0] * (m + 1)

    for i in range(1, n + 1):
        curr[0] = i
        for j in range(1, m + 1):
            # 현재 문자
            a, c = answer[i - 1], correct[j - 1]

            # 변환 비용 계산
            if a == c or (a == 'i' and c in 'ijl') or (a == 'v' and c in 'vw'):
                cost = 0
            else:
                cost = 1

            # DP 점화식
            curr[j] = min(
                prev[j] + 1,        # 삭제
                curr[j - 1] + 1,    # 추가
                prev[j - 1] + cost  # 변환
            )

        # 현재 행을 이전 행으로 복사
        prev, curr = curr, prev

    # 최소 수정 횟수 반환
    return prev[m]

print(calculate_score(n, m, answer, correct))

💡TIL

• 혼자서 문제 풀이 방법을 떠올리지 못해서 정답풀이들을 보면서 코드를 완성하였다.
• 두 문자열 간의 최소 편집 거리를 계산하는 문제로, 레벤슈타인 거리를 계산하는 방식과 유사하다. 주어진 조건에 따라 i와 v를 추가적으로 처리해야 하므로 기본적인 편집 거리 알고리즘에 약간의 변형이 필요하다.
• dp[i][j]는 "답안의 첫 i글자"를 "정답의 첫 j글자"로 바꾸는 데 필요한 최소 편집 횟수를 저장한다.

백준 #2776.암기왕: 이진탐색 / 실버4

정리한 링크: (바로가기)

🚩플로우 (선택)

• 수첩1과 수첩2에 각각 적힌 숫자들이 주어진다.
• 수첩 2의 각 숫자가 수첩 1에 존재하는지 여부를 판단하여, 존재하면 1, 존재하지 않으면 0을 출력한다.
• 입력 크기가 $N,M=1,000,000$으로 매우 크기 때문에 효율적인 탐색이 중요하다.
• 테스트케이스 개수 $T$를 입력받는다.
• 각 테스트케이스마다 수첩1, 2의 숫자를 각각 저장한다.
• 수첩2의 각 숫자에 대해, 수첩1의 set에 존재하는지 확인하고, 존재여부에 따라 1 또는 0을 출력한다.

🚩제출한 코드

import sys 
input = sys.stdin.readline

T = int(input()) # 테스트케이스의 개수 

for _ in range(T):
    # 수첩1
    N = int(input()) 
    note1 = set(map(int, input().split()))
    # 수첩2
    M = int(input()) 
    note2 = list(map(int, input().split())) 

    for num in note2:
        if num in note1:
            print(1)
        else:
            print(0)

💡TIL

• note1의 숫자를 list()로 받으면 시간초과가 발생한다. → set()으로 받아야 한다.
  • 리스트는 데이터를 처음부터 끝까지 순차적으로 확인한다. 탐색의 시간 복잡도는 $O(N)$이다.
    즉, 리스트에서 특정 값이 존재하는지 확인하려면 최악의 경우 리스트의 모든 요소를 확인해야한다.
  • set은 해시 테이블 구조를 기반으로 동작하며, 탐색의 시간 복잡도는 $O(1)$이다.
    즉, set에서는 값을 바로 찾아낼 수 있다.
• in(): 어떤 값이 특정 시퀀스(리스트, 튜플, 문자열 등) 혹은 컬렉션(딕셔너리, 집합 등) 안에 존재하는지 검사하는 연산자이다.
• 입력 크기가 매우 클 때, 리스트를 사용하면 $O(N×M)$의 시간 복잡도를 가지게 된다. note2의 각 숫자에 대해 note1을 한번씩 순회하는 방식이라 매우 비효율적이다.
• set을 사용하면 탐색이 $O(1)$로 최적화되므로, 전체 시간 복잡도가 $O(N+M)$로 줄어들어 효율적으로 작동한다.
• 이진탐색(Binary Seacrh): 배열 내부의 데이터가 정렬되어 있어야만 사용할 수 있고, 탐색 범위를 반으로 좁혀가며 빠르게 탐색하는 알고리즘이다.
• 시작점, 끝점, 중간점을 이용하여 탐색 범위를 설정한다.
• 찾으려는 데이터와 중간점 위치에 있는 데이터를 반복적으로 비교해서 원하는 데이터를 찾는 것이 과정이다.
  • 한 번 확인할 때마다 확인하는 원소의 개수가 절반씩 줄어든다. 시간 복잡도가 $O(\log N)$이다.
• 이진탐색을 구현하는 방법

  • (1) 재귀함수를 이용하는 방법

       **def binary_search(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) # 시작점을 중간점 오른쪽으로 이동
       
       # 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) # {해당 원소가 존재하는 인덱스+1}번째 원소인지를 출력

  • (2) 반복문을 이용하는 방법

       def binary_search(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)

• 데이터 구조를 선택할 때 시간 복잡도를 고려해야한다. 입력 크기, 사용한 연산, 자료형의 특징을 분석하여 적합하고 효율적인 데이터 구조를 선택할 줄 알아야한다.
• 정렬된 데이터에서의 탐색 문제에서 이진 탐색을 바로 떠올리지 못했다. 이번 문제를 통해 이진 탐색의 개념과 구현 방법을 정리하며 익혔다.
  • 이진 탐색 문제는 탐색 범위가 큰 상황에서의 탐색을 가정하는 문제가 많다. 탐색 범위가 2,000만을 넘어가면 이진 탐색으로 문제를 접근해보자.
  • 처리해야할 데이터의 개수나 값이 1,000만 단위 이상으로 넘어가면 이진탐색과 같이 $O(\log N)$의 속도를 내야하는 알고리즘을 떠올려야 풀 수 있다는 경우가 많다는 것을 기억하자.

백준 #1654. 랜선 자르기: 이진탐색 / 실버2

정리한 링크: (바로가기)

🚩플로우 (선택)

• $K$개의 서로 다른 길이의 랜선을 모두 $N$개의 같은 길이의 랜선으로 만들어야 한다.
• $N$개를 만들 수 있는 랜선의 최대 길이를 정수로 출력한다.
• 어떤 길이로 잘라야 랜선 개수에 맞는 최대 길이의 랜선을 획득할 수 있을지 한눈에 알기 어렵다. 이진탐색 알고리즘을 사용하여 검색 범위를 좁혀 나갈 수 있다.
• 이진탐색 알고리즘에 따라 랜선의 길이를 움직여가며 랜선의 개수를 채우는지 확인한다.
  • 이때, 1을 start로, 랜선 중 가장 긴 길이를 end로 둔다.
  • 검색마다 잘라지는 랜선 개수와 원하는 랜선 개수를 비교하여 원하는 랜선 개수보다 잘라지는 랜선 개수가 적다면 자르는 랜선의 길이를 짧게 하고, 잘라지는 랜선 개수가 원하는 랜선 개수 이상이라면 랜선 길이를 더 길게 한다.

🚩제출한 코드

import sys 
input = sys.stdin.readline

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

def binary_search(start, end):
    while start <= end:
        mid = (start + end) // 2
        lines = 0 # 랜선의 개수 
        for i in lan:
            lines += i // mid
        if lines >= N: # 랜선의 개수가 많음 (랜선의 길이가 짧음)
            start = mid + 1
        else: # 랜선의 개수가 적음 (랜선의 길이가 김)
            end = mid - 1
    return end

print(binary_search(1, max(lan)))

💡TIL

• 이진탐색 알고리즘 문제들은 해당 문제가 이진탐색으로 접근해야한다는것을 깨닫는 것이 가장 중요한 것 같다.
  • 어떤 값이 최적인지 직접적으로 알기 어렵고, 가능성을 판별하며 범위를 좁혀야할 때 (최대값, 최소값을 구해야하는 문제)
  • 문제에서 값이 특정 방향으로 변할 때, 조건을 만족하는지 여부가 단조적으로 변한다.
    • ex. 랜선의 길이를 줄이면 개수는 증가하고, 길이를 늘리면 개수는 감소한다.
• 문제 조건에 따라 탐색 범위(start, end)를 잘 설정해야한다.

백준 #11663. 선분 위의 점: 이진탐색 / 실버3

정리한 링크: (바로가기)

🚩플로우 (선택)

• 일차원 좌표상의 점과 선분이 주어지면, 각각의 선분 위에 입력으로 주어진 점이 몇 개 있는지 출력한다.
• 점의 개수 $N$, 선분의 개수 $M$, 점의 좌표, $M$개의 선분의 시작점과 끝점
• 입력 받은 점의 좌표를 오름차순 정렬한다.
• 최소값의 index와 최대값의 index를 비교해 “개수”만 구하는 방식을 사용해야한다.
  • 시작점에 가까운 점을 찾는 이진탐색, 끝점에 가까운 점을 찾는 이진탐색
  • 그 두 점 사이의 점 개수를 세서 출력한다. 찾은 점들의 index 차를 구한다.
• 최소값과 최대값의 index를 체크하기 위해 이진탐색을 두번하므로 for문하나+이진탐색 = 시간복잡도 $O(N\log N)$이 되어 시간초과 문제를 해결할 수 있게 된다.

🚩제출한 코드

import sys 
input = sys.stdin.readline
from bisect import bisect_left, bisect_right

N, M = map(int, input().split())
points = list(map(int, input().split()))
lines = [tuple(map(int, input().split())) for _ in range(M)]

points.sort()

counts = []
for start, end in lines:
    left = bisect_left(points, start)  
    right = bisect_right(points, end)
    counts.append(right - left)

print("\n".join(map(str, counts)))

💡TIL

• 점 좌표를 정렬하는데는 시간복잡도가 $O(N \log N)$이고, 2개의 이진탐색을 $M$번 반복하는 것의 시간복잡도는 $O(M \log N)$이다.
• 최종 시간 복잡도는 $O(N \log N + M \log N)$이다.

백준 #2343. 기타 레슨: DP / 실버1

정리한 링크: (바로가기)

🚩플로우 (선택)

• 블루레이 강의의 수 $N$
  블루레이 개수 $M$

• 가능한 블루레이의 크기 중 최소를 출력한다.

• 조건

  • 강의 순서는 바뀌지 않아야 한다.
  • $M$개의 블루레이로 모든 강의를 나눌 수 있어야 한다.
  • 모든 블루레이는 같은 쿠기를 가져야 한다.

• 예제 입출력

  # 예제 입력
  9 3 
  1 2 3 4 5 6 7 8 9
  
  # 예제 출력
  17

  • 강의는 총 9개이고, 블루레이는 총 3개 가지고 있다.
  • 1번 블루레이에 1,2,3,4,5 / 2번 블루레이에 6,7,3 / 3번 블루레이에 8,9를 넣으면 각 블루레이의 크기는 15, 13, 17이 된다. 블루레이의 크기는 모두 같아야 하기 때문에, 블루레이의 크기는 17이 된다. 17보다 더 작은 크기를 가지는 블루레이를 만들 수 없다.

• 블루레이의 크기가 탐색 대상이다.

  • start = max(time): 블루레이의 크기가 최소가 되려면, 가장 긴 강의의 길이가 기준이다. 가장 긴 강의보다 블루레이가 작으면 그 강의를 담을 수 없기 때문이다.
  • end = sum(time): 블루레이의 크기가 최대가 되려면, 모든 강의를 하나의 블루레이에 담아야 하므로, 강의 길이의 합이 기준이다.

• 이진 탐색으로 start와 end 사이의 중간값을 설정해, 블루레이 크기를 제한하며 조건을 만족하는지 확인한다.

  • mid를 블루레이 크기로 설정했을 때, 블루레이에 강의를 나누어 담는다.
  • 강의를 나눴을 때 블루레이 개수가 $M$ 이하라면, 크기를 줄여서 더 작은 블루레이 크기를 탐색한다.
  • 블루레이 개수가 $M$을 초과하면 크기를 늘려야 하므로, 더 큰 블루레이 크기를 탐색한다.

🚩제출한 코드

import sys 
input = sys.stdin.readline

N, M = map(int, input().split()) # 강의의 수, 블루레이의 수 
time = list(map(int, input().split())) # 강의의 길이 

# time.sort() # 강의의 순서가 바뀌면 안됨 

# 탐색 대상: 블루레이의 크기 
start = max(time)
end = sum(time) 

while start <= end:
    mid = (start + end) // 2 
    
    total = 0 # 현재 블루레이에 담은 강의 길이  
    count = 1  # 블루레이 개수
    for t in time:
        if total + t > mid: # 블루레이의 크기를 초과하는 경우 
            count += 1 # 블루레이 개수 증가
            total = 0 # 블루레이에 담은 강의 길이 초기화
        total += t # 블루레이에 강의 추가
    
    # 블루레이 개수를 확인하고 이진탐색 범위 조정
    if count <= M: 
        answer = mid # 가능한 블루레이 크기 저장
        end = mid - 1 
    else: 
        start = mid + 1 

print(answer)

💡TIL

• 강의의 수가 최대 10만개, 강의의 길이는 최대 10,000분, 블루레이의 최소 개수가 1개이기 때문에 가능한 블루레이의 크기는 최대 10만*10,000 = 10억이다. 선형 탐색이 시간이 오래 걸리기 때문에 이분 탐색을 고려할 수 있다.
• $O(N * \log(sum(time) - max(time)))$
  • 가능한 블루레이의 크기 범위는 [max(time), sum(time)] 이다. 탐색 범위가 절반씩 줄어들기 때문에 $O(\log(sum(time) - max(time)))$이다.
  • 각 탐색 단계에서 강의 배열을 한번 순회하므로 $O(N)$이다.
• 이진탐색 문제를 풀 때는 탐색 대상, 그 대상의 범위가 무엇인지부터 정의해야한다는 것을 잊지 말아야 한다.
• 문제를 이해하는 것이 어려웠다. 접근법을 찾아보고도 그를 코드로 구현할 방법을 떠올리지 못했던 것 같다. 강의를 순서대로 담고, 블루레이의 크기에 따라 개수와 길이를 조정하는 것을 어떻게 구현했는지 잘 기억해놓으면 좋을 것 같다.