문제: 자연수 $n$이 주어질 때, 이를 연속된 자연수들의 합으로 표현하는 방법의 수를 구하라. 예시: $n = 15$일 때, $1 + 2 + 3 + 4 + 5 = 15$ $4 + 5 + 6 = 15$ $7 + 8 = 15$ $15 = 15$ 총 4가지 방법 존재.

풀이

완전탐색을 이용한 풀이, 투포인터를 사용한 풀이가 가능하다.

1️⃣ 완전 탐색 (Brute Force)

가장 직관적인 방법은 $1$부터 시작해서 $n$까지 각 숫자를 '시작점'으로 잡고, 숫자를 하나씩 더해가며 $n$이 되는지 확인하는 것이다.

• 1을 시작으로 하는 연속된 자연수들
• 2를 시작으로 하는 연속된 자연수들
• ...
• $n$을 시작으로 하는 연속된 자연수들

풀이 로직

1. $i$를 $1$부터 $n$까지 반복합니다 (연속된 수의 시작점).
2. $i$부터 시작해서 $i + 1, i + 2, \dots$를 차례대로 더합니다.
3. 합이 $n$과 같아지면 카운트를 1 증가시키고 다음 시작점($i+1$)으로 넘어갑니다.
4. 합이 $n$을 초과하면 더 이상 더할 필요가 없으므로 중단하고 다음 시작점으로 넘어갑니다.

💻 풀이 코드 (완전 탐색)

def solution(n):
    answer = 0
    for i in range(1, n + 1):
        total = 0
        for j in range(i, n + 1):
            total += j
            if total == n:
                answer += 1
                break
            if total > n:
                break
    return answer

2️⃣ 투 포인터(Two Pointers)

투 포인터는 주로 정렬된 배열에서 연속된 구간의 합을 구할 때 사용하는 알고리즘이다. 이 문제에서도 $1$부터 $n$까지의 자연수가 순서대로 나열되어 있다고 가정하고 적용할 수 있다.

투 포인터 접근법

left, right 두 포인터로 구간 [left, right]의 합을 관리한다.

• left, right를 모두 $1$로 설정하고 시작한다.
• 종료 조건 : left가 n을 넘어가면 종료한다.

💻 풀이 코드 (투포인터)

def solution(n):
    count = 0
    left, right = 1, 1
    total = 1  # 초기 구간 [1, 1]의 합

    while left <= n:
        if total == n:
            count += 1
            right += 1
            total += right   # right 확장
        elif total < n:
            right += 1
            total += right   # right 확장
        else:  # total > n
            total -= left    # left 제거
            left += 1

    return count

동작 흐름 (n = 15)

[1,1]  total=1  → right 이동
[1,2]  total=3  → right 이동
[1,3]  total=6  → right 이동
[1,4]  total=10 → right 이동
[1,5]  total=15 → ✅ count=1, right 이동
[1,6]  total=21 → left 이동
[2,6]  total=20 → left 이동
[3,6]  total=18 → left 이동
[4,6]  total=15 → ✅ count=2, right 이동
[4,7]  total=22 → left 이동
[5,7]  total=19 → left 이동
[6,7]  total=13 → right 이동
[6,8]  total=21 → left 이동
[7,8]  total=15 → ✅ count=3, right 이동
[7,9]  total=24 → left 이동
...
[15,15] total=15 → ✅ count=4

핵심 포인트

• 시간복잡도: O(n) — left, right 각각 최대 n번 이동
• 종료 조건: left > n 이 되면 더 이상 유효한 구간 없음
• right += 1 후 total += right 순서에 주의 (먼저 포인터를 옮긴 뒤 합산)
  

🤔 total == n 일때, 왜 right만 이동하지?

right, left둘다 이동시키거나 left만 이동시키는 방식은 안되는걸까? 결론부터 말하면 셋 다 가능하다. 다만 각각 놓치는 케이스가 없도록 처리를 다르게 해야 한다.

right만 이동하면?

total == n을 찾은 순간, left를 고정한 채 right를 늘리면 다음 상태는 total > n이 되어 자연스럽게 left가 이동한다.

[4,5,6] = 15 ✅  → right 이동
[4,5,6,7] = 22  → left 이동
[5,6,7] = 18    → left 이동
[6,7] = 13      → right 이동
[6,7,8] = 21    → left 이동
[7,8] = 15 ✅

흐름이 자연스럽게 이어져서 코드가 단순해지는 장점이 있다.

left만 이동하면?

if total == n:
    count += 1
    total -= left  # left 제거
    left += 1

이것도 동작한다. left를 줄이면 total < n이 되어 right가 자연스럽게 이동한다.

[4,5,6] = 15 ✅  → left 이동
[5,6] = 11       → right 이동
[5,6,7] = 18     → left 이동
[6,7] = 13       → right 이동
[6,7,8] = 21     → left 이동
[7,8] = 15 ✅

left, right 둘 다 이동하면?

if total == n:
    count += 1
    total -= left  # left 제거 후
    left += 1
    right += 1     # right도 추가
    total += right

이것도 가능하다. 단, 반드시 두 줄을 같이 써야 하고, 순서도 지켜야 해서 실수하기 쉽다.

문제

n개의 서로 다른 양의 정수 a1, a2, ..., an으로 이루어진 수열이 있다. ai의 값은 1보다 크거나 같고, 1000000보다 작거나 같은 자연수이다. 자연수 x가 주어졌을 때, ai + aj = x (1 ≤ i < j ≤ n)을 만족하는 (ai, aj)쌍의 수를 구하는 프로그램을 작성하시오.

입력

첫째 줄에 수열의 크기 n이 주어진다. 다음 줄에는 수열에 포함되는 수가 주어진다. 셋째 줄에는 x가 주어진다. (1 ≤ n ≤ 100000, 1 ≤ x ≤ 2000000)

출력

문제의 조건을 만족하는 쌍의 개수를 출력한다.

예제 입력

9
5 12 7 10 9 1 2 3 11
13

예제 출력

3

풀이

1. 문제의 핵심 이해하기

이 문제는 정수 배열에서 두 수를 골라서 합이 $x$가 되는 쌍의 개수를 구하는 문제이다.

처음 떠올리기 쉬운 방법은 모든 두 수를 다 확인하는 것이다. 구현하기엔 쉽겠지만, 시간복잡도가 O(N²) 이라서 비효율적이다. 따라서, 정렬 + 투포인터를 사용해 풀어야 한다.

2. 투포인터(Two Pointers)란?

배열을 정렬한 뒤, 왼쪽 끝을 left, 오른쪽 끝을 right라고 두 개의 손가락(포인터)을 둔다. 양 끝 지점에서 가운데로 한쪽 포인터를 조건에 따라 이동시키며 탐색 범위를 줄여가는 방식이다.

준비물: 정렬된 숫자 배열 (중요! 반드시 오름차순 정렬이 되어 있어야 한다.) 시작 위치:

• 왼쪽 포인터 ($left$): 배열의 맨 첫 번째 (가장 작은 값)
• 오른쪽 포인터 ($right$): 배열의 맨 마지막 (가장 큰 값)

💡 투 포인터를 쉽게 이해하기

배열을 정렬한 뒤, 왼쪽 끝을 left, 오른쪽 끝을 right 라고 두고 시작한다.

예를 들어 정렬된 배열이 [1, 2, 3, 4, 5, 7] 이고, 목표 합이 8이라면

• left = 0 → 1
• right = 5 → 7

1️⃣ 1단계 1 + 7 = 8 찾았다. 개수 1 증가.

그다음엔 같은 쌍을 또 세면 안 되니까 left += 1, right -= 1

2️⃣ 2단계 이제 2 + 5 = 7. 목표보다 작다.

그러면 더 큰 수가 필요하니까 왼쪽 값을 키워야 한다. 즉, left += 1

3️⃣ 3단계 3 + 5 = 8. 또 찾았다. 개수 1 증가.

다시 left += 1, right -= 1 이제 left >= right가 되면 종료.

왜 이렇게 움직이는걸까?

현재 합이 x보다 작다는 건, 더 큰 수가 필요하다는 뜻이다.

정렬되어 있으니까

• 오른쪽은 이미 큰 값
• 왼쪽을 오른쪽으로 옮기면 값이 커짐

그래서 left를 증가시켜야 한다.

현재 합이 x보다 크다는 건, 더 작은 수가 필요하다는 뜻이다.

정렬되어 있으니까

• 오른쪽을 왼쪽으로 옮기면 값이 작아짐

그래서 right를 감소시켜야 한다.

이제 이 내용을 바탕으로 알고리즘을 정리해보면 다음과 같다.

🧠 최종 알고리즘

1. 수열을 입력받는다
2. 정렬한다
3. left = 0, right = n - 1로 시작한다
4. left < right 동안 반복한다
    5. 두 수의 합을 보고
    6. x와 같으면 count 증가 후 양쪽 이동
    7. x보다 작으면 left 증가
    8. x보다 크면 right 감소

코드

코드로 구현한다면 아래와 같다.

n = int(input())
arr = list(map(int, input().split()))
x = int(input())

arr.sort()

left = 0
right = n - 1
count = 0

while left < right:
    total = arr[left] + arr[right]

    if total == x:
        count += 1
        left += 1
        right -= 1
    elif total < x:
        left += 1
    else:
        right -= 1

print(count)

문제

좌표 (0,0)에서 (x,y)까지 이동할 때, 직선 이동(상하좌우)과 대각선 이동을 사용할 수 있다.

• 직선 이동 비용: w
• 대각선 이동 비용: s

최소 비용으로 목적지까지 이동하는 시간을 구하는 문제이다.

💻 정석 코드

x, y, w, s = map(int, input().split())

case1 = (x + y) * w
case2 = min(x, y) * s + abs(x - y) * w

if (x + y) % 2 == 0:
    case3 = max(x, y) * s
else:
    case3 = (max(x, y) - 1) * s + w

print(min(case1, case2, case3))

코드 풀이

(0, 0)에서 (x, y)로 평행선과 대각선을 사용하여 이동할 때 걸리는 시간 3가지 경우로 나눌 수 있다.

1) 전부 직선 이동 2) 대각선 최대한 + 남은거리는 직선으로만 3) 가능한 한 대각선만 사용

이 세 가지 경우중에 최소값이 곧 결과가 된다.

1) 전부 직선 이동

(x + y) * w

2) 대각선 최대한 + 남은거리는 직선으로만

min(x, y) * s + abs(x - y) * w

3) 가능한 한 대각선만 사용

평행한 일직선의 거리도 대각선이동으로 가능하다.

예를 들어 (0,0)에서 (2,0) 로 이동하는 경우, x축으로 두 번 평행이동하는 방법도 있겠지만, (0,0) - (1,1) - (2,0) 이렇게 대각선으로 두 번 이동하는 것도 가능하다.

단, 거리가 2의 배수인 경우는 위의 예시처럼 모두 대각선이동으로 가능하지만, 예를들어 (0,0)에서 (1,0)으로 이동하는 경우처럼 거리가 홀수인 경우는 대각선이동과 한번의 직선이동이 필요하다. (0,0) - (1,1) - (1,0)

if (x + y) % 2 == 0:
    max(x, y) * s
else:
    (max(x, y) - 1) * s + w

🔥 나의 시행착오

위의 풀이가 정석풀이라면, 지금부터는 그 전까지 내가 시행착오했던 풀이들이다.

첫 번째 시도 : 실패

처음에는 다음과 같은 아이디어로 접근했다.

• 가로1 + 세로1 이동은 대각선이동 하나로 대체가능하다.
• s < 2w : 대각선 이동이 유리함
• s > 2w : 평행이동이 유리함.

s < 2w이면 대각선이 유리하므로 최대한 대각선으로 이동하고, 나머지는 직선으로 이동한다.

이를 코드로 구현하면 다음과 같다.

x, y, w, s = map(int, input().split())

max_s = min(x, y)
s_cnt = 0

if s < 2 * w:
    s_cnt = min(x, y)

print(((x - s_cnt) + (y - s_cnt)) * w + s*s_cnt)

