놀러오세요 엘피의 숲

[Programmers/Lv. 2/Python] 완전범죄

elffffy — Mon, 6 Jul 2026 19:20:51 +0900

문제 정보

난이도	Lv. 2
유형	DP (0/1 배낭)
언어	Python
플랫폼 / 제목	Programmers / 완전범죄

문제 분석

A도둑과 B도둑이 물건을 나눠 훔치는데, 물건 i를 A가 훔치면 A흔적에 info[i][0], B가 훔치면 B흔적에 info[i][1]이 쌓인다.
A흔적 합이 n 이상이거나 B흔적 합이 m 이상이면 잡힌다.

풀이 아이디어

dp[x]: 지금까지 처리한 물건 중 A흔적 합이 정확히 x일 때, 나머지(B흔적 합)의 최솟값.
물건마다 두 가지 전이만 존재한다
- B가 훔치는 경우: A흔적(x)은 그대로, B흔적에 b를 더함
- A가 훔치는 경우: A흔적이 a만큼 늘어난 자리로 이동, B흔적은 그대로 유지
매 물건 처리 시 next_dp를 INF로 새로 초기화해야한다.

코드

"""
dp[x] : A 흔적이 x일 때 만들 수 있는 최소 B 흔적

1. 초기 상태
n = 5라면, [0, INF, INF, INF, INF]

2. 첫 번째 물건를 본다  (a, b = 2, 3)
- B가 훔치면: A 흔적 유지, B 흔적 0 + 3 = 3 => dp[0] = 3
- A가 훔치면 : A 흔적 0 + 2 = 2로 이동, B 흔적은 그대로 => dp[2] = 0
[3, INF, 0, INF, INF]

3. 두 번째 물건을 본다 (a, b = 1, 2)
- dp[0] = 3에서
    - B 선택 시 dp[0] = 3 + 2 = 5
    - A 선택 시 dp[1] = 3
- dp[2] = 0에서
    - B 선택 시 dp[2] = 0 + 2 = 2
    - A 선택 시 dp[3] = 0
[5, 3, 2, 0, INF]

0/1 배낭 DP의 핵심: 물건마다 A행/B행 둘 중 정확히 하나만 선택 (동시에 두 값을 더하는 게 아님)
"""


def solution(info, n, m):
    INF = float('inf')
    dp = [INF] * n
    dp[0] = 0

    for a, b in info:
        next_dp = [INF] * n

        for x in range(n):
            if dp[x] == INF:
                continue

            # 1. B가 훔치는 경우
            if dp[x] + b < m:
                next_dp[x] = min(next_dp[x], dp[x] + b)

            # 2. A가 훔치는 경우
            if x + a < n:
                next_dp[x + a] = min(next_dp[x + a], dp[x])

        dp = next_dp

    for x in range(n):
        if dp[x] < m:
            return x

    return -1

⏱️ 시간/공간 복잡도

시간 복잡도	O(len(info) × n) — 물건마다 n칸을 순회
공간 복잡도	O(n)

배운 점 / 실수했던 부분

처음엔 b가 큰 물건부터 정렬해서 B에 최대한 채우고 못 들어가면 A로 넘기는 그리디로 접근했으나, 이미 B에 배정한 물건을 나중에 재고할 수 없어 반례에서 실패했다
DP 문제인 지 몰랐는데... 내가 제일 못하는 문제였다... 어렵다... 답을 봐도 이해까지 시간이 꽤 걸린다...

DP 고수분들 기다리겠습니다,,,

잘하는 법 알고싶습니다...

DP 극복해야만 해

[Programmers/Lv. 2/Python] 바이러스 파이프

elffffy — Fri, 3 Jul 2026 16:12:11 +0900

문제 정보

난이도	Lv. 2 / 2025 카카오 하반기 1차
유형	완전탐색, DFS/그래프 탐색, 트리
언어	Python
플랫폼 / 제목	Programmers / 바이러스 파이프

문제 분석

n개의 배양체가 n-1개의 파이프로 트리 형태로 연결되어 있고, 하나의 배양체가 처음부터 감염되어 있다.
파이프는 종류 단위로만 열고 닫을 수 있고, 열려 있는 동안 감염이 인접 노드로 전파된다.

풀이 아이디어