1) 틀린 이유

이 코드는 남은 거리를 무조건 직선으로 처리한다고 가정했다. 하지만 실제로는 남은 거리도 대각선으로 처리하는 것이 더 빠를 수 있다.

2) 반례

x = 2, y = 0
w = 12, s = 10

• 내 코드 결과: 24
• 실제 정답: 20

이유:

• (0,0) → (1,1) → (2,0)
• 대각선 2번으로 이동 가능

즉, 한 축만 남았다고 해서 직선만 써야 하는 것은 아니다.

💻 나의 풀이 (개선 코드)

x, y, w, s = map(int, input().split())

if s >= 2 * w:
    answer = (x + y) * w
else:
    diag = min(x, y) #대각선(diagonal)으로 이동하는 횟수
    diff = abs(x - y) #대각선으로 최대한 이동하고 남은 거리

    answer = diag * s

    if diff % 2 == 0:
        answer += min(diff * w, diff * s)
    else:
        answer += min(diff * w, (diff - 1) * s + w)

print(answer)

1) 핵심 로직

• min(x,y) 만큼은 대각선 이동
• 남은 거리 diff = abs(x-y) 처리

2) 남은 거리 처리

1. 짝수 → 대각선만으로 정확히 도달 가능 diff * s

2. 홀수 → 마지막 1칸은 직선 필요 (diff - 1) * s + w

3) 직선 vs 대각선 비교

min(diff * w, 대각선 방식)

지금 이 풀이에서는 s >= 2 * w에 따라 조건을 나눴지만, 이렇게 할 필요없이 정석코드에서처럼 case1, 2, 3을 구하고 이 중에 최소값을 결과로 출력하는 편이 훨씬 보기에도 편하고 간단하다.

문제

빈 병 a개를 가져가면 콜라 b병을 받을 수 있다. 현재 가지고 있는 빈 병이 n개일 때, 최대로 받을 수 있는 콜라 병 수를 구하는 문제이다.

요구사항 분석

1) 교환 조건

• 빈 병이 a개 이상 있어야 교환 가능하다.
• 한 번에 여러 번 교환 가능하다. (예: 10개면 5번 교환)

2) 반복 구조

• 교환할 때마다

  • 새로 받은 병을 더하고
  • 남은 병을 다음 턴으로 넘긴다.

3) 종료 조건

• 더 이상 교환할 수 없을 때 (n < a) 반복 종료

나의 풀이 과정

첫 번째 시도 : 통과

통과되긴하지만 더 간단하게 작성할 수 있다.

def solution(a, b, n):
    answer = 0
    bottles = n

    while bottles >=  a:
        x = (bottles // a) * a
        bottles -= x

        received = (x // a) * b
        answer += received
        bottles += received 

    return answer

💻 정석 코드

def solution(a, b, n):
    answer = 0

    while n >= a:
        new_cola = (n // a) * b
        answer += new_cola
        n = (n % a) + new_cola

    return answer

배운점

• x와 같이 모호한 변수명은 사용하지 말자.

문제 간단 요약 및 설명

매일 점수가 하나씩 발표된다. 지금까지 나온 점수 중 상위 k개를 “명예의 전당”에 유지한다.

매일 명예의 전당에 포함된 점수들 중 가장 낮은 점수를 기록하여 반환하는 문제이다.

🔥 나의 풀이 및 시행착오

1️⃣ 첫 번째 시도 : 실패

처음에는 문제를 다음과 같이 k를 기준으로 나누어 접근했다.

1) 2일차부터 k일까지 2) k일 이후부터

단, k 보다 score 길이가 짧은 경우까지 고려하지 못해 실패했다.

def solution(k, score):
    answer = [score[0]]
    honor = [score[0]]
    days = len(score)

    for i in range(2, k+1):
        honor.append(score[i-1])
        answer.append(min(honor))

    for j in range(k+1, days + 1):
        if answer[-1] < score[j-1]:
            honor.sort(reverse=True)
            honor[-1] = score[j-1]
            answer.append(min(honor))
        else:
            answer.append(answer[-1])

    return answer

2️⃣ 두 번째 시도 : 성공

🔍 실패 원인 : k보다 score 길이가 짧은 경우를 생각해보았는가? 🚀 해결 방법 : k보다 score 길이가 짧은 경우를 조건으로 나누어 따로 처리

이 방식으로도 풀 수는 있다. 다만 좋은 풀이는 아니다.

def solution(k, score):
    answer = [score[0]]
    honor = [score[0]]
    days = len(score)

    if k > days:
        for i in range(2, days+1):
            honor.append(score[i-1])
            answer.append(min(honor))
        return answer


    for i in range(2, k+1):
        honor.append(score[i-1])
        answer.append(min(honor))

    for j in range(k+1, days + 1):
        if answer[-1] < score[j-1]:
            honor.sort(reverse=True)
            honor[-1] = score[j-1]
            answer.append(min(honor))
        else:
            answer.append(answer[-1])

    return answer

💬 GPT의 피드백

네 코드는 “구간을 나눠서 처리”하고 있어

이 코드는 문제를 이렇게 보고 있는 거야.

• 첫째 날은 따로 처리
• 2일차 ~ k일차도 따로 처리
• k+1일차부터 또 따로 처리
• k가 전체 날짜보다 큰 경우도 따로 처리

즉, 상황별로 나눠서 계산하고 있어.

이 방식의 단점은 문제를 풀다 보면 “예외 처리”가 계속 늘어난다는 거야.

예를 들면 이런 생각이 계속 생겨:

• 첫날은 이미 넣었으니까 2일부터 시작해야 하나?
• k가 days보다 크면?
• k일까지는 그냥 넣기만 하면 되나?
• 그 다음부터는 교체만 하면 되나?

🔥 이런 식으로 코드가 점점 “문제 자체”보다 “예외를 다루는 코드”가 돼버리기 쉬워.

그렇다면 어떻게 해야하나?

정석 코드는 “매일 같은 규칙만 반복”해

💻 정석 코드

이 문제는 정답 리스트를 한 번에 만드는 문제가 아니라, 하루씩 보면서 명예의 전당 상태를 갱신하는 문제야.

def solution(k, score):
    answer = []
    honor = []

    for s in score:
        honor.append(s)

        if len(honor) > k:
            honor.remove(min(honor))

        answer.append(min(honor))

    return answer

즉 핵심은:

1. 오늘 점수가 들어온다
2. 명예의 전당 후보에 반영한다
3. 상위 k개만 남긴다
4. 그중 최하위 점수를 answer에 넣는다

이걸 매일 반복하면 끝이야.

문제를 이렇게 보면 “처음 k일”, “그 이후”로 나눌 필요가 없어져. 즉, 첫날도 똑같고 둘째 날도 똑같고 마지막 날도 똑같아.

이게 정석 풀이가 자연스러운 가장 큰 이유야. 문제를 매일 반복되는 하나의 규칙으로 바꿨기 때문이야.

🤔 앞으로 비슷한 문제에서 어떻게 생각하면 좋을까?

1) 상태를 유지하는 방식으로 접근해야 한다

이 문제의 핵심은 “정답을 계산”하는 것이 아니라 👉 매 순간 명예의 전당 상태를 유지하는 것이다.

2) 구간을 나누지 말고 동일한 규칙을 반복하자

• 넣는다
• k 초과면 최소값 제거
• 최솟값 기록

이 규칙 하나로 모든 케이스를 처리할 수 있다.

3) 결과 배열이 아니라 상태 배열을 기준으로 판단하자

• answer → 출력용
• honor → 상태 관리

이 둘을 분리하면 로직이 훨씬 명확해진다.

4) 문제를 이렇게 바라보면 쉬워진다

• 유지해야 하는 상태: 상위 k개
• 새로운 값이 들어왔을 때: 넣고, 넘치면 제거
• 출력: 현재 상태의 최솟값

이 3단계로 생각하면 대부분의 구현 문제가 훨씬 단순해진다.

문제

N×N 크기의 지역이 주어지고, 각 칸에는 높이가 있다. 비가 일정 높이만큼 내리면 그 높이 이하의 모든 지역은 물에 잠긴다.

물에 잠기지 않은 칸들끼리 상하좌우로 연결되어 있다면 하나의 안전 영역으로 본다. 비의 높이를 바꿔가며 안전 영역의 최대 개수를 구하는 문제이다.

📚 문제 분석

1. 핵심은 “여러 번 탐색해야 하는 문제”이다

비의 높이가 하나로 고정되어 있지 않다. 따라서 한 번 BFS/DFS로 끝나는 문제가 아니라, 비의 높이를 바꿔가며 매번 안전 영역 개수를 다시 계산해야 한다.

2. 안전 영역은 연결 요소 개수 문제이다

잠기지 않은 칸들을 기준으로 보면, 결국 상하좌우로 연결된 덩어리 개수를 세는 문제이다.

→ BFS 또는 DFS로 해결 가능

3. 탐색 기준

• graph[i][j] > rain → 잠기지 않은 칸 (안전 영역)
• 이 조건을 만족하는 칸들끼리 연결된 영역 개수 세기

4. 비의 범위

비는 0 ~ (최대 높이-1)까지 확인하면 충분하다.

• rain = 0 → 비가 안 온 경우
• rain >= max_height → 전부 잠김 → 의미 없음

💻 나의 최종 코드 (정석 코드)

from collections import deque

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

maximum = max(max(row) for row in graph)

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

def get_secure_zone(rain):
    secure_num = 0
    visited = [[False] * N for _ in range(N)]

    for i in range(N):
        for j in range(N):
            if visited[i][j] or graph[i][j] <= rain:
                continue

            queue = deque([(i, j)])
            visited[i][j] = True

            while queue:
                x, y = queue.popleft()

                for d in range(4):
                    nx = x + dx[d]
                    ny = y + dy[d]

                    if 0 <= nx < N and 0 <= ny < N:
                        if not visited[nx][ny] and graph[nx][ny] > rain:
                            visited[nx][ny] = True
                            queue.append((nx, ny))

            secure_num += 1

    return secure_num

answer = 0

for rain in range(maximum):
    answer = max(answer, get_secure_zone(rain))

print(answer)

🔥 시행착오했던 풀이

1. 그래프를 직접 변경하는 방식으로 접근 처음에는 매번 그래프를 복사해서 BFS 중 방문한 칸을 0으로 바꾸는 방식으로 구현했다.

tgraph[tx][ty] = 0

그래서 매 강수량마다 그래프를 복사해서 사용하려고 했다.

get_secure_zone(copy.deepcopy(graph), rain)

이 방식 자체는 동작은 가능하다. 다만, 매번 깊은복사를 해야하기때문에 무거워질수 있어 visited 배열로 따로 방문처리하는 편이 낫다. 이 방법은 3번에서 다시 다루겠다.

2. 2차원 리스트 복사 문제 발생

처음에는 deepcopy 대신 아래처럼도 시도했다가 실패했다.

graph[:]

1차원 리스트였다면 깊은 복사가 되었겠지만, 2차원 리스트의 경우 깊은복사가 안된다.

• 바깥 리스트만 복사됨
• 내부 리스트는 그대로 공유됨

그래서 BFS 중에 값을 바꾸면 원본 graph까지 같이 바뀌는 문제가 발생했다.

이 때문에 다음 강수량 계산에서 이미 변경된 그래프를 사용하게 되어 오답이 발생했다.

3. 해결 방법

• copy.deepcopy(graph) 사용 → 완전한 깊은 복사
• 또는 [row[:] for row in graph] 사용

하지만 이 문제에서는 더 좋은 방법이 있다.

→ 그래프를 건드리지 않고 visited 배열을 사용하는 것

이렇게 하면 복사 자체가 필요 없어지고, 코드도 훨씬 깔끔해진다.

• graph[i][j]는 높이 정보
• visited[i][j]는 방문 여부 이렇게 역할이 나뉘어 있어서 코드가 더 명확하다.

한번만 검사할때는 visited 없이 그래프를 직접 바꾸는게 더 간단하겠지만, 여러 조건을 반복해서 검사해야 할 때는 그래프를 직접 바꾸는 방식은 불편해질 수 있다.

4. 비가 안 오는 경우를 따로 처리했던 점

• 0<= rain < min : 안전지대 항상 1개
• min <= rain < max : 안전지대 1개 이상

처음에는 위의 조건대로 0<= rain < min 범위에서는 안전지대가 항상 1개이기 때문에 이 범위에 대해서 탐색할 필요가 없다고 생각했다. 그래서 result 리스트에 강수량별 안전지대 개수를 저장해놓고, 마지막에 max(result)를 정답으로 출력할 생각이었다.

result = [1]

로 0<= rain < min범위의 안전지대 값(1)으로 초기화해두고, min <= rain < max에 대해 안전지대 개수를 구해 result에 추가하는 방식이다.

하지만, 이 문제의 시간복잡도는 O(높이 범위 × N²) 으로, 0<= rain < min를 포함하나 안하나 시간복잡도에 큰 영향을 주지 않는다. 최악의 경우, 100 × (100 × 100) = 1,000,000번 정도 이다.

물론 조금이라도 시간을 줄이고싶다면, 최적화하는게 좋겠지만, 세세하게까지 다루다 실수해버릴수도 있기 때문에 휴먼에러와 코드단순화를 생각한다면 좀 더 단순하게 가는게 좋아보인다.

🤔 느낀점

문제의 큰 틀, 즉 핵심 풀이 아이디어는는 잘 파악했으나, 이를 구현하는 과정에서 오래걸린 것이 아쉽다. 사실 큰틀만 놓고보면 '단지 번호 붙이기' 같은 연결요소개수 구하기를 * n번 반복하는 것 뿐이다. 근데 왜이렇게 오래걸렸을까... 너무 복잡하게, 사소한것까지 최적화하려고 해서 그런것 같다. 시간복잡도를 고려해서 필요없는 최적화는 버리고 단순하게 가는것도 중요하겠다.

✏️ 배운점

1. 연결 요소 문제로 변환하는 사고가 중요하다

처음에는 단순히 “잠기는 영역”에 집중했지만, 실제 문제는 잠기지 않은 영역의 개수를 구하는 문제였다.

→ BFS/DFS 문제로 바꿔 생각하는 것이 핵심

2. 그래프를 직접 바꿀지, visited를 쓸지 먼저 결정해야 한다

• 그래프 직접 변경 → 구현은 쉽지만 복사 문제 발생
• visited 사용 → 조금 더 구조적이고 안정적

특히 이 문제처럼 여러 번 탐색해야 할 때는 visited 방식이 훨씬 유리하다. 상황에 따라 판단하자.

3. 2차원 리스트 복사 개념은 반드시 정확히 알아야 한다

• graph[:] → 얕은 복사 (실수 포인트)
• [row[:] for row in graph] → 2차원 복사 가능
• copy.deepcopy(graph) → 완전한 깊은 복사

이 차이를 모르고 BFS/DFS 문제를 풀면 디버깅이 매우 어려워진다.

4. 모든 경우를 하나의 흐름으로 처리하는 것이 더 안전하다

예외를 따로 두기보다

for rain in range(maximum):

처럼 통일된 구조로 처리하면 코드가 단순해지고 실수도 줄어든다.(시간복잡도에 큰 영향을 미치지 않는 경우)

문제

건물에 F층이 있고, 현재 S층에서 G층으로 이동하려고 한다. 엘리베이터 버튼은 두 가지:

• 위로 U층 이동
• 아래로 D층 이동

목표는 최소 버튼 횟수로 G층에 도달하는 것이다. 도달할 수 없다면 "use the stairs"를 출력한다.

풀이 과정

1. BFS로 접근해야 하는 이유

이 문제는 버튼을 한 번 누를 때마다 이동 횟수가 항상 1이다. 즉, 모든 이동 비용이 동일하므로 BFS로 최단 횟수를 구할 수 있다.

2. BFS 핵심 개념

BFS는 이동 횟수 기준으로 다음과 같이 탐색한다.

• 1번 이동
• 2번 이동
• 3번 이동

이 순서로 탐색하기 때문에 처음 방문한 순간이 곧 최소 이동 횟수가 된다.

나의 시행착오

1. 이미 방문한 층도 다시 갱신하려고 했던 접근

처음에는 아래처럼 생각했다.

“이미 방문한 층이라도, 더 적은 횟수로 도달할 수 있지 않을까? 더 짧으면 갱신해야지”

그래서 다음과 같이 코드를 작성했다.

if apt[moved] == 0:
    apt[moved] = apt[current] + 1
else:
    apt[moved] = min(apt[current] + 1, apt[moved])

즉, 더 작은 값이 나오면 갱신하려는 방식이었다.

하지만 이 접근은 BFS에서는 필요 없는 로직이었다.

이 문제는 버튼 한 번 누를 때마다 비용이 전부 같다. 위로 가기 1번, 아래로 가기 1번. 즉 모든 간선의 가중치가 1인 그래프이다.

• BFS는 애초에 최소 횟수부터 탐색 -> 따라서 나중에 더 작은 값이 나올 일이 없음
• BFS: 간선 가중치가 모두 같을 때 최단거리 보장 그래서 처음 방문 = 최소 횟수 이미 방문한 곳을 다시 더 짧게 갱신할 일은 없음

반대로 이런 경우는 다르다.만약 가중치가 다른 상황이면(예를들어 엘리베이터 위로 가면 10초, 아래로 가면 1초) BFS 안됨. 나중에 더 빠른 경로가 생길 수 있다. (이게 다익스트라)

• 이동 1번, 점프 1번, 버튼 1번처럼 모든 행동 비용이 동일하다 → BFS로 최단거리
• 이동마다 비용이 다르다 → 다익스트라 같은 다른 최단경로 알고리즘 고려

2. 방문 체크 없이 큐에 계속 추가한 문제

또 하나의 문제는 다음 코드였다.

queue.append(moved)

방문 여부를 확인하지 않고 무조건 큐에 넣었기 때문에:

• 같은 층이 계속 반복해서 큐에 들어감
• A → B → A → B 무한 반복 구조 발생
• 결국 SIGTERM (강제 종료) 발생

3. dist 배열 초기값 문제

처음에는 0으로 초기화했는데:

• 시작점도 0
• 방문 안 한 곳도 0

이 둘이 구분되지 않아 로직이 꼬였다.

그래서 -1로 초기화하여 명확히 구분하도록 수정했다.

최종 알고리즘

1. dist 배열을 -1로 초기화 (미방문 표시)

2. 시작점 S를 큐에 넣고 dist[S] = 0

3. BFS 수행

• 현재 층에서

  • 위로 이동
  • 아래로 이동

• 범위 안이고 아직 방문하지 않은 경우만 큐에 추가

4. 목표 G에 도달하면 종료

5. dist[G]가 -1이면 도달 불가

최종 코드

from collections import deque

F, S, G, U, D = map(int, input().split())

dist = [-1] * (F + 1)
dist[S] = 0

queue = deque([S])

while queue:
    current = queue.popleft()

    if current == G:
        break

    for moved in (current + U, current - D):
        if 1 <= moved <= F and dist[moved] == -1:
            dist[moved] = dist[current] + 1
            queue.append(moved)

if dist[G] == -1:
    print("use the stairs")
else:
    print(dist[G])

배운 점 및 코테 팁

1. BFS에서는 재방문 갱신이 필요 없다

• 처음 방문이 최단 거리
• min() 갱신 로직 불필요

2. 방문 체크는 큐에 넣기 전에 한다

• 안 하면 무한 반복
• 시간 초과 / SIGTERM 발생

3. 거리 배열은 -1로 초기화하는 것이 안전하다

• 0 초기화는 시작점과 구분이 안 됨

4. 판단 기준 정리

• 최소 횟수 → BFS
• 이동 비용 동일 → BFS
• 상태 전이 명확 → BFS

🍅 문제

3차원 상자에 토마토가 저장되어 있다.

• 익은 토마토: 1
• 익지 않은 토마토: 0
• 빈 칸: -1

익은 토마토는 하루가 지나면 상하좌우뿐만 아니라 위아래 방향까지 포함한 총 6방향으로 인접한 토마토를 익게 만든다.

모든 토마토가 익는데 걸리는 최소 일수를 구해야 하며, 모든 토마토가 익지 못하는 경우에는 -1을 출력한다.

풀이 과정

1) 문제 접근 이 문제는 단순 탐색 문제가 아니라 “최소 일수”를 구하는 문제이다. 또한 토마토가 동시에 퍼지기 때문에 순차 탐색이 아닌 BFS를 사용해야 한다.

특히 처음부터 익은 토마토가 여러 개 존재하므로, 모든 시작점을 큐에 넣는 다중 시작점 BFS가 필요하다.

2) BFS를 사용해야 하는 이유 DFS는 한 방향으로 깊게 탐색하기 때문에 최소 거리를 보장하지 못한다. 반면 BFS는 레벨 단위로 확장되므로, 각 토마토가 익는 시점이 곧 최소 일수가 된다.

3) 구현 핵심

• 처음 입력을 받을 때 익은 토마토(1)의 위치를 모두 큐에 넣는다.
• BFS를 진행하면서 인접한 토마토를 익힌다.
• 이때, 별도의 날짜 배열 없이 graph에 값을 누적한다.

🔥 나의 시행착오

1) 모든 좌표를 순회하며 처리하려 했던 문제

처음에는 3차원 배열을 모두 순회하면서 주변을 익히는 방식으로 접근하려 했다.

하지만 이 방법은 동시에 퍼지는 개념을 반영하지 못하고, 이미 같은 날 익어야 하는 토마토까지 순차적으로 처리되는 문제가 발생한다.

이 문제의 핵심은 “전파 + 최소 시간”이다. 이 조합은 BFS로 해결해야 한다.

2) days 변수로 최적화하려던 시도

전체 최댓값을 구하는 과정이 비효율적일 것 같아 days 변수를 따로 두고 graph의 값을 업데이트 할때마다 max()로 최댓값을 저장하려 했다.

하지만 실제로는 마지막에 한 번 전체를 순회하는 것은 시간복잡도에 큰 영향을 주지 않으며, 오히려 코드 복잡도와 실수 가능성만 증가시키는 요소였다.

최종 알고리즘

1) 입력을 받으며 초기 설정 익은 토마토의 위치를 모두 큐에 넣는다

2) BFS 수행

• 큐에서 하나씩 꺼낸다
• 6방향 탐색을 수행한다
• 익지 않은 토마토(0)를 만나면 → 현재 값 + 1로 갱신 → 큐에 추가

3) 결과 처리

• BFS 이후에도 0이 존재하면 → -1
• 그렇지 않으면 → 전체 최댓값 - 1 출력

💻 최종 코드

from collections import deque
import sys

input = sys.stdin.readline

M, N, H = map(int, input().split())

graph = []
queue = deque()

for h in range(H):
    box = []
    for n in range(N):
        row = list(map(int, input().split()))
        box.append(row)

        for m in range(M):
            if row[m] == 1:
                queue.append((h, n, m))
    graph.append(box)

# 6방향 (상, 하, 좌, 우, 위, 아래)
dh = [0, 0, 0, 0, -1, 1]
dn = [-1, 1, 0, 0, 0, 0]
dm = [0, 0, -1, 1, 0, 0]

while queue:
    h, n, m = queue.popleft()

    for i in range(6):
        nh = h + dh[i]
        nn = n + dn[i]
        nm = m + dm[i]

        if 0 <= nh < H and 0 <= nn < N and 0 <= nm < M:
            if graph[nh][nn][nm] == 0:
                graph[nh][nn][nm] = graph[h][n][m] + 1
                queue.append((nh, nn, nm))

answer = 0

for h in range(H):
    for n in range(N):
        for m in range(M):
            if graph[h][n][m] == 0:
                print(-1)
                sys.exit()
            answer = max(answer, graph[h][n][m])

print(answer - 1)

📚 배운점