파이프 타입별로 인접 리스트 arr[node][type]를 만들어, 특정 타입을 열었을 때 해당 타입 간선만 따라 감염이 퍼지도록 구성한다.
k번의 행동을 (A, B, C)의 길이 k 중복순열로 모두 나열하고 product([1,2,3], repeat=k), 각 순열대로 순서대로 파이프를 열어 감염 상태를 갱신한 뒤 감염 수의 최댓값을 추적한다.

코드

from itertools import product


def infect(arr, opened, start, pipe):
    if not arr[start][pipe]:
        return

    for next_n in arr[start][pipe]:
        if opened[next_n] == 1: continue
        opened[next_n] = 1
        infect(arr, opened, next_n, pipe)

    return


def solution(n, infection, edges, k):
    arr = [[[] for _ in range(4)] for _ in range(n + 1)]

    for x, y, c_type in edges:
        arr[x][c_type].append(y)
        arr[y][c_type].append(x)

    pipes_candidates = product([1, 2, 3], repeat=k)
    answer = 1

    for pipes_candidate in pipes_candidates:
        opened = [0] * (n + 1)
        opened[infection] = 1

        for pipe in pipes_candidate:
            for i in range(1, n + 1):
                if opened[i] == 1:
                    infect(arr, opened, i, pipe)

        cnt = sum(opened)
        answer = max(answer, cnt)

    return answer

⏱️ 시간/공간 복잡도

시간 복잡도	O(3^k · k · n) - 후보 개수 3^k, k번 파이프 개방 × 매번 노드 최대 n개 순회 + DFS 전파
공간 복잡도	O(n)

배운 점 / 실수했던 부분

itertools.permutations(iterable, r)은 중복 순열이 아니다! product를 써야한다!!!
현재 내 코드는.. 매우 비효율적이다.
- 검색을 해보면, 비트마스크, 큐 BFS, 메모이제이션 등 다양한 해결 방법이 있어보인다..
- product로 전체 후보를 만드는 것이 아니라, DFS/백트래킹 구조로 체크를 해야한다.
- 각 단계에서 갈 수 있는 방향으로 하나씩 끝까지 가보고, 돌아올 때마다 지금까지 본 것 중 최댓값을 챙겨서 위로 넘긴다.
- 이렇게 한다면 시간 복잡도는 O(n · 2^k)가 된다!

from collections import deque
from itertools import product


def infect(arr, opened, pipe, n):
    q = deque(i for i in range(1, n + 1) if opened[i])
    while q:
        cur = q.popleft()
        for next_n in arr[cur][pipe]:
            if not opened[next_n]:
                opened[next_n] = 1
                q.append(next_n)


def solution(n, infection, edges, k):
    arr = [[[] for _ in range(4)] for _ in range(n + 1)]
    for x, y, c_type in edges:
        arr[x][c_type].append(y)
        arr[y][c_type].append(x)

    def dfs(depth, last_pipe, opened):
        cnt = sum(opened)
        best = cnt                      

        if cnt == n or depth == k:
            return best

        for pipe in (1, 2, 3):
            if pipe == last_pipe:
                continue
            new_opened = opened[:]
            infect(arr, new_opened, pipe, n)
            best = max(best, dfs(depth + 1, pipe, new_opened))

        return best

    opened = [0] * (n + 1)
    opened[infection] = 1
    return dfs(0, 0, opened)

pipe=1 박스는 두 자식들 중에서 큰 값을 받아서, depth가 0인 박스로 올려보낸다.

[Programmers/Lv. 2/Python] 지게차와 크레인

elffffy — Thu, 2 Jul 2026 16:50:29 +0900

문제 정보

난이도	Lv. 2/ 2025 프로그래머스 코드챌린지 1차 예선
유형	BFS, 시뮬레이션, 구현
언어	Python
플랫폼 / 제목	Programmers / 지게차와 크레인

문제 분석

n×m 창고에 알파벳으로 구분되는 컨테이너가 놓여 있고, 요청이 들어올 때마다 특정 종류를 꺼낸다.
요청 문자열 길이가 1이면 지게차 출고, 길이가 2면 크레인 출고

풀이 아이디어

memo로 제거된 칸을 표시하고, 크레인 요청은 storage[y][x] == delete_w인 칸을 위치 상관없이 바로 제거한다.
지게차 요청 직전마다 get_border()로 BFS를 새로 돌려서 외부와 연결된 칸을 구한다.
is_border(board, y, x)로 해당 칸이 격자 테두리 자체이거나, 이웃 중 하나라도 외부와 이어진 칸이라면 접근 가능한 것으로 판정 후 제거한다.