1) 전파 + 최소 시간 → BFS로 접근한다 이 문제처럼 “퍼진다” + “최소 일수”가 같이 나오면 BFS를 먼저 떠올리는 것이 중요하다.

2) 다중 시작점 BFS를 기억하자 시작점이 여러 개인 경우, 처음부터 큐에 모두 넣고 시작해야 한다.

3) graph를 거리 배열로 활용할 수 있다 별도의 distance 배열 없이 값 자체를 증가시키는 방식으로 해결 가능하다.

4) 불필요한 최적화는 오히려 독이 된다 전체를 한 번 더 순회하는 비용보다, 코드 안정성과 정확성이 더 중요하다. 전체를 한 번 더 순회하는 것은 시간복잡도에 큰 영향을 미치지 않는다.

두 사람의 관계가 주어졌을 때, 이 둘 사이의 촌수(거리)를 계산하는 문제이다.

부모-자식 관계가 주어짐 두 사람 사이의 촌수를 구하기 연결이 안 되어 있으면 -1

💡 문제 접근 : DFS인가 BFS인가?

👉 사람 간 관계 = 그래프 👉 부모-자식 관계 → 양방향 간선

👉 “촌수” = 두 사람 사이의 거리 (간선 개수) 👉 두 노드 사이 거리 찾기 문제

이 문제를 처음봤을때 “최소 거리(촌수)를 찾아야 하니까 BFS?”라고 생각했다. DFS를 사용한다 하더라도 모든 경로 탐색 + 최솟값 갱신 필요하다고 생각했다.

하지만 실제로는 BFS, DFS로도 충분히 해결 가능하다. 이 문제의 관계는 단순한 그래프가 아니라 트리(Tree) 구조로 볼 수 있다.

부모 - 자식 관계는 트리 구조이다. 즉, *start → end로 가는 경로가 딱 하나인 것이다. *

트리의 특징

• 사이클이 없음
• 두 노드 사이 경로는 항상 하나

따라서 이 문제는 BFS, DFS 모두 가능하며, DFS로 푼다고 하더라도 굳이 최솟값 갱신하는 과정이 필요없다.

BFS 풀이

from collections import deque

n = int(input())
start, end = map(int, input().split())
m = int(input())

graph = [[] for _ in range(n+1)]
visited = [0] * (n+1) 

for _ in range(m):
    a, b = map(int, input().split())
    graph[a].append(b)
    graph[b].append(a)

def bfs(v):
    queue = deque()
    queue.append(v)
    visited[v] += 1

    while queue:
        now = queue.popleft()
        if now == end:
            return visited[now] - 1
        for next in graph[now]:
            if not visited[next] :
                visited[next] = visited[now] + 1
                queue.append(next)

    return -1

print(bfs(start))

DFS 풀이

from collections import deque

n = int(input())
start, end = map(int, input().split())
m = int(input())

graph = [[] for _ in range(n+1)]
visited = [False] * (n+1) 
result = -1

for _ in range(m):
    a, b = map(int, input().split())
    graph[a].append(b)
    graph[b].append(a)

def dfs(v, depth):
    global result

    if v == end:
        result = depth
        return 

    visited[v] = True

    for next in graph[v]:
        if not visited[next]:
            dfs(next, depth + 1)

dfs(start, 0)

print(result)

문제

NxN 크기의 지도에서 1은 집이 있는 곳, 0은 집이 없는 곳을 의미한다. 상하좌우로 연결된 집들을 하나의 단지로 정의할 때,

• 총 단지 수
• 각 단지의 집 개수 (오름차순)

를 구하는 문제이다.

요구사항 분석

1. 그래프 탐색 문제로 해석

2차원 배열은 그래프로 볼 수 있으며, 각 칸은 노드가 된다. 상하좌우 이동은 인접 노드 탐색에 해당한다.

2. 연결 요소 문제

연결된 1들의 묶음은 하나의 단지이다. 즉, 이 문제는 “연결 요소의 개수와 크기”를 구하는 문제이다.

나의 풀이

1. BFS를 이용한 단지 탐색

• 1을 발견하면 BFS 시작
• 연결된 모든 1을 탐색하며 0으로 변경 (방문 처리)
• 탐색하면서 집 개수를 세어 단지 크기로 저장

from collections import deque

N = int(input())

graph = []
houses = []

for i in range(N):
    graph.append(list(map(int, input())))

def bfs(a, b):
    queue = deque()
    queue.append((a, b))
    graph[a][b] = 0
    house = 1

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

    while queue:
        x, y = queue.pop()

        for i in range(4):
            tx = x + dx[i]
            ty = y + dy[i]

            if 0 <= tx < N and 0 <= ty < N and graph[tx][ty] == 1:
                queue.append((tx, ty))
                graph[tx][ty] = 0
                house += 1

    return house


for i in range(N):
    for j in range(N):
        if graph[i][j] == 1:
            houses.append(bfs(i, j))

print(len(houses))
houses.sort()
for house in houses:
    print(house)

코드 피드백

1. BFS에서 pop() 사용

x, y = queue.pop()

이 방식은 DFS처럼 동작한다. BFS를 정확하게 구현하려면 다음과 같이 작성해야 한다.

x, y = queue.popleft()

문제는 풀리지만, 탐색 방식의 의미를 맞추는 것이 중요하다.

정석 코드 (BFS + DFS)

1. BFS 풀이

from collections import deque

N = int(input())
graph = [list(map(int, input().strip())) for _ in range(N)]

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

def bfs(a, b):
    queue = deque()
    queue.append((a, b))
    graph[a][b] = 0
    count = 1

    while queue:
        x, y = queue.popleft()

        for i in range(4):
            nx = x + dx[i]
            ny = y + dy[i]

            if 0 <= nx < N and 0 <= ny < N and graph[nx][ny] == 1:
                queue.append((nx, ny))
                graph[nx][ny] = 0
                count += 1

    return count

2. DFS 풀이

def dfs(x, y):
    graph[x][y] = 0
    count = 1

    for i in range(4):
        nx = x + dx[i]
        ny = y + dy[i]

        if 0 <= nx < N and 0 <= ny < N and graph[nx][ny] == 1:
            count += dfs(nx, ny)

    return count

3. 실행 코드

houses = []

for i in range(N):
    for j in range(N):
        if graph[i][j] == 1:
            houses.append(bfs(i, j))  # dfs(i, j)로 변경 가능

houses.sort()

print(len(houses))
for house in houses:
    print(house)

풀이 팁 및 정리

1. 연결 요소 문제 패턴

• 1 발견 → 탐색 시작
• 연결된 모든 1 방문 처리
• 개수 카운트

이 패턴은 매우 자주 등장하므로 익혀두는 것이 중요하다.

2. 방문 처리 방법

• visited 배열 사용
• graph 값 직접 변경

이 문제에서는 1 → 0으로 변경하는 방식이 더 간단하다.

3. BFS vs DFS 차이

• BFS → queue.popleft()
• DFS → 재귀 또는 stack

이 문제는 둘 다 가능하지만 구현 방식은 구분해야 한다.

4. map 함수 활용

list(map(int, input()))

문자열을 한 글자씩 나누어 정수로 변환한다.

예: "10101" → [1, 0, 1, 0, 1]

마무리

이 문제는 그래프 탐색의 기본인 연결 요소 개념을 연습하기에 적합한 문제이다. BFS와 DFS 구조, 방문 처리 방식을 확실히 이해하고 넘어가는 것이 중요하다.

CloudFront는 정적데이터 동적데이터 모두 처리 가능하다. CDN이면 '캐시서버'아닌가? 그럼 정적 파일만 해당하는거 아닌가?

로그인 API, 게시글 조회 같은 동적 요청은 캐싱도 못 하는데 그럼 CloudFront를 왜 쓰는 거지?

결론부터 말하자면,

CloudFront는 동적 데이터를 캐싱하지 않는다. 대신 동적 데이터를 가장 빠른 네트워크 경로로 전달해준다.

CloudFront의 두 가지 역할

CloudFront는 단순한 “캐시 서버”가 아니다. 실제로는 두 가지 모드로 동작한다.

👉 동적 콘텐츠는 Cache 모드가 아니라 Proxy 모드로 처리된다.

동적 요청은 실제로 어떻게 흐를까?

예를 들어, 사용자가 아래 API를 호출한다고 해보자.

https://www.example.com/api/posts

CloudFront 없이 요청할 경우

한국 → 미국 리전 ALB → EC2 → DB → 다시 한국

• 요청과 응답이 공용 인터넷을 왕복
• 물리적 거리 + 네트워크 혼잡
• 지연 시간(latency) 증가, 변동성 큼

CloudFront를 사용하는 경우 (동적 요청)

사용자
 → 가장 가까운 CloudFront Edge
 → AWS 전용 글로벌 네트워크
 → Origin(ALB)

사용자와 먼 서버 사이를 이미 뚫려있는 전용 고속도로를 이용해 빠르게 접근할 수 있다.

📌 이 방식을 Dynamic Content Acceleration이라고 부른다.

Dynamic Content Acceleration 의 핵심 원리

1️⃣ TCP/IP 핸드셰이크 최적화 : Edge에서 연결을 끝낸다 (Edge Connection Termination)

가장 큰 차이는 TCP/IP 핸드셰이크가 어디서 일어나느냐다.

• CloudFront 미사용

  사용자 ↔ 멀리 있는 원본 서버 TCP 핸드셰이크 + TLS 설정을 먼 거리에서 수행

  사용자가 전 세계 어디에 있든 멀리 떨어진 원본 서버(서울, 미국 등)와 직접 "연결할 준비가 됐니?"(TCP Handshake)라며 서너 번의 신호를 주고받아야 합니다. 거리가 멀수록 이 과정에서 시간이 많이 걸립니다.

• CloudFront 사용

  사용자 ↔ 가장 가까운 Edge Location 물리적 거리가 짧아 초기 연결이 매우 빠름

  사용자는 가장 가까운 곳에 있는 CloudFront 엣지 로케이션과 즉시 연결을 맺습니다. 엣지까지의 거리는 매우 가깝기 때문에 초기 연결 속도가 압도적으로 빠릅니다. 그 이후 엣지와 원본 서버 사이는 이미 연결이 뚫려 있는 '고속도로'를 이용하게 됩니다.

👉 즉, 사용자는 가까운 엣지 로케이션과 핸드셰이크(연결)하면된다. 엣지 로케이션은 멀리떨어진 원본서버와 미리 연결되어있는 상태다. (이미 뚫려있는 ‘고속도로’)

2️⃣ Edge와 Origin은 이미 연결돼 있다 (Keep-Alive & Connection Pooling)

이 부분이 성능 향상의 숨은 주역이다.

• 일반적인 서버 통신

  요청마다 연결 생성 → 종료 반복

  일반적으로 서버와 통신할 때는 데이터를 주고받을 때마다 연결을 맺고 끊는 과정이 반복됩니다.

• CloudFront

  Edge ↔ Origin(ALB/EC2) 사이에 이미 수많은 연결을 미리 유지

  하지만 CloudFront 엣지 서버는 원본 서버(ALB/EC2)와 이미 수많은 연결을 미리 맺어놓고 유지(Connection Pooling)하고 있습니다. 사용자의 요청이 들어오면, 새로 연결을 만드는 시간을 낭비하지 않고 이미 열려 있는 통로에 데이터를 바로 실어 보냅니다. 이로 인해 왕복 시간(RTT)이 획기적으로 줄어듭니다.

👉 새로 연결을 만드는 시간이 0이다. 이미 뚫려 있는 통로에 요청을 바로 실어 보낸다

3️⃣ AWS 전용 글로벌 네트워크를 탄다

데이터가 이동하는 “길” 자체가 다르다.

• 공용 인터넷

  • ISP 여러 곳을 경유
  • 병목, 우회, 품질 변동 발생

  수많은 통신사(ISP)를 거치며 복잡하게 얽혀 있습니다. 트래픽이 몰리는 구간에서 병목 현상이 발생하거나 경로가 길어질 수 있습니다.

• AWS 전용 네트워크

  • CloudFront Edge → Origin까지 AWS 글로벌 광섬유 백본망

  CloudFront 엣지에서 원본 서버까지는 전 세계에 깔린 AWS 전용 광섬유 네트워크를 통해 이동합니다. 전용 고속도로를 타는 것과 같아서 지연 시간(Latency)이 일정하고, 공용 인터넷보다 훨씬 안전하고 빠릅니다.

👉 전용 고속도로를 타는 것과 같다.

4️⃣ 실시간 네트워크 경로 최적화

CloudFront는 네트워크 상태를 실시간으로 감시한다.

• 특정 구간이 느려지면
• 자동으로 더 빠른 우회 경로 선택

개발자가 직접 제어하기 어려운 영역을 AWS가 인프라 레벨에서 대신 처리해준다.

그래서 동적 데이터에 왜 유리할까?

동적 데이터는 반드시 Origin까지 가야 한다. 캐싱이 안 되기 때문이다.

그럼에도 CloudFront가 효과적인 이유는 명확하다.

✔ 연결 시간 자체를 줄인다

• TCP 3-way handshake
• TLS handshake → 이 왕복 과정을 Edge에서 끝내버린다

✔ 이미 워밍업된 연결을 재사용한다

• TCP Slow Start 문제 없음
• 처음부터 높은 전송 속도 유지

✔ 결과

“동적 데이터라도 체감 응답 속도는 확실히 빨라진다.”

💫 참고

• https://velog.io/@gagaeun/AWS-EC2-Instance-Storage-Section
• Udemy Ultimate AWS Certified Solutions Architect Associate (SAA)

EBS

💡 Volume 볼륨 EC2 인스턴스에 연결되어 데이터를 저장하는 블록스토리지 = EC2가 사용하는 하드디스크

💡 EBS (Elastic Block Store) 네트워크로 연결된 볼륨

• 인스턴스와 EBS가 서로 같은 가용영역(AZ)에 있어야 연결가능하다.
  • us-east-1a에서 생성된 경우 us-east-1b에는 연결이 불가능하다.
• 인스턴스가 종료된 후에도 데이터를 지속적으로 유지할 수 있도록 하기위함이다.
• CCP 레벨에서 한 번에 하나의 인스턴스에만 마운트될 수 있다.
  • CCP 레벨: 하나의 EBS는 하나의 EC2 인스턴스에만 마운트 가능 (하나의 EBS에 여러 인스턴스 불가능)
  • Associate 레벨: 일부 EBS 다중 연결 (e.g. 하나의 EBS에 2개의 인스턴스 마운트 가능)
• 네트워크 USB스틱이라고 생각하면 쉽다. 물리적으로 연결되는건 아니지만 네트워크를 통해 연결된다.
• 미리 용량(size), IOPS 등을 결정해야 한다.
• 인스턴스에 연결하지 않은 상태로 그냥 두어도 된다.
• 인스턴스 종료 시 자동삭제 여부를 설정할 수 있다. (디폴트 : 루트볼륨은 자동삭제, 다른 볼륨은 삭제되지 않음.)

💡 루트 EBS 볼륨 인스턴스를 생성하면 기본적으로 생성되는 볼륨으로, 인스턴스가 부팅할 때 사용하는 운영체제가 설치된 EBS 볼륨이다. = EC2의 C드라이브

• 인스턴스 종료시 루트볼륨은 자동으로 삭제되는것이 디폴트이다.
• 하나의 인스턴스에 루트볼륨 외에 다른 볼륨도 부착할 수 있다.

EBS Snapshot

💡 EBS Snapshot EBS 볼륨의 특정시점에 대한 백업이다.

• EBS볼륨과 다르게 서로 다른 AZ, 리전에도 복사가 가능하다.

EBS Sanpshots Features

• EBS Snapshot Archive
  • 아카이브 티어로 백업을 옮긴다.
  • 즉시 복원되지 않는다. 24-72시간이 걸리지만 75% 더 저렴하다.
  • 적합한 경우 : 장기보관목적으로 사용된다.
• Recycle Bin for EBS Snapshots
  • 스냅샷을 삭제하면 바로 영구삭제되지 않고 휴지통에 넣어진다. 복구 가능
  • 디폴트는 바로 삭제되지만, 휴지통기능을 따로 설정해주면 실수로 삭제하는 경우를 대비할 수 있다.
  • 삭제 후 유지할 스냅샷 보존 기간은 1일부터 1년까지 지정 가능.
• Fast Snapshot Restore (FSR)
  • 스냅샷 → 볼륨으로 복원하는 과정을 빠르게 진행한다.
  • 다만, 비용이 많이 든다.

AMI

💡 AMI (Amazon Machine Image) EC2 인스턴스를 만드는데 필요한 템플릿 이미지 즉, EC2를 만들 때 OS, 애플리케이션, 설정 등을 복제해서 똑같이 다시 만들 수 있는 스냅샷.

• 인스턴스 생성할 때 Amazon Linux, Ubuntu 등 선택하는걸 말함. (또는 내가 직접 커스텀한 이미지 선택가능)
• AMI에다 원하는 소프트웨어 또는 설정 파일을 추가하거나 별도의 운영 체제를 설치할 수도 있고 모니터링 툴을 추가할 수도 있다.
• AMI를 따로 구성하면(커스터마이징), 부팅 및 설정에 드는 시간을 줄일 수 있다. (EC2 인스턴스에 설치하고자 하는 모든 소프트웨어를 AMI가 미리 패키징해주니까)
• AMI의 종류
  • Public AMI : AWS에서 제공하는
  • Your own AMI : 내가 직접 구성한
  • An AWS Marketplace AMI : 다른사람이 만든 AMI 가져다

AMI 생성 과정

1. EC2 인스턴스를 띄움
2. 필요한 설정/애플리케이션 설치
3. 인스턴스 상태가 완성되면
4. "Create Image" 클릭 or AWS CLI로 AMI 생성
5. EC2 상태를 기반으로 AMI(스냅샷) 생성됨
6. 나중에 이 AMI로 EC2를 다시 만들면 → 똑같은 상태로 복제됨!

EC2 인스턴스 스토어

💡 EC2 Instance Store EC2 인스턴스 물리서버에 물리적으로 직접 연결된 하드웨어 드라이브를 가리킨다.

• 물리적으로 연결되어있다보니 속도가 빠르다.
• I/O 성능향상을 위해 활용된다.
• 인스턴스 중지, 종료하면 스토리지가 손실된다. (그래서 임시 스토어라고함)
• 장기적으로 보관할만한 곳이 아님
• 적합한 경우 : 버퍼,캐시, 임시콘텐츠 사용하는 경우에 적합. (장기는 ebs가 적합)
• 기본서버에 장애발생하면 여기에도 장애발생하므로 데이터 백업, 복제해둬야함.

EBS 볼륨 유형

EBS 볼륨을 정의하는 요소 : 크기, 처리량, IOPS(I/O Ops Per Sec)

General Purpose SSD

💿 gp2 / gp3 (SSD)

• 범용 SSD 볼륨

• 효율적인 비용, low-latency 낮은 지연시간

• gp2보다 gp3가 최신세대 볼륨

• gp2 : 볼륨크기에 따라 IOPS가 비례해서 증가한다. (i.e. 볼륨의 GB수를 늘리면 IOP도 늘어남)

• gp3 : 최신 표준, IOPS와 처리량을 독립적으로 설정할 수 있다. 대부분의 워크로드에 추천.

Provisioned IOPS (PIOPS) SSD

💿 io1 / io2 (SSD) 가장 높은 성능의 SSD 볼륨, IOPS를 매우 높고 안정적으로 보장한다.

• 적합한 곳 : 미션 크리티컬, 저지연, 고처리량 작업, 금융, 대규모 트랜잭션에 사용
• IOP 16,000 이상 필요한 경우에 적합

Hard Disk Drives (HDD)

• Throughput Optimized HDD (처리량 중심 HDD)

  💿 st1 (HDD) 저비용 HDD 볼륨. 자주 액세스되는 처리량 중심 작업을 위해 설계됨.

  • 적합한 곳 : 로그 처리, 빅데이터, 스트리밍 워크로드

• Cold HDD (저비용 HDD)

  💿 sc1 (HDD) 가장 저렴한 HDD 볼륨. 접근빈도가 낮은 작업을 위해 설계됨.

  • 적합한 곳 : 백업 데이터, 장기 보관용 데이터
  • Cold = 자주 안 쓰는 데이터 = 접근빈도 낮으므로 느려도 된다. = 싼 게 최고(저비용)

• 부팅볼륨으로 사용할 수 없다. (OS의 루트가 실행되는 위치)

✏️ 시험 대비용 한 줄 요약

데이터베이스가 필요한 경우 범용 SSD와 프로비저닝된 IOP SSD이고, 높은 처리량과 가장 낮은 비용이 필요하다면 ST1 또는 SC1이다.

• 범용 → gp3
• DB 고성능(32,000 이상의 IOP) → io2 (또는 io1)
• 로그/빅데이터 → st1
• 백업/저장 → sc1

EBS 다중 연결

💡 EBS Multi-Attach (다중연결) 동일한 EBS 볼륨을 동일한 AZ에 있는 다수의 EC2 인스턴스에 연결

• io1 / io2 family
• 애플리케이션이 동시 쓰기작업할때 사용한다.
• 한번에 16개 인스턴스까지 연결가능하다.
• 클러스터 인식 파일시스템을 사용해야한다.

EBS 암호화

• 백그라운드에서 처리된다.
• 지연시간에는 거의 영향이 없다.

Encrypt an unencrypted EBS volume

암호화되지않은 볼륨 암호화하기 → 스냅샷을 복사해 암호화한 후, 암호화된 스냅샷을 통해 볼륨을 생성하면 된다. (자동으로 볼륨도 암호화됨)

1. 볼륨의 EBS Snapshot 생성
2. 복사기능을 통해 EBS Snapshot 암호화한다.
3. 스냅샷을 이용해 새 EBS 볼륨을 생성하면 해당 볼륨도 암호화된다.
4. 암호화된 볼륨을 인스턴스 원본에 연결한다.

• 암호화되지 않은 EBS 볼륨에서 생성한 스냅샷은 암호화되지 않는다.
• Actions > Copy snapshot (encrypt 옵션체크하기) > 스냅샷A 완성.
• 스냅샷A에서 create volume from snapshot > 자동으로 encryption 체크되어있음.
• 암호화되지않은 스냅샷에서 바로 암호화 활성화 체크해서 볼륨생성도 가능하다.

Amazon EFS

💡 EFS (Elastic File System) 여러 EC2가 동시에 접근가능한 네트워크 파일 시스템(NFS)으로 EC2 인스턴스가 서로 다른 AZ에 있어도 가능하다.

• 확장성 O, 가용성 O
• 단, 윈도우 안됨. 리눅스 기반 AMI와만 호환된다.
• 그만큼 비싸다. (EBS gp2의 3배)
• 사용량에 따라 비용을지불하므로 미리 용량에 대해 프로비저닝할 필요가 없다. (용량 미리 계획할 필요 없다는 뜻) 자동으로 확장되며, GB 사용량에 따라 비용을 지불한다.
• 보안그룹 설정 필요

Performance Classes

• EFS Scale

Storage Classes

• Performance Mode
  • General Purpose : 고성능, low-latency
  • Max I/O
• Throughput Mode
  • Bursting
  • Provisioned
  • Elastic : 작업 부하에 따라 처리량을 자동으로 조정

Storage Classes → 최대 90% 비용 절감 가능

• Storage Tiers
  • Standard
  • Infrequent access(EFS-IA)
  • Archive
  • Implement lifecycle policies
• Availability and durability
  • Standard
  • One Zone : 하나의 AZ, 비용 절감

💡 Private IP AWS VPC등 특정 네트워크 안에서 서로를 인식하기 위한 IP

예를들어 A회사와 B회사의 네트워크안에는 동일한 사설IP가 존재가능하다. 그 회사 네트워크 안에서만 유일하면 됨.