코드

from collections import deque


def solution(storage, requests):
    n, m = len(storage), len(storage[0])
    memo = [[0] * m for _ in range(n)]

    answer = n * m
	
    # 빈 칸들 중에서 어디가 외부와 진짜로 뚫려있는지 표시하기
    def get_border():
        visited = [[0] * m for _ in range(n)]
        q = deque()

        for y in range(n):
            for x in range(m):
                if (y == 0 or x == 0 or y == n - 1 or x == m - 1) and memo[y][x] == 1:
                    visited[y][x] = 1
                    q.append((y, x))

            dy = [-1, 1, 0, 0]
            dx = [0, 0, -1, 1]

            while q:
                cy, cx = q.popleft()
                for i in range(4):
                    ny, nx = dy[i] + cy, dx[i] + cx
                    if ny < 0 or nx < 0 or ny >= n or nx >= m: continue
                    if memo[ny][nx] != 1: continue
                    if visited[ny][nx] == 1: continue

                    visited[ny][nx] = 1
                    q.append((ny, nx))

        return visited
	
    # 컨테이너가 있는 칸을 지게차로 꺼낼 수 있는지 판단하기
    def is_border(board, y, x):
        if y == 0 or x == 0 or y == n - 1 or x == m - 1:
            return True

        dy = [-1, 1, 0, 0]
        dx = [0, 0, -1, 1]

        for i in range(4):
            ny, nx = dy[i] + y, dx[i] + x
            if board[ny][nx] == 1:
                return True

        return False

    for request in requests:
        if len(request) == 2:
            delete_w = request[0]
            for y in range(n):
                for x in range(m):
                    if memo[y][x] == 1: continue
                    if storage[y][x] == delete_w:
                        memo[y][x] = 1
                        answer -= 1

        else:
            board = get_border()
            for y in range(n):
                for x in range(m):
                    if board[y][x] == 1: continue
                    if not is_border(board, y, x): continue
                    if storage[y][x] == request:
                        memo[y][x] = 1
                        answer -= 1

    return answer

⏱️ 시간/공간 복잡도

시간 복잡도	O(R × n × m) - 요청 R개마다 지게차면 BFS
공간 복잡도	O(n × m)

배운 점 / 실수했던 부분

BFS에서는 큐를 활용할 것!!!
처음에는 이웃 칸이 비어있는지만 보고 접근 가능 여부를 판단했는데, 그 빈 칸 자체가 외부와 단절된 고립 공간일 수 있어 오답이었음..

12. DI와 DIP

elffffy — Fri, 26 Jun 2026 22:23:30 +0900

※ 이 글은 인프런 강의를 수강하며
개인 학습 목적으로 이해한 내용을 정리한 글입니다.

1️⃣ Dependency Injection(DI)란?

메인 모듈이 직접 의존 객체를 생성하지 않고, 외부(injector)에서 주입받는 설계 패턴

Dependency Injection / https://miro.medium.com/1*Nd1aRAjjIfY8M0Xjb1xBVw.gif

외부에서 주입받는 구조로 만들면

모듈 간 결합도를 낮추고 구현체를 유연하게 교체할 수 있습니다.

코드로 바로 살펴봅시다!

우선, DI가 없는 버전입니다.

class BackendDeveloper:
    def coding(self):
        print("백엔드 개발자 : use Java")

class FrontendDeveloper:
    def coding(self):
        print("프론트엔드 개발자: use JavaScript")

class Project:
    def __init__(self):
        self.backend = BackendDeveloper()
        self.frontend = FrontendDeveloper() 

    def implement(self):
        self.backend.coding()
        self.frontend.coding()

project = Project()
project.implement()

Project가 BackendDeveloper와 FrontendDeveloper를 생성합니다.

하지만, 백엔드 개발자를 AI 개발자로 바꾸고 싶다면,

Project 내부 코드를 직접 수정해야 하죠

또한, 클래스 간 결합이 강해 유지보수와 테스트가 어려워지기도 합니다...

그럼, 이제 DI를 적용한 버전을 한 번 볼까요?

class BackendDeveloper:
    def coding(self):
        print("백엔드 개발자 : use Java")