💡 Public IP 외부 인터넷 세상에서, 전 세계적으로 고유하게 식별하기위한 IP

💡 Elastic IP (탄력적 IP) AWS가 제공하는 고정된 Public IP 주소

EC2 배치그룹

💡 배치그룹 EC2 인스턴스들을 물리적으로 어떻게 배치할지 지정하는 기능

클러스터 배치그룹 (Cluster)

💡 클러스터 배치그룹 모든 EC2 인스턴스들을 같은 AZ안에 두는 방식.

• 장점
  • EC2간 거리가 가까우니 latency 짧고, 네트워크 처리량 향상된다.
• 단점
  • 가용영역에 장애가 생기면 모든 인스턴스들에 장애가 발생한다.
• 적합한 경우
  • 매우 빠른 네트워킹, 많은 네트워크 처리량 필요한 경우

분산 배치그룹 (Spread)

💡 분산 배치그룹 모든 EC2 인스턴스가 각각 다른 하드웨어에 위치하여 실패 위험을 최소화한 구조 (최대 고가용성)

• 장점
  • 여러 가용영역에 걸쳐 있으므로 실패위험 감소한다.
  • 장애가 생겨도 인스턴스 간에 서로 영향을 끼치지 않는다. (3가지 종류의 배치그룹 중 최대 가용성)
• 단점
  • 가용영역당 최대 7개의 인스턴스가 가능하다.
  • 따라서 규모가 제한적. 대규모 서비스에는 부적합.
• 적합한 경우
  • 인스턴스 오류를 격리해야하는 경우 적합, 매우 중요한 크리티컬 작업에 적합

분할 배치그룹 (Partition)

💡 분할 배치그룹 EC2들을 파티션 단위로 나눈 구조(각 파티션은 서로 다른 하드웨어에 위치)

각 파티션은 AWS의 랙(서버들을 적층한 선반구조물)을 의미한다. 파티션이 많으면 인스턴스가 여러 하드웨어 랙에 분산되어 랙 실패로부터 안전하다.

각 파티션에는 수백개 이상의 EC2가 가능하다.

• 장점

  • 파티션이 많을수록 인스턴스들이 서로 다른 랙 하드웨어에 배치된다는 의미이므로 실패 위험이 감소한다. (분산 배치그룹의 장점처럼)
  • 하나의 파티션당 수백대의 EC2들이 가능(분산배치그룹의 규모제한 단점을 이겨냄)하면서도
  • 클러스터 배치그룹 보다 EC2간 서로 실패영향력이 적다.

• 단점

  관리 복잡도 (파티션 지정 필요)

배치그룹 총 정리/비교

ENI 탄력적 네트워크 인터페이스

💡 ENI (Elastic Network Interfaces) EC2 인스턴스에 꽂는 가상 네트워크 카드 (IP주소, 보안그룹 등의 네트워크 속성을 담고있다.)

• 하나의 EC2에 여러개 ENI를 부착할수 있다.
• A 인스턴스에서 장애가 나면 ENI를 B로 이동시키면 된다. → IP주소를 쉽게 옮기게 해주는 역할, 장애 해결! 고가용성 확보
• 특정 가용영역에 바인딩된다. = 특정 AZ에서 ENI를 생성하면 해당 AZ에만 바인딩 가능. = 다른 AZ에 있는 EC2와는 연결 할 수 없다.

EC2 Hibernate (최대 절전 모드)

💡 EC2 Hibernate 인스턴스를 잠시 중단했다가 다시 켜도 RAM의 상태를 보존시켜주는 모드이다.

• RAM 상태를 암호화된 EBS 루트 볼륨에 저장하고, 다시 킬때 이를 복원시킴으로서 더 빠르게 부팅되도록 돕는다.
  • 일반적(stop) : ec2를 껐다 켜면 → 메모리 초기화
  • hibernate : ram 내용을 ebs에 저장하고, 다시 시작할때 그 상태 복원
• 중지한 적이 없는 것처럼 운영체제가 인식하게 하는 것이 절전모드의 목적이다.
• RAM에 있는 메모리상태는 그대로 보존됨 → 부팅 더 빨라진다는 뜻
• 인스턴스 RAM 최대 크기는 150 GB
• EBS에만 저장 가능
• 루트 EBS 볼륨이 암호화되어있어야 한다.
• 최대 60일까지 절전모드 가능
• 인스턴스 종류(온디맨드, 예약…)에 상관없이 가능
• 루트볼륨에 RAM을 저장할 수 있는 충분한 공간이 있어야 한다. (e.g. RAM이 1GB인 t2.micro인스턴스의 경우, 8GB의 볼륨은 충분하다.)

💡 EC2 AWS에서 임대하는 가상 서버다.

OS, CPU, RAM, 스토리지, Network, 보안그룹(방화벽 규칙)등을 선택 가능하다.

💡 부트스트래핑 Bootstrapping

EC2 인스턴스가 처음 실행될때 자동으로 실행되는 스크립트를 의미한다.

EC2 생성할 때 ‘User Data’에 스크립트를 넣어주면 된다. 패키지 설치, 설정 파일 작성, 애플리케이션 실행 등을 자동으로 처리할 수 있다.

EC2 인스턴스 생성하는 방법

1. AMI 선택
2. 인스턴스 유형 선택
3. 키페어 설정(SSH 사용하기 위해)
4. 네트워크 설정
5. 스토리지 설정
6. User Data
7. 등등

💡 AMI (Amazon Machine Image) EC2의 이미지. 운영체제+설정 을 의미한다.

💡 Instance Type 인스턴스 유형 EC2의 하드웨어 스펙(CPU, Ram 등)을 의미한다. t2.micro, m5.2xlarge ... 등

EC2 인스턴스 유형 예제

m5.2xlarge

• m : 인스턴스 클래스
• 5 : generation
• 2xlarge : 인스턴스 크기

1. 범용

e.g. M5 인스턴스

2. 컴퓨팅 최적화

e.g. C5 인스턴스

3. 메모리 최적화

e.g. R6g 인스턴스 (R로 시작, Ram을 의미), X1, Z1

4. 가속 컴퓨팅

e.g. P4 인스턴스

5. 스토리지 최적화

e.g. D2 인스턴스, I, D, H1

EC2 요금

1. AWS 프리티어

t2.micro 달에 750시간 까지 무료 (인스턴스 여러개에서 합산가능)

2. 온디맨드 인스턴스

사용한 만큼 지불하는 요금제 (초 or 시간 단위로 과금)

• 사용량을 예측할 수 없고, 중단되면 안되는 워크로드에 적합
• Linux/Ubuntu : 최초 1분 이후 초단위로 요금 결제
• Window/Mac : 시간 단위로 요금 결제

3. 스팟 인스턴스

최대 90%까지 할인. 단, AWS가 필요할때 언제든 회수해 갈 수 있다.

• 중요한 작업에는 적합하지 않다.
• 짧은 워크로드, 배치작업 등 시작/종료 시간을 유연하게 설정가능한 경우에 적합하다.

4. 예약 인스턴스

5. Saving Plans

예약 인스턴스 Vs. Saving Plans

• 공통점
  • 1~3년간 약정
  • 온디맨드에 비해 72-5% 절감 가능
  • 장기 워크로드를 위함.
• 예약 인스턴스 : 인스턴스 타입 변경 불가능!
• Saving Plans : 인스턴스 타입, 리전 중간에 변경 가능. (유연함)

6. 전용 호스트 / 전용 인스턴스

다른 고객과 h/w를 공유하지 않는다. 가장 비싼 옵션.

• 전용 호스트 : 서버 통째로 독점 (호텔 건물 통째로 임대)
• 전용 인스턴스 : 서버는 공유, 내 인스턴스는 독점 (호텔방만 임대)

보안 그룹

• ec2의 방화벽으로 , 포트에 대해 액세스를 규제한다.

• IP주소 기준으로 규칙을 설정

• 보안그룹과 인스턴스 사이에는 1:1 관계가 없다.

• 하나의 인스턴스에는 여러 보안그룹이 가능하다.

• ssh 액세스를 위해 보안그룹을 분리하는 편이 낫다. (개발자를 위한 조언)

• 인바운드 트래픽 (www → ec2) : 디폴트는 모두 거부

• 아웃바운드 트래픽 (ec2 → www) : 디폴트는 모든 트래픽 나가는거 허용

Classic Ports to know

• 22번 포트 : SSH, Secure Shell
• 22번 포트 : SFTP Secure File Transfer Protocol (SSH를 이용해 파일 업로드)
• 21번 포트 : FTP
• 80번 포트 : HTTP access unsecured websites → 웹브라우저에서 ip 입력해서 aws접근가능했던게 이 덕분. (80포트 0.0.0.0/0 인바운드로 설정 → 이 룰 삭제하면 웹 브라우저에서 접근 불가능하다. 보통 타임아웃 뜨면 100% 보안그룹 문제다.)
• 443번 포트 : HTTPS
• 3389번 포트 : RDP, 원격 데스크톱 프로토콜

다른 보안그룹의 보안그룹을 참조하는 방법

참고 https://www.udemy.com/course/best-aws-certified-solutions-architect-associate/

💡 IAM (Identity Access Management) AWS의 보안 인증 서비스로, AWS 계정 및 리소스에 대한 보안을 관리하고 권한을 제어한다.

• IAM은 글로벌 서비스다. (선택할 리전이 없다는 뜻)
• 실제 물리적 사용자와 매핑한다.

Root Account

• 처음 계정을 생성하면 기본적으로 만들어진다.
• 루트 계정은 처음 계정생성했을때만 사용하고, 이후에는 IAM으로 Users를 만들어 사용하는 것이 권장된다.(보안 강화를 위해)

IAM Users

: 사용자

• 하나의 사용자는 여러 그룹에 속할 수 있다.
• 반드시 사용자가 그룹에 속해야하는건 아니다.
• IAM 정책은 IAM 사용자에게 직접 지정, 연결할 수 있다. (그룹을 통해 정책 지정하는 것이 아닌 사용자 개별마다 직접 지정가능)

IAM Groups

: 사용자들을 묶어 그룹으로 관리한다.

• 그룹안에 그룹을 포함시킬 수 없다.

방어 매커니즘

1. 비밀번호 강화

2. MFA (Multi-Factor Authentication)

비밀번호 + 보안기기를 사용하여 이중으로 보안을 강화한다.

MFA의 이점은 앨리스가 비밀번호를 도난당하거나 해킹당하여 비밀번호를 잊어버린 경우에도 해커가 앨리스의 물리적 장치도 확보해야 하므로 계정이 손상되지 않는다는 것입니다

• Virtual MFA

  실제 장비 없이도 보안을 강화해준다. 예시로 스마트폰에 인증앱을 설치하는 방법이 있다.

  로그인할때 비밀번호 + 스마트폰 twilio 인증앱에서 생성된 인증코드를 웹사이트에 그대로 입력

• 물리적 장치 (e.g. 보안토큰)

Permissions

• IAM 정책을 JSON 문서로 지정

💡 최소 권한의 원칙 (least privilege principle) : 사용자 또는 시스템이 업무 수행에 꼭 필요한 권한만 부여받아야 한다.

Policies Structure

{
  "Version": "2012-10-17",
  "Statement": [
    {
      "Sid": "PublicReadGetObject",
      "Effect": "Allow",
      "Principal": {
              "AWS": "arn:aws:iam::123456789012:user/Alice"
            },
      "Action": "s3:GetObject",
      "Resource": "arn:aws:s3:::my-public-bucket/*"
    }
  ]
}

Consists of

• Version:
• Id:
• Statement: 한 개 이상의 statements (required)

Statements consist of

• Sid(시드): Statement ID (선택사항)
• Effect(효과): Allow / Deny
• Principal(원칙/주체): 누가 액세스하는지
• Action(조치): 어떤 API를 허용/거부할지
• Resource(리소스): 어떤 리소스에 적용할지
• Condition(조건):

IAM Roles 역할

→ 임시된 권한 부여