class FrontendDeveloper:
    def coding(self):
        print("프론트엔드 개발자 : use JavaScript")

class Project:
    def __init__(self, *developers): 
        self.developers = developers

    def implement(self):
        for dev in self.developers:
            dev.coding()

project = Project(BackendDeveloper(), FrontendDeveloper())
project.implement()

Project는 누가 들어올 지 전혀 모르는 구조입니다.

어떤 개발자든 외부에서 넣어주기만 하면, 실행할 뿐인데요!

예를 들어, AIDeveloper()를 추가하더라도

해당 클래스만 새로 만들면 될 뿐, 기존의 Project 코드는 수정하지 않아도 됩니다.

이처럼 의존성을 외부에서 주입하는 것이 DI의 핵심입니다!

DI의 단점으로는 복잡도가 증가하고 종속성 관련 에러를 추적하기 어려울 수 있습니다.

하지만, 구현체 교체가 자유롭고, 단위 테스트와 마이그레이션이 쉬워지며,

코드 흐름을 추론하기도 훨씬 편해진다는 강력한 장점이 있습니다!

2️⃣ Dependency Inversion Principle(DIP) 란?

‍♀️ "그런데 잠깐, Project가 여전히 하위 클래스에 의존하고 있는거 아닌가요?"

맞습니다!

예를 들어, coding 메서드가 deleting 메서드로 바뀐다면, 런타임에서 에러가 납니다.

이걸 설계 단계에서 막아주는 원칙이 바로 DIP입니다.

의존 관계 역전 원칙은 다음 두 가지의 규칙을 따릅니다.

상위 모듈은 하위 모듈에 의존해서는 안 된다. 둘 다 추상화에 의존해야 한다.
추상화는 세부 사항에 의존해서는 안 된다. 세부 사항이 추상화를 따라야 한다.

즉, "구체적인 클래스 말고, 인터페이스만 바라봐"라는 뜻인데요,

DIP가 적용된 버전을 보겠습니다!

from abc import ABC, abstractmethod

class Developer(ABC):      
    @abstractmethod
    def coding(self):
        pass

class BackendDeveloper(Developer):
    def coding(self):
        print("백엔드 개발자 : use Java")

class FrontendDeveloper(Developer):
    def coding(self):
        print("프론트엔드 개발자 : use JavaScript")

class Project:
    def __init__(self, *developers: Developer):
        self.developers = developers

    def implement(self):
        for dev in self.developers:
            dev.coding()

project = Project(BackendDeveloper(), FrontendDeveloper())
project.implement()

이제 Developer를 상속받지 않은 클래스는

coding()을 반드시 구현했다는 보장이 없으므로, 애초에 설계 단계에서 걸러낼 수 있습니다.

Project는 구체적인 클래스가 무엇인지 전혀 몰라도 되고,

Developer라는 약속만 지키면 누구든 주입할 수 있게 됩니다!

마무리

오늘도 다소 어려운 개념을 공부한 것 같다.

코드와 함께 보니 확실히 이해는 좀 더 빠르게 된 것 같지만,,,

프로젝트 클래스 설계할 일이 있다면,

DI 구조와 DIP 원칙을 떠올릴 수 있으면 좋을 것 같다!

[토이 PJT #1] VLM이란? - 이미지를 이해하는 AI 만들기

elffffy — Fri, 26 Jun 2026 20:56:57 +0900

발표를 들을 때,

말로만 설명하는 것보다

말과 시각자료가 함께할 때 더 오래 기억에 남지 않으신가요?

발표에 ppt 빠지면 섭섭하지~

우리가 AI에게 질문할 때도

이미지와 함께 물어본다면 어떨까요?

지난 글에서 소개한 영화 챗봇 프로젝트, 기억하시나요?

(보고 오시는 걸 추천드립니다 )

[토이 PJT #1] RAG란? - 검색해서 답하는 AI 만들기

"몸이 아프다" 하면 병원을 가죠.기침이랑 열이 난다 → 내과귀가 좀 아프다 → 이비인후과충치 때문에 아프다 → 치과넘어져서 골절됐다 → 정형외과증상에 따라 우리는 다른 원을 찾아갑니다.

elffffy.tistory.com

이 챗봇은 질문의 유형에 따라 네 가지 방식으로 처리합니다.
그 중 이미지가 첨부된 질문은 VLM 경로로 전달되는데요!

오늘은 VLM이 무엇인지,
그리고 어떤 흐름으로 동작하는지 함께 살펴보겠습니다!

1️⃣ VLM이 뭔가요?

Vision Language Model의 줄임말로, 이미지와 언어를 함께 이해하는 AI 모델

기존 LLM은 텍스트만 이해합니다.

그렇기 때문에

"이 포스터 무슨 영화야?"

처럼 이미지를 바탕으로 한 질문에는 답하지 못합니다...

하지만, 시각 언어 모델인 VLM은 가능한데요!

크게 세 가지 단계로 동작합니다.

이미지 인코딩 : 이미지를 숫자 벡터로 변환합니다.
입력 결합 : 텍스트 질문과 이미지 벡터를 함께 모델에 입력합니다.
답변 생성 : 텍스트와 이미지 맥락을 동시에 고려해서 답변을 생성합니다.

이러한 단계를 통해 AI는 이미지를 이해하게 됩니다!

그럼, 이제부터!

구체적인 VLM의 흐름에 대해 한 번 살펴볼까요?

2️⃣ VLM 흐름 살펴보기

✨ 1단계 : 이미지 인코딩

VLM 모델이 이미지를 이해할 수 있도록 숫자 벡터로 변환하는 과정이 필요합니다!

‍♀️ "파일 경로를 던져주면 안되나요?"

네, 안됩니다!

파일 경로를 넘기면,

서버가 직접 파일을 읽어야 하고,

URL을 넘기면 외부 접근이 필요하게 됩니다.

주로 Base64 인코딩 방식을 사용합니다.

이미지 바이너리 데이터를 텍스트 문자열로 변환해서 그대로 API에 실어 보내는 방식입니다!

✨ 2단계 : 멀티모달 메시지 구성

이미지 벡터와 텍스트 질문을 하나의 메시지로 합치는 과정입니다.

여기서 중요한 것은,

텍스트 질문과 이미지를 하나의 메시지 객체로 묶어서 전달한다는 것인데요!

따로 보내면,

모델은 텍스트와 이미지 사이의 관계를 파악할 수 없게 됩니다

✨ 3단계 : 생성

모델이 이미지와 텍스트 맥락을 동시에 고려해 답변을 만들어내는 과정입니다.

일반 LLM과 달리,

VLM은 이미지 속 색감, 구도, 텍스트까지 함께 읽고,

그 맥락을 녹여서 답변을 생성합니다!

그래서 영화 포스터를 함께 첨부한다면,

장르, 분위기, 등장인물까지 추론해서 답을 해줄 수 있는 것이죠!

단순히 읽는 AI가 아닌, 읽고 보는 AI.

바로 VLM입니다.

다음 글에서는 RAG와 VLM을 활용한 챗봇에 대해 살펴보도록 하겠습니다!

그럼... 이만!

[Programmers/Lv. 2/Python] 비밀 코드 해독

elffffy — Fri, 26 Jun 2026 17:17:12 +0900

문제 정보

난이도	Lv. 2 / 2025 프로그래머스 코드챌린지 1차 예선
유형	완전탐색, 조합
언어	Python
플랫폼 / 제목	Programmers / 비밀 코드 해독

문제 분석

1~n 사이 숫자 중 5개를 고른 비밀코드가 있고, q번의 힌트가 주어진다.
모든 힌트 조건을 동시에 만족하는 5개 조합의 경우의 수를 구한다.

풀이 아이디어

combinations(1..n, 5)로 후보 조합을 전부 생성한다.
각 후보에 대해 모든 쿼리를 순회하고 모든 쿼리를 통과한 후보만 카운트 한다.
내부 교집합 계산은 set 연산 case_set & query_set을 쓰면 정렬 순서에 무관하게 정확하다.

코드

from itertools import combinations


def solution(n, q, ans):
    nums = [i for i in range(1, n + 1)]
    possible_cases = list(combinations(nums, 5))
    answer = 0

    for case in possible_cases:
        check = 0
        for i in range(len(q)):
            cnt = 0
            case_set = set(case)
            query_set = set(q[i])

            cnt += len(case_set & query_set)

            if cnt == ans[i]:
                check += 1

        if check == len(q):
            answer += 1

    return answer

⏱️ 시간/공간 복잡도

시간 복잡도	O(C(n,5) × len(q))
공간 복잡도	O(C(n,5))

배운 점 / 실수했던 부분

내부 이중 루프에서 if x < y: break는 배열이 정렬되어 있다고 암묵적으로 가정해야한다.
& 연산자로 교집합을 구하려면 양쪽 모두 set이어야 한다.
list/tuple이 섞이면 .intersection()을 쓰자!!!

[토이 PJT #1] RAG란? - 검색해서 답하는 AI 만들기

elffffy — Thu, 25 Jun 2026 22:35:18 +0900

아플 땐 병원을 가시오.

"몸이 아프다" 하면 병원을 가죠.

기침이랑 열이 난다 → 내과
귀가 좀 아프다 → 이비인후과
충치 때문에 아프다 → 치과
넘어져서 골절됐다 → 정형외과

증상에 따라 우리는 다른 원을 찾아갑니다.

이번에 만들어본 토이 프로젝트도 똑같은 구조입니다!

영화를 주제로 질문이 들어오면,

AI가 자동으로 질문 유형을 판단해서

네 가지 처리 방식 중 하나로 보내주는 구조예요.

그 네 가지 중 오늘 집중적으로 다룰 건 RAG입니다!

지금부터 알아보겠습니다!

1️⃣ RAG가 뭔가요?

Retrieval-Augmented Generation의 줄임말로,
관련 문서를 먼저 검색해온 뒤, 그 내용을 바탕으로 AI가 답변을 생성하는 방식

‍♂️ 그럼, ChatGPT나 Cluade랑 똑같은 거 아닌가? 하는 생각이 들 수도 있지만,,,

아닙니다!

위와 같은 LLM은 학습 데이터를 기반으로 답변을 하기 때문에,

학습 데이터에 없는 정보는 그럴 듯하게 지어내서 답을 제공해주는 경우도 있습니다..

RAG는 이 할루시네이션 문제를 이렇게 해결합니다!

➡️ 답하기 전에 먼저 관련 문서를 찾고, 그 문서를 참고해서 답하자.

얼마나 똑똑하게요,,, 이 녀석은 헛소리 하지 않는다는 뜻이죠.

??: 헛소리 하지마 임마 / RAG:네, 형.

크게 두 단계로 나뉩니다.

Retrieval (검색) : 사용자 질문과 관련된 문서 조각을 벡터 DB에서 꺼내온다.
Generation (생성) : 꺼내온 문서를 context로 넣어서 LLM이 답변을 만든다.

이러한 단계를 통해 신뢰할 수 있는 답변을 사용자에게 제공하게 됩니다!

다음으로,

RAG의 흐름에 대해 한 번 살펴볼까요?

2️⃣ RAG 흐름 살펴보기

✨ 1단계 : 문서 준비 · 청킹

AI가 참고할 문서를 준비하는 단계입니다!

PDF, 웹페이지, DB 등 다양한 소스에서 텍스트를 가져온 뒤, 이를 적당한 크기로 잘라냅니다.

이 과정을 청킹(Chunking) 이라고 합니다!

텍스트를 자를 때,

너무 길면 하나의 벡터에 너무 많은 의미가 섞여 핵심을 잃고,

너무 짧으면 문장이 끊겨서 맥락이 사라지기 때문에

적절한 단위로 나누는 게 중요합니다.

실무에서는 보통100~500 토큰 단위로 자르고, 청크 간에 약간 겹치게 설정해서 문장이 끊기는 걸 방지하기도 해요!

✨ 2단계 : 임베딩 · 벡터 저장

잘라낸 텍스트 조각들을 숫자 벡터로 변환해야 합니다.

이 과정을 임베딩(Embedding) 이라고 합니다!

의미가 비슷한 텍스트는 벡터 공간에서 가까이 위치하게 되는데,

변환된 벡터는 Vector DB에 저장해두고, 나중에 빠르게 검색할 수 있도록 준비합니다.

Vector DB/https://weaviate.io/assets/images/vector-search-c9852b39f62abb6122b2123e6d5f7ed5.jpg

✨ 3단계 : 검색

사용자의 질문이 들어오면,

그 질문도 동일한 방식으로 벡터로 변환합니다.

그리고 Vector DB에서 이 벡터와 가장 유사한 문서 조각들을 찾아냅니다.

이 과정이 바로 RAG의 "R"을 담당하고 있는 Retrieval 검색입니다!

✨ 4단계 : 생성

검색된 문서 조각들을 사용자의 질문과 함께 LLM에게 전달합니다.

LLM은 이 자료를 바탕으로 답변을 생성하게 됩니다!

이 과정이 바로 RAG의 "G"를 담당하고 있는 Generation 생성입니다!

무엇이든 아는 척 답하는 AI가 아니라,

관련 문서를 찾아보고 그 범위 안에서만 답하게 만드는 것!

그것이 바로 RAG의 핵심입니다.

다음 글에서는 텍스트가 아닌 이미지를 이해하는 AI, VLM을 다루도록 하겠습니다!

이상 끝!

[Programmers/Lv. 2/Python] 서버 증설 횟수

elffffy — Thu, 25 Jun 2026 16:12:27 +0900

문제 정보

난이도	Lv. 2 / 2025 프로그래머스 코드챌린지 2차 예선
유형	그리디, 시뮬레이션
언어	Python
플랫폼 / 제목	Programmers / 서버 증설 횟수

문제 분석

0~23시 24개 시간대에 시간당 접속자 수 players[t]가 주어진다.
서버 1대는 m명을 처리하며 증설 후 k시간 뒤 자동 반납된다.

풀이 아이디어

server_time_limit[t + k] = new_server_cnt로 만료 시각을 키, 반납 대수를 값으로 딕셔너리에 기록해두고, 매 시간대 시작 시 해당 키가 있으면 server_cnt에서 뺀다.
현재 시각 t에서 필요한 총 서버 수는 players[t] // m이고, 이미 server_cnt대가 돌고 있으므로 new_server_cnt = players[t] // m - server_cnt만큼만 증설한다.

코드

from collections import defaultdict


def solution(players, m, k):
    answer = 0
    server_cnt = 0
    server_time_limit = defaultdict()

    for t in range(24):
        if t in server_time_limit.keys():
            server_cnt -= server_time_limit[t]
        if players[t] < m or players[t] < m * server_cnt + 1:
            continue

        new_server_cnt = players[t] // m - server_cnt
        if new_server_cnt:
            server_cnt += new_server_cnt
            answer += new_server_cnt
            server_time_limit[t + k] = new_server_cnt

    return answer

⏱️ 시간/공간 복잡도

시간 복잡도	O(1)
공간 복잡도	O(k)

배운 점 / 실수했던 부분

처음에 현재 가동 중인 서버 수를 빼지 않았었다. 이미 server_cnt대가 돌고 있다는 점을 유의하자!!
반납 시간을 기록하기 위해서 처음에는 리스트로 관리하고자 했으나, 만료시각과 반납 대수를 함께 정리해야 했으므로 딕셔너리를 활용했다.

[Programmers/Lv. 1/Python] 노란불 신호등

문제 정보난이도Lv. 1 / 2025 카카오 하반기 1차유형수학, 브루트포스, LCM언어Python플랫폼 / 제목Programmers / 노란불 신호등 문제 분석n개의 신호등이 각각 초록 → 노란 → 빨간 순서로 반복되

elffffy.tistory.com

어제 풀었던 1단계 노란불 신호등보다 2단계 서버 증설 횟수가 더 쉬운 느낌이랄까..?

물론, 문제를 읽고 고민하는 시간은 있었지만,

난이도 설정이 조금 잘못되어 있는 것 같다..ㅇㅇ..

[Programmers/Lv. 1/Python] 노란불 신호등

elffffy — Wed, 24 Jun 2026 21:37:44 +0900

문제 정보

레벨 1일리가 없어.. 없다고!!!!

난이도	Lv. 1 / 2025 카카오 하반기 1차
유형	수학, 브루트포스, LCM
언어	Python
플랫폼 / 제목	Programmers / 노란불 신호등

문제 분석

n개의 신호등이 각각 초록 → 노란 → 빨간 순서로 반복되며, 모든 신호등이 동시에 노란불이 되는 가장 빠른 시각을 구한다.
신호등마다 주기가 다르고, 동시에 노란불인 경우가 없으면 -1을 반환한다.

풀이 아이디어

각 신호등의 주기를 구하고, 전체 주기의 LCM을 탐색 limit으로 설정한다.
매 시각 time마다 yellow_start = time % period를 계산해, G < yellow_start <= G+Y 범위이면 노란불로 판별한다.

코드

def minimal_common(a, b):
    for i in range(max(a, b), (a * b) + 1):
        if i % a == 0 and i % b == 0:
            return i


def solution(signals):
    plus = [sum(signal) for signal in signals]

    limit = plus[0]
    for p in plus[1:]:
        limit = minimal_common(limit, p)

    check = 0
    for time in range(2, limit + 1):
        for i in range(len(signals)):
            signal = signals[i]
            yellow_start = time % plus[i]
            if signal[0] < yellow_start <= signal[0] + signal[1]:
                check += 1
            else:
                break

        if check == len(signals):
            return time
        else:
            check = 0

    return -1

⏱️ 시간/공간 복잡도

시간 복잡도	O(n)
공간 복잡도	O(n)

배운 점 / 실수했던 부분

이게 레벨 1..? 절대 그럴 일 없다.. 없어...
minimal_common대신 math.lcm()을 활용할 수 있다.
limit을 무엇으로 할까에 대해 고민을 많이 했었다. 모든 신호등의 초+노+빨 불의 합을 구하고, 그 값들의 최소공배수가 limit이 되는 걸 명심하자!!!

[Programmers/Lv. 3/Python] 파괴되지 않은 건물

elffffy — Sun, 21 Jun 2026 18:17:22 +0900

문제 정보

난이도	Lv. 3
유형	2차원 누적합, 구간 업데이트
언어	Python
플랫폼 / 제목	Programmers / 파괴되지 않은 건물

문제 분석

board에 건물 내구도가 주어지고, 여러 스킬이 각각 사각형 범위에 일정 수치만큼 내구도를 증감시킨다.
모든 스킬을 적용한 뒤, 내구도가 0보다 큰 건물의 개수를 구해야 한다.

풀이 아이디어

(n+1) × (m+1) 크기의 memo 배열을 두고, 스킬마다 사각형의 네 모서리에만 부호를 맞춰 표시한다.
이후 memo를 가로 방향 누적합 → 세로 방향 누적합 순으로 두 번 훑으면, 각 칸에 실제로 적용된 변화량이 복원된다.
마지막으로 board[y][x] + memo[y][x] > 0인 칸의 개수를 센다.

코드

def solution(board, skill):
    n, m = len(board), len(board[0])
    memo = [[0] * (m + 1) for _ in range(n + 1)]

    for s_type, y1, x1, y2, x2, degree in skill:
        if s_type == 1:
            memo[y1][x1] -= degree
            memo[y1][x2 + 1] += degree
            memo[y2 + 1][x1] += degree
            memo[y2 + 1][x2 + 1] -= degree
        else:
            memo[y1][x1] += degree
            memo[y1][x2 + 1] -= degree
            memo[y2 + 1][x1] -= degree
            memo[y2 + 1][x2 + 1] += degree

    for y in range(n + 1):
        for x in range(m + 1):
            if x == 0: continue
            memo[y][x] += memo[y][x - 1]

    for x in range(m + 1):
        for y in range(n + 1):
            if y == 0: continue
            memo[y][x] += memo[y - 1][x]

    answer = 0
    for by in range(n):
        for bx in range(m):
            final_v = board[by][bx] + memo[by][bx]
            if final_v > 0:
                answer += 1

    return answer

⏱️ 시간/공간 복잡도

시간 복잡도	O(s + n×m)
공간 복잡도	O(n×m)

배운 점 / 실수했던 부분

어머, 이게 뭐야!!!!

처음 코드는 스킬마다 사각형 범위를 직접 이중 for문으로 순회하며 memo에 누적했다.

값을 바로 board에 더하지 않고 memo에 모아뒀다가 나중에 더하기 라는 아이디어 자체는 맞았지만,

기록하는 행위 자체가 이미 사각형 전체를 순회하고 있어서 최적화 효과가 전혀 없었다.

핵심은 기록 자체를 O(1)로 만드는 것이였다.

2차원 사각형에서는 네 모서리에 부호를 맞춰 표시하고

가로·세로 누적합을 각각 한 번씩 적용하는 방식으로 확장해야 한다는 걸 새로 배웠다.

이때, 부호를 설정할 때 오류가 생기기 좋으니,

부호를 외우기보다 누적합이 어떻게 상쇄되는지 원리로 이해해야 실수를 줄일 수 있을 것 같다.