다른 AWS 리소스나 서비스에 임시로 액세스하기 위해서 특정사용자나 서비스가 임시적으로 권한을 얻게하는 방법이다.

⛑️ 모자로 생각하면 이해하기 쉽다. Developer가 DA모자를 쓰면 잠시 DA업무를 수행가능하게된다. 단, 기존의 Developer의 권한은 없어진다.

IAM 보안도구

→ 계정의 권한을 감시하기 위함이다.

1. IAM Credential Reports 자격증명보고서 csv파일로 생성됨. 계정을 생성한 시기, pw를 바꾼 시기, access key를 만든 시기… 등에 대한 정보를 파악가능.

2. IAM Access Advisor 액세스 관리자 언제 어떤 서비스에 접근했는지를 보여준다.

How can users access AWS?

1. Management Console

AWS 관리를 위한 웹 기반 인터페이스 (aws 웹에서 접속하는 방법)

2. AWS CLI

Command Line Interface AWS를 CLI로 접근하는 방법, access key가 필요하다.

3. AWS SDK

Software Development Kit 코드 내에서 API를 호출하기 위한 방법, access key가 필요하다.

IAM Section – Summary

• Users: mapped to a physical user, has a password for AWS Console
• Groups: contains users only
• Policies: JSON document that outlines permissions for users or groups
• Roles: for EC2 instances or AWS services
• Security: MFA + Password Policy
• AWS CLI: manage your AWS services using the command-line
• AWS SDK: manage your AWS services using a programming language
• Access Keys: access AWS using the CLI or SDK
• Audit: IAM Credential Reports & IAM Access Advisor

참고 https://www.udemy.com/course/best-aws-certified-solutions-architect-associate/

node -v

노드 버전 확인결과, v20.14.0 으로 확인되었다.

현재 프로젝트에서는 18버전으로 진행해야하므로 버전을 바꿔보자.

이를 위해 nvm (Node Version Manager) 설치하면 편하다!

1단계: nvm 설치 확인

nvm -v

확인해서 버전이 나오면 OK

버전값이 안 나오면 설치해야 한다.

2단계: nvm 설치 (맥 기준)

💡 nvm이 무엇인가?

• Node Version Manager
• 말 그대로 Node.js 버전을 여러 개 깔아놓고, 필요할 때마다 바꿔 쓰게 해주는 도구야.
• 예: 프로젝트 A는 18, 프로젝트 B는 20 써야 할 때 nvm use 18, nvm use 20 이런 식으로 전환 가능.

1. 내가 zsh인지 bash인지 먼저 확인

맥은 기본이 보통 zsh야.

echo $SHELL

• /bin/zsh → zsh 사용 중 → .zshrc 설정
• /bin/bash → bash 사용 중 → .bashrc 설정

대부분 요즘 맥은 /bin/zsh 나올 거야.

2. nvm 설치 (Homebrew 사용, 맥 기준)

터미널에서 아래 명령어 실행

brew install nvm

설치가 완료되면 brew가 이런 식으로 메시지를 줄 수도 있는데 그게 바로 .zshrc / .bashrc에 넣으라는 내용이야.

Add the following to your profile: ...

You should create NVM's working directory if it doesn't exist:
  mkdir ~/.nvm

Add the following to your shell profile e.g. ~/.profile or ~/.zshrc:
  export NVM_DIR="$HOME/.nvm"
  [ -s "/opt/homebrew/opt/nvm/nvm.sh" ] && \. "/opt/homebrew/opt/nvm/nvm.sh"  # This loads nvm
  [ -s "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm" ] && \. "/opt/homebrew/opt/nvm/etc/bash_completion.d/nvm"  # This loads nvm bash_completion

3. ~/.nvm 폴더 만들기

mkdir -p ~/.nvm

• p는 “이미 있어도 에러 내지 말고 그냥 넘어가” 옵션.
• nvm이 내부적으로 Node 버전들을 저장하는 디렉토리라고 생각하면 돼.

4. .zshrc / .bashrc를 왜 수정하냐?

💡.zshrc / .bashrc가 하는 일

• 둘 다 “쉘 시작할 때 자동으로 읽는 설정 파일”이야.
• 터미널을 새로 열면:
  • zsh 쓰는 경우 → ~/.zshrc 내용 자동 실행
  • bash 쓰는 경우 → ~/.bashrc 내용 자동 실행
• 보통 여기에
  • PATH 설정
  • alias (예: alias ll='ls -al')
  • 각종 툴 초기화 코드 (nvm, pyenv, rbenv 등) 를 넣어.
    👉 즉, “터미널 켤 때마다 매번 손으로 치기 귀찮은 설정들을 모아두는 곳”이라고 생각하면 됨.

zsh를 쓰는 경우 (~/.zshrc 수정)

vim ~/.zshrc

파일 맨 아래에 아래 내용 추가:

export NVM_DIR="$HOME/.nvm"
source $(brew --prefix nvm)/nvm.sh

• NVM_DIR

  → nvm이 설치된/설치될 디렉토리를 환경 변수로 알려주는 역할

• source $(brew --prefix nvm)/nvm.sh

  → “nvm 기능을 현재 쉘에서 사용할 수 있게 스크립트를 불러온다”는 뜻

  → 이 줄이 있어야 nvm 명령이 인식돼.

수정 끝나면 esc → :wq!로 저장 & 종료.

그리고 변경사항을 지금 쉘에 반영:

source ~/.zshrc

5. nvm 잘 깔렸는지 확인

nvm -v

예를 들어:

0.40.3

이런 식으로 버전이 나오면 성공 🎉

이제 Node 18 설치 가능!

3단계: Node 18 설치하기

nvm install 18
nvm use 18
node -v   # v18.x.x 나오면 OK

🔍 정리: 왜 .zshrc / .bashrc를 만드는/수정하는가?

한 줄로 말하면:

터미널이 켜질 때마다 nvm을 자동으로 사용할 수 있게 “초기 설정을 등록하는 파일”이라서.

조금 길게 말하면:

• nvm은 그 자체로 하나의 “스크립트”
• 그 스크립트를 매번 손으로 source 하기 귀찮으니까
• ~/.zshrc 또는 ~/.bashrc에 “이 스크립트 불러와!”라고 써두는 것
• 그러면 터미널 새로 열 때마다 자동으로 실행 → nvm 명령이 항상 준비 완료 상태가 됨

• 행 ($i$): $i$번째 물건까지 고려했을 때
• 열 ($w$): 배낭의 현재 용량이 $w$일 때값
• $DP[i][w]$: $i$번째 물건까지 고려하고 배낭 용량이 $w$일 때 가질 수 있는 최대 가치

💎 루비를 선택하는 경우(dp[루비])

💎 다이아를 선택하는 경우 (dp[다이아] = 각 무게별로 [루비, 다이아]에서 만들어낼 수 있는 최대 가치합)

💎 사파이어를 선택하는 경우 (dp[사파이어] = 각 무게별로 [루비, 다이아, 사파이어]에서 만들어낼 수 있는 최대 가치합)

• 가방의 크기가 7인 경우,
  • 사파이어를 챙길 경우 남은 공간 2, 남은 공간이 2일 경우 루비, 다이아 두가지 보석 모두를 이용해도 더 넣을 수가 없으므로 가치는 5,
  • 사파이어를 챙기지 않은 경우 이전에 구해둔 9가 최대이기 때문에 최대이윤은 9가됩니다.
• 가방의 크기가 8인 경우
  • 사파이어를 챙길 경우, 남은공간은 3, 이미 테이블을 통해 가방의 크기가 3일 때 루비/다이아를 이용해 구할 수 있는 최대 이윤은 6임을 구했습니다. 사파이어 가치 5 + ~다이아까지 넣을 떄 최대이윤 6 = 11, 즉 최대이윤이 11이 됩니다.

현재 내가 구하려고 하는 셀의 값은 MAX(현재 보석의 가치+남은가방크기만큼 나머지 보석을 넣을 때 최대 가치, 이전까지 구해둔 보석의 가치)

즉, ans[i][j] = max(profit[i] + ans[i-1][j-weight[i], ans[i-1][j]]

최종 코드

n, k = map(int, input().split())

weight = [0]
value = [0]

for i in range(n):
    w, v = map(int, input().split())
    weight.append(w)
    value.append(v)

dp = [[0] * (k+1) for i in range(n+1)]

# dp 리스트 채우기
for i in range(n+1):
    for j in range(1, k+1):
        if weight[i] <= j:
            dp[i][j] = max(value[i] + dp[i-1][j-weight[i]], dp[i-1][j])
        else:
            dp[i][j] = dp[i-1][j]

# 최종 답
answer = max(dp[n-1])

print(answer)

• DP의 행과 열을 1-based로 한 이유 (DP가 N+1행, K+1열인 이유) N=1인 경우, DP[i-1][j]값이 존재해야 한다. 즉, 아무것도 담지 않은 빈 배낭의 상태를 초기화 해놓기 위해 0행, 0열이 필요하다.

배운 점 정리

도무지 모르겠어서 풀이 참고 사이트 를 참고했다.

dp[i] = i요소를 반드시 포함하는 경우의 최대 가치의 합 까지는 알고리즘을 떠올려봤는데, [루비] → [루비, 다이아] → [루비, 다이아, 사파이어] 이런식으로 요소들을 누적시켜서 계산할 생각은 못했다. (그게 바로 DP의 핵심인데 왜 못떠올렸을까...)

처음엔 n행은 0-based로, k열은 1-based로 설정하였다. 그래서 dp[0][]을 초기화한 후 dp[1][]부터 순회하도록 구현했다. 그러나 행또한 1-based로 하면 굳이 초기화 코드가 없어도 된다는걸 깨닫고 행과 열 모두 1-based로 수정했다.

이전에 풀었던 비슷한 유형의 문제 : 11053. 가장 긴 증가하는 부분 수열 (DP) 🥈2️⃣

🧩 문제

수열이 주어졌을 때, 증가하는 부분 수열 중 합이 가장 큰 값을 구하기.

예를 들어 10 30 10 20 20 50 이라면,

가능한 증가 부분 수열 중 합이 가장 큰 건 10 + 20 + 50 = 80 또는 10 + 30 + 50 = 90 → 답은 90

✏️ 나의 알고리즘

이전에 풀었던 LIS문제와 다르게 이 문제는 길이가 아니라 합을 기준으로 해야 한다.

1. DP 배열 정의

먼저, 수열을 seq[0] ~ seq[n-1] 라고 할 때,

*💡 DP 리스트의 정의 * dp[i] = seq[i]를 마지막 원소로 가지는 “증가 부분 수열”들 중, 합이 가장 큰 값

2. 초기값 설정

처음에는 각 원소 하나만 선택한 경우를 생각하면 되기 때문에,

dp[i] = seq[i]

를 만족하도록 초기화할 수 있다.

파이썬에서는 아래처럼 한 줄로 처리:

dp = seq[:]   # 원본과 독립된 새 리스트 (깊은 복사 느낌)

나중에 반복문을 돌면서 “앞에 다른 수를 붙일 수 있는 경우들”을 고려해 dp[i]를 점점 키워 나간다.

3. 점화식 세우기

i번째 위치에 seq[i]가 있을 때, 그 앞에 올 수 있는 인덱스 j는 다음 조건을 만족해야 한다.

• 항상 앞에 있어야 하니까: 0 ≤ j < i
• 증가 수열이어야 하니까: seq[j] < seq[i]

이 조건을 만족하는 모든 j에 대해,

dp[i] = max(dp[i], dp[j] + seq[i])

라고 갱신해 주면 된다.

즉,

• “나보다 작은 값들 중에서”
• “그 값으로 끝나는 증가 부분 수열의 합(dp[j])이 가장 큰 것”을 골라
• 거기에 나(seq[i])를 붙여서 새로운 합을 만드는 과정이다.

시간 복잡도

• 이중 for문 (i에 대해 0 ~ n-1, j에 대해 0 ~ i-1) → 최악의 경우 약 n * (n-1) / 2 번 연산
• 시간 복잡도: O(n²)

n의 범위가 크지 않기 때문에, 이 정도 복잡도로 충분히 통과 가능하다.

✅ 최종 코드

n = int(input())
seq = list(map(int, input().split()))
dp = seq[:]

for i in range(1, n):
    for j in range(i):
        if seq[i] > seq[j]:
            dp[i] = max(dp[i], dp[j] + seq[i])

answer = max(dp)
print(answer)

📚 파이썬에서 얕은 복사 vs 깊은 복사 정리

또 하나의 시행착오는 리스트 복사 문제였다. 처음에 아래처럼 썼는데:

dp = seq

이렇게 하면 동일한 리스트를 가리키는 얕은 복사라서 dp[i]를 변경하면 seq[i]도 바뀌어버린다. 그래서 계산 과정이 꼬일 위험이 있었다.

이 문제에서는 원본을 건드리면 안 되기 때문에 아래처럼 반드시 깊은 복사 형태가 필요하다:

dp = seq[:]  # 안전한 방법!

✔ 얕은 복사 (Shallow Copy)

같은 리스트 객체를 바라본다.

seq = [1,2,3]
dp = seq
dp[0] = 100
print(seq)  # [100, 2, 3] ← 원본도 바뀜

✔ 깊은 복사 (Deep Copy)

새로운 리스트를 만든다(원본 영향 없음).

🔸 방법 1: 슬라이싱

dp = seq[:]

🔸 방법 2: list() 생성자

dp = list(seq)

🔸 방법 3: copy 모듈

(2차원 리스트 같은 복잡한 구조에서 유용)

import copy
dp = copy.deepcopy(seq)

이번 문제는 1차원 리스트이기 때문에 seq[:] 만으로 충분했다.

• 길이가 N인 수열이 주어진다.
• “증가하는 부분 수열(increasing subsequence)” 중 가장 길이가 긴 것의 길이를 구하는 문제.
• 부분 수열이기 때문에 연속일 필요는 없다. └ 다만 순서는 유지해야 함.

🧠 내가 세운 접근 방식

처음엔 “수열을 앞에서부터 보면서, 각 위치에서 끝나는 LIS의 길이”를 저장하면 되지 않을까? 라고 생각했다.

이 문제는 “구간”이 아니라 “부분 수열”이기 때문에 어떤 수 seq[i]를 선택하려면, 그 이전의 원소 seq[j] (j < i) 중에서

seq[j] < seq[i]

이 조건을 만족하는 것들만 고려해야 한다.

그래서 DP 테이블을 다음처럼 정의했다.

dp[i] = i번째 원소를 ‘마지막 원소’로 갖는 LIS의 길이 LIS는 Longest Increasing Subsequence의 약자로, 가장 긴 증가하는 부분 수열을 의미한다.

이렇게 정의해두면 자연스럽게 점화식도 나온다.

🔍 점화식 형태

i번째 위치에서 고려할 선택지는 두 가지뿐이다:

1. 증가 조건을 만족하는 이전 인덱스 j를 골라, dp[j] + 1 로 이어붙이기
2. 이전에 자신보다 작은 값이 하나도 없다면 → 자기 자신만 쓰는 길이 1

즉,

dp[i] = max(dp[j] + 1)   (단, j < i 이고 seq[j] < seq[i])
dp[i] = 1                (만약 조건을 만족하는 j가 없다면)

🧪 코드

아래 코드는 위 아이디어대로 구현한 O(N²) 정석 풀이다.

n = int(input())
seq = list(map(int, input().split()))
dp = [0] * n

dp[0] = 1

for i in range(1, n):
    candidates = []
    for j in range(i):
        if seq[i] > seq[j]:
            candidates.append(dp[j] + 1)

    if candidates:
        dp[i] = max(candidates)
    else:
        dp[i] = 1

print(max(dp))

⏱ 시간복잡도는? 괜찮을까?

이 코드의 시간복잡도는

바깥 for → N번
안쪽 for → 평균 N/2 정도
총 ≈ N²/2 → 대략 50만번 정도 (N = 1000일 때)

파이썬에서 50만 연산은 아주 가벼운 수준이라서 백준 기준 1초 안에 충분히 통과한다.

✔ 코딩 테스트에서 시간복잡도 감각을 잡는 팁

→ 이 문제는 N ≤ 1000이므로 O(N²) 풀이가 정석.

🧭 배운 점 정리

• LIS 문제의 핵심은 “i에서 끝나는 가장 긴 증가하는 부분 수열의 길이” 를 dp에 저장하는 것.
• 부분 수열이기 때문에 연속 여부는 상관없고, 순서만 지키면 된다.
• “이전 값 중 현재 값보다 작은 것들만” 확인한다는 점이 중요하다.
• 시간복잡도 O(N²) DP는 N이 작을 때(1000 이하) 매우 효과적.
• 이후에 N이 더 큰 LIS 문제(예: 12015, N ≤ 100만)를 만나면 이분 탐색을 이용한 O(N log N) 풀이가 필요해진다.

길이 N인 수열이 주어진다. 연속된 몇 개의 수를 선택해서 만들 수 있는 합 중 최대값을 구하는 문제. 수는 양수, 음수 모두 나올 수 있다.

“수열에서 연속된 구간 하나를 골랐을 때, 그 합이 최대가 되는 값을 구하라”

풀이 과정

1️⃣ 첫 시도 (오답 접근)

처음 내가 세운 전략은 이랬다.

“음수는 구간 합을 감소시키는 요소니까 양수들만 더해서 그중 최대합을 고르면 되지 않을까?”

하지만 이는 틀린 전략이다. 반례를 살펴보자.

1 2 -1 10

내 로직대로 하면 1 + 2 = 3 → -1에서 끊고 3 저장. 하지만, 실제 최대 연속합은 음수를 포함한다. 1 + 2 - 1 + 10 = 12

음수가 포함되어 있더라도, 뒤에 나오는 큰 양수들이 그 음수를 덮고도 남으면 음수를 포함한 긴 구간 전체가 최대합이 될 수 있다.

이 지점을 간과해서 틀렸다.

2️⃣ 정답 풀이 — DP(kadane 알고리즘)으로 해결하기

dp[i] = i번째 원소로 끝나는 연속 부분 수열의 최대 합 즉, “i에서 끝난다고 가정했을 때, 최선의 합” 만을 관리하는 것.

이때 i에서 할 수 있는 선택은 딱 두 가지다.

1. 이전까지의 연속합에 현재 값을 이어붙인다 → dp[i-1] + seq[i]

2. 현재 값 하나로 새 구간을 시작한다 → seq[i]

그럼 점화식은 자연스럽게 이렇게 나온다.

dp[i] = max(dp[i-1] + seq[i], seq[i])

최종 정답은?
→ 전체 i 중에서 **dp[i]의 최댓값**이 바로 우리가 원하는 “연속합 최댓값”


## ✅ 최종 코드
내가 작성한 정답 코드는 아래와 같다.
```python
n = int(input())
seq = list(map(int, input().split()))
dp = [0] * n

dp[0] = seq[0]

for i in range(1, n):
    dp[i] = max(dp[i-1] + seq[i], seq[i])

print(max(dp))

코드 한 줄씩 해석해보기

• dp[0] = seq[0]

  첫 번째 원소로 끝나는 최대 연속합은 당연히 그 원소 하나뿐.

• for i in range(1, n):

  • dp[i-1] + seq[i]

    → 이전까지 이어오던 구간에 지금 값을 붙였을 때의 합

  • seq[i]

    → “아, 그냥 여기서부터 새로 시작하자”라고 마음먹었을 때의 합

  • 둘 중 더 큰 걸 dp[i]에 저장.

• 마지막에 max(dp)

  → “각 위치에서 끝나는 최대합들” 중 가장 큰 값을 정답으로 출력.

💬 GPT의 이런 알고리즘을 떠올리는 팁 정리

이번 문제 풀면서 “어떻게 이런 점화식을 생각해낼까?” 스스로도 궁금했는데,

정리해보니까 이런 사고 흐름을 타면 훨씬 수월해진다.

1. “이전 결과가 항상 좋은 건 아니다”를 인정하기

연속합 문제라 해서

“앞에서 이어붙이는 게 무조건 이득이겠지?”

라고 생각하면 함정에 빠진다.

예시:

-999 100

• 999 + 100 = -899
• 100 혼자 = 100

이런 예시를 떠올리면

“아, 이전까지의 합이 오히려 발목을 잡을 수도 있구나”

라는 생각이 자연스럽게 든다.

그 순간,

“그럼 어떤 지점에서는 과감히 새로 시작해야겠다”

는 아이디어가 나온다.

2. “현재 위치에서 선택지는 딱 두 개뿐”이라고 생각하기

DP 점화식 만들 때 제일 큰 힌트:

“i번째 칸에서 내가 할 수 있는 선택이 뭔지 다 써보자”

이 문제에서 i번째 위치에서 할 수 있는 선택:

1. 이전까지의 구간에 이어붙이기

   → dp[i-1] + seq[i]

2. 새로 시작하기

   → seq[i]

딱 둘뿐이다.

선택지를 정리하면 점화식도 훨씬 쉽게 보인다.

3. “전체 답”이 아니라 “한 칸 한 칸 최선의 선택”에 집중하기

우리는 자꾸 이런 생각을 한다.

“최대 연속합 구간이 어디부터 어디까지일까…”

근데 DP의 관점에서는

“i에서 끝나는 최대 연속합만 잘 관리하면,

나중에 전체 최댓값은 max(dp)로 한 번에 구할 수 있다.”

즉,

완성된 구간을 한 번에 찾는 게 아니라, 각 위치에서 최선의 결과를 쌓아가는 느낌을 익히는 게 중요하다.

4. “언제 구간을 끊고 새로 시작할지” 기준 세우기

이 문제에서도 구간을 끊는 기준은 명확하다.

“이전까지의 합에 현재 값을 더한 것” vs “현재 값 하나만”

둘을 비교해봤을 때

현재 값 하나로 시작하는 게 더 크면 과감히 이전 구간을 버린다.

이 패턴은 다른 DP/그리디류 문제에서도 꽤 자주 등장하는 사고방식이다.

🧠 배운 점 정리

• 음수라고 해서 무조건 버리면 안 된다.

  → 뒤에 나오는 큰 양수가 그 음수를 덮을 수 있다.

• dp[i]를 어떻게 정의할지가 문제의 절반

  → 이 문제에서는 i에서 끝나는 최대 연속합으로 정의하면서 길이감이 확 줄어든다.

• 현재 위치에서 할 수 있는 선택을 “두 가지” 정도로 좁혀서 생각해보기

  → 이어붙일지 / 새로 시작할지

• 최종 답은 dp 배열 전체를 보고 max(dp)로 고를 수 있다는 감각 익히기.

이제 1912번은 그냥 “연속합 = 카데인 알고리즘”으로 기억해두고,

비슷한 DP 문제(최대 부분 수열, 누적합 + DP 등)에서 이 패턴을 계속 써먹으면 감각이 훨씬 빨리 늘어날 것 같다.

💡 카데인 알고리즘이란?

“연속된 부분 배열(subarray)의 최대 합”을 가장 빠르게 구하는 알고리즘이다.

현재 위치에서 끝나는 최대 연속합을 매 순간 업데이트하면서, 그 중 가장 큰 값을 고르는 알고리즘.

카데인의 강점은 한 번의 반복(O(N))만으로 정답을 구할 수 있다는 점이다.

카데인 알고리즘의 핵심 포인트 요약

1) 전체를 한 번에 보지 않고, “i에서 끝나는 최댓값”만 본다 복잡한 문제를 작은 부분 문제로 쪼개는 DP 사고의 정석.

2) 과거의 합이 미래에도 유리하리란 보장이 없다 과거에 아무리 많이 쌓아왔더라도 지금 값 하나가 더 크면 그냥 리셋하는 게 낫다.

3) 음수를 만나도 끊지 않는다 음수를 건너뛰는 게 아니라, 음수를 포함한 전체가 뒤에서 이득이 될 수 있기 때문.