Gatsby Starter Blog RSS Feed

스택으로 히스토그램 최대 직사각형 찾기

Fri, 03 Apr 2026 00:00:00 GMT

백준 3050 집들이 문제는 2D 격자에서 벽이 없는 가장 큰 직사각형 방을 찾는 문제입니다. 핵심은 이 문제를 "히스토그램에서 가장 큰 직사각형 찾기" 로 변환한 뒤, 스택을 이용해 O(N)에 풀어내는 것입니다. 처음 보면 접근 방법이 전혀 안 보이지만, 핵심 아이디어를 이해하면 같은 패턴의 문제를 반복적으로 적용할 수 있습니다.

1. 문제 구조 이해

히스토그램에서 최대 직사각형 (기본 문제)

히스토그램이 주어질 때, 막대 안에 포함되는 가장 넓은 직사각형의 넓이를 구합니다.

h = [2, 1, 4, 5, 1, 3, 3]

직사각형 후보 예시:
- 인덱스 2~3, 높이 4 → 넓이 8  ← 최대
- 인덱스 5~6, 높이 3 → 넓이 6
- 인덱스 0~6, 높이 1 → 넓이 7

2D 격자 → 히스토그램 변환 (3050 집들이)

2D 격자에서 각 행마다 히스토그램을 만들어 적용합니다.

격자 (0=벽, 1=빈칸):
row0: [1,1,0,1,1]
row1: [1,1,1,1,0]
row2: [0,1,1,1,1]
row3: [1,1,1,0,1]

r번째 행에서의 히스토그램 높이 h[c]:
  grid[r][c] == 0이면 → h[c] = 0  (벽)
  grid[r][c] == 1이면 → h[c] += 1 (위에서 연속된 빈칸 수)

row0의 h: [1, 1, 0, 1, 1]
row1의 h: [2, 2, 0, 2, 0]   ← row0에서 이어짐
row2의 h: [0, 3, 1, 3, 0]
row3의 h: [1, 4, 2, 0, 1]

각 행의 히스토그램에서 최대 직사각형을 구하고 전체 최대를 갱신

2. 브루트포스 O(N²) 접근

먼저 직관적인 방법을 이해합니다.

def largest_rect_brute(heights):
    n = len(heights)
    ans = 0

    for i in range(n):           # 각 막대를 높이 기준으로
        min_h = heights[i]
        for j in range(i, n):   # 오른쪽으로 확장
            min_h = min(min_h, heights[j])   # 확장 구간의 최솟값이 높이
            ans = max(ans, min_h * (j - i + 1))

    return ans

모든 구간 쌍을 확인하므로 O(N²)입니다. N이 크면 시간 초과가 납니다.

3. 스택 기반 O(N) 알고리즘

핵심 아이디어

각 막대 h[i]를 "이 높이로 만들 수 있는 직사각형의 높이"로 사용한다. 막대가 감소하는 순간(h[i] < 스택 top), 더 높은 막대들의 직사각형을 확정 지을 수 있다.

스택에는 (시작 인덱스, 높이) 쌍을 저장하며, 항상 오름차순 을 유지합니다.

Push / Pop 규칙

PUSH 조건: h[i] >= 스택 top의 높이
  → 아직 더 오른쪽으로 확장 가능, 스택에 저장

POP 조건: h[i] < 스택 top의 높이
  → top보다 낮은 막대를 만났으므로, top 높이의 직사각형은 여기서 끝
  → 넓이 = top.height × (i - top.start_index)
  → 더 낮아질 때까지 반복 팝

pop 시 start_index 저장 → 새 막대의 시작 인덱스로 사용
  (이전에 팝된 막대들은 h[i] 높이로 왼쪽으로 확장 가능)

단계별 시각화

h = [2, 1, 4, 5, 1, 3, 3]

i=0: stack=[] → push (0,2)    stack: [(0,2)]
i=1: h=1 < top=2
     pop(0,2): area=2×(1-0)=2, save start=0
     push (0,1)               stack: [(0,1)]
i=2: h=4 > top=1 → push(2,4) stack: [(0,1),(2,4)]
i=3: h=5 > top=4 → push(3,5) stack: [(0,1),(2,4),(3,5)]
i=4: h=1 < top=5
     pop(3,5): area=5×(4-3)=5,  save start=3
     pop(2,4): area=4×(4-2)=8 ← MAX!, save start=2
     top(0,1) <= 1이므로 stop
     push (2,1)               stack: [(0,1),(2,1)]
     ※ 실제로는 (0,1)과 (2,1)을 합칠 수 있어 start=0 사용
i=5: h=3 > top=1 → push(4,3) stack: [(0,1),(4,3)]
     ※ saved_start=4 사용
i=6: h=3 = top=3 → push(6,3) stack: [(0,1),(4,3),(6,3)]

END (sentinel h=0):
     pop(6,3): area=3×(7-6)=3
     pop(4,3): area=3×(7-4)=9 ← NEW MAX!
     pop(0,1): area=1×(7-0)=7

Final Answer = 9

4. Python 구현 — 히스토그램 최대 직사각형

def largest_rect_in_histogram(heights: list) -> int:
    """
    스택 기반 O(N) 히스토그램 최대 직사각형
    heights: 각 막대의 높이 리스트
    """
    stack = []   # (start_index, height) 오름차순 유지
    ans = 0

    # 마지막에 h=0 센티넬 추가 → 스택을 완전히 비워냄
    for i, h in enumerate(heights + [0]):
        start = i   # 현재 막대의 시작 인덱스

        while stack and stack[-1][1] > h:
            idx, height = stack.pop()
            # 팝된 막대의 직사각형: 이 높이로 확장 가능한 너비
            area = height * (i - idx)
            ans = max(ans, area)
            start = idx   # 더 왼쪽까지 확장 가능

        # 현재 높이보다 작거나 같으면 push (start는 갱신된 값 사용)
        if not stack or stack[-1][1] < h:
            stack.append((start, h))

    return ans


# 테스트
print(largest_rect_in_histogram([2, 1, 4, 5, 1, 3, 3]))  # 9
print(largest_rect_in_histogram([6, 2, 5, 4, 5, 1, 6]))  # 12
print(largest_rect_in_histogram([1]))                      # 1
print(largest_rect_in_histogram([5, 5, 5, 5]))             # 20

구현 포인트 정리

# 1. 센티넬(sentinel) 0을 마지막에 추가
for i, h in enumerate(heights + [0]):
    # → 스택에 남은 모든 원소를 마지막에 처리

# 2. start 인덱스 갱신
start = i   # 초기값
while stack and stack[-1][1] > h:
    idx, height = stack.pop()
    area = height * (i - idx)   # 너비: i - 저장된 인덱스
    ans = max(ans, area)
    start = idx   # 팝할수록 왼쪽으로 확장

# 3. push 시 갱신된 start 사용
stack.append((start, h))
# start = 현재 높이 h가 왼쪽으로 확장 가능한 가장 왼쪽 인덱스

5. 백준 3050 집들이 — 전체 풀이

2D 격자에서 각 행을 히스토그램으로 변환 후 적용합니다.

import sys
input = sys.stdin.readline

def largest_rect(heights):
    stack = []
    ans = 0
    for i, h in enumerate(heights + [0]):
        start = i
        while stack and stack[-1][1] > h:
            idx, height = stack.pop()
            ans = max(ans, height * (i - idx))
            start = idx
        if not stack or stack[-1][1] < h:
            stack.append((start, h))
    return ans


def solve():
    R, C = map(int, input().split())
    grid = []
    for _ in range(R):
        row = list(map(int, input().split()))
        grid.append(row)

    # 히스토그램 높이 초기화
    hist = [0] * C
    ans = 0

    for r in range(R):
        for c in range(C):
            if grid[r][c] == 1:     # 빈칸: 높이 누적
                hist[c] += 1
            else:                    # 벽: 높이 초기화
                hist[c] = 0

        # 현재 행의 히스토그램으로 최대 직사각형 계산
        ans = max(ans, largest_rect(hist[:]))

    print(ans)


solve()

입력/출력 예시

입력:
4 5
1 1 0 1 1
1 1 1 1 0
0 1 1 1 1
1 1 1 0 1

출력:
6

히스토그램 변환 과정:
row0 hist: [1,1,0,1,1]  → max=2
row1 hist: [2,2,0,2,0]  → max=4
row2 hist: [0,3,1,3,0]  → max=6 ← 최대 (높이3, 너비2)
row3 hist: [1,4,2,0,1]  → max=6

6. 왜 O(N)인가?

각 막대는 스택에 최대 한 번 push 되고 최대 한 번 pop 됩니다.

총 push 횟수: N번 이하
총 pop  횟수: N번 이하
→ 전체: O(N)

2D 격자 (R행 × C열):
  각 행마다 O(C) → 전체 O(R × C)

7. 자주 하는 실수

1. 너비 계산 실수

# ❌ 틀린 방법 — pop 직전 인덱스를 기준으로 계산
area = height * (i - i_prev)   # i_prev = 이전 인덱스?

# ✅ 올바른 방법 — 스택에 저장된 start_index를 기준으로
area = height * (i - stored_start_index)

2. start 인덱스 갱신 누락

# ❌ start를 갱신하지 않으면 왼쪽 확장이 반영 안 됨
while stack and stack[-1][1] > h:
    idx, height = stack.pop()
    area = height * (i - idx)
    ans = max(ans, area)
    # start 갱신 안 함 → push할 때 i 사용 → 틀림

# ✅ 팝할 때마다 start 갱신
start = i
while stack and stack[-1][1] > h:
    idx, height = stack.pop()
    area = height * (i - idx)
    ans = max(ans, area)
    start = idx   # ← 반드시 갱신
stack.append((start, h))

3. 센티넬 없이 스택 미처리

# ❌ 센티넬 없이 루프 종료 → 스택에 남은 원소 처리 안 됨
for i, h in enumerate(heights):
    ...

# ✅ 센티넬 0 추가로 스택 완전히 비움
for i, h in enumerate(heights + [0]):
    ...

4. 2D 문제에서 hist 초기화 실수

# ❌ 벽(0)을 만났을 때 초기화 안 함
if grid[r][c] == 1:
    hist[c] += 1
# else: 아무것도 안 함 → 이전 높이가 유지됨

# ✅ 반드시 0으로 초기화
if grid[r][c] == 1:
    hist[c] += 1
else:
    hist[c] = 0   # 벽이면 연속성 끊김

8. 유사 문제 패턴

이 알고리즘이 적용되는 문제 유형들입니다.

기본형
  → 히스토그램에서 최대 직사각형 (백준 6549)

2D 응용
  → 격자에서 1로만 이루어진 최대 직사각형 (LeetCode 85)
  → 집들이 문제 (백준 3050)
  → N×M 격자 최대 직사각형

변형
  → 히스토그램 최대 직사각형 (0-indexed, 가중치)
  → 건물 스카이라인 문제

LeetCode 85 — 2D 이진 행렬 최대 직사각형

def maximalRectangle(matrix):
    if not matrix: return 0
    R, C = len(matrix), len(matrix[0])
    hist = [0] * C
    ans = 0

    for r in range(R):
        for c in range(C):
            hist[c] = hist[c]+1 if matrix[r][c]=='1' else 0
        ans = max(ans, largest_rect(hist[:]))

    return ans

9. 관련 백준 문제

문제	난이도	핵심
3050 집들이	Gold V	2D → 히스토그램 + 스택
6549 히스토그램에서 가장 큰 직사각형	Platinum V	스택 기본
2741 히스토그램	Gold IV	히스토그램 기본
1725 히스토그램	Gold IV	스택 / 분할정복

참고 자료

Sungho's Blog — Largest Rectangle in Histogram
백준 6549 스택 풀이
Claude AI

클라우드 서비스 개발

Sat, 07 Mar 2026 00:00:00 GMT

클라우드 기반 서비스 개발에서 다루게 되는 기술들을 정리했습니다. 크게 세 가지 영역으로 나눌 수 있습니다. 클라우드 인프라를 이해하고 서비스를 설계/개발하는 것, 비즈니스 요구사항을 바탕으로 솔루션을 구현하는 것, 그리고 전체 시스템의 아키텍처 전략을 수립하는 것입니다.

1. 클라우드 기초 개념

서비스 모델 — IaaS / PaaS / SaaS

클라우드는 제공하는 추상화 수준에 따라 세 가지 모델로 구분됩니다.

모델	제공 범위	사용자 관리 범위	예시
IaaS	서버, 네트워크, 스토리지	OS, 미들웨어, 앱 직접 관리	AWS EC2, GCP Compute Engine
PaaS	OS + 런타임 + 미들웨어	애플리케이션 코드만 관리	AWS Elastic Beanstalk, Heroku
SaaS	완성된 소프트웨어	데이터, 사용 설정만 관리	Gmail, Slack, Salesforce

배포 모델

Public Cloud  : AWS, GCP, Azure 등 퍼블릭 사업자 인프라 활용
               → 비용 효율, 빠른 확장

Private Cloud : 기업 전용 클라우드 (온프레미스 또는 전용 호스팅)
               → 높은 보안, 높은 초기 비용

Hybrid Cloud  : Public + Private 혼합
               → 민감 데이터는 Private, 탄력적 부하는 Public

Multi Cloud   : 여러 퍼블릭 클라우드 동시 활용
               → 벤더 종속 방지, 서비스별 최적 클라우드 선택

2. 클라우드 인프라 핵심 기술

가상화 (Virtualization)

물리 서버 위에 독립된 가상 머신(VM)을 여러 개 실행하는 기술입니다. 클라우드 컴퓨팅의 근간입니다.

물리 서버
└── Hypervisor (VMware, KVM, Hyper-V)
    ├── VM 1 — Ubuntu + App A
    ├── VM 2 — CentOS + App B
    └── VM 3 — Windows + App C

컨테이너 (Container)

VM보다 가벼운 격리 단위입니다. OS 커널을 공유하면서 프로세스 수준에서 격리합니다.

VM vs Container

VM                          Container
├── Guest OS 포함           ├── Guest OS 없음 (호스트 OS 공유)
├── GB 단위 이미지           ├── MB 단위 이미지
├── 부팅에 수십 초           ├── 부팅에 수 초 이내
└── 강한 격리, 무거움         └── 가볍고 빠른 배포에 적합

Dockerfile 예시:

FROM openjdk:17-jdk-slim

WORKDIR /app

COPY target/my-app.jar app.jar

EXPOSE 8080

ENTRYPOINT ["java", "-jar", "app.jar"]

Docker 기본 명령어:

# 이미지 빌드
docker build -t my-app:1.0 .

# 컨테이너 실행
docker run -d -p 8080:80 --name my-container my-app:1.0

# 실행 중인 컨테이너 확인
docker ps

# 로그 확인
docker logs my-container

컨테이너 오케스트레이션 — Kubernetes

다수의 컨테이너를 자동으로 배포/관리/확장하는 시스템입니다.

Control Plane
├── API Server        : 모든 요청의 진입점
├── Scheduler         : Pod를 어느 노드에 배치할지 결정
├── etcd              : 클러스터 상태 저장 (분산 KV 스토어)
└── Controller Manager: 원하는 상태 지속 유지

Worker Node
├── kubelet           : 노드 에이전트, Pod 실행 관리
├── kube-proxy        : 네트워크 규칙 관리
└── Container Runtime : Docker, containerd

Deployment & Service 예시:

apiVersion: apps/v1
kind: Deployment
metadata:
  name: my-app
spec:
  replicas: 3
  selector:
    matchLabels:
      app: my-app
  template:
    metadata:
      labels:
        app: my-app
    spec:
      containers:
      - name: my-app
        image: my-app:1.0
        ports:
        - containerPort: 8080
        resources:
          requests:
            memory: "256Mi"
            cpu: "250m"
          limits:
            memory: "512Mi"
            cpu: "500m"
---
apiVersion: v1
kind: Service
metadata:
  name: my-app-service
spec:
  type: LoadBalancer
  selector:
    app: my-app
  ports:
  - port: 80
    targetPort: 8080

3. 가용성 (High Availability) 설계

클라우드 서비스에서 가용성은 서비스가 중단 없이 운영되는 비율을 의미합니다.

가용성 목표 (SLA)

99%     → 연간 약 87시간 다운타임 허용
99.9%   → 연간 약 8.7시간   ("Three Nines")
99.99%  → 연간 약 52분      ("Four Nines")
99.999% → 연간 약 5분       ("Five Nines") ← 금융/의료급

가용성 확보 전략

이중화 — 단일 장애점(SPOF) 제거

        [사용자]
           │
      [Load Balancer]  ← 이중화
      ┌────┴────┐
  [App 1]   [App 2]    ← 다중 인스턴스
      └────┬────┘
     [DB Primary]
           └── [DB Replica]  ← 복제본

Auto Scaling

트래픽에 따라 인스턴스 수를 자동으로 조절합니다.

Scale Out : 인스턴스 수 증가 (트래픽 급증 시)
Scale In  : 인스턴스 수 감소 (트래픽 감소 시)
Scale Up  : 인스턴스 사양 향상 (CPU, RAM 증가)
Scale Down: 인스턴스 사양 축소

Circuit Breaker 패턴

외부 서비스 장애가 내부로 전파되는 것을 차단합니다.

CLOSED (정상 운영)
  → 오류율이 임계치 초과하면
OPEN (요청 차단)    ← 모든 요청 즉시 실패 처리
  → 일정 시간 후 테스트 요청 허용
HALF-OPEN
  → 성공 시 CLOSED 복귀
  → 실패 시 OPEN 유지

4. 클라우드 네이티브 아키텍처 패턴

마이크로서비스 아키텍처 (MSA)

하나의 큰 애플리케이션을 독립적으로 배포 가능한 작은 서비스들로 분리하는 방식입니다.

모놀리식 (Monolithic)              마이크로서비스 (MSA)

┌──────────────────┐              ┌────────┐  ┌────────┐
│  사용자 관리      │              │  User  │  │ Order  │
│  주문 처리        │    →         │  Svc   │  │  Svc   │
│  결제             │              └────────┘  └────────┘
│  알림             │              ┌────────┐  ┌────────┐
└──────────────────┘              │  Pay   │  │ Notify │
                                  │  Svc   │  │  Svc   │
                                  └────────┘  └────────┘

	모놀리식	MSA
배포	전체를 한 번에	서비스별 독립 배포
확장	전체 스케일 아웃	필요한 서비스만 스케일
장애 격리	한 곳 장애 → 전체 영향	해당 서비스만 영향
복잡도	낮음	높음 (분산 시스템 관리)

API Gateway 패턴

클라이언트와 내부 서비스 사이의 단일 진입점입니다.

클라이언트
    │
[API Gateway]
├── 인증 / 인가
├── 요청 라우팅
├── Rate Limiting
├── 로드밸런싱
└── 로깅 / 모니터링
    │
    ├── User Service
    ├── Order Service
    └── Payment Service

이벤트 드리븐 아키텍처

서비스 간 직접 호출 대신 이벤트(메시지)를 통해 통신합니다. 결합도를 낮추고 확장성을 높입니다.

[주문 서비스] → "주문 완료" 이벤트 발행
                      │
                [Kafka / RabbitMQ]
                      │
       ┌──────────────┼──────────────┐
  [결제 서비스]  [재고 서비스]   [알림 서비스]

5. CI/CD 파이프라인

빠르고 안정적인 배포를 위한 자동화 파이프라인입니다.

코드 Push
    │
[소스 저장소 — GitHub / GitLab]
    │
[CI: 빌드 & 검증]
├── 빌드 (Maven, Gradle)
├── 단위 테스트
├── 정적 분석 (SonarQube)
└── Docker 이미지 빌드 & 레지스트리 Push
    │
[CD: 자동 배포]
├── 개발 환경 자동 배포
├── 스테이징 환경 배포 (승인 후)
└── 프로덕션 환경 배포 (승인 후)

GitHub Actions 예시:

name: CI/CD Pipeline

on:
  push:
    branches: [main]

jobs:
  build-and-deploy:
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v3

    - name: Set up JDK 17
      uses: actions/setup-java@v3
      with:
        java-version: '17'

    - name: Build & Test
      run: ./gradlew build test

    - name: Build Docker Image
      run: docker build -t my-app:${{ github.sha }} .

    - name: Push to Registry
      run: |
        docker tag my-app:${{ github.sha }} registry.example.com/my-app:latest
        docker push registry.example.com/my-app:latest

    - name: Deploy to Kubernetes
      run: |
        kubectl set image deployment/my-app \
          my-app=registry.example.com/my-app:latest

6. 관찰 가능성 (Observability)

운영 중인 서비스의 상태를 파악하고 문제를 조기에 감지하기 위한 세 가지 핵심 요소입니다.

┌───────────┬───────────┬───────────┐
│  Metrics  │   Logs    │  Traces   │
│  (지표)   │  (로그)   │  (추적)   │
├───────────┼───────────┼───────────┤
│ CPU, 메모리│ 애플리케이션│ 요청이 여러│
│ 응답시간  │ 이벤트 기록 │ 서비스를  │
│ 처리량 등 │            │ 거치는 경로│
├───────────┼───────────┼───────────┤
│Prometheus │ ELK Stack │  Jaeger   │
│ Grafana   │  Datadog  │  Zipkin   │
└───────────┴───────────┴───────────┘

SLI / SLO / SLA

SLI (Service Level Indicator) : 실제 측정 지표
├── 가용성   : 성공 요청 수 / 전체 요청 수
├── 지연시간 : 요청~응답 소요 시간 (p50, p95, p99)
└── 처리량   : 초당 처리 요청 수 (TPS, RPS)

SLO (Service Level Objective) : 내부 목표 수준
└── 예: "99.9% 요청이 200ms 이내 응답"

SLA (Service Level Agreement) : 고객과의 계약
└── SLO 미달 시 패널티/환불 조항 포함

7. 보안 (Cloud Security)

인프라, 네트워크, 애플리케이션 레벨 모두에서 보안을 고려해야 합니다.

IAM — 최소 권한 원칙

필요한 최소한의 권한만 부여하는 것이 핵심입니다.

User   : 개별 사람 계정
Group  : User들의 집합 → 그룹 단위 정책 적용
Role   : 서비스/인스턴스에 부여하는 권한 묶음
Policy : 특정 리소스에 대한 허용/거부 규칙 문서

네트워크 보안 — VPC 구조

[Internet]
     │
[Internet Gateway]
     │
┌─── VPC ─────────────────────────┐
│  Public Subnet                  │
│  ├── Load Balancer              │
│  └── Bastion Host               │
│                                 │
│  Private Subnet                 │
│  ├── Application Server         │
│  └── Database                   │
│                                 │
│  Security Group (방화벽)          │
│  ├── Inbound : 80, 443만 허용   │
│  └── Outbound: 제한적 허용       │
└─────────────────────────────────┘

DevSecOps

CI/CD 파이프라인에 보안 검사를 내장하는 방식입니다.

코드 작성 → SAST (정적 코드 분석)
빌드      → SCA  (오픈소스 취약점 스캔)
배포 전   → DAST (동적 취약점 테스트)
운영 중   → RASP (실시간 공격 탐지)

8. 아키텍처 설계 원칙

12-Factor App

클라우드 네이티브 애플리케이션 설계를 위한 12가지 원칙입니다.

I.   Codebase        : 하나의 코드베이스, 여러 배포 환경
II.  Dependencies    : 의존성 명시적 선언 (pom.xml, package.json)
III. Config          : 설정은 환경 변수로 분리 (.env, ConfigMap)
IV.  Backing Services: DB, 캐시 등을 교체 가능한 리소스로 취급
V.   Build/Release   : 빌드-릴리즈-실행 단계 엄격히 분리
VI.  Processes       : 무상태(Stateless) 프로세스로 실행
VII. Port Binding    : 포트 바인딩으로 서비스 노출
VIII.Concurrency     : 프로세스 모델로 수평 확장
IX.  Disposability   : 빠른 시작, 안전한 종료 (Graceful Shutdown)
X.   Dev/Prod Parity : 개발-스테이징-프로덕션 환경 최대한 동일하게
XI.  Logs            : 로그를 이벤트 스트림으로 처리
XII. Admin Processes : 관리 작업을 일회성 프로세스로 실행

요구사항 분류

아키텍처를 설계할 때 기능적 요구사항 외에 비기능적 요구사항을 함께 정의해야 합니다.

기능적 요구사항 (Functional Requirements)
└── "무엇을" 해야 하는가 — 기능 명세

비기능적 요구사항 (Non-Functional Requirements)
├── 성능    : 응답시간 목표, TPS
├── 가용성  : SLA 목표 수준
├── 확장성  : 트래픽 증가 대응 방법
├── 보안    : 인증/인가, 데이터 암호화
├── 유지보수 : 코드 가독성, 테스트 커버리지
└── 비용    : 인프라 비용 최적화 전략

참고 자료

세그먼트 트리 (Segment Tree)

Thu, 29 Jan 2026 00:00:00 GMT

세그먼트 트리(Segment Tree)는 특정 구간(Segment)에 대한 구간 값을 트리 구조에 미리 저장해두는 자료구조입니다. 이진 트리를 기반으로 하며, 구간 합·구간 곱·구간 최솟값 등 다양한 구간 쿼리를 효율적으로 처리할 수 있습니다.

왜 세그먼트 트리를 사용하는가?

아래와 같은 배열이 있다고 가정해봅시다.

nums = [3, 2, 8, 4, 7, 5, 6]

특정 구간 nums[start:end]의 합을 n번 구해야 한다면, 매번 순회할 경우 총 (end - start) * n번의 연산이 필요합니다. 배열이 길고 쿼리가 많을수록 비효율적입니다.

세그먼트 트리는 구간 합을 미리 계산해 트리에 저장해두고, 필요할 때 O(log n) 만에 꺼내 쓰는 방식으로 이 문제를 해결합니다.

방법	구간 합 탐색	값 업데이트
단순 순회	O(n)	O(1)
누적 합 배열	O(1)	O(n)
세그먼트 트리	O(log n)	O(log n)

트리 구조

세그먼트 트리는 이진 트리로, 리프 노드에는 배열의 각 원소가, 내부 노드에는 두 자식 노드의 합(또는 곱 등)이 저장됩니다.

nums = [3, 2, 8, 4, 7, 5, 6]

              35
           /      \
         17        18
        /  \      /  \
       5   12    12    6
      / \  / \  / \
     3   2 8  4 7  5

1차원 배열로 구현할 경우 루트 노드의 인덱스를 1로 설정하고, 노드 i의 왼쪽 자식은 i*2, 오른쪽 자식은 i*2+1이 됩니다.

트리 배열의 크기는 다음과 같이 구합니다:

from math import ceil, log

n = len(nums)
tree = [0] * (2 ** (ceil(log(n, 2)) + 1))

1. 트리 생성 (Top-Down)

재귀를 이용해 루트 노드부터 아래로 내려가며 트리를 구성합니다.

def segment(left, right, i=1):
    # 리프 노드에 도달하면 배열 값 저장
    if left == right:
        tree[i] = nums[left]
        return tree[i]

    mid = (left + right) // 2
    # 왼쪽, 오른쪽 자식 노드의 합을 현재 노드에 저장
    tree[i] = segment(left, mid, i*2) + segment(mid+1, right, i*2+1)
    return tree[i]

segment(0, n-1)

2. 구간 합 탐색

찾고자 하는 구간 [left, right]에 대해 재귀적으로 탐색합니다.

def search(start, end, left, right, i=1):
    # 탐색 범위가 구간을 완전히 벗어난 경우
    if end < left or start > right:
        return 0

    # 탐색 범위가 구간에 완전히 포함된 경우
    if left <= start and end <= right:
        return tree[i]

    # 구간을 절반으로 나눠 재귀 탐색
    mid = (start + end) // 2
    return search(start, mid, left, right, i*2) + search(mid+1, end, left, right, i*2+1)

예시: nums[2:5] = [8, 4, 7]의 합을 구할 때, 8+4+7을 일일이 더하는 대신 트리에 저장된 12(=8+4)와 7만 찾아 더해 19를 반환합니다.

print(search(0, n-1, 2, 4))  # 19

3. 값 업데이트

배열의 특정 인덱스 값이 바뀌면 해당 값과 연관된 트리 노드들을 모두 갱신해야 합니다. 변경된 값과 기존 값의 차이(diff) 를 루트부터 아래로 전파하는 방식을 사용합니다.

def update(start, end, idx, diff, i=1):
    # 업데이트 인덱스가 구간을 벗어나면 종료
    if start > idx or idx > end:
        return

    tree[i] += diff

    if start != end:
        mid = (start + end) // 2
        update(start, mid, idx, diff, i*2)
        update(mid+1, end, idx, diff, i*2+1)

예시: nums[3]을 4에서 1로 변경할 경우:

update(0, n-1, 3, 1 - nums[3])  # diff = 1 - 4 = -3
nums[3] = 1

4. 구간 곱 세그먼트 트리

구간 곱의 경우 업데이트 시 변경값 / 기존값을 곱하는 방식은 기존 값이 0일 때 ZeroDivision 오류가 발생합니다. 이를 해결하려면 리프 노드의 위치를 미리 저장해두고, Bottom-Up 방식으로 업데이트하는 것이 더 직관적입니다.

location = [0] * n

def segment_mul(left, right, i=1):
    if left == right:
        tree[i] = nums[left]
        location[left] = i  # 리프 노드 위치 저장
        return tree[i]
    mid = (left + right) // 2
    tree[i] = segment_mul(left, mid, i*2) * segment_mul(mid+1, right, i*2+1)
    return tree[i]

업데이트 시 리프 노드에서 루트 방향으로 올라가며 갱신합니다:

# nums[3]을 1로 변경
idx = location[3]
tree[idx] = 1
nums[3] = 1

while idx > 1:
    idx //= 2
    tree[idx] = tree[idx*2] * tree[idx*2 + 1]

전체 코드 (구간 합)

from math import ceil, log

nums = [3, 2, 8, 4, 7, 5, 6]
n = len(nums)
tree = [0] * (2 ** (ceil(log(n, 2)) + 1))

def segment(left, right, i=1):
    if left == right:
        tree[i] = nums[left]
        return tree[i]
    mid = (left + right) // 2
    tree[i] = segment(left, mid, i*2) + segment(mid+1, right, i*2+1)
    return tree[i]

def search(start, end, left, right, i=1):
    if end < left or start > right:
        return 0
    if left <= start and end <= right:
        return tree[i]
    mid = (start + end) // 2
    return search(start, mid, left, right, i*2) + search(mid+1, end, left, right, i*2+1)

def update(start, end, idx, diff, i=1):
    if start > idx or idx > end:
        return
    tree[i] += diff
    if start != end:
        mid = (start + end) // 2
        update(start, mid, idx, diff, i*2)
        update(mid+1, end, idx, diff, i*2+1)

segment(0, n-1)
print(search(0, n-1, 2, 4))   # 19
update(0, n-1, 3, 1 - nums[3])
nums[3] = 1
print(search(0, n-1, 0, 6))   # 32

시간 복잡도 정리

연산	시간 복잡도
트리 생성	O(n)
구간 탐색	O(log n)
값 업데이트	O(log n)

Docker

Sun, 11 Jan 2026 00:00:00 GMT

"내 컴퓨터에서는 잘 되는데요."

개발할 때 한 번쯤은 겪어봤을 상황입니다. 개발 환경, 테스트 환경, 운영 환경이 서로 달라서 생기는 문제인데, Docker는 이 문제를 컨테이너라는 개념으로 해결합니다. 애플리케이션과 그 실행에 필요한 모든 것을 하나의 패키지로 묶어서, 어디서든 동일하게 실행되도록 보장합니다.

1. Docker란?

Docker는 애플리케이션을 컨테이너(Container) 단위로 패키징하고 실행하는 오픈소스 플랫폼입니다. 2013년 출시 이후 현재 DevOps와 클라우드 환경의 표준 기술로 자리잡았습니다.

왜 Docker를 사용하는가?

Before Docker                    After Docker

개발자 A: Python 3.9, ubuntu    ┌────────────────────┐
개발자 B: Python 3.11, macOS    │   Docker Container  │
서버:     Python 3.8, CentOS    │  Python 3.11 + App  │
                                 │  (always the same)  │
→ "내 컴퓨터에서는 됩니다…"     └────────────────────┘

                                 → Works everywhere

Docker가 해결하는 문제들:

환경 불일치 — 개발/스테이징/운영 환경을 동일하게 유지
의존성 충돌 — 각 서비스가 독립된 환경을 가짐
배포 복잡성 — 이미지 하나로 어디서든 동일하게 실행
리소스 효율 — VM보다 가볍고 빠르게 실행

2. VM vs Container

가상머신 (VM)

가상머신은 하이퍼바이저 위에 독립적인 Guest OS를 올려 격리합니다. 완전한 OS를 포함하기 때문에 이미지가 크고 부팅이 느리지만 격리 수준이 매우 높습니다.

Infrastructure
└── Host OS
    └── Hypervisor
        ├── VM 1: Guest OS + App A  (수 GB)
        ├── VM 2: Guest OS + App B  (수 GB)
        └── VM 3: Guest OS + App C  (수 GB)

컨테이너 (Container)

컨테이너는 Host OS의 커널을 공유하며 프로세스 수준에서 격리합니다. Guest OS가 없어 이미지가 작고 시작이 매우 빠릅니다.

Infrastructure
└── Host OS (커널 공유)
    └── Docker Engine
        ├── Container 1: Bins/Libs + App A  (수 MB)
        ├── Container 2: Bins/Libs + App B  (수 MB)
        └── Container 3: Bins/Libs + App C  (수 MB)

비교 항목	VM	Container
OS	Guest OS 포함	Host OS 커널 공유
이미지 크기	GB 단위	MB 단위
시작 시간	수십 초	1초 이내
리소스 사용	높음	낮음
격리 수준	강함 (하드웨어 수준)	보통 (프로세스 수준)
이식성	낮음	매우 높음

3. Docker 핵심 구성요소

Dockerfile

이미지를 만들기 위한 설계도(레시피) 입니다. 텍스트 파일에 명령어를 순서대로 작성합니다.

Image

Dockerfile로 빌드한 읽기 전용 템플릿입니다. 레이어 구조로 이루어져 있으며 불변(Immutable)합니다.

Container

이미지를 실행한 인스턴스입니다. 이미지 위에 쓰기 가능한 레이어가 추가됩니다. 중지하거나 삭제할 수 있으며, 기본적으로 종료 시 내부 데이터는 사라집니다.

Registry

이미지를 저장하고 공유하는 저장소입니다. Docker Hub가 공개 레지스트리이며, AWS ECR, GCP GCR 등 프라이빗 레지스트리도 있습니다.

Volume

컨테이너가 종료되어도 데이터를 유지하는 영속적 저장소입니다.

Dockerfile  →  (build)  →  Image  →  (run)  →  Container
                              ↕                      ↕
                           Registry               Volume

4. Docker 이미지 레이어 구조

Docker 이미지는 여러 레이어가 쌓인 구조입니다. Dockerfile의 각 명령어가 하나의 레이어가 됩니다.

┌─────────────────────────────────┐  ← Writable Layer (Container 실행 시)
├─────────────────────────────────┤  ← COPY app/ /app
├─────────────────────────────────┤  ← RUN pip install -r requirements.txt
├─────────────────────────────────┤  ← RUN apt-get install -y curl
└─────────────────────────────────┘  ← FROM python:3.11-slim  (Base Image)

레이어 캐싱 (Layer Caching)

변경된 레이어 이후의 레이어만 재빌드되기 때문에, 자주 변경되는 내용은 아래쪽에 배치할수록 빌드가 빠릅니다.

# ❌ 비효율적 — 코드 변경마다 pip install 재실행
COPY . /app
RUN pip install -r requirements.txt

# ✅ 효율적 — requirements.txt 변경 시에만 pip install 재실행
COPY requirements.txt /app/
RUN pip install -r /app/requirements.txt
COPY . /app

5. Dockerfile 작성

주요 명령어

명령어	설명
`FROM`	베이스 이미지 지정 (첫 번째 명령어)
`WORKDIR`	작업 디렉토리 설정
`COPY`	호스트 파일을 이미지로 복사
`ADD`	COPY + URL/압축파일 지원
`RUN`	빌드 시 실행할 명령어
`ENV`	환경 변수 설정
`EXPOSE`	컨테이너가 사용할 포트 명시
`CMD`	컨테이너 시작 시 기본 실행 명령어
`ENTRYPOINT`	컨테이너 시작 시 실행될 명령어 (변경 불가)
`ARG`	빌드 시점 변수

Python 웹 앱 Dockerfile 예시

# 1. 베이스 이미지 선택 (slim = 최소화된 버전)
FROM python:3.11-slim

# 2. 작업 디렉토리 설정
WORKDIR /app

# 3. 의존성 파일 먼저 복사 (캐싱 최적화)
COPY requirements.txt .

# 4. 의존성 설치
RUN pip install --no-cache-dir -r requirements.txt

# 5. 나머지 소스 코드 복사
COPY . .

# 6. 환경 변수 설정
ENV PYTHONUNBUFFERED=1 \
    PORT=8000

# 7. 포트 명시 (문서화 목적)
EXPOSE 8000

# 8. 실행 명령어
CMD ["python", "-m", "uvicorn", "main:app", "--host", "0.0.0.0", "--port", "8000"]

Node.js 앱 Dockerfile 예시

FROM node:20-alpine

WORKDIR /app

# package.json 먼저 복사 → npm install 캐싱
COPY package*.json ./
RUN npm ci --only=production

COPY . .

EXPOSE 3000

CMD ["node", "server.js"]

.dockerignore 작성

.gitignore처럼 이미지에 포함하지 않을 파일을 지정합니다.

node_modules/
.env
.git
*.log
__pycache__/
*.pyc
.DS_Store

6. 주요 Docker 명령어

이미지 관련

# 이미지 빌드 (현재 디렉토리의 Dockerfile 사용)
docker build -t my-app:1.0 .

# 빌드 캐시 없이 새로 빌드
docker build --no-cache -t my-app:1.0 .

# 로컬 이미지 목록 확인
docker images

# 이미지 다운로드
docker pull nginx:latest

# 이미지 삭제
docker rmi my-app:1.0

# 사용하지 않는 이미지 일괄 삭제
docker image prune -a

컨테이너 실행

# 기본 실행 (포그라운드)
docker run my-app:1.0

# 백그라운드 실행 (-d: detached)
docker run -d my-app:1.0

# 포트 매핑 (-p 호스트포트:컨테이너포트)
docker run -d -p 8080:8000 my-app:1.0

# 이름 지정 + 환경변수 + 볼륨 마운트
docker run -d \
  --name my-container \
  -p 8080:8000 \
  -e DATABASE_URL=postgres://... \
  -v $(pwd)/data:/app/data \
  my-app:1.0

# 종료 시 자동 삭제 (--rm)
docker run --rm my-app:1.0

# 인터랙티브 셸 실행 (-it)
docker run -it my-app:1.0 /bin/bash

컨테이너 관리

# 실행 중인 컨테이너 목록
docker ps

# 모든 컨테이너 목록 (중지 포함)
docker ps -a

# 컨테이너 중지 (Graceful)
docker stop my-container

# 컨테이너 강제 종료
docker kill my-container

# 컨테이너 삭제
docker rm my-container

# 중지된 컨테이너 일괄 삭제
docker container prune

# 실행 중인 컨테이너에 명령어 실행
docker exec -it my-container bash

# 컨테이너 로그 확인
docker logs my-container

# 로그 실시간 팔로우
docker logs -f my-container

# 컨테이너 상세 정보
docker inspect my-container

# 리소스 사용량 모니터링
docker stats

볼륨 & 네트워크

# Named Volume 생성 및 사용
docker volume create my-data
docker run -v my-data:/app/data my-app:1.0

# 볼륨 목록 및 삭제
docker volume ls
docker volume rm my-data

# 커스텀 네트워크 생성
docker network create my-net

# 네트워크에 연결하여 실행
docker run --network my-net my-app:1.0

7. Docker Compose

여러 컨테이너를 함께 실행해야 할 때 사용합니다. docker-compose.yml 파일 하나로 전체 서비스를 정의하고 관리합니다.

docker-compose.yml 구조

version: '3.8'

services:
  # 웹 애플리케이션
  web:
    build: .                      # 현재 디렉토리의 Dockerfile로 빌드
    ports:
      - "8080:8000"
    environment:
      - DATABASE_URL=postgresql://user:pass@db:5432/mydb
      - REDIS_URL=redis://redis:6379
    depends_on:                   # db, redis가 먼저 시작됨
      - db
      - redis
    volumes:
      - ./app:/app                # 개발 시 코드 실시간 반영
    restart: unless-stopped

  # PostgreSQL 데이터베이스
  db:
    image: postgres:15
    environment:
      POSTGRES_DB: mydb
      POSTGRES_USER: user
      POSTGRES_PASSWORD: pass
    volumes:
      - db_data:/var/lib/postgresql/data   # 데이터 영속성
    ports:
      - "5432:5432"

  # Redis 캐시
  redis:
    image: redis:7-alpine
    ports:
      - "6379:6379"

# Named Volume 정의
volumes:
  db_data:

Docker Compose 명령어

# 모든 서비스 시작 (백그라운드)
docker compose up -d

# 이미지 다시 빌드 후 시작
docker compose up -d --build

# 모든 서비스 중지 (컨테이너/네트워크 삭제)
docker compose down

# 볼륨까지 삭제 (데이터 초기화)
docker compose down -v

# 서비스 로그 확인
docker compose logs -f web

# 특정 서비스만 재시작
docker compose restart web

# 실행 중인 서비스 목록
docker compose ps

# 특정 서비스 컨테이너에서 명령 실행
docker compose exec web bash

8. 실무 팁

멀티 스테이지 빌드 (Multi-stage Build)

빌드 환경과 실행 환경을 분리해 최종 이미지 크기를 줄입니다.

# Stage 1: 빌드
FROM node:20 AS builder
WORKDIR /app
COPY package*.json ./
RUN npm ci
COPY . .
RUN npm run build          # dist/ 생성

# Stage 2: 실행 (빌드 결과물만 복사)
FROM node:20-alpine AS runner
WORKDIR /app
COPY --from=builder /app/dist ./dist
COPY --from=builder /app/node_modules ./node_modules
EXPOSE 3000
CMD ["node", "dist/server.js"]

빌드 도구, 테스트 코드, 소스맵 등이 최종 이미지에서 제외되어 이미지 크기가 크게 줄어듭니다.

환경변수 관리 (.env 파일)

# .env 파일
DATABASE_URL=postgresql://user:pass@localhost:5432/mydb
SECRET_KEY=my-secret-key
DEBUG=false

# docker-compose.yml에서 .env 자동 로드
services:
  web:
    env_file:
      - .env

헬스체크 (Healthcheck)

HEALTHCHECK --interval=30s --timeout=10s --retries=3 \
  CMD curl -f http://localhost:8000/health || exit 1

9. 자주 하는 실수

1. 컨테이너 내 데이터 저장

# ❌ 컨테이너 재시작 시 데이터 사라짐
docker run my-app  # 컨테이너 내부에만 저장

# ✅ Volume을 사용해 데이터 영속성 확보
docker run -v my-data:/app/data my-app

2. latest 태그에만 의존

# ❌ 버전 추적 불가
docker pull my-app:latest

# ✅ 명시적 버전 태그 사용
docker pull my-app:1.2.3

3. root 권한으로 실행

# ❌ 보안 위험
FROM python:3.11
...

# ✅ 전용 유저 생성
FROM python:3.11
RUN useradd -m appuser
USER appuser

4. 민감 정보를 이미지에 포함

# ❌ 이미지에 비밀번호가 기록됨
ENV DB_PASSWORD=mysecret

# ✅ 실행 시 환경변수로 주입
docker run -e DB_PASSWORD=$DB_PASSWORD my-app

참고 자료

CCW(Counter Clock Wise)

Sat, 26 Jul 2025 00:00:00 GMT

CCW(Counter Clock Wise)는 2차원 평면 위의 세 점 A, B, C가 있을 때, 세 점을 이은 방향이 시계 방향인지 반시계 방향인지, 혹은 일직선인지를 판별하는 기하 알고리즘입니다.

판별 결과

외적의 결과값에 따라 세 가지로 나뉩니다.

결과값	방향
양수 (+)	반시계 방향 (CCW)
0	일직선 (Collinear)
음수 (-)	시계 방향 (CW)

외적(Cross Product)이란?

CCW를 이해하려면 먼저 외적의 개념이 필요합니다.

외적은 3차원 공간의 두 벡터에 대한 연산으로, 다음과 같은 특징이 있습니다.

기호로는 ×를 사용합니다.
두 벡터를 외적하면 두 벡터에 수직인 새로운 벡터가 나옵니다. (내적은 스칼라값)
교환 법칙이 성립하지 않습니다. a × b ≠ b × a (방향이 반대)
두 벡터의 외적의 크기는 두 벡터가 만드는 평행사변형의 넓이입니다.

오른손 법칙

두 벡터 외적의 방향은 오른손 법칙으로 알 수 있습니다. 오른손으로 첫 번째 벡터에서 두 번째 벡터 방향으로 감아쥐었을 때 엄지가 가리키는 방향이 외적 벡터의 방향이 됩니다.

예를 들어 u × v이면 u에서 v 방향으로 손을 감을 때 엄지가 위를 향하고, v × u이면 반대로 아래를 향하게 됩니다.

CCW 계산 방법

세 점 A(x₁, y₁), B(x₂, y₂), C(x₃, y₃)가 있을 때, 벡터 AB와 AC를 만들어 외적을 계산합니다.

2차원이므로 z값을 0으로 놓고 외적을 계산하면 z 성분만 남습니다.

CCW = (x₂ - x₁)(y₃ - y₁) - (x₃ - x₁)(y₂ - y₁)

이 값의 부호로 방향을 판별합니다.

구현 (C++)

#include <iostream>

struct Point {
    int x;
    int y;
};

int CCW(int x1, int y1, int x2, int y2, int x3, int y3) {
    return (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);
}

int main() {
    Point P1, P2, P3;

    std::cin >> P1.x >> P1.y;
    std::cin >> P2.x >> P2.y;
    std::cin >> P3.x >> P3.y;

    int result = CCW(P1.x, P1.y, P2.x, P2.y, P3.x, P3.y);

    if (result == 0) {
        std::cout << "직선: " << result << "\n";
    } else if (result > 0) {
        std::cout << "반시계 방향: " << result << "\n";
    } else {
        std::cout << "시계 방향: " << result << "\n";
    }
}

구현 (Python)

def ccw(x1, y1, x2, y2, x3, y3):
    result = (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)
    if result > 0:
        return 1   # 반시계 방향
    elif result < 0:
        return -1  # 시계 방향
    else:
        return 0   # 일직선

활용

CCW는 단순히 방향 판별에 그치지 않고, 다양한 기하 문제의 기반이 됩니다.

선분 교차 판별: 두 선분이 서로 교차하는지 확인할 때 CCW를 활용합니다.
볼록 껍질(Convex Hull): 점 집합의 볼록 껍질을 구하는 Graham Scan 알고리즘에 사용됩니다.
다각형 내부 판별: 점이 다각형 내부에 있는지 확인할 때 활용됩니다.
넓이 계산: 세 점이 이루는 삼각형의 넓이를 |CCW| / 2로 구할 수 있습니다.

주의 사항

좌표값이 클 경우 int 범위를 초과할 수 있습니다. 예를 들어 좌표가 최대 10⁶이라면 외적 계산 결과가 10¹²까지 커질 수 있으므로, long long을 사용하는 것이 안전합니다.

long long CCW(long long x1, long long y1, long long x2, long long y2, long long x3, long long y3) {
    return (x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1);
}

Ref: [알고리즘] CCW(Counter Clock Wise)

트라이 (Trie)

Fri, 25 Apr 2025 00:00:00 GMT

검색창에 'ap'를 입력하는 순간 'apple', 'application', 'apply' 같은 단어가 뜨는 자동완성 기능. 이 기능의 핵심에 트라이(Trie) 가 있습니다. 트라이는 문자열을 저장하고 빠르게 탐색하기 위해 설계된 트리 형태의 자료구조입니다.

1. 트라이(Trie)란?

트라이(Trie) 는 문자열을 문자 단위로 분해해서 트리 구조로 저장하는 자료구조입니다. 래딕스 트리(Radix Tree), 접두사 트리(Prefix Tree) 라고도 불리며, 이름 자체는 re_trie_val tree 에서 유래했습니다.

핵심 아이디어

"app", "apple", "apt" 를 저장한다면?

        ROOT
         │
         a
         │
         p ← 여기까지가 공통 접두사 'ap'
        / \
       p   t
       │   │
      (app)(apt)
       │
       l
       │
       e
       │
      (apple)

같은 접두사를 공유하는 문자열들은 노드를 공유 합니다. 덕분에 저장 공간을 절약하고, 접두사 탐색을 매우 빠르게 수행할 수 있습니다.

장단점

	내용
장점	문자열 탐색이 O(L)로 매우 빠름 (L = 문자열 길이)
장점	접두사(prefix) 기반 탐색·자동완성에 최적
장점	사전 순서 정렬이 자연스럽게 유지됨
단점	각 노드가 자식 배열(최대 26개)을 가져 메모리 사용량이 큼
단점	문자열이 길거나 종류가 많을수록 공간 비효율 가능

2. 노드 구조

트라이의 각 노드는 다음 세 가지 정보를 가집니다.

class Node:
    def __init__(self, key, data=None):
        self.key      = key        # 이 노드가 나타내는 문자
        self.data     = data       # 단어가 끝나는 노드에만 값 저장 (None이면 끝 아님)
        self.children = {}         # 자식 노드 딕셔너리 {문자: Node}

Node 구조 예시:
┌────────────────────────────┐
│ key      = 'b'             │
│ data     = 'ab'  ← 'ab' 끝│
│ children = {'c': Node('c')}│
└────────────────────────────┘

data 필드가 None이면 해당 위치에서 끝나는 단어가 없다는 의미입니다. 예를 들어 'abc'만 저장했을 때 'a', 'b' 노드의 data는 None이고, 'c' 노드의 data만 'abc'가 됩니다.

3. 삽입 (Insert) 동작

'abc', 'ab', 'car' 를 순서대로 삽입하는 과정입니다.

'abc' 삽입

ROOT → a(신규) → b(신규) → c(신규, data='abc')

'ab' 삽입

ROOT → a(기존) → b(기존, data='ab') → c(기존)
        ↑ 이미 있으므로 그대로 이동

'car' 삽입

ROOT → a(기존)
     → c(신규) → a(신규) → r(신규, data='car')

삽입 규칙

1. 루트부터 시작
2. 문자 하나씩 순회
   - 해당 문자의 자식 노드가 있으면 → 그 노드로 이동
   - 없으면 → 새 노드 생성 후 이동
3. 마지막 문자 노드에 data 값 저장

4. 탐색 (Search) 동작

'car' 탐색

ROOT → 'c' 있음 → 'a' 있음 → 'r' 있음
→ 'r' 노드의 data = 'car' (≠ None)
→ 탐색 성공 ✅

'ca' 탐색

ROOT → 'c' 있음 → 'a' 있음
→ 'a' 노드의 data = None
→ 탐색 실패 ❌ ('ca'는 접두사로만 존재, 단어 아님)

'cat' 탐색

ROOT → 'c' 있음 → 'a' 있음 → 't' 없음
→ 탐색 실패 ❌

5. Python 구현

기본 구현 (삽입 + 탐색)

class Node:
    def __init__(self, key, data=None):
        self.key      = key
        self.data     = data
        self.children = {}


class Trie:
    def __init__(self):
        self.head = Node(None)   # 루트 노드 (빈 노드)

    def insert(self, string: str) -> None:
        """문자열 삽입"""
        curr = self.head

        for char in string:
            if char not in curr.children:
                curr.children[char] = Node(char)   # 새 노드 생성
            curr = curr.children[char]              # 이동

        curr.data = string   # 마지막 노드에 단어 표시

    def search(self, string: str) -> bool:
        """문자열이 정확히 존재하는지 탐색"""
        curr = self.head

        for char in string:
            if char not in curr.children:
                return False   # 경로가 없으면 False
            curr = curr.children[char]

        return curr.data is not None   # data 있으면 단어, 없으면 접두사만 존재


# 사용 예시
trie = Trie()
words = ['abc', 'ab', 'car']
for w in words:
    trie.insert(w)

print(trie.search('abc'))   # True
print(trie.search('ab'))    # True
print(trie.search('a'))     # False  (접두사만 존재)
print(trie.search('ca'))    # False  (접두사만 존재)
print(trie.search('car'))   # True
print(trie.search('cat'))   # False  (존재하지 않음)

접두사 존재 여부 확인 (starts_with)

def starts_with(self, prefix: str) -> bool:
    """해당 접두사로 시작하는 단어가 하나라도 있는지 확인"""
    curr = self.head

    for char in prefix:
        if char not in curr.children:
            return False
        curr = curr.children[char]

    return True   # 노드가 존재하면 접두사는 있음 (data 여부 관계없음)


# search vs starts_with 차이
trie.search('ab')        # True   — 'ab'라는 단어가 정확히 존재
trie.starts_with('ab')   # True   — 'ab'로 시작하는 단어 존재
trie.search('a')         # False  — 'a'라는 단어는 없음
trie.starts_with('a')    # True   — 'a'로 시작하는 단어는 있음

6. 자동완성 구현

특정 접두사로 시작하는 모든 단어를 수집합니다.

def autocomplete(self, prefix: str) -> list:
    """주어진 접두사로 시작하는 모든 단어 반환"""
    curr = self.head

    # 1. 접두사 끝 노드까지 이동
    for char in prefix:
        if char not in curr.children:
            return []   # 해당 접두사가 없으면 빈 리스트
        curr = curr.children[char]

    # 2. 그 노드 아래를 DFS로 탐색해 단어 수집
    result = []
    self._dfs(curr, result)
    return result

def _dfs(self, node: Node, result: list) -> None:
    """재귀 DFS로 data가 있는 노드를 모두 수집"""
    if node.data is not None:
        result.append(node.data)

    for child in node.children.values():
        self._dfs(child, result)


# 사용 예시
trie = Trie()
words = ['apple', 'app', 'application', 'apply', 'apt', 'banana']
for w in words:
    trie.insert(w)

print(trie.autocomplete('ap'))
# ['app', 'apple', 'application', 'apply', 'apt']

print(trie.autocomplete('app'))
# ['app', 'apple', 'application', 'apply']

print(trie.autocomplete('ban'))
# ['banana']

print(trie.autocomplete('xyz'))
# []

7. 삭제 (Delete) 구현

삭제는 삽입보다 까다롭습니다. 다른 단어의 접두사로 사용 중인 노드는 삭제하면 안 됩니다.

def delete(self, string: str) -> bool:
    """문자열 삭제 (True: 성공, False: 존재하지 않음)"""

    def _delete(node: Node, string: str, depth: int) -> bool:
        if depth == len(string):
            if node.data is None:
                return False       # 단어가 없음
            node.data = None       # 단어 끝 표시 제거
            return len(node.children) == 0   # 자식 없으면 노드 삭제 가능

        char = string[depth]
        if char not in node.children:
            return False           # 경로 없음

        should_delete = _delete(node.children[char], string, depth + 1)

        if should_delete:
            del node.children[char]   # 자식 노드 삭제
            # 현재 노드도 삭제 가능한지 확인
            return node.data is None and len(node.children) == 0

        return False

    _delete(self.head, string, 0)

8. 시간/공간 복잡도

시간복잡도

연산	복잡도	설명
삽입 (단어 하나)	O(L)	L = 단어 길이
전체 구축	O(M × L)	M = 단어 수, L = 최장 단어 길이
탐색	O(L)	L = 검색 단어 길이
접두사 탐색	O(L + output)	접두사 이동 + 결과 수집

공간복잡도

O(ALPHABET_SIZE × N)
ALPHABET_SIZE = 26 (영소문자 기준)
N = 전체 노드 수

최악: 공통 접두사가 전혀 없는 경우
최선: 모든 단어가 같은 접두사를 공유하는 경우

Hash Table vs BST vs Trie 비교

	Hash Table	BST	Trie
탐색	O(L) avg	O(L log N)	O(L)
접두사 탐색	❌ 불가	△ 가능	✅ 최적
사전순 정렬	❌	✅	✅
공간	O(N×L)	O(N×L)	O(N×L)*
적합한 상황	단순 검색	정렬 필요	접두사·자동완성

Trie는 공통 접두사를 공유하므로 유사한 문자열이 많을수록 공간 효율이 좋아집니다.

9. 실전 활용 패턴

문자열 집합에서 검색 (백준 5052 스타일)

def solve():
    n = int(input())
    words = [input() for _ in range(n)]

    trie = Trie()
    for w in words:
        trie.insert(w)

    # 각 단어가 다른 단어의 접두사인지 확인
    for w in words:
        curr = trie.head
        for i, char in enumerate(w):
            curr = curr.children[char]
            # 중간 노드에서 단어가 끝나면 → 다른 단어의 접두사
            if curr.data is not None and i < len(w) - 1:
                print("NO")
                return
    print("YES")

최장 공통 접두사 찾기

def longest_common_prefix(words: list) -> str:
    trie = Trie()
    for w in words:
        trie.insert(w)

    prefix = ""
    curr = trie.head

    while True:
        # 자식이 딱 하나이고, 현재 노드에서 단어가 끝나지 않으면 계속 내려감
        if len(curr.children) == 1 and curr.data is None:
            char = next(iter(curr.children))
            prefix += char
            curr = curr.children[char]
        else:
            break

    return prefix


words = ["flower", "flow", "flight"]
print(longest_common_prefix(words))   # "fl"

10. 주의할 점

1. search vs starts_with 구분

# 정확한 단어 탐색 (data 있어야 True)
trie.search('ap')        # False  — 'ap'라는 단어가 없으면

# 접두사 존재 여부 (노드만 있으면 True)
trie.starts_with('ap')   # True   — 'ap'로 시작하는 단어가 있으면

2. 대소문자 처리

# 대소문자 구분 없이 처리하려면 소문자로 통일
def insert(self, string: str) -> None:
    string = string.lower()   # 소문자 변환
    ...

3. 메모리 효율을 위한 배열 vs 딕셔너리

# 딕셔너리 방식 — 실제 사용하는 문자만 저장 (메모리 효율적)
self.children = {}

# 배열 방식 — 항상 26개 슬롯 (빠른 접근, 메모리 비효율)
self.children = [None] * 26
# 접근: self.children[ord(char) - ord('a')]

4. 재귀 깊이 제한

DFS 기반 자동완성에서 단어가 매우 길면 재귀 깊이 제한에 걸릴 수 있습니다.

import sys
sys.setrecursionlimit(10**6)

11. 관련 백준 문제

문제	난이도	핵심 기법
5052 전화번호 목록	Gold IV	트라이 + 접두사 판별
14425 문자열 집합	Silver III	트라이 기본 탐색
9202 Boggle	Platinum V	트라이 + DFS
1786 찾기	Platinum V	KMP or 트라이 응용

참고 자료

[자료구조] 트라이 (Trie)
Claude AI

외판원 순회 (TSP, Traveling Salesman Problem)

Fri, 25 Apr 2025 00:00:00 GMT

외판원 순회 문제(Traveling Salesman Problem, TSP) 는 조합 최적화 분야에서 가장 유명한 문제 중 하나입니다.

여러 도시를 방문하며 물건을 팔아야 하는 외판원이, 모든 도시를 정확히 한 번씩 방문하고 출발점으로 돌아올 때 이동 거리의 합이 최소인 경로 를 구하라.

단순해 보이지만 도시 수가 늘어날수록 경우의 수가 폭발적으로 증가하는 NP-Hard 문제입니다.

1. 브루트포스의 한계

가장 직관적인 방법은 모든 방문 순서(순열)를 시도해보는 것입니다. 하지만 n개 도시의 순열 개수는 n!이므로, n이 조금만 커져도 현실적으로 계산이 불가능합니다.

n	브루트포스 (n!)	DP + 비트마스킹 (n²·2ⁿ)
5	120	800
10	3,628,800	102,400
15	1조 3천억	7,372,800
20	243경	20,971,520

브루트포스는 n ≤ 11 수준에서만 현실적입니다. 반면 비트마스킹 DP는 n ≤ 20 정도까지 충분히 풀 수 있습니다.

2. 핵심 아이디어 — 비트마스킹 DP

상태 정의

dp[i][visited]를 다음과 같이 정의합니다.

현재 위치가 도시 i이고, 지금까지 방문한 도시 집합이 visited일 때, 남은 도시를 모두 방문하고 출발점으로 돌아오는 최소 거리

visited를 비트마스크로 표현

visited는 정수(integer)로 표현하며, 각 비트가 해당 도시의 방문 여부를 나타냅니다.

도시 4개: A(0번), B(1번), C(2번), D(3번)

visited = 0001 (2진수) = 1  → A만 방문
visited = 0011 (2진수) = 3  → A, B 방문
visited = 0111 (2진수) = 7  → A, B, C 방문
visited = 1111 (2진수) = 15 → 모두 방문 = (1<<n) - 1

특정 도시 j를 방문했다고 표시하려면 visited | (1 << j) 로 해당 비트를 1로 설정합니다. 도시 j를 이미 방문했는지 확인하려면 visited & (1 << j) 로 확인합니다.

점화식

dp[i][visited] = min(
    dp[j][visited | (1 << j)] + dist(i, j)
)
단, j는 아직 방문하지 않은 도시

"현재 i에서 미방문 도시 j로 이동한다고 가정했을 때, j에서 나머지를 최적으로 돌아오는 거리 + i~j 사이의 거리" 중 최솟값을 선택합니다.

종료 조건

모든 도시를 방문한 상태(visited == (1 << n) - 1)에서는 출발점(0번)으로 돌아가는 거리를 반환합니다.

if visited == (1 << n) - 1:
    return dist(current, 0)  # 출발점으로 복귀

3. 단계별 동작 시각화 (4도시 예제)

4개 도시 A, B, C, D가 있고 거리가 다음과 같을 때 A를 출발점으로 TSP를 풉니다.

A ↔ B : 10    A ↔ C : 15    A ↔ D : 20
B ↔ C : 35    B ↔ D : 25    C ↔ D : 30

각 단계를 재귀 트리로 정리하면 다음과 같습니다.

dfs(A, 0001)
├── A→B : dfs(B, 0011)
│   ├── B→C : dfs(C, 0111) → C→D→A = 30+20 = 50 → 35+50 = 85
│   └── B→D : dfs(D, 1011) → D→C→A = 30+15 = 45 → 25+45 = 70  ← 최솟값
├── A→C : dfs(C, 0101)
│   ├── C→B : dfs(B, 0111) → B→D→A = 25+20 = 45 → 35+45 = 80
│   └── C→D : dfs(D, 1101) → D→B→A = 25+10 = 35 → 30+35 = 65  ← 최솟값
└── A→D : dfs(D, 1001)
    ├── D→B : dfs(B, 1011) → B→C→A = 35+15 = 50 → 25+50 = 75
    └── D→C : dfs(C, 1101) → C→B→A = 35+10 = 45 → 30+45 = 75

최적: A→B→D→C→A = 10+25+30+15 = 80

4. Python 구현

전체 코드 (최솟값)

import sys
import math
from functools import lru_cache

input = sys.stdin.readline

def solve():
    n = int(input())
    graph = [list(map(int, input().split())) for _ in range(n)]

    INF = float('inf')
    dp = [[INF] * (1 << n) for _ in range(n)]

    def dfs(current, visited):
        # 모든 도시 방문 완료 → 출발점(0)으로 귀환
        if visited == (1 << n) - 1:
            return graph[current][0] if graph[current][0] else INF

        # 이미 계산된 상태면 재사용 (메모이제이션)
        if dp[current][visited] != INF:
            return dp[current][visited]

        for next_city in range(n):
            # 이미 방문했거나 경로가 없으면 skip
            if visited & (1 << next_city):
                continue
            if graph[current][next_city] == 0:
                continue

            cost = dfs(next_city, visited | (1 << next_city)) + graph[current][next_city]
            dp[current][visited] = min(dp[current][visited], cost)

        return dp[current][visited]

    # 0번 도시에서 출발 (visited = 0001)
    print(dfs(0, 1))

solve()

핵심 로직 흐름

1. dfs(현재 도시, 방문 상태) 호출
2. 종료 조건: visited == (1<<n)-1 이면 출발점까지 거리 반환
3. 이미 계산된 dp[현재][visited] 가 있으면 바로 반환
4. 미방문 도시 j마다:
   - dfs(j, visited | (1<<j)) 재귀 호출
   - 반환값 + dist(현재→j) 를 dp에 업데이트
5. dp[현재][visited] 반환

5. 경로 복원

최솟값뿐 아니라 어떤 순서로 방문해야 하는지 경로도 출력하려면 dp 테이블을 역추적합니다.

def print_path(current, visited, path):
    path.append(current)

    # 모두 방문했으면 종료
    if visited == (1 << n) - 1:
        path.append(0)  # 출발점으로 귀환
        return

    next_city = -1
    min_cost = float('inf')

    for j in range(n):
        if visited & (1 << j):
            continue
        if graph[current][j] == 0:
            continue

        # dp[j][next_visited] + dist(current→j) 가 최소인 도시를 다음 목적지로 선택
        next_visited = visited | (1 << j)
        cost = dp[j][next_visited] + graph[current][j]
        if cost < min_cost:
            min_cost = cost
            next_city = j

    if next_city != -1:
        print_path(next_city, visited | (1 << next_city), path)

# 사용 예
path = []
print_path(0, 1, path)
print(" → ".join(str(p) for p in path))
# 출력 예: 0 → 1 → 3 → 2 → 0

6. 시간 복잡도 분석

항목	내용
부분 문제 수	현재 위치 n가지 × visited 상태 2ⁿ가지 = n·2ⁿ
각 부분 문제 해결 비용	미방문 도시 탐색 O(n)
총 시간복잡도	O(n²·2ⁿ)
공간복잡도	O(n·2ⁿ) — dp 테이블 크기

브루트포스 O(n!)에 비해 압도적으로 빠르지만, 여전히 지수 시간이므로 n ≤ 20 이 실용적인 한계입니다.

7. 자주 하는 실수

1. 방문 체크 방향 혼동

# ❌ 잘못됨 — 이미 방문한 도시를 skip하는 게 아니라 반대로 처리
if not (visited & (1 << j)):
    continue

# ✅ 올바름 — 이미 방문한 도시면 skip
if visited & (1 << j):
    continue

2. 점화식에서 인덱스 혼동

# ❌ 잘못됨 — dp[i]에서 갱신해야 하는데 dp[j]로 작성
dp[j][visited] = min(dp[j][visited], dp[j][visited|(1<<j)] + graph[i][j])

# ✅ 올바름
dp[i][visited] = min(dp[i][visited], dp[j][visited|(1<<j)] + graph[i][j])

3. 출발점 복귀 조건에서 0 거리 처리

# 도시 간 경로가 없을 때 0으로 표현하는 문제의 경우
if visited == (1 << n) - 1:
    if graph[current][0] == 0:  # 출발점으로 돌아오는 길이 없으면
        return INF
    return graph[current][0]

8. 관련 백준 문제

문제	난이도	설명
2098 외판원 순회	Gold I	TSP 기본 문제 — 비트마스킹 DP
1102 발전소	Gold I	비트마스킹 DP 응용
1562 계단 수	Gold I	비트마스킹 + DP 조합 연습

참고 자료

[알고리즘] 외판원 순회(TSP) 알고리즘

프림 알고리즘 (Prim's Algorithm)

Thu, 10 Apr 2025 00:00:00 GMT

이전 포스트에서 크루스칼 알고리즘으로 최소 신장 트리(MST)를 구하는 방법을 정리했습니다. 이번에는 같은 MST 문제를 다른 방식으로 접근하는 프림 알고리즘(Prim's Algorithm) 을 정리합니다.

최소 신장 트리(MST) 복습

신장 트리(Spanning Tree) 란 그래프의 모든 노드를 포함하면서 사이클이 없는 트리입니다. 이 중에서 간선 가중치의 합이 가장 작은 것을 최소 신장 트리(Minimum Spanning Tree, MST) 라고 합니다.

MST의 조건:

그래프의 모든 노드를 포함한다
사이클이 존재하지 않는다
간선의 수는 정확히 노드 수 - 1개이다

프림 알고리즘이란?

프림 알고리즘은 임의의 노드에서 시작해서, 현재까지 방문한 노드 집합에서 연결된 간선 중 가중치가 가장 작은 간선을 반복적으로 선택해 MST를 확장해 나가는 알고리즘입니다.

핵심 아이디어: "지금 닿을 수 있는 곳 중 가장 가까운 곳으로 한 발씩 나아간다"

그리디(Greedy) 알고리즘의 일종으로, 매 단계에서 최선의 선택(최소 가중치 간선)을 반복합니다.

프림 vs 크루스칼

두 알고리즘 모두 MST를 구하지만 접근 방식이 다릅니다.

	프림	크루스칼
전략	노드 중심 — 방문 집합을 확장	간선 중심 — 전체 간선을 정렬 후 선택
자료구조	우선순위 큐 (최소 힙)	유니온 파인드
시간복잡도	O(E log V)	O(E log E)
유리한 경우	밀집 그래프 (간선이 많을 때)	희소 그래프 (간선이 적을 때)
사이클 처리	방문 배열로 묵시적 처리	유니온 파인드로 명시적 처리

동작 원리 — 단계별 시각화

아래 그래프를 예시로 사용합니다. (노드 8개, 간선 10개)

각 단계를 정리하면 다음과 같습니다.

단계	선택 간선	가중치	방문 노드 추가
0	시작	—	1
1	1 — 2	13	2
2	2 — 7	4	7
3	6 — 7	3	6
4	7 — 8	6	8
5	5 — 8	9	5
6	4 — 5	12	4
7	3 — 4	11	3

최종 MST 총 가중치: 13 + 4 + 3 + 6 + 9 + 12 + 11 = 58

시작 노드가 달라져도 결과 MST는 항상 동일합니다.

우선순위 큐(최소 힙) 활용

프림 알고리즘의 핵심은 "현재 닿을 수 있는 간선 중 가장 가중치가 작은 것"을 빠르게 뽑는 것입니다. 이를 위해 최소 힙(Min-Heap) 을 사용합니다.

힙에는 (가중치, 노드) 형태로 저장합니다. 가중치를 첫 번째 원소로 넣어야 heapq가 가중치 기준으로 정렬합니다.

import heapq

heap = []
heapq.heappush(heap, (13, 2))  # 가중치 13, 노드 2
heapq.heappush(heap, (4,  7))  # 가중치 4,  노드 7
heapq.heappush(heap, (15, 3))  # 가중치 15, 노드 3

weight, node = heapq.heappop(heap)
# → weight=4, node=7  (최솟값 먼저 꺼냄)

Python 구현

기본 구현

import sys
import heapq

input = sys.stdin.readline

def prim(start):
    visited[start] = True
    route = [start]
    heap = graph[start][:]     # 시작 노드의 인접 간선을 힙에 삽입
    heapq.heapify(heap)        # 리스트를 힙으로 변환
    total_weight = 0

    while heap:
        weight, node = heapq.heappop(heap)

        if visited[node]:      # 이미 방문한 노드는 건너뜀
            continue

        visited[node] = True
        route.append(node)
        total_weight += weight

        for edge in graph[node]:
            if not visited[edge[1]]:
                heapq.heappush(heap, edge)

    return route, total_weight


v, e = map(int, input().split())
graph   = [[] for _ in range(v + 1)]
visited = [False] * (v + 1)

for _ in range(e):
    u, w, weight = map(int, input().split())
    # 무방향 그래프 — 양방향 모두 저장
    graph[u].append([weight, w])
    graph[w].append([weight, u])

route, total = prim(1)
print(f"방문 순서: {route}")
print(f"MST 총 가중치: {total}")

# 출력:
# 방문 순서: [1, 2, 7, 6, 8, 5, 4, 3]
# MST 총 가중치: 58

코드 흐름 정리

1. 시작 노드를 visited 처리하고, 인접 간선을 모두 힙에 넣는다
2. 힙에서 (최소 가중치, 노드)를 꺼낸다
3. 이미 방문한 노드면 skip
4. 방문하지 않은 노드면:
   a. visited 처리
   b. 가중치를 누적
   c. 해당 노드의 인접 간선 중 미방문 노드만 힙에 추가
5. 힙이 빌 때까지 2~4를 반복

시간복잡도 분석

연산	횟수	비용
힙 삽입 (heappush)	최대 E번	O(log E)
힙 추출 (heappop)	최대 E번	O(log E)
전체		O(E log E) ≈ O(E log V)

E ≤ V² 이므로 log E ≤ 2 log V, 따라서 O(E log E) = O(E log V)로 표기합니다.

주의할 점

1. 간선 저장 형식 — 가중치를 반드시 첫 번째로

# ✅ 올바른 형태 — heapq가 가중치 기준으로 정렬
graph[u].append([weight, v])

# ❌ 잘못된 형태 — 노드 번호 기준으로 정렬됨
graph[u].append([v, weight])

2. 방문 체크로 사이클 방지

# heappop 후 반드시 visited 확인
weight, node = heapq.heappop(heap)
if visited[node]:
    continue  # 이미 MST에 포함된 노드 — 건너뜀

3. 무방향 그래프 처리

# 양쪽 방향 모두 저장
graph[u].append([weight, v])
graph[v].append([weight, u])

백준 관련 문제

프림 알고리즘을 연습할 수 있는 문제들입니다.

문제	난이도	설명
1197 최소 스패닝 트리	Gold IV	MST 기본 문제 — 프림 또는 크루스칼
1922 네트워크 연결	Gold IV	1197과 동일한 유형
4386 별자리 만들기	Gold III	좌표 기반 MST

Ref: 프림 알고리즘(Prim's Algorithm)

정보처리기사 실기 — C언어 & Java 코딩 문제 핵심 정리

Mon, 31 Mar 2025 00:00:00 GMT

정보처리기사 실기 코딩 문제는 코드를 직접 작성하는 것이 아니라 코드의 출력값을 맞히는 형태입니다. 코드를 눈으로 읽고 정확하게 트레이싱하는 능력이 핵심입니다. 시험에서 자주 등장하는 개념과 실수하기 쉬운 함정 패턴을 정리합니다.

C언어 핵심 개념

1. 자료형과 형 변환

#include <stdio.h>

int main() {
    int   a = 5, b = 2;
    float f;

    printf("%d\n", a / b);      // 2  (정수 나눗셈 → 소수점 버림)
    printf("%f\n", a / b);      // 2.000000  (결과는 여전히 정수 2)
    printf("%f\n", (float)a / b); // 2.500000  (형 변환 후 나눗셈)
    printf("%d\n", a % b);      // 1  (나머지)

    int x = 3.9;                // 소수점 버림 → x = 3
    printf("%d\n", x);          // 3

    return 0;
}

핵심: 정수 / 정수 = 정수 (소수점 버림). float으로 캐스팅 후 연산해야 실수 결과를 얻습니다.

자료형 크기 (32비트 기준)

자료형	크기	범위
`char`	1 byte	-128 ~ 127
`int`	4 byte	-2,147,483,648 ~ 2,147,483,647
`float`	4 byte	소수점 약 7자리
`double`	8 byte	소수점 약 15자리
`long`	4 or 8 byte	시스템 의존

2. 연산자 우선순위와 증감 연산자

#include <stdio.h>

int main() {
    int a = 5;

    // 후위 증감: 현재 값 사용 후 증가
    printf("%d\n", a++);  // 5  출력 (출력 후 a=6)
    printf("%d\n", a);    // 6

    // 전위 증감: 먼저 증가 후 사용
    int b = 5;
    printf("%d\n", ++b);  // 6  출력 (먼저 b=6)
    printf("%d\n", b);    // 6

    // 복합 표현식
    int c = 3, d = 4;
    printf("%d\n", c++ + ++d);  // 3 + 5 = 8
    // 출력 후: c=4, d=5

    // 비교 연산자
    printf("%d\n", 5 > 3);   // 1 (true)
    printf("%d\n", 5 == 3);  // 0 (false)

    return 0;
}

연산자 우선순위 (높음 → 낮음)

() [] → .              최우선
++ -- (후위) ! ~ (단항)
* / %
+ -
< <= > >=
== !=
&  ^  |
&&
||
= += -= *=

3. 포인터

#include <stdio.h>

int main() {
    int  a = 10;
    int *p = &a;    // p는 a의 주소를 저장

    printf("%d\n", a);   // 10  (변수 a의 값)
    printf("%p\n", &a);  // a의 주소 (예: 0x1000)
    printf("%p\n", p);   // p가 저장한 주소 = &a
    printf("%d\n", *p);  // 10  (역참조: p가 가리키는 곳의 값)

    *p = 20;            // 역참조로 a의 값 변경
    printf("%d\n", a);  // 20

    return 0;
}

배열과 포인터의 관계

int arr[5] = {10, 20, 30, 40, 50};
int *p = arr;   // == &arr[0]

// 아래 네 표현은 모두 동일 (arr[2] = 30)
printf("%d\n", arr[2]);    // 30
printf("%d\n", *(arr+2));  // 30
printf("%d\n", *(p+2));    // 30
printf("%d\n", p[2]);      // 30

이중 포인터

int  a  = 10;
int *p  = &a;
int **pp = &p;

printf("%d\n", **pp);  // 10  (**pp → *p → a)
**pp = 99;
printf("%d\n", a);     // 99

포인터 연산 주의

int  arr[] = {1, 2, 3};
int *p = arr;

p++;          // 주소가 sizeof(int) = 4바이트 증가
printf("%d\n", *p);  // 2  (arr[1])

4. 문자열과 문자 배열

#include <stdio.h>
#include <string.h>

int main() {
    char str1[] = "hello";      // {'h','e','l','l','o','\0'}
    char str2[10] = "world";

    // 문자열 길이 (null 제외)
    printf("%d\n", strlen(str1));  // 5

    // 배열 크기 (null 포함)
    printf("%d\n", sizeof(str1));  // 6

    // 문자 접근
    printf("%c\n", str1[0]);     // h
    printf("%d\n", str1[0]);     // 104  (ASCII)

    // 문자 산술 연산
    char c = 'A';
    printf("%c\n", c + 3);       // D  (65+3=68='D')
    printf("%c\n", 'a' - 32);    // A  (소문자 → 대문자)
    printf("%d\n", '5' - '0');   // 5  (숫자 문자 → 정수)

    // 주요 문자열 함수
    // strlen(s)       : 길이 반환 (null 제외)
    // strcpy(dst, src): 문자열 복사
    // strcat(dst, src): 문자열 이어 붙이기
    // strcmp(s1, s2)  : 같으면 0, s1<s2이면 음수, s1>s2이면 양수
    // strchr(s, c)    : 문자 c의 첫 위치 포인터 반환

    return 0;
}

5. 구조체 (struct)

#include <stdio.h>

struct Student {
    char name[20];
    int  age;
    double gpa;
};  // 세미콜론 필수!

int main() {
    struct Student s1;
    struct Student s2 = {"Kim", 25, 4.3};

    // 멤버 접근 (. 연산자)
    s1.age = 22;

    // 구조체 포인터 (->) 연산자
    struct Student *p = &s2;
    printf("%s\n", p->name);   // Kim
    printf("%d\n", p->age);    // 25
    // p->name  ==  (*p).name

    // typedef로 타입 이름 단순화
    typedef struct {
        int x, y;
    } Point;

    Point pt = {3, 4};
    printf("%d %d\n", pt.x, pt.y);  // 3 4

    return 0;
}

6. 재귀 함수 트레이싱

재귀 문제는 콜 스택을 직접 그려가며 추적하는 것이 가장 확실합니다.

#include <stdio.h>

// 팩토리얼
int factorial(int n) {
    if (n <= 1) return 1;
    return n * factorial(n - 1);
}

// 피보나치
int fib(int n) {
    if (n <= 1) return n;
    return fib(n-1) + fib(n-2);
}

// 트레이싱: factorial(4)
// factorial(4) = 4 × factorial(3)
//                    = 3 × factorial(2)
//                          = 2 × factorial(1)
//                                = 1
//                    = 2 × 1 = 2
//               = 3 × 2 = 6
//           = 4 × 6 = 24

// 트레이싱: fib(5)
// fib(5) = fib(4) + fib(3)
//        = (fib(3)+fib(2)) + (fib(2)+fib(1))
//        = ((fib(2)+fib(1))+fib(2)) + ...
//        = 5

int main() {
    printf("%d\n", factorial(4));  // 24
    printf("%d\n", fib(6));        // 8  (0,1,1,2,3,5,8)
    return 0;
}

7. 반복문과 제어문 트레이싱

#include <stdio.h>

int main() {
    // 중첩 반복문 — break는 가장 안쪽 루프만 탈출
    for (int i = 0; i < 3; i++) {
        for (int j = 0; j < 3; j++) {
            if (j == 1) break;   // 안쪽 for만 종료
            printf("%d %d\n", i, j);
        }
    }
    // 출력: 0 0 / 1 0 / 2 0

    // continue — 현재 반복 건너뜀
    for (int i = 0; i < 5; i++) {
        if (i % 2 == 0) continue;
        printf("%d ", i);
    }
    // 출력: 1 3

    // do-while — 조건 관계없이 최소 한 번 실행
    int x = 10;
    do {
        printf("%d\n", x);
        x--;
    } while (x > 10);
    // 출력: 10  (조건 false여도 한 번 실행)

    return 0;
}

8. 전처리기와 매크로

#include <stdio.h>

#define PI 3.14
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#define SQUARE(x) ((x)*(x))

int main() {
    printf("%f\n", PI);           // 3.140000
    printf("%d\n", MAX(3, 7));    // 7
    printf("%d\n", SQUARE(4));    // 16

    // 주의: 괄호 없으면 함정
    // #define SQ(x) x*x
    // SQ(2+3) → 2+3*2+3 = 11  (의도: 25)
    // 괄호로 감싸야 안전: ((x)*(x))

    return 0;
}

Java 핵심 개념

9. 자료형과 형 변환

public class Main {
    public static void main(String[] args) {
        // 정수 나눗셈
        System.out.println(5 / 2);          // 2
        System.out.println(5.0 / 2);        // 2.5
        System.out.println((double)5 / 2);  // 2.5

        // 문자열 + 숫자 연산 — 실수 주의!
        System.out.println(1 + 2 + "3");    // 33  (1+2=3 → "3"+"3")
        System.out.println("1" + 2 + 3);    // 123 ("1"+2="12"+"3"="123")
        System.out.println("1" + (2 + 3));  // 15  (괄호 먼저)

        // char 산술
        char c = 'A';
        System.out.println(c + 1);          // 66  (int로 자동 변환)
        System.out.println((char)(c + 1));  // B

        // 자동 형 변환 (묵시적)
        // byte → short → int → long → float → double
        int  i = 100;
        long l = i;     // 자동 변환 OK
        // int j = l;   // 에러 — 명시적 캐스팅 필요
        int  j = (int)l;  // OK
    }
}

10. 증감 연산자 & 출력 순서

public class Main {
    public static void main(String[] args) {
        int a = 5;

        System.out.println(a++);  // 5  (출력 후 a=6)
        System.out.println(a);    // 6

        int b = 5;
        System.out.println(++b);  // 6  (b=6 후 출력)

        // 연산 우선순위 주의
        int c = 2;
        int d = c++ * 3 + ++c;
        // c++ → c=2 사용 후 c=3
        // ++c → c=4, 4 사용
        // d = 2*3 + 4 = 10
        System.out.println(d);    // 10
        System.out.println(c);    // 4
    }
}

11. 클래스와 객체지향

생성자와 this

class Car {
    String model;
    int    speed;
    static int count = 0;   // 모든 인스턴스가 공유

    // 생성자
    Car(String model, int speed) {
        this.model = model;   // this: 현재 인스턴스 참조
        this.speed = speed;
        count++;
    }

    // 생성자 오버로딩
    Car(String model) {
        this(model, 0);   // 다른 생성자 호출
    }
}

// 사용
Car c1 = new Car("BMW", 200);
Car c2 = new Car("Kia");
System.out.println(Car.count);  // 2  (static → 클래스명으로 접근)

상속과 메서드 오버라이딩

class Animal {
    String name;

    Animal(String name) { this.name = name; }

    void sound() { System.out.println("..."); }
    void info()  { System.out.println("Animal: " + name); }
}

class Dog extends Animal {
    Dog(String name) {
        super(name);   // 부모 생성자 반드시 먼저 호출
    }

    @Override
    void sound() { System.out.println("Woof"); }  // 오버라이딩

    // info()는 오버라이딩 안 함 → 부모 것 사용
}

// 다형성 (Polymorphism)
Animal a = new Dog("Rex");  // 부모 타입으로 자식 객체 참조
a.sound();   // "Woof"  — 실제 타입(Dog)의 메서드 실행 (동적 바인딩)
a.info();    // "Animal: Rex"

추상 클래스 vs 인터페이스

// 추상 클래스 — 일부 구현 가능, 단일 상속
abstract class Shape {
    abstract double area();          // 추상 메서드 (구현 없음)
    void display() {                 // 일반 메서드 (구현 있음)
        System.out.println("넓이: " + area());
    }
}

// 인터페이스 — 모두 추상, 다중 구현 가능
interface Drawable {
    void draw();   // public abstract 생략 가능
    default void print() { System.out.println("출력"); }
}

class Circle extends Shape implements Drawable {
    double r;
    Circle(double r) { this.r = r; }

    @Override public double area()  { return 3.14 * r * r; }
    @Override public void   draw()  { System.out.println("원 그리기"); }
}

12. String 클래스 주의사항

public class Main {
    public static void main(String[] args) {
        // 문자열 비교 — == vs equals
        String a = "hello";
        String b = "hello";
        String c = new String("hello");

        System.out.println(a == b);        // true  (같은 리터럴 풀)
        System.out.println(a == c);        // false (다른 객체)
        System.out.println(a.equals(c));   // true  (값 비교)

        // 주요 String 메서드
        String s = "Hello World";
        System.out.println(s.length());        // 11
        System.out.println(s.charAt(0));       // H
        System.out.println(s.indexOf("o"));    // 4 (첫 번째 o)
        System.out.println(s.substring(6));    // World
        System.out.println(s.substring(0,5));  // Hello
        System.out.println(s.toLowerCase());   // hello world
        System.out.println(s.toUpperCase());   // HELLO WORLD
        System.out.println(s.replace("l","L")); // HeLLo WorLd
        System.out.println(s.trim());          // 앞뒤 공백 제거

        // 숫자 ↔ 문자열 변환
        int n = Integer.parseInt("42");        // 문자열 → 정수
        String str = String.valueOf(42);       // 정수 → 문자열
        String str2 = Integer.toString(42);    // 정수 → 문자열
    }
}

13. 배열 (Array)

public class Main {
    public static void main(String[] args) {
        // 1차원 배열 — 기본값으로 초기화됨
        int[]    nums   = new int[5];     // [0, 0, 0, 0, 0]
        boolean[]flags  = new boolean[3]; // [false, false, false]
        String[] strs   = new String[2];  // [null, null]

        // 초기화와 동시에 선언
        int[] arr = {10, 20, 30, 40, 50};
        System.out.println(arr.length);   // 5 (메서드 아님, 필드)

        // 2차원 배열
        int[][] matrix = {
            {1, 2, 3},
            {4, 5, 6},
            {7, 8, 9}
        };
        System.out.println(matrix[1][2]);  // 6
        System.out.println(matrix.length); // 3 (행 수)
        System.out.println(matrix[0].length); // 3 (열 수)

        // 배열 순회
        for (int x : arr) {
            System.out.print(x + " ");  // 향상된 for문
        }
    }
}

14. 컬렉션 프레임워크

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // ArrayList — 순서 있음, 중복 허용
        ArrayList<Integer> list = new ArrayList<>();
        list.add(10); list.add(20); list.add(30);
        list.remove(Integer.valueOf(20));  // 값으로 제거
        list.remove(0);                    // 인덱스로 제거
        System.out.println(list.size());   // 1
        System.out.println(list.get(0));   // 30

        // HashMap — Key-Value, 순서 없음
        HashMap<String, Integer> map = new HashMap<>();
        map.put("apple", 3);
        map.put("banana", 5);
        System.out.println(map.get("apple"));       // 3
        System.out.println(map.containsKey("grape")); // false
        System.out.println(map.getOrDefault("grape", 0)); // 0

        // HashSet — 중복 없음, 순서 없음
        HashSet<Integer> set = new HashSet<>();
        set.add(1); set.add(2); set.add(1);
        System.out.println(set.size());   // 2 (중복 제거)

        // Stack
        Stack<Integer> stack = new Stack<>();
        stack.push(1); stack.push(2); stack.push(3);
        System.out.println(stack.pop());    // 3 (LIFO)
        System.out.println(stack.peek());   // 2 (제거 안 함)
    }
}

15. 예외 처리

public class Main {
    public static void main(String[] args) {
        // try-catch-finally
        try {
            int[] arr = new int[3];
            arr[5] = 10;               // ArrayIndexOutOfBoundsException
            System.out.println("정상");
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("배열 범위 초과: " + e.getMessage());
        } catch (Exception e) {
            System.out.println("기타 예외");
        } finally {
            System.out.println("항상 실행");  // 예외 여부 관계없이 반드시 실행
        }

        // 자주 나오는 예외 종류
        // NullPointerException         : null 참조
        // ArrayIndexOutOfBoundsException: 배열 범위 초과
        // ClassCastException           : 잘못된 형 변환
        // NumberFormatException        : 숫자 변환 실패
        // ArithmeticException          : 0으로 나누기
        // StackOverflowError           : 재귀 무한 반복
    }
}

자주 나오는 함정 패턴

C언어 함정

// 1. 조건문 안에서 대입 vs 비교
int a = 0;
if (a = 5) { ... }   // 대입! 항상 true (5는 참)
if (a == 5) { ... }  // 비교 (올바른 방법)

// 2. 배열 크기 구하기
int arr[] = {1,2,3,4,5};
int size = sizeof(arr) / sizeof(arr[0]);   // 5
// 포인터로 받으면 sizeof는 포인터 크기(4 or 8)만 반환

// 3. 포인터와 배열 이름의 차이
int arr[5] = {1,2,3,4,5};
int *p = arr;
// arr은 상수 포인터 → arr++ 불가
// p는 변수 포인터 → p++ 가능

// 4. 문자열 비교 (== 불가)
char s1[] = "hello", s2[] = "hello";
s1 == s2;          // ❌ 주소 비교 (항상 false)
strcmp(s1, s2);    // ✅ 값 비교 (같으면 0)

Java 함정

// 1. Integer 캐시 범위
Integer a = 127, b = 127;
Integer c = 128, d = 128;
System.out.println(a == b);  // true  (-128~127 캐싱)
System.out.println(c == d);  // false (캐시 범위 초과 → 새 객체)
// Integer는 항상 equals()로 비교할 것

// 2. String은 불변(Immutable)
String s = "hello";
s.toUpperCase();              // ❌ 원본 불변 → 반환값 무시됨
String upper = s.toUpperCase(); // ✅ 새 String 반환
System.out.println(s);        // "hello" (원본 그대로)

// 3. 배열 기본값
int[]    a = new int[3];    // 0으로 초기화
boolean[]b = new boolean[3]; // false로 초기화
String[] c = new String[3];  // null로 초기화

// 4. 다형성에서 오버라이딩 vs 오버로딩
class A {
    void print() { System.out.println("A"); }
}
class B extends A {
    @Override
    void print() { System.out.println("B"); }
}
A obj = new B();
obj.print();  // "B" — 실제 타입(B)의 메서드 실행 (동적 바인딩)

// 5. static 메서드는 오버라이딩 불가 (숨겨짐)
// static은 컴파일 타임에 결정 → 참조 타입 기준으로 호출

시험 직전 체크리스트

C언어

□ 정수 나눗셈은 소수점 버림
□ a++ (후위): 현재 값 사용 후 증가
□ ++a (전위): 먼저 증가 후 사용
□ *p 역참조, &a 주소, p→m 구조체 포인터 접근
□ 배열 이름 = 첫 번째 원소의 주소
□ sizeof(배열) / sizeof(원소) = 원소 개수
□ 재귀: 콜 스택 직접 그려서 추적
□ 문자열 비교는 strcmp() 사용 (== 은 주소 비교)
□ 구조체 선언 끝에 세미콜론(;) 필수
□ 매크로 인수는 반드시 괄호로 감싸기

Java

□ 정수 / 정수 = 정수 (소수점 버림)
□ "문자열" + 숫자 = 문자열 연결 (왼쪽에서 오른쪽 평가)
□ String 비교는 equals() 사용 (== 은 주소 비교)
□ String 메서드는 원본 불변, 반환값 사용
□ 배열 기본값: int=0, boolean=false, 참조형=null
□ 오버라이딩: 부모 타입 참조여도 자식 메서드 실행
□ static 멤버는 클래스명.멤버로 접근
□ super()는 자식 생성자 첫 줄에 위치
□ finally는 예외 여부 관계없이 항상 실행
□ Integer == 비교 주의 (-128~127만 캐싱)

Ref: Claude AI

최소 스패닝 트리(MST)와 크루스칼 알고리즘

Sun, 16 Mar 2025 00:00:00 GMT

스패닝 트리 (Spanning Tree)란?

스패닝 트리(신장 트리)란 그래프의 모든 정점을 포함하면서 사이클이 없는 부분 그래프를 말합니다.

스패닝 트리의 핵심 특징은 다음과 같습니다.

그래프의 모든 정점을 연결합니다.
사이클이 존재하지 않습니다.
V개의 정점을 연결하는 간선의 수는 정확히 V - 1개입니다.
하나의 그래프에서 스패닝 트리는 여러 가지 형태로 만들어질 수 있습니다.

최소 스패닝 트리 (MST, Minimum Spanning Tree)

최소 스패닝 트리는 여러 스패닝 트리 중 간선의 가중치 합이 최소인 스패닝 트리입니다.

MST를 구하는 대표 알고리즘은 두 가지입니다.

크루스칼 알고리즘(Kruskal): 간선 중심, 그리디 방식
프림 알고리즘(Prim): 정점 중심, 그리디 방식

이번 포스트에서는 크루스칼 알고리즘을 다룹니다.

크루스칼 알고리즘 (Kruskal Algorithm)

크루스칼 알고리즘은 간선을 가중치 기준으로 정렬한 뒤, 사이클을 형성하지 않는 간선을 순서대로 선택해 MST를 완성하는 그리디 알고리즘입니다.

동작 원리

모든 간선을 가중치 기준 오름차순으로 정렬합니다.
정렬된 간선을 순서대로 확인하며:
- 해당 간선이 사이클을 형성하지 않으면 MST에 추가합니다.
- 사이클을 형성하면 스킵합니다.
MST에 포함된 간선이 V - 1개가 되면 종료합니다.

사이클 여부는 Union-Find(유니온 파인드) 알고리즘으로 판별합니다.
두 정점의 루트 노드가 같다면 같은 집합 → 간선 추가 시 사이클 발생!

단계별 동작 예시

아래 그래프를 기준으로 크루스칼 알고리즘을 수행합니다.

정점: 1, 2, 3, 4, 5, 6
간선 목록 (가중치 오름차순 정렬):
(1-5): 1
(4-5): 2
(1-4): 3  ← 사이클 발생 → 스킵
(1-3): 4
(2-4): 4
(2-5): 5
(3-6): 6
(4-6): 8
(1-2): 9

단계	선택 간선	가중치	사이클 여부	MST 포함
1	1 - 5	1	❌	✅
2	4 - 5	2	❌	✅
3	1 - 4	3	✅ (1-4-5 사이클)	❌ 스킵
4	1 - 3	4	❌	✅
5	2 - 4	4	❌	✅
6	3 - 6	6	❌	✅

V - 1 = 5개의 간선이 선택되었으므로 알고리즘 종료!

완성된 MST

선택된 간선: (1-5):1, (4-5):2, (1-3):4, (2-4):4, (3-6):6

총 가중치 합 = 1 + 2 + 4 + 4 + 6 = 17

사이클 감지: Union-Find

크루스칼의 핵심은 간선 추가 시 사이클이 발생하는지 판별하는 것입니다. 이를 위해 Union-Find를 사용합니다.

두 정점의 루트 노드가 같으면 → 이미 같은 집합 → 사이클 발생
루트 노드가 다르면 → 다른 집합 → 간선 추가 후 Union

def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])  # 경로 압축
    return parent[x]

def union(x, y):
    rx, ry = find(x), find(y)
    if rx == ry:
        return False  # 사이클 발생
    parent[ry] = rx
    return True

Python 구현

import sys
input = sys.stdin.readline

def find(x):
    if parent[x] != x:
        parent[x] = find(parent[x])  # 경로 압축
    return parent[x]

def union(x, y):
    rx, ry = find(x), find(y)
    if rx == ry:
        return False  # 사이클 발생 → 스킵
    if rx < ry:
        parent[ry] = rx
    else:
        parent[rx] = ry
    return True

def kruskal(v, edges):
    global parent
    parent = list(range(v + 1))

    # 간선을 가중치 기준 오름차순 정렬
    edges.sort(key=lambda x: x[0])

    mst = []
    total_cost = 0

    for cost, a, b in edges:
        if union(a, b):  # 사이클이 없으면 MST에 추가
            mst.append((a, b, cost))
            total_cost += cost
        if len(mst) == v - 1:  # V-1개 선택 시 종료
            break

    return mst, total_cost


# 사용 예시
v = 6
edges = [
    (1, 1, 5),
    (4, 1, 3),
    (3, 1, 4),
    (9, 1, 2),
    (4, 2, 4),
    (5, 2, 5),
    (6, 3, 6),
    (2, 4, 5),
    (8, 4, 6),
]

mst, total = kruskal(v, edges)

print("[MST]")
for a, b, cost in mst:
    print(f"{a} - {b} : 비용 {cost}")
print(f"총 비용: {total}")

출력 결과

[MST]
1 - 5 : 비용 1
4 - 5 : 비용 2
1 - 4 : 비용 3  ← 사이클로 스킵됨 (실제 출력 안됨)
1 - 3 : 비용 4
2 - 4 : 비용 4
3 - 6 : 비용 6
총 비용: 17

C++ 구현

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<int, pair<int, int>> Edge;

int parent[10001];

int find_root(int x) {
    if (parent[x] == x) return x;
    return parent[x] = find_root(parent[x]);  // 경로 압축
}

bool union_root(int x, int y) {
    x = find_root(x);
    y = find_root(y);
    if (x == y) return false;  // 사이클 발생
    if (x < y) parent[y] = x;
    else parent[x] = y;
    return true;
}

int main() {
    int v, e;
    cin >> v >> e;

    vector<Edge> edges;
    for (int i = 0; i < e; i++) {
        int a, b, c;
        cin >> a >> b >> c;
        edges.push_back({c, {a, b}});
    }

    // 가중치 기준 오름차순 정렬
    sort(edges.begin(), edges.end());

    // Union-Find 초기화
    for (int i = 1; i <= v; i++) parent[i] = i;

    int total_cost = 0;
    int edge_count = 0;

    for (auto& edge : edges) {
        int cost = edge.first;
        int a = edge.second.first;
        int b = edge.second.second;

        if (union_root(a, b)) {
            total_cost += cost;
            edge_count++;
            cout << a << " - " << b << " : 비용 " << cost << "\n";
        }

        if (edge_count == v - 1) break;
    }

    cout << "총 비용: " << total_cost << "\n";
    return 0;
}

시간 복잡도

단계	복잡도
간선 정렬	O(E log E)
Union-Find (경로 압축)	O(α(V)) ≈ O(1)
전체	O(E log E)

E는 간선 수, V는 정점 수입니다. 간선 정렬이 지배적이므로 전체 복잡도는 **O(E log E)**입니다.

크루스칼 vs 프림

구분	크루스칼	프림
중심	간선	정점
방식	그리디 (간선 정렬)	그리디 (인접 정점 선택)
사용 자료구조	Union-Find	우선순위 큐
시간 복잡도	O(E log E)	O(E log V)
적합한 그래프	간선이 적은 희소 그래프	간선이 많은 밀집 그래프

분할정복(Divide and Conquer)

Tue, 25 Feb 2025 00:00:00 GMT

분할정복(Divide and Conquer)은 복잡한 문제를 더 작은 하위 문제로 나눠 해결하는 알고리즘 설계 패러다임입니다.

기본 단계

분할정복은 세 단계로 이루어집니다.

분할(Divide): 원래 문제를 더 작은 하위 문제들로 나눕니다.
정복(Conquer): 하위 문제들을 재귀적으로 해결합니다.
병합(Combine): 하위 문제들의 해결책을 합쳐 원래 문제의 해결책을 만듭니다.

1. 병합 정렬 (Merge Sort)

배열을 절반으로 나누고, 각각을 재귀적으로 정렬한 다음 병합하는 방식입니다.

def merge_sort(arr):
    if len(arr) <= 1:
        return arr

    mid = len(arr) // 2
    left = merge_sort(arr[:mid])
    right = merge_sort(arr[mid:])

    return merge(left, right)

def merge(left, right):
    result = []
    i = j = 0

    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1

    result.extend(left[i:])
    result.extend(right[j:])
    return result

케이스	시간 복잡도
최선	O(n log n)
평균	O(n log n)
최악	O(n log n)
공간	O(n)

2. 퀵 정렬 (Quick Sort)

피벗을 기준으로 배열을 두 부분으로 분할한 뒤 재귀적으로 정렬합니다.

def quick_sort(arr):
    if len(arr) <= 1:
        return arr

    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]

    return quick_sort(left) + middle + quick_sort(right)

케이스	시간 복잡도
최선	O(n log n)
평균	O(n log n)
최악	O(n²) — 이미 정렬된 배열이거나 모든 요소가 같을 때

병합 정렬과 달리 추가 메모리가 거의 필요 없어 실무에서 자주 사용됩니다.

3. 이진 검색 (Binary Search)

정렬된 배열에서 중간 값을 기준으로 탐색 범위를 절반씩 줄여나갑니다.

def binary_search(arr, target):
    left, right = 0, len(arr) - 1

    while left <= right:
        mid = (left + right) // 2

        if arr[mid] == target:
            return mid
        elif arr[mid] < target:
            left = mid + 1
        else:
            right = mid - 1

    return -1

시간 복잡도: O(log n)
반드시 정렬된 배열에서만 사용 가능합니다.

4. 스트라센 알고리즘 (Strassen's Algorithm)

기존 행렬 곱셈(O(n³))보다 효율적으로, 8번의 곱셈을 7번으로 줄여 시간을 단축합니다.

두 행렬을 각각 4개의 부분 행렬로 분할합니다.
7개의 중간 행렬 M₁ ~ M₇을 계산합니다.
이를 조합해 결과 행렬을 만듭니다.
시간 복잡도: O(n^log₂7) ≈ O(n^2.81)

5. 최대 부분 배열 합 (Maximum Subarray Sum)

배열을 절반으로 나눠 왼쪽, 오른쪽, 그리고 중간을 가로지르는 세 경우의 최댓값을 비교합니다.

def max_crossing_sum(arr, low, mid, high):
    left_sum = float('-inf')
    sum_so_far = 0
    for i in range(mid, low - 1, -1):
        sum_so_far += arr[i]
        left_sum = max(left_sum, sum_so_far)

    right_sum = float('-inf')
    sum_so_far = 0
    for i in range(mid + 1, high + 1):
        sum_so_far += arr[i]
        right_sum = max(right_sum, sum_so_far)

    return left_sum + right_sum

def max_subarray_sum(arr, low, high):
    if low == high:
        return arr[low]

    mid = (low + high) // 2
    left_sum = max_subarray_sum(arr, low, mid)
    right_sum = max_subarray_sum(arr, mid + 1, high)
    cross_sum = max_crossing_sum(arr, low, mid, high)

    return max(left_sum, right_sum, cross_sum)

시간 복잡도: O(n log n)
참고로 카데인 알고리즘(Kadane's Algorithm)을 사용하면 O(n)으로도 풀 수 있습니다.

6. 가장 가까운 점 쌍 (Closest Pair of Points)

점들을 x좌표로 정렬한 뒤 절반으로 나눠 각 구역의 최소 거리를 구하고, 경계에 걸친 경우도 탐색합니다.

점들을 x좌표로 정렬합니다.
점 집합을 절반으로 나눕니다.
왼쪽과 오른쪽 각각에서 가장 가까운 점 쌍을 재귀적으로 찾습니다.
두 부분 경계에 걸쳐 있는 가장 가까운 점 쌍을 탐색합니다.
세 경우 중 최소 거리를 반환합니다.

시간 복잡도: O(n log n)

시간 복잡도 비교

알고리즘	시간 복잡도
병합 정렬	O(n log n)
퀵 정렬 (평균)	O(n log n)
이진 검색	O(log n)
스트라센	O(n^2.81)
최대 부분 배열 합	O(n log n)
가장 가까운 점 쌍	O(n log n)

분할정복 vs 동적 계획법

두 패러다임 모두 문제를 하위 문제로 나눠 해결하지만, 핵심 차이가 있습니다.

분할정복: 하위 문제들이 독립적입니다. 중복 계산이 발생해도 그냥 다시 풀어요.
동적 계획법: 하위 문제들이 중복됩니다. 한 번 푼 결과를 저장(메모이제이션)해서 재사용합니다.

하위 문제가 겹치는지 여부가 두 방법을 선택하는 핵심 기준입니다.

마스터 정리 (Master Theorem)

분할정복 알고리즘의 시간 복잡도를 분석할 때 사용하는 공식입니다.

T(n) = aT(n/b) + f(n)

a: 하위 문제의 수
b: 분할 비율
f(n): 분할 및 병합에 드는 비용

Ref: Claude AI

트리 순회 — 전위, 중위, 후위, 레벨 순회

Sat, 15 Feb 2025 00:00:00 GMT

순회(Traversal) 란 트리의 모든 노드를 방문하면서 값을 확인하는 작업입니다. 어떤 노드를 먼저 방문하느냐에 따라 순회 방법이 달라지며, 이진 트리에서는 크게 네 가지로 나뉩니다. 전위, 중위, 후위 순회는 재귀로, 레벨 순회는 큐(BFS) 로 구현합니다.

트리 구조 및 예제

아래 트리를 기준으로 네 가지 순회를 설명합니다.

        1
      /   \
     2     3
    / \   / \
   4   5 6   7
  /
 8

순회 방법	방문 순서	결과
전위 순회	Root → Left → Right	1 2 4 8 5 3 6 7
중위 순회	Left → Root → Right	8 4 2 5 1 6 3 7
후위 순회	Left → Right → Root	8 4 5 2 6 7 3 1
레벨 순회	레벨 순서 (BFS)	1 2 3 4 5 6 7 8

트리 구현 (Python)

class Node:
    def __init__(self, item):
        self.item  = item
        self.left  = None
        self.right = None

class BinaryTree:
    def __init__(self):
        self.root = None

item: 노드가 저장하는 값
left / right: 왼쪽/오른쪽 자식 노드를 가리키는 포인터
BinaryTree는 root 하나만 갖고, 노드를 연결해 트리를 구성

예제 트리 구성:

BT = BinaryTree()
N1, N2, N3 = Node(1), Node(2), Node(3)
N4, N5, N6 = Node(4), Node(5), Node(6)
N7, N8     = Node(7), Node(8)

BT.root = N1
N1.left  = N2;  N1.right = N3
N2.left  = N4;  N2.right = N5
N3.left  = N6;  N3.right = N7
N4.left  = N8

전위 순회 (Preorder)

방문 순서

Root → Left → Right

현재 노드를 먼저 방문한 뒤 왼쪽 서브트리, 오른쪽 서브트리 순으로 재귀 탐색합니다.

동작 흐름

1 방문 → 왼쪽(2)으로
2 방문 → 왼쪽(4)으로
4 방문 → 왼쪽(8)으로
8 방문 → 자식 없음 → 백트래킹
4의 오른쪽 없음 → 백트래킹
2의 오른쪽(5)으로
5 방문 → 자식 없음 → 백트래킹
1의 오른쪽(3)으로
3 방문 → 왼쪽(6)으로
6 방문 → 자식 없음 → 백트래킹
3의 오른쪽(7)으로
7 방문 → 자식 없음 → 완료

결과: 1 → 2 → 4 → 8 → 5 → 3 → 6 → 7

Python 구현

def preorder(self):
    def _preorder(node):
        print(node.item, end=' ')  # 1. 현재 노드 방문
        if node.left:
            _preorder(node.left)   # 2. 왼쪽 서브트리
        if node.right:
            _preorder(node.right)  # 3. 오른쪽 서브트리
    _preorder(self.root)

출력: 1 2 4 8 5 3 6 7

중위 순회 (Inorder)

방문 순서

Left → Root → Right

왼쪽 서브트리를 끝까지 내려간 후 현재 노드를 방문하고, 오른쪽 서브트리로 이동합니다. 이진 탐색 트리(BST)에 적용하면 오름차순 정렬 결과가 나오는 특성이 있습니다.

동작 흐름

1의 왼쪽(2) → 2의 왼쪽(4) → 4의 왼쪽(8)
8 방문 (자식 없음)
4 방문 → 4의 오른쪽 없음
2 방문 → 2의 오른쪽(5)
5 방문 (자식 없음)
1 방문 → 1의 오른쪽(3)
3의 왼쪽(6) → 6 방문 (자식 없음)
3 방문 → 3의 오른쪽(7)
7 방문 (자식 없음) → 완료

결과: 8 → 4 → 2 → 5 → 1 → 6 → 3 → 7

Python 구현

def inorder(self):
    def _inorder(node):
        if node.left:
            _inorder(node.left)    # 1. 왼쪽 서브트리
        print(node.item, end=' ')  # 2. 현재 노드 방문
        if node.right:
            _inorder(node.right)   # 3. 오른쪽 서브트리
    _inorder(self.root)

출력: 8 4 2 5 1 6 3 7

후위 순회 (Postorder)

방문 순서

Left → Right → Root

왼쪽과 오른쪽 자식을 모두 방문한 후에야 현재 노드를 방문합니다. 디렉토리 삭제처럼 자식을 먼저 처리해야 하는 작업에 적합합니다.

동작 흐름

1의 왼쪽(2) → 2의 왼쪽(4) → 4의 왼쪽(8)
8 방문 (자식 없음, 리프)
4의 오른쪽 없음 → 4 방문
2의 오른쪽(5) → 5 방문 (리프)
2의 자식 모두 완료 → 2 방문
1의 오른쪽(3) → 3의 왼쪽(6)
6 방문 (리프) → 3의 오른쪽(7)
7 방문 (리프) → 3 방문
1의 자식 모두 완료 → 1 방문 → 완료

결과: 8 → 4 → 5 → 2 → 6 → 7 → 3 → 1

Python 구현

def postorder(self):
    def _postorder(node):
        if node.left:
            _postorder(node.left)   # 1. 왼쪽 서브트리
        if node.right:
            _postorder(node.right)  # 2. 오른쪽 서브트리
        print(node.item, end=' ')   # 3. 현재 노드 방문
    _postorder(self.root)

출력: 8 4 5 2 6 7 3 1

레벨 순회 (Level-order)

방문 순서

레벨(깊이) 순서 — BFS

루트부터 시작해 같은 레벨의 노드를 왼쪽에서 오른쪽으로 모두 방문한 뒤 다음 레벨로 내려갑니다. 큐(Queue) 를 사용해 구현합니다.

동작 흐름

Queue: [1]
1 방문 → 자식 2, 3 enqueue       Queue: [2, 3]
2 방문 → 자식 4, 5 enqueue       Queue: [3, 4, 5]
3 방문 → 자식 6, 7 enqueue       Queue: [4, 5, 6, 7]
4 방문 → 자식 8 enqueue          Queue: [5, 6, 7, 8]
5 방문 → 자식 없음               Queue: [6, 7, 8]
6 방문 → 자식 없음               Queue: [7, 8]
7 방문 → 자식 없음               Queue: [8]
8 방문 → 자식 없음 → Queue 비어 완료

결과: 1 → 2 → 3 → 4 → 5 → 6 → 7 → 8

Python 구현

from collections import deque

def levelorder(self):
    q = deque([self.root])
    while q:
        node = q.popleft()
        print(node.item, end=' ')  # 방문
        if node.left:
            q.append(node.left)    # 왼쪽 자식 enqueue
        if node.right:
            q.append(node.right)   # 오른쪽 자식 enqueue

출력: 1 2 3 4 5 6 7 8

전체 코드

from collections import deque

class Node:
    def __init__(self, item):
        self.item  = item
        self.left  = None
        self.right = None

class BinaryTree:
    def __init__(self):
        self.root = None

    def preorder(self):
        def _preorder(node):
            print(node.item, end=' ')
            if node.left:  _preorder(node.left)
            if node.right: _preorder(node.right)
        _preorder(self.root)

    def inorder(self):
        def _inorder(node):
            if node.left:  _inorder(node.left)
            print(node.item, end=' ')
            if node.right: _inorder(node.right)
        _inorder(self.root)

    def postorder(self):
        def _postorder(node):
            if node.left:  _postorder(node.left)
            if node.right: _postorder(node.right)
            print(node.item, end=' ')
        _postorder(self.root)

    def levelorder(self):
        q = deque([self.root])
        while q:
            node = q.popleft()
            print(node.item, end=' ')
            if node.left:  q.append(node.left)
            if node.right: q.append(node.right)


# 트리 구성
BT = BinaryTree()
N1,N2,N3 = Node(1), Node(2), Node(3)
N4,N5,N6 = Node(4), Node(5), Node(6)
N7,N8    = Node(7), Node(8)

BT.root  = N1
N1.left  = N2;  N1.right = N3
N2.left  = N4;  N2.right = N5
N3.left  = N6;  N3.right = N7
N4.left  = N8

print('preorder   :', end=' ');   BT.preorder()    # 1 2 4 8 5 3 6 7
print('\ninorder    :', end=' '); BT.inorder()     # 8 4 2 5 1 6 3 7
print('\npostorder  :', end=' '); BT.postorder()   # 8 4 5 2 6 7 3 1
print('\nlevelorder :', end=' '); BT.levelorder()  # 1 2 3 4 5 6 7 8

순회 방법 선택 기준

상황	적합한 순회
트리를 복사하거나 직렬화할 때	전위 순회
BST에서 정렬된 순서로 값을 뽑을 때	중위 순회
파일/디렉토리 삭제, 수식 트리 계산	후위 순회
레벨별 탐색, 최단 경로 (BFS)	레벨 순회

참고 자료

[Python] 트리 구현 / 순회(전위 순회, 중위 순회, 후위 순회, 레벨 순회)

트리에서의 동적 계획법 (Tree DP)

Mon, 10 Feb 2025 00:00:00 GMT

트리 DP는 일반 DP와 다르게 계층 구조의 트리 위에서 상태를 전이합니다. 핵심은 DFS로 트리를 탐색하면서 자식 노드의 결과를 먼저 계산한 뒤 부모 노드로 전달하는 것입니다. 처음에는 낯설지만 패턴을 익히면 비슷한 문제를 일관되게 풀 수 있습니다.

1. 트리 DP란?

일반 DP vs 트리 DP

	일반 DP	트리 DP
자료 구조	배열, 수열 (선형)	트리 (계층)
상태 전이	dp[i] → dp[i+1]	부모 ← 자식
탐색 방식	반복문	DFS 재귀
처리 순서	왼쪽 → 오른쪽	자식 → 부모
dp 테이블	1D / 2D 배열	dp[node][state]

핵심 흐름

DFS(node)
    for child in children[node]:
        DFS(child)   ← 자식 먼저 계산
    dp[node] = f(dp[child1], dp[child2], ...)  ← 자식 결과로 부모 계산

트리 DP는 본질적으로 후위 순회(post-order DFS) 입니다. 리프 노드에서 시작해 루트 방향으로 값이 쌓여 올라갑니다.

2. 기본 템플릿

트리 DP 문제를 풀 때 항상 이 구조에서 출발합니다.

import sys
from collections import defaultdict
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

def dfs(v, parent):
    for child in graph[v]:
        if child == parent:    # 부모 방향으로 올라가지 않도록
            continue
        dfs(child, v)          # 자식 먼저 계산 (후위 순회)
        # dp[v] 갱신: 자식의 결과를 활용
        dp[v] = update(dp[v], dp[child])

n = int(input())
graph = defaultdict(list)
for _ in range(n - 1):
    u, v = map(int, input().split())
    graph[u].append(v)
    graph[v].append(u)    # 무방향 그래프

dp = [초기값] * (n + 1)
dfs(1, 0)                 # 루트 1, 부모 없음(0)
print(dp[1])

방향 없는 트리(무방향 그래프) 에서는 parent 변수로 부모 방향 역행을 막아야 합니다. 방문 배열 대신 parent 인자를 사용하는 것이 트리 DP의 표준 패턴입니다.

3. 유형 1 — 선택/미선택 DP

문제 유형

"인접한 두 노드를 동시에 선택할 수 없다. 각 노드에 가중치가 있을 때 선택한 노드의 가중치 합의 최대를 구하라."

대표 문제: 백준 2533 (SNS), 백준 1949 (우수 마을)

상태 설계

dp[v][0] = 노드 v를 선택하지 않았을 때, v의 서브트리에서 얻을 수 있는 최대 가중치
dp[v][1] = 노드 v를 선택했을 때, v의 서브트리에서 얻을 수 있는 최대 가중치

점화식

v를 선택 안 함 → 자식은 선택/미선택 모두 가능
dp[v][0] = Σ max(dp[c][0], dp[c][1])   (c: v의 자식)

v를 선택    → 자식은 반드시 미선택
dp[v][1] = w[v] + Σ dp[c][0]

초기값 (리프 노드):
dp[leaf][0] = 0
dp[leaf][1] = w[leaf]

최종 답: max(dp[root][0], dp[root][1])

Python 구현

import sys
from collections import defaultdict
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

def dfs(v, parent):
    dp[v][0] = 0
    dp[v][1] = weight[v]    # v를 선택하는 경우 기본값 = 자신의 가중치

    for child in graph[v]:
        if child == parent:
            continue
        dfs(child, v)

        # v 미선택: 자식은 선택/미선택 중 최대
        dp[v][0] += max(dp[child][0], dp[child][1])
        # v 선택: 자식은 반드시 미선택
        dp[v][1] += dp[child][0]


n = int(input())
weight = [0] + list(map(int, input().split()))   # 1-indexed
graph = defaultdict(list)
for _ in range(n - 1):
    u, v = map(int, input().split())
    graph[u].append(v)
    graph[v].append(u)

dp = [[0, 0] for _ in range(n + 1)]
dfs(1, 0)
print(max(dp[1][0], dp[1][1]))

응용: 최소 정점 커버 (백준 2533)

# SNS에서 얼리어답터 최솟값
# dp[v][0] = v가 얼리어답터 아님 (자식은 모두 얼리어답터여야 함)
# dp[v][1] = v가 얼리어답터

def dfs(v, parent):
    dp[v][0] = 0
    dp[v][1] = 1    # 자신 포함

    for child in graph[v]:
        if child == parent:
            continue
        dfs(child, v)

        dp[v][0] += dp[child][1]              # 자식은 반드시 얼리어답터
        dp[v][1] += min(dp[child][0], dp[child][1])  # 자식은 둘 중 최솟값

print(min(dp[1][0], dp[1][1]))

4. 유형 2 — 트리의 높이 / 서브트리 크기 / 깊이

서브트리 크기 (subtree size)

sz = [1] * (n + 1)   # 자기 자신 포함

def dfs(v, parent):
    for child in graph[v]:
        if child == parent:
            continue
        dfs(child, v)
        sz[v] += sz[child]   # 자식 크기를 부모에 누적

트리의 높이 (height)

h = [0] * (n + 1)    # 리프의 높이 = 0

def dfs(v, parent):
    for child in graph[v]:
        if child == parent:
            continue
        dfs(child, v)
        h[v] = max(h[v], h[child] + 1)  # 자식 높이 + 1

깊이 (depth) — 루트에서 내려오며 계산

depth = [0] * (n + 1)   # 루트의 깊이 = 0

def dfs(v, parent):
    for child in graph[v]:
        if child == parent:
            continue
        depth[child] = depth[v] + 1    # 부모 깊이 + 1 (top-down)
        dfs(child, v)

5. 유형 3 — 트리의 지름 (Tree Diameter)

트리에서 임의의 두 노드 사이의 거리 중 가장 긴 것을 트리의 지름이라고 합니다.

핵심 아이디어

지름은 특정 노드를 "꺾이는 점"으로 하는 두 서브트리 방향의 깊이 합이 최대인 경우입니다.

지름 후보 = depth_max1[v] + depth_max2[v]
(v에서 뻗어 나가는 두 가장 긴 경로의 합)

Python 구현

import sys
from collections import defaultdict
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

n = int(input())
graph = defaultdict(list)
for _ in range(n - 1):
    u, v, w = map(int, input().split())
    graph[u].append((v, w))
    graph[v].append((u, w))

ans = 0
depth = [0] * (n + 1)   # depth[v]: v에서 자식 방향 최대 거리

def dfs(v, parent):
    global ans
    depths = []   # 이 노드에서 각 자식 방향 깊이

    for child, w in graph[v]:
        if child == parent:
            continue
        dfs(child, v)
        depths.append(depth[child] + w)

    depths.sort(reverse=True)

    # 가장 긴 두 경로의 합이 지름 후보
    if len(depths) >= 2:
        ans = max(ans, depths[0] + depths[1])
    if len(depths) >= 1:
        ans = max(ans, depths[0])   # 자식이 하나인 경우도 고려

    depth[v] = depths[0] if depths else 0

dfs(1, 0)
print(ans)

가중치 없는 트리의 지름 (BFS 두 번)

from collections import deque

def bfs(start, graph, n):
    dist = [-1] * (n + 1)
    dist[start] = 0
    q = deque([start])
    far_node = start

    while q:
        v = q.popleft()
        for u in graph[v]:
            if dist[u] == -1:
                dist[u] = dist[v] + 1
                q.append(u)
                if dist[u] > dist[far_node]:
                    far_node = u
    return far_node, dist[far_node]

# 임의의 노드에서 가장 먼 노드 A 찾기
A, _ = bfs(1, graph, n)
# A에서 가장 먼 노드 B까지의 거리 = 지름
B, diameter = bfs(A, graph, n)
print(diameter)

6. 유형 4 — 재루팅 DP (Re-rooting)

언제 필요한가?

"모든 노드를 루트로 설정했을 때의 값을 각각 구하라."

예: "각 노드에서 다른 모든 노드까지의 거리 합" → 모든 노드에 대해 O(N)씩 구하면 O(N²). 재루팅으로 O(N)에 해결합니다.

핵심 아이디어

DFS 1번 (아래 → 위): down[v] 계산
    서브트리 안에서의 값 (루트 기준 부분 정보)

DFS 2번 (위 → 아래): up[v] 전파
    부모가 자신의 up 정보를 자식에게 내려줌
    ans[v] = down[v] + up[v]

예제: 각 노드에서 모든 노드까지의 거리 합

import sys
from collections import defaultdict
sys.setrecursionlimit(10**6)
input = sys.stdin.readline

n = int(input())
graph = defaultdict(list)
for _ in range(n - 1):
    u, v = map(int, input().split())
    graph[u].append(v)
    graph[v].append(u)

sz   = [1] * (n + 1)   # 서브트리 크기
down = [0] * (n + 1)   # 서브트리 내 거리 합
ans  = [0] * (n + 1)   # 최종 답 (각 노드에서 전체 거리 합)

# DFS 1: down 계산 (아래 → 위)
def dfs1(v, parent):
    for child in graph[v]:
        if child == parent:
            continue
        dfs1(child, v)
        sz[v]   += sz[child]
        down[v] += down[child] + sz[child]  # 자식 서브트리까지 거리 += 크기

# DFS 2: ans 계산 (위 → 아래)
def dfs2(v, parent):
    for child in graph[v]:
        if child == parent:
            continue
        # child를 루트로 바꿀 때:
        # child 서브트리 바깥 노드 수 = n - sz[child]
        # ans[child] = ans[v] - sz[child] + (n - sz[child])
        ans[child] = ans[v] - sz[child] + (n - sz[child])
        dfs2(child, v)

dfs1(1, 0)
ans[1] = down[1]   # 루트의 답 = down값
dfs2(1, 0)

for i in range(1, n + 1):
    print(ans[i])

왜 `ans[child] = ans[v] - sz[child] + (n - sz[child])` 인가?

루트를 v에서 child로 바꾸면:
- child 서브트리의 모든 노드(sz[child]개)는 child에 1씩 가까워짐
  → ans[v]에서 sz[child] 빼기
- 나머지 노드(n - sz[child]개)는 child에 1씩 멀어짐
  → ans[v]에 (n - sz[child]) 더하기

7. 유형 5 — 트리 DP + 배낭 (Knapsack on Tree)

각 서브트리에서 k개를 선택하는 문제 등에 활용합니다.

# dp[v][k] = v의 서브트리에서 정확히 k개를 선택할 때의 최대 가중치
# 각 자식 서브트리를 하나씩 합쳐나가며 배낭처럼 처리

def dfs(v, parent):
    dp[v] = [0] * (sz[v] + 1)   # 0개~sz[v]개 선택
    dp[v][0] = 0
    dp[v][1] = weight[v]
    cur_size = 1

    for child in graph[v]:
        if child == parent:
            continue
        dfs(child, v)

        # 두 dp 배열 합치기 (배낭 DP 방식)
        new_dp = [0] * (cur_size + sz[child] + 1)
        for j in range(cur_size + 1):
            for k in range(sz[child] + 1):
                new_dp[j + k] = max(new_dp[j + k], dp[v][j] + dp[child][k])

        dp[v] = new_dp
        cur_size += sz[child]

8. 실수 포인트 & 주의사항

1. 방문 처리 방법

# ❌ 방법 1: visited 배열 사용 (불필요)
visited = [False] * (n + 1)
def dfs(v):
    visited[v] = True
    for u in graph[v]:
        if not visited[u]:
            dfs(u)

# ✅ 방법 2: parent 인자 전달 (트리 DP 표준)
def dfs(v, parent):
    for u in graph[v]:
        if u == parent:   # 부모 방향 역행 방지
            continue
        dfs(u, v)

2. 루트 설정

# 트리 DP는 루트가 어디든 결과가 같아야 함 (re-rooting 아닌 경우)
# 루트를 1로 고정하고 풀면 됨

dfs(1, 0)   # 루트=1, 부모없음=0 (존재하지 않는 노드 번호)

3. 재귀 깊이 제한

# 노드가 최대 N=10^6일 때 재귀가 N만큼 깊어질 수 있음
import sys
sys.setrecursionlimit(10**6)

# 또는 반복적 DFS (스택 사용)로 변환

4. 1-indexed vs 0-indexed

# 트리 노드 번호는 보통 1부터 시작
n = int(input())
dp  = [0] * (n + 1)   # 인덱스 0은 더미
sz  = [1] * (n + 1)

5. 초기값 설정

# 리프 노드에서 자동으로 초기화되려면
# 자식 루프가 실행되지 않을 때도 올바른 값이 나와야 함
dp[v][0] = 0      # 미선택: 리프에서는 기여 0
dp[v][1] = w[v]   # 선택: 리프에서는 자신의 가중치

9. 접근 전략 — 문제 보고 유형 파악하기

트리 + DP 냄새가 나면?
│
├── "인접한 노드 제약이 있다"
│   └── → 선택/미선택 DP  (dp[v][0/1])
│
├── "가장 긴 경로/지름을 구하라"
│   └── → 트리의 지름 DP  (depth + 전역 ans)
│
├── "서브트리의 크기/합/최대를 구하라"
│   └── → 기본 트리 DP  (dp[v] = f(dp[child]))
│
├── "모든 노드를 루트로 했을 때를 구하라"
│   └── → 재루팅 DP  (DFS 두 번)
│
└── "서브트리에서 k개를 선택하라"
    └── → 트리 배낭 DP  (dp[v][k])

10. 관련 백준 문제

문제	난이도	유형
1967 트리의 지름	Gold IV	트리 지름 DP
1167 트리의 지름	Gold II	트리 지름 BFS×2
2533 사회망 서비스	Gold III	선택/미선택 DP
1949 우수 마을	Gold II	선택/미선택 DP
1240 노드사이의 거리	Gold V	트리 거리
15681 트리와 쿼리	Gold V	서브트리 크기
2213 트리의 독립집합	Gold I	선택/미선택 + 경로 복원
1303 전쟁 - 전투	Silver I	서브트리 크기 응용

위상 정렬 (Topological Sort)

Thu, 30 Jan 2025 00:00:00 GMT

수강신청을 할 때 선수과목을 먼저 들어야 하는 것처럼, 작업들 사이에 선후 관계가 있을 때 올바른 실행 순서를 결정하는 알고리즘이 위상 정렬(Topological Sort) 입니다.

1. 위상 정렬이란?

위상 정렬은 방향 비순환 그래프(DAG, Directed Acyclic Graph) 에서 간선의 방향을 거스르지 않도록 모든 노드를 선형으로 나열하는 알고리즘입니다.

u → v 간선이 있다면, 결과 순서에서 u는 반드시 v보다 앞에 위치합니다.

조건

위상 정렬이 가능하려면 반드시 DAG 여야 합니다.

방향 그래프(Directed): 간선에 방향이 있어야 함
비순환(Acyclic): 사이클이 없어야 함 → 사이클이 있으면 위상 정렬 불가능

위상 정렬 결과는 유일하지 않다

같은 그래프에서도 여러 가지 올바른 위상 순서가 존재할 수 있습니다.

그래프: 1→3, 2→3, 3→4

가능한 위상 순서:
1 → 2 → 3 → 4
2 → 1 → 3 → 4

실생활 예시

수강신청  : 선수과목 → 본과목
빌드 시스템: 의존 모듈 → 메인 모듈
작업 스케줄: 선행 작업 → 후행 작업
패키지 설치: 의존 패키지 → 대상 패키지

2. 핵심 개념 — 진입차수 (In-degree)

진입차수(In-degree) 는 특정 노드로 들어오는 간선의 수입니다.

A → C
B → C     →  C의 진입차수 = 2
D → C

위상 정렬의 핵심 아이디어는 다음과 같습니다.

진입차수가 0인 노드 = 선수 조건이 없는 노드 = 지금 당장 처리 가능한 노드

노드를 처리할 때마다 해당 노드와 연결된 다음 노드들의 진입차수를 1씩 줄입니다. 그 결과 진입차수가 0이 된 노드를 다시 처리 대상에 추가하면, 자연스럽게 올바른 순서가 만들어집니다.

3. Kahn's Algorithm (BFS 기반)

진입차수와 큐를 이용한 BFS 방식으로, 코딩테스트에서 가장 많이 사용되는 구현법입니다.

동작 순서

1. 모든 노드의 진입차수를 계산한다
2. 진입차수가 0인 노드를 모두 큐에 삽입한다
3. 큐에서 노드를 꺼내 결과에 추가한다
4. 꺼낸 노드와 연결된 모든 이웃 노드의 진입차수를 1 줄인다
5. 진입차수가 0이 된 이웃 노드를 큐에 삽입한다
6. 큐가 빌 때까지 3~5를 반복한다

Python 구현

from collections import deque

def topological_sort(n, edges):
    """
    n: 노드 수 (1번 ~ n번)
    edges: [(u, v), ...] — u → v 방향
    """
    graph   = [[] for _ in range(n + 1)]
    indegree = [0] * (n + 1)

    for u, v in edges:
        graph[u].append(v)
        indegree[v] += 1

    # 진입차수 0인 노드를 큐에 삽입
    queue = deque()
    for i in range(1, n + 1):
        if indegree[i] == 0:
            queue.append(i)

    result = []
    while queue:
        node = queue.popleft()
        result.append(node)

        for nxt in graph[node]:
            indegree[nxt] -= 1
            if indegree[nxt] == 0:
                queue.append(nxt)

    return result


# 예시 입력
n = 5
edges = [(1,2),(1,3),(2,4),(3,4),(4,5)]
print(topological_sort(n, edges))
# [1, 2, 3, 4, 5]  또는  [1, 3, 2, 4, 5]

사이클 감지

Kahn's Algorithm에서는 결과 리스트의 길이가 전체 노드 수보다 적으면 사이클이 존재한다고 판단합니다.

def topological_sort_with_cycle_check(n, edges):
    graph    = [[] for _ in range(n + 1)]
    indegree = [0] * (n + 1)

    for u, v in edges:
        graph[u].append(v)
        indegree[v] += 1

    queue = deque(i for i in range(1, n+1) if indegree[i] == 0)
    result = []

    while queue:
        node = queue.popleft()
        result.append(node)
        for nxt in graph[node]:
            indegree[nxt] -= 1
            if indegree[nxt] == 0:
                queue.append(nxt)

    if len(result) != n:
        return None   # 사이클 존재 → 위상 정렬 불가능
    return result

4. DFS 기반 위상 정렬

DFS로 모든 노드를 탐색하면서, 탐색이 완전히 끝난 노드를 스택에 쌓고 마지막에 뒤집으면 위상 순서가 됩니다.

핵심 아이디어

DFS에서 노드의 모든 후손을 탐색한 뒤 해당 노드를 결과에 추가합니다. 이를 후위 순회(post-order) 라고 합니다. 마지막에 결과를 뒤집으면 위상 순서가 됩니다.

import sys
sys.setrecursionlimit(10**6)

def topological_sort_dfs(n, edges):
    graph   = [[] for _ in range(n + 1)]
    visited = [False] * (n + 1)
    result  = []

    for u, v in edges:
        graph[u].append(v)

    def dfs(v):
        visited[v] = True
        for nxt in graph[v]:
            if not visited[nxt]:
                dfs(nxt)
        result.append(v)   # 후위 삽입 — 모든 후손 처리 후 추가

    for i in range(1, n + 1):
        if not visited[i]:
            dfs(i)

    result.reverse()   # 뒤집으면 위상 순서
    return result

왜 뒤집는가?

그래프: 1→2→3

DFS(1) 호출 → DFS(2) 호출 → DFS(3) 호출
DFS(3) 종료 → result.append(3)  → [3]
DFS(2) 종료 → result.append(2)  → [3, 2]
DFS(1) 종료 → result.append(1)  → [3, 2, 1]

reverse() → [1, 2, 3]  ← 올바른 위상 순서

스택 기반 반복 구현 (재귀 깊이 제한 회피)

def topological_sort_iterative(n, edges):
    graph   = [[] for _ in range(n + 1)]
    visited = [False] * (n + 1)
    result  = []

    for u, v in edges:
        graph[u].append(v)

    for start in range(1, n + 1):
        if visited[start]:
            continue

        stack = [(start, False)]

        while stack:
            node, processed = stack.pop()

            if processed:
                result.append(node)   # 후위 삽입
                continue

            if visited[node]:
                continue

            visited[node] = True
            stack.append((node, True))   # 나중에 후위 처리

            for nxt in graph[node]:
                if not visited[nxt]:
                    stack.append((nxt, False))

    result.reverse()
    return result

5. Kahn's vs DFS 비교

	Kahn's Algorithm	DFS 기반
방식	BFS + 진입차수	재귀 DFS + 후위 삽입
사이클 감지	`len(result) != n`	3-색 방문 처리 필요
시간복잡도	O(V + E)	O(V + E)
공간복잡도	O(V + E)	O(V + E)
구현 난이도	쉬움	보통
재귀 깊이 제한	없음	주의 필요
코딩테스트	권장	가능

6. 실전 예제 — 선수과목 순서 결정

from collections import deque

def solve():
    # 과목 수, 선수 관계 수
    n, m = map(int, input().split())

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

    for _ in range(m):
        u, v = map(int, input().split())   # u 수강 후 v 수강 가능
        graph[u].append(v)
        indegree[v] += 1

    queue = deque(i for i in range(1, n+1) if indegree[i] == 0)
    order = []

    while queue:
        cur = queue.popleft()
        order.append(cur)
        for nxt in graph[cur]:
            indegree[nxt] -= 1
            if indegree[nxt] == 0:
                queue.append(nxt)

    if len(order) == n:
        print(*order)
    else:
        print("순환 선수 조건이 있습니다.")

'''
입력 예시:
6 6
1 2
1 3
2 4
3 4
4 5
4 6

출력: 1 2 3 4 5 6
  또는 1 3 2 4 5 6 (둘 다 정답)
'''

각 노드의 최소 수행 시간 계산

각 과목의 수강 시간이 주어질 때, 가장 늦게 끝나는 시간을 계산합니다.

from collections import deque

def earliest_completion(n, times, edges):
    """
    times: 각 노드(과목)의 처리 시간 리스트 (1-indexed)
    반환: 각 노드의 가장 빠른 완료 시간
    """
    graph    = [[] for _ in range(n + 1)]
    indegree = [0] * (n + 1)
    dist     = [0] * (n + 1)   # 각 노드까지의 최소 완료 시간

    for u, v in edges:
        graph[u].append(v)
        indegree[v] += 1

    queue = deque()
    for i in range(1, n + 1):
        if indegree[i] == 0:
            queue.append(i)
            dist[i] = times[i]

    while queue:
        node = queue.popleft()
        for nxt in graph[node]:
            # 이전 노드의 완료 시간 + 현재 노드의 처리 시간
            dist[nxt] = max(dist[nxt], dist[node] + times[nxt])
            indegree[nxt] -= 1
            if indegree[nxt] == 0:
                queue.append(nxt)

    return dist

7. 주의할 점

1. 위상 정렬 결과는 유일하지 않을 수 있다

# 1→3, 2→3 인 경우
# [1, 2, 3] 도 맞고 [2, 1, 3] 도 맞습니다.
# 문제에서 "사전순"이나 "특정 순서"를 요구하면 우선순위 큐 사용
from heapq import heappush, heappop

queue = []
for i in range(1, n+1):
    if indegree[i] == 0:
        heappush(queue, i)   # 최소 힙으로 사전순 보장

while queue:
    node = heappop(queue)
    ...

2. 사이클 확인 필수

# 결과 길이가 n이 아니면 사이클 존재
result = topological_sort(n, edges)
if len(result) != n:
    print("위상 정렬 불가 — 사이클 존재")

3. DFS 재귀 깊이 제한

import sys
sys.setrecursionlimit(10**6)  # DFS 기반 구현 시 반드시 설정

8. 관련 백준 문제

문제	난이도	설명
2252 줄 세우기	Gold III	위상 정렬 기본 문제
1005 ACM Craft	Gold III	위상 정렬 + 최장 경로
1516 게임 개발	Gold III	위상 정렬 + DP
3665 최종 순위	Gold I	위상 정렬 + 사이클 감지
2623 음악 프로그램	Gold III	위상 정렬 활용

참고 자료

Wikipedia — Topological sorting
Claude AI

유니온 파인드(Union-Find) 알고리즘

Fri, 08 Nov 2024 00:00:00 GMT

유니온 파인드(Union-Find)는 두 노드가 같은 집합에 속하는지 판별하는 그래프 알고리즘입니다. 합집합 찾기 알고리즘이라고도 부르며, 서로 연결되지 않은 노드들의 집합을 다루기 때문에 서로소 집합(Disjoint Set) 이라고도 합니다.

두 가지 핵심 연산으로 이루어집니다.

Union: 두 노드를 같은 집합으로 합치는 연산
Find: 노드의 루트 노드를 찾는 연산

핵심 아이디어

유니온 파인드는 각 노드의 **부모 노드 번호를 저장하는 배열(parent)**을 사용합니다. 초기에는 모든 노드가 독립적이므로 자기 자신이 부모 노드입니다.

초기 상태 (노드 7개)
인덱스: 1  2  3  4  5  6  7
부모:   1  2  3  4  5  6  7

두 노드가 같은 집합에 속하는지 확인하려면 각 노드의 루트 노드가 동일한지 비교하면 됩니다. 루트 노드는 parent[i] == i인 노드입니다.

동작 예시

Union 연산

Union(1, 2) → 2번 노드의 부모를 1번으로 설정

인덱스: 1  2  3  4  5  6  7
부모:   1  1  3  4  5  6  7

Union(4, 5), Union(5, 6) → 5, 6번의 루트를 4번으로 설정

인덱스: 1  2  3  4  5  6  7
부모:   1  1  3  4  4  4  7

Find 연산

2번 노드의 루트를 찾는 과정

parent[2] = 1
parent[1] = 1 → 인덱스와 값이 같음 → 루트는 1번

6번 노드의 루트를 찾는 과정

parent[6] = 4
parent[4] = 4 → 인덱스와 값이 같음 → 루트는 4번

2번의 루트(1)와 6번의 루트(4)가 다르므로 → 두 노드는 연결되어 있지 않음

이후 Union(1, 4)를 수행하면 두 집합이 합쳐져 2번과 6번이 같은 집합이 됩니다.

트리 치우침 문제와 경로 압축

문제 상황

아래처럼 한쪽으로만 노드가 이어지는 경우, Find 연산의 재귀 호출 깊이가 깊어져 탐색 시간이 오래 걸립니다.

Union(3, 4) → Union(4, 5) → Union(5, 6) → Union(6, 7)

3 - 4 - 5 - 6 - 7  (선형 구조 → Find가 O(N))

해결책: 경로 압축 (Path Compression)

Find 연산에서 루트를 찾는 과정에 경로 압축을 적용합니다. 재귀적으로 루트를 찾으면서 거쳐가는 모든 노드의 부모를 바로 루트로 갱신합니다.

def find(x):
    if x == parent[x]:
        return x
    parent[x] = find(parent[x])  # 경로 압축: 부모를 루트로 직접 연결
    return parent[x]

경로 압축 후 트리 구조가 훨씬 평탄해져, 이후 Find 연산이 거의 O(1)에 가까워집니다.

경로 압축 적용 후
인덱스: 1  2  3  4  5  6  7
부모:   1  2  3  3  3  3  3  (4,5,6,7 모두 루트 3을 직접 가리킴)

Python 구현

import sys
input = sys.stdin.readline

def find(x):
    # 루트 노드면 반환
    if x == parent[x]:
        return x
    # 경로 압축: 부모를 루트로 직접 갱신
    parent[x] = find(parent[x])
    return parent[x]

def union(x, y):
    x = find(x)
    y = find(y)

    # 이미 같은 집합이면 무시
    if x == y:
        return

    # 더 작은 번호가 부모가 되도록
    if x < y:
        parent[y] = x
    else:
        parent[x] = y

def is_union(x, y):
    # 두 노드의 루트가 같으면 같은 집합
    return find(x) == find(y)


# 사용 예시
n = 7
parent = list(range(n + 1))  # parent[i] = i로 초기화

union(1, 2)
union(4, 5)
union(5, 6)

print(is_union(2, 6))  # False (아직 다른 집합)

union(1, 4)

print(is_union(2, 6))  # True (같은 집합)

Union by Rank (랭크 기반 합치기)

경로 압축 외에도 Union by Rank를 함께 사용하면 트리의 높이를 최소화할 수 있습니다. 트리의 높이(rank)가 낮은 쪽을 높은 쪽에 붙이는 방식입니다.

def union_by_rank(x, y):
    rx, ry = find(x), find(y)

    if rx == ry:
        return

    # rank가 낮은 트리를 높은 트리 아래에 붙임
    if rank[rx] < rank[ry]:
        parent[rx] = ry
    elif rank[rx] > rank[ry]:
        parent[ry] = rx
    else:
        parent[ry] = rx
        rank[rx] += 1  # 높이가 같을 때만 rank 증가

n = 7
parent = list(range(n + 1))
rank = [0] * (n + 1)

시간 복잡도

최적화 방법	Find 복잡도	Union 복잡도
기본 구현	O(N)	O(N)
경로 압축	O(log N)	O(log N)
경로 압축 + Union by Rank	O(α(N)) ≈ O(1)	O(α(N)) ≈ O(1)

α(N)은 아커만 함수의 역함수로, 사실상 상수에 가까운 값입니다. 두 최적화를 함께 적용하면 거의 O(1)로 동작합니다.

활용

유니온 파인드는 단순히 두 노드의 연결 여부를 확인하는 것 외에도 다양한 곳에 활용됩니다.

사이클 감지: 간선을 추가할 때 두 노드의 루트가 같으면 사이클이 형성됨
크루스칼 알고리즘(MST): 최소 신장 트리를 구할 때 사이클 없이 간선을 선택하는 데 사용
네트워크 연결 확인: 특정 노드들이 같은 네트워크에 속하는지 판별

플로이드 워셜(Floyd-Warshall) 알고리즘

Fri, 25 Oct 2024 00:00:00 GMT

플로이드 워셜(Floyd-Warshall) 알고리즘은 모든 노드에서 다른 모든 노드까지의 최단 경로를 한 번에 구하는 알고리즘입니다. 다익스트라가 단일 출발점의 최단 경로를 구하는 것과 달리, 플로이드 워셜은 모든 쌍(Pair)에 대한 최단 거리를 구할 수 있습니다.

또한 플로이드 워셜은 DP(동적 계획법) 알고리즘에 속합니다. N번의 단계를 반복하며 점화식에 맞게 2차원 테이블을 갱신하기 때문입니다.

다익스트라 vs 플로이드 워셜

구분	다익스트라	플로이드 워셜
최단 경로 범위	단일 출발점 → 다른 모든 노드	모든 노드 쌍
거리 저장 구조	1차원 배열	2차원 배열
알고리즘 유형	그리디	DP
음수 가중치	❌	✅
시간 복잡도	O(E log V)	O(N³)
구현 난이도	보통	쉬움

다익스트라는 매 단계마다 방문하지 않은 노드 중 최단 거리 노드를 선택하지만, 플로이드 워셜은 '거쳐 가는 노드'를 기준으로 테이블을 갱신하므로 최단 노드를 별도로 찾을 필요가 없습니다.

핵심 아이디어: 점화식

플로이드 워셜의 핵심은 아래 점화식입니다.

dist[a][b] = min(dist[a][b], dist[a][k] + dist[k][b])

dist[a][b]: 노드 a에서 노드 b까지의 현재 최단 거리
dist[a][k] + dist[k][b]: 노드 k를 경유해서 a → b로 가는 거리

즉, "k번 노드를 거쳐서 가는 것이 더 짧다면 갱신한다" 는 원리입니다. 이 과정을 모든 노드 k에 대해 반복하면 모든 쌍의 최단 거리가 구해집니다.

동작 단계

2차원 거리 테이블 dist[N+1][N+1]을 INF로 초기화합니다.
자기 자신으로 가는 거리 dist[i][i]는 0으로 설정합니다.
입력된 간선 정보로 테이블을 초기화합니다.
모든 노드 k에 대해 아래를 반복합니다. (k = 경유 노드)
- 모든 노드 쌍 (a, b)에 대해 점화식을 적용해 테이블을 갱신합니다.

동작 예시

아래 그래프를 기준으로 단계별 테이블 변화를 확인합니다.

노드: 1, 2, 3, 4
간선: 1→2(4), 1→4(6), 2→1(3), 2→3(7), 3→1(5), 3→4(4), 4→3(2)

[초기 테이블] 직접 연결된 간선만 반영

	1	2	3	4
1	0	4	∞	6
2	3	0	7	∞
3	5	∞	0	4
4	∞	∞	2	0

[Step 1] 노드 1을 경유하는 경우 반영

예: dist[2][4] = min(∞, dist[2][1] + dist[1][4]) = min(∞, 3+6) = 9

	1	2	3	4
1	0	4	∞	6
2	3	0	7	9
3	5	9	0	4
4	∞	∞	2	0

[Step 2] 노드 2를 경유하는 경우 반영

예: dist[1][3] = min(∞, dist[1][2] + dist[2][3]) = min(∞, 4+7) = 11

	1	2	3	4
1	0	4	11	6
2	3	0	7	9
3	5	9	0	4
4	∞	∞	2	0

[Step 3, 4] 노드 3, 4를 경유하는 경우 반영 후 최종 테이블

	1	2	3	4
1	0	4	8	6
2	3	0	7	9
3	5	9	0	4
4	7	11	2	0

Python 구현

import sys

INF = int(1e9)

def floyd_warshall(n, edges):
    # 2차원 거리 테이블 초기화
    dist = [[INF] * (n + 1) for _ in range(n + 1)]

    # 자기 자신으로 가는 비용은 0
    for i in range(1, n + 1):
        dist[i][i] = 0

    # 간선 정보로 테이블 초기화
    for a, b, c in edges:
        dist[a][b] = c

    # 점화식: 노드 k를 경유하는 경우를 모든 쌍에 대해 갱신
    for k in range(1, n + 1):
        for a in range(1, n + 1):
            for b in range(1, n + 1):
                dist[a][b] = min(dist[a][b], dist[a][k] + dist[k][b])

    return dist


# 사용 예시
def main():
    n = int(input())   # 노드 수
    m = int(input())   # 간선 수

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

    dist = floyd_warshall(n, edges)

    # 결과 출력
    for a in range(1, n + 1):
        for b in range(1, n + 1):
            if dist[a][b] == INF:
                print("INF", end=" ")
            else:
                print(dist[a][b], end=" ")
        print()


main()

입력 예시

출력 예시

음수 순환 감지

플로이드 워셜 수행 후 dist[i][i] < 0인 노드가 있다면 음수 순환이 존재하는 것입니다. 자기 자신으로 돌아오는 경로의 비용이 음수라는 의미이기 때문입니다.

# 음수 순환 감지
for i in range(1, n + 1):
    if dist[i][i] < 0:
        print("음수 순환 존재")
        break

시간 복잡도

구조	복잡도
경유 노드 k 반복	O(N)
모든 쌍 (a, b) 확인	O(N²)
전체	O(N³)

노드 수가 많아질수록 연산량이 급격히 증가합니다. 일반적으로 노드 수가 500 이하인 경우에 적합합니다.

최단 경로 알고리즘 종합 비교

알고리즘	최단 경로 범위	음수 가중치	시간 복잡도	적합한 상황
다익스트라	단일 출발점	❌	O(E log V)	노드/간선이 많고 양수 가중치
벨만-포드	단일 출발점	✅	O(VE)	음수 가중치, 음수 순환 감지 필요
플로이드 워셜	모든 쌍	✅	O(N³)	노드 수가 적고 모든 쌍 최단 경로 필요

비트 연산과 아스키코드 변환

Wed, 25 Sep 2024 00:00:00 GMT

비트 연산과 아스키코드 변환은 코딩테스트에서 단골로 등장하는 테크닉입니다. 특히 비트마스킹은 집합을 정수 하나로 표현해 상태 압축 DP나 방문 체크에 활용되고, 아스키코드는 문자를 숫자처럼 다룰 수 있게 해줍니다. 두 개념을 함께 익히면 문자열과 정수를 넘나드는 문제를 훨씬 간결하게 풀 수 있습니다.

1. 비트(Bit)와 이진수 기초

비트 연산을 이해하려면 먼저 10진수를 2진수로 표현하는 방식을 알아야 합니다.

# 파이썬에서 진수 변환
print(bin(10))    # '0b1010'  — 10진수 → 2진수 문자열
print(oct(10))    # '0o12'    — 10진수 → 8진수
print(hex(255))   # '0xff'    — 10진수 → 16진수

print(int('1010', 2))   # 10  — 2진수 문자열 → 10진수
print(int('ff', 16))    # 255 — 16진수 문자열 → 10진수

# 비트 수 확인
print((10).bit_length())  # 4  — 1010이므로 4비트

10진수    2진수 (8비트)
  0   →  0000 0000
  1   →  0000 0001
  5   →  0000 0101
 10   →  0000 1010
255   →  1111 1111

2. 비트 연산자

AND ( & )

두 비트가 모두 1일 때만 1입니다.

a = 0b1010   # 10
b = 0b1100   # 12

print(a & b)          # 8
print(bin(a & b))     # 0b1000

#   1010
# & 1100
# ------
#   1000  = 8

OR ( | )

두 비트 중 하나라도 1이면 1입니다.

a = 0b1010   # 10
b = 0b1100   # 12

print(a | b)          # 14
print(bin(a | b))     # 0b1110

#   1010
# | 1100
# ------
#   1110  = 14

XOR ( ^ )

두 비트가 서로 다를 때 1입니다. 같으면 0, 다르면 1 로 기억하면 됩니다.

a = 0b1010   # 10
b = 0b1100   # 12

print(a ^ b)          # 6
print(bin(a ^ b))     # 0b0110

#   1010
# ^ 1100
# ------
#   0110  = 6

XOR의 특성: a ^ a = 0, a ^ 0 = a — 같은 값을 두 번 XOR하면 원래 값이 됩니다.

NOT ( ~ )

모든 비트를 뒤집습니다. Python에서 ~n = -(n+1) 입니다.

n = 10
print(~n)    # -11

# 규칙: ~n = -(n+1)
# ~0  = -1
# ~1  = -2
# ~10 = -11

왼쪽 시프트 ( << )

비트를 왼쪽으로 k칸 이동합니다. n × 2^k 와 같습니다.

print(1 << 0)   # 1    (1 × 2⁰)
print(1 << 1)   # 2    (1 × 2¹)
print(1 << 3)   # 8    (1 × 2³)
print(5 << 2)   # 20   (5 × 2²)

# 0b00101 << 2
# = 0b10100 = 20

오른쪽 시프트 ( >> )

비트를 오른쪽으로 k칸 이동합니다. n ÷ 2^k (몫)와 같습니다.

print(20 >> 1)  # 10   (20 ÷ 2¹)
print(20 >> 2)  # 5    (20 ÷ 2²)
print(16 >> 3)  # 2    (16 ÷ 2³)

# 0b10100 >> 2
# = 0b00101 = 5

3. 비트마스크 패턴

비트마스크는 정수 하나로 여러 플래그 상태를 동시에 관리하는 기법입니다.

k번째 비트 확인 (Check)

def is_set(n, k):
    return bool(n & (1 << k))

n = 0b1010  # = 10

is_set(n, 0)   # False — 0번 비트: 0
is_set(n, 1)   # True  — 1번 비트: 1
is_set(n, 2)   # False — 2번 비트: 0
is_set(n, 3)   # True  — 3번 비트: 1

k번째 비트 켜기 (Set)

def set_bit(n, k):
    return n | (1 << k)

n = 0b1010  # = 10
print(bin(set_bit(n, 0)))   # 0b1011 = 11  (0번 비트 ON)
print(bin(set_bit(n, 2)))   # 0b1110 = 14  (2번 비트 ON)

k번째 비트 끄기 (Clear)

def clear_bit(n, k):
    return n & ~(1 << k)

n = 0b1010  # = 10
print(bin(clear_bit(n, 1)))  # 0b1000 = 8  (1번 비트 OFF)
print(bin(clear_bit(n, 3)))  # 0b0010 = 2  (3번 비트 OFF)

k번째 비트 토글 (Toggle)

def toggle_bit(n, k):
    return n ^ (1 << k)

n = 0b1010  # = 10
print(bin(toggle_bit(n, 0)))  # 0b1011 = 11  (0번 0→1)
print(bin(toggle_bit(n, 1)))  # 0b1000 = 8   (1번 1→0)

2의 거듭제곱 판별

def is_power_of_2(n):
    return n > 0 and (n & (n - 1)) == 0

# 원리: 2의 거듭제곱은 이진수에서 1비트가 딱 하나
# 8  = 1000
# 7  = 0111
# 8 & 7 = 0000 → True

is_power_of_2(1)    # True  (2⁰)
is_power_of_2(8)    # True  (2³)
is_power_of_2(6)    # False
is_power_of_2(0)    # False

1인 비트 개수 세기 (Brian Kernighan's Algorithm)

def count_bits(n):
    count = 0
    while n:
        n &= n - 1   # 가장 오른쪽 1비트를 0으로 만듦
        count += 1
    return count

# 또는 Python 내장 방식
bin(13).count('1')   # 3  (13 = 0b1101)
n.bit_count()        # Python 3.10+

count_bits(0b1101)   # 3
count_bits(0b1111)   # 4

최하위 1비트 추출

n = 0b1100   # 12

lowest_bit = n & (-n)   # 0b0100 = 4  (가장 오른쪽 1비트만)
# -n은 두의 보수: 0b0100

4. 아스키코드 (ASCII Code)

아스키(ASCII)는 문자와 숫자를 대응시키는 인코딩 표준입니다.

핵심 범위 외우기

숫자  '0'~'9' : 48~57
대문자 'A'~'Z' : 65~90
소문자 'a'~'z' : 97~122
공백   ' '     : 32

'a' - 'A' = 32 = 0b100000 — 대소문자 차이는 딱 32, 즉 6번 비트 하나의 차이입니다.

변환 함수

# 문자 → 아스키 코드
ord('A')    # 65
ord('a')    # 97
ord('0')    # 48
ord(' ')    # 32
ord('Z')    # 90

# 아스키 코드 → 문자
chr(65)     # 'A'
chr(97)     # 'a'
chr(48)     # '0'
chr(90)     # 'Z'

자주 쓰는 변환 패턴

# 알파벳 인덱스 (a=0, b=1, ..., z=25)
def char_to_idx(c):
    return ord(c) - ord('a')

def idx_to_char(i):
    return chr(i + ord('a'))

char_to_idx('a')   # 0
char_to_idx('z')   # 25
idx_to_char(4)     # 'e'

# 문자 숫자 → 정수
def char_to_int(c):
    return ord(c) - ord('0')

char_to_int('5')   # 5
char_to_int('9')   # 9

# 정수 → 문자 숫자
def int_to_char(n):
    return chr(n + ord('0'))

int_to_char(3)     # '3'

# 대문자 ↔ 소문자
def to_upper(c):
    return chr(ord(c) - 32)

def to_lower(c):
    return chr(ord(c) + 32)

to_upper('a')   # 'A'
to_lower('Z')   # 'z'

알파벳 순환 (카이사르 암호 등)

def shift_char(c, n):
    """알파벳을 n칸 이동 (소문자 기준, 순환)"""
    return chr((ord(c) - ord('a') + n) % 26 + ord('a'))

shift_char('a', 3)    # 'd'
shift_char('z', 1)    # 'a'   — 순환
shift_char('m', 13)   # 'z'

5. 비트 연산 + 아스키코드 알고리즘 활용

대소문자 변환 — XOR 트릭

대문자와 소문자의 차이는 정확히 32 = 0b100000이므로 6번 비트를 XOR로 토글하면 대소문자를 변환할 수 있습니다.

def to_lower_bit(c):
    return chr(ord(c) | 0x20)    # 6번 비트 강제로 1

def to_upper_bit(c):
    return chr(ord(c) & ~0x20)   # 6번 비트 강제로 0

to_lower_bit('A')   # 'a'
to_lower_bit('a')   # 'a'  (이미 소문자 → 그대로)
to_upper_bit('z')   # 'Z'
to_upper_bit('Z')   # 'Z'  (이미 대문자 → 그대로)

# toggle (대소문자 전환)
def toggle_case(c):
    return chr(ord(c) ^ 0x20)

toggle_case('A')   # 'a'
toggle_case('a')   # 'A'

문자열 중복 문자 검사 — 비트마스크

26개 알파벳을 정수의 비트로 표현해 O(n) 시간, O(1) 공간으로 중복 검사를 할 수 있습니다.

def has_unique_chars(s: str) -> bool:
    """문자열에 중복된 소문자 알파벳이 없으면 True"""
    checker = 0
    for c in s:
        idx = ord(c) - ord('a')   # a=0, b=1, ..., z=25
        bit = 1 << idx
        if checker & bit:          # 이미 본 문자
            return False
        checker |= bit             # 비트 표시
    return True

has_unique_chars("abcde")   # True
has_unique_chars("abcda")   # False  ('a' 중복)

# 어떤 문자들이 있는지도 확인 가능
def get_char_set(s: str) -> str:
    checker = 0
    for c in s:
        checker |= 1 << (ord(c) - ord('a'))
    return ''.join(chr(i + ord('a')) for i in range(26) if checker & (1 << i))

get_char_set("hello")   # 'ehlo'

홀짝 판별 — 비트 AND

# & 1이 0이면 짝수, 1이면 홀수
def is_even(n): return (n & 1) == 0
def is_odd(n):  return (n & 1) == 1

is_even(4)   # True
is_odd(7)    # True

# 전통 방식 (%) 보다 비트 연산이 빠름

비트로 집합 연산 표현

n개의 원소로 이루어진 집합을 n비트 정수 하나로 표현합니다.

# 원소: {0, 1, 2, 3, 4}
# A = {0, 2, 3}  →  0b01101 = 13
# B = {1, 2, 4}  →  0b10110 = 22

A = (1<<0) | (1<<2) | (1<<3)   # 0b01101 = 13
B = (1<<1) | (1<<2) | (1<<4)   # 0b10110 = 22

# 합집합 A ∪ B
print(bin(A | B))    # 0b11111 = {0,1,2,3,4}

# 교집합 A ∩ B
print(bin(A & B))    # 0b00100 = {2}

# 차집합 A - B
print(bin(A & ~B))   # 0b01001 = {0,3}  (A에만 있는 원소)

# 여집합 (전체 집합이 5비트라 가정)
ALL = (1 << 5) - 1   # 0b11111
print(bin(ALL ^ A))  # 0b10010 = {1,4}  (A에 없는 원소)

# 원소 포함 여부
def contains(S, elem):
    return bool(S & (1 << elem))

contains(A, 2)   # True
contains(A, 4)   # False

XOR로 중복 없는 수 찾기

# 배열에서 딱 한 번 등장하는 수 찾기 (나머지는 두 번씩)
# 원리: a ^ a = 0, a ^ 0 = a

def find_single(nums):
    result = 0
    for n in nums:
        result ^= n
    return result

find_single([1, 2, 3, 2, 1])    # 3
find_single([4, 1, 2, 1, 2])    # 4

# 두 수만 두 번: 짝수 XOR은 0이 되어 홀수 XOR만 남음

6. 코딩테스트 실전 팁

자주 쓰는 비트 표현 모음

# 비트 n개 모두 1인 마스크
mask = (1 << n) - 1     # n=4: 0b1111 = 15

# 전체 방문 상태 (n개 도시)
ALL_VISITED = (1 << n) - 1

# i번째 노드 방문 표시
visited |= (1 << i)

# i번째 노드 방문 여부
is_visited = bool(visited & (1 << i))

# 짝수/홀수
n & 1 == 0    # 짝수
n & 1 == 1    # 홀수

# 2 곱하기 / 나누기
n << 1        # n * 2
n >> 1        # n // 2

아스키 코드 요약

# 자주 쓰는 ord 값
ord('0') = 48    →   ord('9') = 57
ord('A') = 65    →   ord('Z') = 90
ord('a') = 97    →   ord('z') = 122
ord('a') - ord('A') = 32

# 패턴
ord(c) - ord('a')          # 소문자 알파벳 인덱스 (0~25)
ord(c) - ord('A')          # 대문자 알파벳 인덱스 (0~25)
ord(c) - ord('0')          # 문자 숫자 → 정수 (0~9)
chr(i + ord('a'))          # 인덱스 → 소문자 알파벳
chr(i + ord('0'))          # 정수 → 문자 숫자

7. 관련 백준 문제

문제	난이도	핵심 기법
11723 집합	Silver V	비트마스크 집합 연산 기본
2098 외판원 순회	Gold I	비트마스크 DP (TSP)
1062 가르침	Gold IV	비트마스크 브루트포스
1086 박성원	Platinum V	비트마스크 DP
10809 알파벳 찾기	Bronze II	ord() 기초 활용
1152 단어의 개수	Bronze II	문자열 + ord 활용
1251 단어 나누기	Silver V	대소문자 변환 활용

참고 자료

우선순위 큐와 힙 (Priority Queue & heapq)

Thu, 05 Sep 2024 00:00:00 GMT

일반 큐(Queue)는 먼저 들어온 것이 먼저 나가는 FIFO 구조입니다. 하지만 응급실에서 환자를 접수 순서가 아닌 증상의 심각도 기준으로 처리하듯이, 현실에서는 우선순위가 높은 것을 먼저 처리해야 하는 상황이 많습니다. 이런 요구를 해결하는 자료구조가 우선순위 큐이고, 이를 효율적으로 구현하는 것이 힙(Heap) 입니다.

1. 우선순위 큐 (Priority Queue)

우선순위 큐는 들어온 순서와 관계없이 우선순위가 높은 원소가 먼저 나오는 자료구조입니다.

일반 큐와의 차이

	일반 큐 (Queue)	우선순위 큐 (Priority Queue)
출력 순서	삽입 순서 (FIFO)	우선순위 순서
구현 방식	배열, 연결리스트	힙(Heap)
삽입 시간	O(1)	O(log n)
삭제 시간	O(1)	O(log n)

실생활 활용 예

우선순위 큐는 다양한 분야에서 활용됩니다.

OS 스케줄링  : CPU가 우선순위 높은 프로세스를 먼저 처리
네트워크 QoS : 중요한 패킷을 먼저 라우팅
알고리즘     : 다익스트라, 프림, A* 경로 탐색
시뮬레이션   : 이벤트 기반 시스템 (가장 빠른 이벤트 먼저 처리)

구현 방법 비교

구현 방식	삽입	삭제(최솟값)	비고
정렬된 배열	O(n)	O(1)	삽입 시 정렬 비용 큼
정렬 안 된 배열	O(1)	O(n)	삭제 시 전체 탐색
힙(Heap)	O(log n)	O(log n)	실무 표준
BST	O(log n)	O(log n)	구현 복잡

힙이 우선순위 큐 구현의 표준입니다.

2. 힙 (Heap) 자료구조

힙(Heap) 은 다음 조건을 만족하는 완전 이진 트리입니다.

힙 속성(Heap Property): 부모 노드의 키값과 자식 노드의 키값 사이에 항상 대소 관계가 성립한다.

최소 힙 (Min Heap)

부모 노드의 값 ≤ 자식 노드의 값이 항상 성립합니다. 루트에 항상 최솟값이 위치합니다.

        1          ← 루트 = 최솟값
      /   \
     3     5
    / \   / \
   7   9 8   6

최대 힙 (Max Heap)

부모 노드의 값 ≥ 자식 노드의 값이 항상 성립합니다. 루트에 항상 최댓값이 위치합니다.

        9          ← 루트 = 최댓값
      /   \
     7     6
    / \   / \
   3   5 1   4

힙의 핵심 특징

완전 이진 트리 : 마지막 레벨을 제외하고 모든 레벨이 꽉 차 있음
배열로 표현    : 인덱스 k의 자식 → 2k+1 (왼쪽), 2k+2 (오른쪽)
                인덱스 k의 부모 → (k-1) // 2
형제 간 무관   : 형제 노드끼리는 대소 관계가 정해지지 않음

3. heapq 모듈

Python의 heapq는 최소 힙(Min Heap) 으로 구현된 내장 라이브러리입니다. 별도 설치 없이 바로 사용할 수 있습니다.

주요 함수

함수	설명	시간복잡도
`heapq.heappush(heap, item)`	원소 추가	O(log n)
`heapq.heappop(heap)`	최솟값 제거 & 반환	O(log n)
`heapq.heapify(x)`	리스트를 힙으로 변환	O(n)
`heap[0]`	최솟값 조회 (제거 없음)	O(1)
`heapq.heappushpop(heap, item)`	push 후 pop	O(log n)
`heapq.heapreplace(heap, item)`	pop 후 push	O(log n)

힙 생성과 원소 추가

import heapq

# 방법 1: 빈 리스트에 heappush
heap = []
heapq.heappush(heap, 50)
heapq.heappush(heap, 10)
heapq.heappush(heap, 20)
print(heap)  # [10, 50, 20]

# 방법 2: 기존 리스트를 heapify로 즉시 변환 — O(n)
heap2 = [50, 10, 20]
heapq.heapify(heap2)
print(heap2)  # [10, 50, 20]

heapify는 O(n)으로 힙을 구성합니다. n번 heappush하는 O(n log n)보다 빠르므로, 이미 리스트가 있다면 heapify를 사용하세요.

원소 삭제 (heappop)

import heapq

heap = [10, 50, 20]

# 최솟값 제거 & 반환
result = heapq.heappop(heap)
print(result)  # 10
print(heap)    # [20, 50]

# 최솟값만 조회 (제거하지 않음)
min_val = heap[0]
print(min_val)  # 20
print(heap)     # [20, 50]  ← 변화 없음

전체 정렬 (힙 정렬)

import heapq

data = [3, 1, 4, 1, 5, 9, 2, 6]
heapq.heapify(data)

sorted_data = []
while data:
    sorted_data.append(heapq.heappop(data))

print(sorted_data)  # [1, 1, 2, 3, 4, 5, 6, 9]

4. 최대 힙 구현 (Max Heap)

Python의 heapq는 최소 힙만 지원합니다. 최대 힙이 필요할 때는 값을 음수로 변환하는 트릭을 사용합니다.

음수 변환 트릭

import heapq

heap_items = [1, 3, 5, 7, 9]
max_heap = []

# 삽입: (-val, val) 튜플로 저장
for item in heap_items:
    heapq.heappush(max_heap, (-item, item))

print(max_heap)
# [(-9, 9), (-7, 7), (-3, 3), (-1, 1), (-5, 5)]

# 추출: [1]로 실제 값 접근
max_val = heapq.heappop(max_heap)[1]
print(max_val)  # 9

음수로 저장하면 값이 가장 큰 원소가 가장 작은 음수가 되어 최소 힙의 루트에 위치합니다.

단순 최대 힙 (값만 저장)

import heapq

max_heap = []
for v in [1, 3, 5, 7, 9]:
    heapq.heappush(max_heap, -v)

# 최댓값 추출
max_val = -heapq.heappop(max_heap)
print(max_val)  # 9

5. 커스텀 정렬 기준

여러 값을 갖는 원소(튜플, 객체)를 우선순위 기준에 따라 힙에 넣는 방법입니다.

튜플로 우선순위 설정

import heapq

# (우선순위, 작업명) 형태로 삽입
tasks = []
heapq.heappush(tasks, (3, "task_low"))
heapq.heappush(tasks, (1, "task_urgent"))
heapq.heappush(tasks, (2, "task_normal"))

while tasks:
    priority, name = heapq.heappop(tasks)
    print(f"[{priority}] {name}")

# 출력:
# [1] task_urgent
# [2] task_normal
# [3] task_low

다중 정렬 기준

import heapq

# (1차 기준, 2차 기준, 값) — 동일 우선순위면 2차 기준으로 정렬
heap = []
heapq.heappush(heap, (1, 0, "A"))  # 우선순위 1, 순서 0
heapq.heappush(heap, (1, 1, "B"))  # 우선순위 1, 순서 1
heapq.heappush(heap, (2, 0, "C"))  # 우선순위 2

while heap:
    p, order, name = heapq.heappop(heap)
    print(name)

# 출력: A → B → C

객체 정렬 — `lt` 정의

import heapq

class Task:
    def __init__(self, priority, name):
        self.priority = priority
        self.name = name

    def __lt__(self, other):
        return self.priority < other.priority  # 비교 기준 정의

    def __repr__(self):
        return f"Task({self.priority}, {self.name})"

heap = []
heapq.heappush(heap, Task(3, "low"))
heapq.heappush(heap, Task(1, "urgent"))
heapq.heappush(heap, Task(2, "normal"))

print(heapq.heappop(heap))  # Task(1, urgent)

6. 실전 활용 패턴

다익스트라 알고리즘 (최단 경로)

import heapq

def dijkstra(graph, start):
    dist = {node: float('inf') for node in graph}
    dist[start] = 0
    pq = [(0, start)]  # (거리, 노드)

    while pq:
        cost, node = heapq.heappop(pq)

        if cost > dist[node]:
            continue  # 이미 더 짧은 경로가 있으면 skip

        for neighbor, weight in graph[node]:
            new_cost = cost + weight
            if new_cost < dist[neighbor]:
                dist[neighbor] = new_cost
                heapq.heappush(pq, (new_cost, neighbor))

    return dist

graph = {
    'A': [('B', 1), ('C', 4)],
    'B': [('C', 2), ('D', 5)],
    'C': [('D', 1)],
    'D': []
}
print(dijkstra(graph, 'A'))
# {'A': 0, 'B': 1, 'C': 3, 'D': 4}

K번째 최솟값 찾기

import heapq

def kth_smallest(nums, k):
    heapq.heapify(nums)
    result = None
    for _ in range(k):
        result = heapq.heappop(nums)
    return result

nums = [7, 10, 4, 3, 20, 15]
print(kth_smallest(nums[:], 3))  # 7  (3번째로 작은 값)

K개 최솟값 유지 (실시간 스트림)

import heapq

def top_k_largest(stream, k):
    """스트림에서 항상 최대 k개의 가장 큰 값 유지 (최소 힙 활용)"""
    heap = []
    for val in stream:
        heapq.heappush(heap, val)
        if len(heap) > k:
            heapq.heappop(heap)  # k+1번째 이상이면 최솟값 제거
    return sorted(heap, reverse=True)

stream = [3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]
print(top_k_largest(stream, 3))  # [9, 6, 5]

7. 자주 하는 실수

1. 빈 힙에서 heappop 호출

heap = []
# ❌ IndexError 발생
heapq.heappop(heap)

# ✅ 비어있는지 확인 후 사용
if heap:
    heapq.heappop(heap)

2. heapify 없이 리스트 직접 사용

data = [5, 3, 1, 4, 2]

# ❌ 힙 구조가 아니어서 heappop이 올바르지 않을 수 있음
heapq.heappop(data)

# ✅ heapify로 힙 구조로 먼저 변환
heapq.heapify(data)
heapq.heappop(data)

3. 최대 힙에서 실제 값 접근 방법 혼동

max_heap = []
heapq.heappush(max_heap, (-5, 5))

# ❌ 음수 값을 그대로 사용
val = heapq.heappop(max_heap)   # (-5, 5)
print(val)   # (-5, 5) — 의도한 값이 아님

# ✅ [1]로 실제 값 접근
val = heapq.heappop(max_heap)[1]
print(val)   # 5

8. 관련 백준 문제

문제	난이도	핵심 기법
11279 최대 힙	Silver II	최대 힙 기본
1927 최소 힙	Silver II	최소 힙 기본
11286 절댓값 힙	Silver I	커스텀 정렬 기준
1715 카드 정렬하기	Gold IV	최소 힙 그리디
1916 최소비용 구하기	Gold V	다익스트라 + 힙
23290 마법사 상어와 복제	Gold I	우선순위 큐 응용

참고 자료

전역 상태관리 — Redux와 Zustand

Thu, 15 Aug 2024 00:00:00 GMT

React에서 상태(state)는 컴포넌트 단위로 관리됩니다. 하지만 컴포넌트 수가 많아지고 서로 다른 위치에 있는 컴포넌트가 같은 데이터를 필요로 할 때, 단순한 useState만으로는 한계가 생깁니다. 이 문제를 해결하기 위한 전역 상태관리 라이브러리인 Redux와 Zustand를 정리합니다.

1. 왜 전역 상태관리가 필요한가?

Props Drilling 문제

컴포넌트 트리가 깊어질수록 부모에서 자식으로 props를 계속 내려줘야 하는 Props Drilling 문제가 발생합니다.

App (user 데이터 보유)
└── Header
    └── Nav
        └── Profile
            └── Avatar  ← user가 실제로 필요한 곳

Avatar 컴포넌트가 user 데이터가 필요할 때, 실제로 사용하지 않는 Header, Nav, Profile까지 모두 props를 받아서 전달해야 합니다. 이렇게 되면:

중간 컴포넌트가 불필요한 props를 가짐
코드 수정 시 연쇄적으로 변경이 필요
어디서 데이터가 내려오는지 추적하기 어려움

전역 상태관리의 해결 방식

전역 Store에 상태를 두고 필요한 컴포넌트가 직접 구독합니다. 중간 컴포넌트를 거칠 필요가 없습니다.

2. Redux

개념

Redux는 JavaScript 앱을 위한 예측 가능한 상태 컨테이너입니다. React에 종속되지 않고 어떤 UI 라이브러리와도 함께 사용할 수 있습니다.

현재는 Redux Toolkit(RTK) 을 공식적으로 권장하며, RTK는 Redux의 복잡한 보일러플레이트를 크게 줄여줍니다.

데이터 흐름

Redux는 단방향 데이터 흐름을 따릅니다.

UI → dispatch(action) → Reducer → Store → UI 리렌더링

Action: 상태 변경을 설명하는 객체 { type: 'counter/increment', payload: 1 }
Reducer: 현재 상태와 Action을 받아 새 상태를 반환하는 순수 함수
Store: 앱 전체의 상태를 담는 단일 객체
Dispatch: Action을 Store에 전달하는 함수

3가지 핵심 원칙

1. Single Source of Truth  : 모든 상태는 하나의 Store에
2. State is Read-Only      : Action을 통해서만 상태 변경
3. Pure Reducers           : 같은 입력 → 항상 같은 출력

설치

npm install @reduxjs/toolkit react-redux

Redux Toolkit으로 구현하기

Store 설정

// store/index.js
import { configureStore } from '@reduxjs/toolkit'
import counterReducer from './counterSlice'
import userReducer from './userSlice'

export const store = configureStore({
  reducer: {
    counter: counterReducer,
    user: userReducer,
  },
})

export type RootState = ReturnType<typeof store.getState>
export type AppDispatch = typeof store.dispatch

Slice 생성 (Action + Reducer 통합)

// store/counterSlice.js
import { createSlice } from '@reduxjs/toolkit'

const counterSlice = createSlice({
  name: 'counter',
  initialState: { value: 0 },
  reducers: {
    increment: (state) => {
      state.value += 1          // Immer 덕분에 직접 변경처럼 작성 가능
    },
    decrement: (state) => {
      state.value -= 1
    },
    incrementByAmount: (state, action) => {
      state.value += action.payload
    },
  },
})

export const { increment, decrement, incrementByAmount } = counterSlice.actions
export default counterSlice.reducer

Provider로 앱 감싸기

// main.jsx
import { Provider } from 'react-redux'
import { store } from './store'

ReactDOM.createRoot(document.getElementById('root')).render(
  <Provider store={store}>
    <App />
  </Provider>
)

컴포넌트에서 사용

import { useSelector, useDispatch } from 'react-redux'
import { increment, decrement, incrementByAmount } from './store/counterSlice'

function Counter() {
  // 상태 읽기
  const count = useSelector((state) => state.counter.value)
  const dispatch = useDispatch()

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={() => dispatch(increment())}>+</button>
      <button onClick={() => dispatch(decrement())}>-</button>
      <button onClick={() => dispatch(incrementByAmount(5))}>+5</button>
    </div>
  )
}

비동기 처리 — createAsyncThunk

// store/userSlice.js
import { createSlice, createAsyncThunk } from '@reduxjs/toolkit'

// 비동기 액션 생성
export const fetchUser = createAsyncThunk(
  'user/fetchUser',
  async (userId, { rejectWithValue }) => {
    try {
      const response = await fetch(`/api/users/${userId}`)
      return await response.json()
    } catch (error) {
      return rejectWithValue(error.message)
    }
  }
)

const userSlice = createSlice({
  name: 'user',
  initialState: { data: null, status: 'idle', error: null },
  reducers: {},
  extraReducers: (builder) => {
    builder
      .addCase(fetchUser.pending, (state) => {
        state.status = 'loading'
      })
      .addCase(fetchUser.fulfilled, (state, action) => {
        state.status = 'succeeded'
        state.data = action.payload
      })
      .addCase(fetchUser.rejected, (state, action) => {
        state.status = 'failed'
        state.error = action.payload
      })
  },
})

export default userSlice.reducer

// 사용
function UserProfile({ userId }) {
  const dispatch = useDispatch()
  const { data, status, error } = useSelector((state) => state.user)

  useEffect(() => {
    dispatch(fetchUser(userId))
  }, [userId])

  if (status === 'loading') return <p>Loading...</p>
  if (status === 'failed') return <p>Error: {error}</p>
  return <p>{data?.name}</p>
}

Selector로 성능 최적화

import { createSelector } from '@reduxjs/toolkit'

// 메모이제이션된 selector — 입력이 바뀔 때만 재계산
const selectTotalPrice = createSelector(
  (state) => state.cart.items,
  (items) => items.reduce((sum, item) => sum + item.price * item.quantity, 0)
)

// 사용
const totalPrice = useSelector(selectTotalPrice)

3. Zustand

개념

Zustand는 독일어로 "상태"를 뜻하며, React 팀의 Jotai 개발자가 만든 가볍고 직관적인 상태관리 라이브러리입니다. Redux의 복잡한 보일러플레이트 없이 전역 상태를 간단하게 관리할 수 있습니다.

Zustand의 핵심 특징

Provider 없이 사용 가능
Store 정의가 5줄 내외
구독한 컴포넌트만 리렌더링
TypeScript 타입 자동 추론

설치

npm install zustand

기본 Store 생성

// store/useCounterStore.js
import { create } from 'zustand'

const useCounterStore = create((set) => ({
  // State
  count: 0,

  // Actions (state와 같은 곳에 정의)
  increment: () => set((state) => ({ count: state.count + 1 })),
  decrement: () => set((state) => ({ count: state.count - 1 })),
  incrementByAmount: (amount) => set((state) => ({ count: state.count + amount })),
  reset: () => set({ count: 0 }),
}))

export default useCounterStore

컴포넌트에서 사용

// Provider 불필요 — 바로 import해서 사용
import useCounterStore from './store/useCounterStore'

function Counter() {
  const { count, increment, decrement } = useCounterStore()

  return (
    <div>
      <p>Count: {count}</p>
      <button onClick={increment}>+</button>
      <button onClick={decrement}>-</button>
    </div>
  )
}

선택적 구독으로 리렌더링 최적화

// count만 구독 → count가 바뀔 때만 리렌더링
const count = useCounterStore((state) => state.count)

// increment만 구독 → 절대 리렌더링 안 됨 (함수는 불변)
const increment = useCounterStore((state) => state.increment)

비동기 처리

Zustand는 미들웨어 없이 액션 안에서 바로 async/await를 사용할 수 있습니다.

import { create } from 'zustand'

const useUserStore = create((set) => ({
  user: null,
  status: 'idle',
  error: null,

  fetchUser: async (userId) => {
    set({ status: 'loading' })
    try {
      const response = await fetch(`/api/users/${userId}`)
      const data = await response.json()
      set({ user: data, status: 'succeeded' })
    } catch (error) {
      set({ error: error.message, status: 'failed' })
    }
  },
}))

export default useUserStore

function UserProfile({ userId }) {
  const { user, status, fetchUser } = useUserStore()

  useEffect(() => {
    fetchUser(userId)
  }, [userId])

  if (status === 'loading') return <p>Loading...</p>
  return <p>{user?.name}</p>
}

TypeScript 적용

import { create } from 'zustand'

interface CounterState {
  count: number
  increment: () => void
  decrement: () => void
  reset: () => void
}

const useCounterStore = create<CounterState>((set) => ({
  count: 0,
  increment: () => set((state) => ({ count: state.count + 1 })),
  decrement: () => set((state) => ({ count: state.count - 1 })),
  reset: () => set({ count: 0 }),
}))

devtools, persist 미들웨어

import { create } from 'zustand'
import { devtools, persist } from 'zustand/middleware'

const useCounterStore = create(
  devtools(                          // Redux DevTools 연동
    persist(                         // localStorage에 상태 저장
      (set) => ({
        count: 0,
        increment: () => set((state) => ({ count: state.count + 1 })),
      }),
      { name: 'counter-storage' }    // localStorage key
    )
  )
)

여러 Store 슬라이스 패턴

// 큰 앱에서는 slice를 나눠서 조합
const createCounterSlice = (set) => ({
  count: 0,
  increment: () => set((state) => ({ count: state.count + 1 })),
})

const createUserSlice = (set) => ({
  user: null,
  setUser: (user) => set({ user }),
})

// 하나의 Store로 합치기
const useStore = create((set) => ({
  ...createCounterSlice(set),
  ...createUserSlice(set),
}))

4. Redux vs Zustand 비교

코드량 비교 — 같은 카운터 기능

Redux (RTK)

파일 구성:
├── store/index.js          (store 설정)
├── store/counterSlice.js   (slice 정의)
└── main.jsx                (Provider 설정)

총 ~40줄

Zustand

파일 구성:
└── store/useCounterStore.js  (store + action 전부)

총 ~10줄

주요 차이점 요약

항목	Redux (RTK)	Zustand
학습 난이도	높음 (Action/Reducer/Selector 개념 필요)	낮음 (create + set만 알면 됨)
보일러플레이트	많음	거의 없음
번들 크기	~47KB	~1KB
Provider 필요	필요	불필요
DevTools	매우 강력 (시간여행 디버깅)	기본 지원
비동기 처리	미들웨어 필요 (thunk/saga)	액션 안에서 바로 async/await
미들웨어 생태계	풍부	제한적
적합한 규모	대규모, 팀 프로젝트	소~중규모, 빠른 개발

5. 언제 무엇을 선택할까?

상황별 선택 가이드

상태가 한 컴포넌트 안에서만 쓰인다
└── useState / useReducer

서버 데이터 페칭이 주된 문제다
└── TanStack Query (React Query) / SWR

진짜 클라이언트 전역 상태가 필요하다
├── 대규모 팀, 복잡한 비즈니스 로직, 강력한 디버깅 필요
│   └── Redux (Redux Toolkit)
└── 소~중규모, 빠른 개발, 단순한 상태
    └── Zustand

Redux를 선택하면 좋은 경우

10명 이상의 팀이 협업하는 대규모 프로젝트
상태 변화 이력 추적(시간여행 디버깅)이 중요할 때
복잡한 비동기 흐름(saga, 복잡한 thunk)이 필요할 때
이미 Redux를 사용 중인 기존 프로젝트

Zustand를 선택하면 좋은 경우

소규모 팀 또는 개인 프로젝트
빠른 프로토타이핑이 필요할 때
Redux의 보일러플레이트가 부담스러울 때
단순하고 직관적인 코드를 선호할 때

Context API는 전역 상태관리 도구보다는 테마, 언어 설정처럼 변경이 드문 정적 데이터에 적합합니다. 자주 바뀌는 상태에 사용하면 불필요한 전체 리렌더링이 발생합니다.

6. 자주 하는 실수

Redux

1. useSelector에서 객체 반환

// ❌ 매 렌더마다 새 객체 생성 → 불필요한 리렌더링
const { count, user } = useSelector((state) => ({
  count: state.counter.value,
  user: state.user.data,
}))

// ✅ 각각 따로 구독
const count = useSelector((state) => state.counter.value)
const user  = useSelector((state) => state.user.data)

2. Reducer에서 직접 상태 변경 (RTK 미사용 시)

// ❌ 직접 변경 — 상태가 불변이어야 함
const reducer = (state, action) => {
  state.count += 1  // 원본 변경
  return state
}

// ✅ 새 객체 반환
const reducer = (state, action) => ({
  ...state,
  count: state.count + 1,
})

Zustand

1. Store 전체 구독

// ❌ store 전체를 구독 → 아무 상태 변경에나 리렌더링
const store = useCounterStore()

// ✅ 필요한 상태만 선택적 구독
const count = useCounterStore((state) => state.count)

2. 컴포넌트 안에서 Store 생성

// ❌ 렌더마다 새 Store 생성
function Component() {
  const store = create(...)  // 컴포넌트 안에서 생성 금지
}

// ✅ 모듈 최상위에서 한 번만 생성
const useStore = create(...)
function Component() {
  const value = useStore((state) => state.value)
}

참고 자료

시계열 데이터 분석 — ARIMA, SARIMA, LSTM으로 환율 예측하기

Thu, 01 Aug 2024 00:00:00 GMT

환율 예측 프로젝트를 진행하면서 다양한 시계열 분석 모델을 조사하고 논문도 읽어봤습니다. 그 과정에서 공부한 내용을 ARIMA, SARIMA, LSTM 세 가지 모델을 중심으로 정리합니다.

시계열 데이터란?

시계열(Time Series) 데이터는 시간 순서대로 기록된 데이터입니다. 환율, 주가, 기온, 판매량 등이 대표적인 예입니다.

시계열 분석의 핵심 개념:

추세(Trend): 장기적인 증가/감소 방향
계절성(Seasonality): 일정 주기로 반복되는 패턴 (월별, 분기별 등)
잔차(Residual): 추세와 계절성을 제거한 나머지 불규칙 성분
정상성(Stationarity): 평균과 분산이 시간에 따라 일정한 성질 → 대부분의 통계 모델이 전제로 요구

세 가지 모델 한눈에 비교

	ARIMA	SARIMA	LSTM
유형	통계 모델	통계 모델	딥러닝
계절성 처리	❌	✅	✅ (자동 학습)
비선형 관계	❌	❌	✅
필요 데이터 양	소~중	중	대
해석 가능성	높음	높음	낮음 (블랙박스)

ARIMA

개념

ARIMA(AutoRegressive Integrated Moving Average) 는 시계열 분석에서 가장 널리 쓰이는 통계 모델입니다. 세 가지 구성 요소의 조합입니다.

AR(p): 과거 p개의 값으로 현재 값을 예측 (자기회귀)
I(d): d번 차분하여 정상성을 확보 (누적/적분)
MA(q): 과거 q개의 예측 오차를 이용해 보정 (이동평균)

수식

$y_t = c + \phi_1 y_{t-1} + \cdots + \phi_p y_{t-p} + \theta_1 e_{t-1} + \cdots + \theta_q e_{t-q} + e_t$

파라미터 선택 방법

파라미터	도구	기준
d	ADF 검정 (단위근 검정)	p-value < 0.05이면 정상 → d 결정
p	PACF 그래프	절단점(cut-off) 위치
q	ACF 그래프	절단점(cut-off) 위치

Python 구현

import pandas as pd
from statsmodels.tsa.arima.model import ARIMA
from statsmodels.tsa.stattools import adfuller
import matplotlib.pyplot as plt

# 1. 정상성 검정 (ADF Test)
def check_stationarity(series):
    result = adfuller(series)
    print(f"ADF Statistic : {result[0]:.4f}")
    print(f"p-value       : {result[1]:.4f}")
    print("정상 시계열" if result[1] < 0.05 else "비정상 시계열 → 차분 필요")

# 2. ARIMA 모델 학습
df = pd.read_csv("exchange_rate.csv", index_col="date", parse_dates=True)
series = df["USD_KRW"]

check_stationarity(series)

model = ARIMA(series, order=(2, 1, 2))  # p=2, d=1, q=2
result = model.fit()
print(result.summary())

# 3. 예측
forecast = result.forecast(steps=30)
plt.plot(series[-60:], label="Actual")
plt.plot(forecast, label="Forecast")
plt.legend()
plt.show()

자동 파라미터 탐색 (auto_arima)

직접 ACF/PACF를 보지 않고 자동으로 최적 파라미터를 찾을 수도 있습니다.

from pmdarima import auto_arima

model = auto_arima(
    series,
    start_p=0, max_p=5,
    start_q=0, max_q=5,
    d=None,           # 자동 차분 횟수 결정
    information_criterion="aic",
    seasonal=False,
    trace=True
)
print(model.summary())

SARIMA

개념

SARIMA(Seasonal ARIMA) 는 ARIMA에 계절성 성분을 추가한 모델입니다. 환율처럼 연말/연초, 분기 마감 등 계절적 패턴이 있는 데이터에 더 적합합니다.

표기: SARIMA(p, d, q)(P, D, Q, m)

소문자 p, d, q: 비계절 ARIMA 파라미터 (위와 동일)
대문자 P, D, Q: 계절 AR, 차분, MA 차수
m: 계절 주기 (월별=12, 분기별=4, 주별=7)

Python 구현

from statsmodels.tsa.statespace.sarimax import SARIMAX

model = SARIMAX(
    series,
    order=(1, 1, 1),            # (p, d, q)
    seasonal_order=(1, 1, 1, 12)  # (P, D, Q, m) — 월별 계절성
)
result = model.fit(disp=False)
print(result.summary())

# 예측
forecast = result.forecast(steps=12)  # 12개월 예측

auto_arima로 SARIMA 탐색

model = auto_arima(
    series,
    seasonal=True,
    m=12,               # 월별 계절성
    start_p=0, max_p=3,
    start_q=0, max_q=3,
    start_P=0, max_P=2,
    start_Q=0, max_Q=2,
    information_criterion="aic",
    trace=True
)

모델 평가 지표

from sklearn.metrics import mean_squared_error, mean_absolute_error
import numpy as np

# Train/Test split
train = series[:-30]
test  = series[-30:]

# 예측
model = SARIMAX(train, order=(1,1,1), seasonal_order=(1,1,1,12)).fit(disp=False)
pred  = model.forecast(steps=30)

rmse = np.sqrt(mean_squared_error(test, pred))
mae  = mean_absolute_error(test, pred)
mape = np.mean(np.abs((test - pred) / test)) * 100

print(f"RMSE : {rmse:.4f}")
print(f"MAE  : {mae:.4f}")
print(f"MAPE : {mape:.2f}%")

LSTM

개념

LSTM(Long Short-Term Memory) 은 순환 신경망(RNN)의 한 종류로, 장기 의존성(long-term dependency) 문제를 해결하기 위해 설계되었습니다. 기존 RNN은 시퀀스가 길어질수록 기울기 소실(Vanishing Gradient) 문제로 앞부분 정보를 잊어버리는데, LSTM은 게이트(Gate) 구조로 이를 해결합니다.

LSTM의 4가지 핵심 구성요소

게이트	수식	역할
Forget Gate	$f_t = \sigma(W_f \cdot [h_{t-1}, x_t] + b_f)$	이전 Cell State에서 무엇을 지울지 결정
Input Gate	$i_t = \sigma(W_i \cdot [h_{t-1}, x_t] + b_i)$	새 정보를 얼마나 저장할지 결정
Cell Update	$\tilde{C}_t = \tanh(W_C \cdot [h_{t-1}, x_t] + b_C)$	새로 추가될 후보 값 생성
Output Gate	$o_t = \sigma(W_o \cdot [h_{t-1}, x_t] + b_o)$	Cell State에서 무엇을 출력할지 결정

Cell State ( $C_t$ ): 장기 기억 — 컨베이어 벨트처럼 정보가 흐름
Hidden State ( $h_t$ ): 단기 기억 + 출력값

Python 구현 (TensorFlow/Keras)

데이터 전처리

import numpy as np
import pandas as pd
from sklearn.preprocessing import MinMaxScaler

df = pd.read_csv("exchange_rate.csv", index_col="date", parse_dates=True)
series = df["USD_KRW"].values.reshape(-1, 1)

# 정규화 (LSTM은 0~1 스케일 권장)
scaler = MinMaxScaler()
scaled = scaler.fit_transform(series)

# 시퀀스 생성 함수
def create_sequences(data, window_size):
    X, y = [], []
    for i in range(len(data) - window_size):
        X.append(data[i:i+window_size])
        y.append(data[i+window_size])
    return np.array(X), np.array(y)

WINDOW = 60  # 60일 데이터로 다음날 예측
X, y = create_sequences(scaled, WINDOW)

# Train/Test split (80:20)
split = int(len(X) * 0.8)
X_train, X_test = X[:split], X[split:]
y_train, y_test = y[:split], y[split:]

모델 구성 및 학습

from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM, Dense, Dropout
from tensorflow.keras.callbacks import EarlyStopping

model = Sequential([
    LSTM(64, return_sequences=True, input_shape=(WINDOW, 1)),
    Dropout(0.2),
    LSTM(32, return_sequences=False),
    Dropout(0.2),
    Dense(1)
])

model.compile(optimizer="adam", loss="mse")
model.summary()

early_stop = EarlyStopping(monitor="val_loss", patience=10, restore_best_weights=True)

history = model.fit(
    X_train, y_train,
    epochs=100,
    batch_size=32,
    validation_split=0.1,
    callbacks=[early_stop],
    verbose=1
)

예측 및 역정규화

pred_scaled = model.predict(X_test)
pred = scaler.inverse_transform(pred_scaled)
actual = scaler.inverse_transform(y_test)

import matplotlib.pyplot as plt

plt.figure(figsize=(14, 5))
plt.plot(actual, label="Actual", color="steelblue")
plt.plot(pred,   label="LSTM Forecast", color="tomato")
plt.title("Exchange Rate Prediction — LSTM")
plt.legend()
plt.tight_layout()
plt.show()

하이퍼파라미터 튜닝 포인트

파라미터	설명	권장 범위
`window_size`	입력 시퀀스 길이	30 ~ 120
`units`	LSTM 유닛 수	32 ~ 256
`layers`	LSTM 레이어 수	1 ~ 3
`dropout`	과적합 방지	0.1 ~ 0.3
`batch_size`	배치 크기	16 ~ 64
`learning_rate`	Adam 학습률	0.001 ~ 0.0001

모델 선택 가이드

실제 프로젝트에서 어떤 모델을 선택해야 할지 판단 기준입니다.

데이터에 계절성이 있는가?
├── YES → SARIMA (통계) 또는 LSTM (딥러닝)
└── NO  → ARIMA (통계) 또는 LSTM (딥러닝)

데이터 양이 충분한가? (수천 개 이상)
├── YES → LSTM 시도 가능
└── NO  → ARIMA / SARIMA 권장

모델 해석이 중요한가?
├── YES → ARIMA / SARIMA
└── NO  → LSTM (예측 정확도 우선)

빠른 프로토타이핑이 필요한가?
└── YES → auto_arima → SARIMA 순서 권장

환율 예측에서 느낀 점

실제로 USD/KRW 환율 데이터로 세 모델을 비교해보면서 느낀 점입니다.

ARIMA/SARIMA: 단기(1~5일) 예측에서 안정적이었고, 파라미터 해석이 직관적이었습니다. 하지만 환율의 급격한 변동(뉴스, 정책 이벤트)을 전혀 반영하지 못합니다.
LSTM: 패턴 학습 능력은 뛰어나지만, 데이터 양과 하이퍼파라미터에 매우 민감합니다. 과적합에 주의가 필요하고, 학습/검증 곡선을 꼼꼼히 모니터링해야 합니다.
공통 한계: 세 모델 모두 외부 변수(금리, 유가, 지정학적 이슈)를 반영하지 못합니다. 외부 변수를 포함하려면 SARIMAX(외생 변수 포함 SARIMA)나 멀티변량 LSTM을 고려해야 합니다.

참고 자료

Box, G.E.P. & Jenkins, G.M. (1976). Time Series Analysis: Forecasting and Control
Hochreiter, S. & Schmidhuber, J. (1997). Long Short-Term Memory. Neural Computation, 9(8)
statsmodels ARIMA 공식 문서
Keras LSTM 공식 문서
Claude AI

WebSocket — 실시간 양방향 통신

Tue, 23 Jul 2024 00:00:00 GMT

채팅, 실시간 알림, 주식 시세처럼 서버에서 클라이언트로 데이터를 즉시 밀어줘야 하는 기능을 구현할 때 가장 먼저 떠오르는 기술이 WebSocket입니다. 기존 HTTP 방식의 한계를 어떻게 해결하는지, 그리고 실무에서 어떻게 구성하는지를 순서대로 정리합니다.

1. WebSocket이란?

WebSocket은 클라이언트와 서버가 하나의 연결을 유지한 채 양방향으로 실시간 통신하는 프로토콜입니다. HTTP를 기반으로 업그레이드 핸드셰이크가 이루어진 뒤, 이후 모든 통신은 WebSocket 프레임으로 처리됩니다.

HTTP와의 차이

구분	HTTP	WebSocket
연결 방식	요청마다 연결/종료	한 번 연결 후 유지
통신 방향	클라이언트 → 서버 (단방향)	양방향
실시간성	낮음 (폴링 필요)	매우 높음
오버헤드	매 요청마다 헤더 포함	최초 핸드셰이크 이후 최소화
사용 예	REST API	채팅, 알림, 실시간 대시보드

HTTP 방식으로 실시간성을 흉내 내려면 폴링(Polling) 이나 롱 폴링(Long Polling) 을 써야 하는데, 불필요한 요청이 많아져 서버 부하가 증가합니다. WebSocket은 이 문제를 단일 연결로 해결합니다.

2. 연결 흐름

WebSocket 통신은 네 단계로 이루어집니다.

① Handshake: 클라이언트가 HTTP 업그레이드 요청을 보냅니다.

GET /ws HTTP/1.1
Host: example.com
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Key: dGhlIHNhbXBsZSBub25jZQ==
Sec-WebSocket-Version: 13

② Upgrade: 서버가 101 응답으로 WebSocket 연결을 수락합니다.

HTTP/1.1 101 Switching Protocols
Upgrade: websocket
Connection: Upgrade
Sec-WebSocket-Accept: s3pPLMBiTxaQ9kYGzzhZRbK+xOo=

③ Data Exchange: 이후부터는 양방향으로 자유롭게 메시지를 주고받습니다.

{
  "type": "chat",
  "from": "userA",
  "to": "userB",
  "message": "안녕하세요!"
}

④ Close: 어느 쪽이든 Close 프레임을 보내 연결을 종료합니다.

3. 구현 방식 선택

실무에서는 두 가지 방식을 상황에 따라 선택합니다.

	순수 WebSocket	STOMP + WebSocket
복잡도	낮음	높음
연결/유저 관리	직접 구현	프레임워크 처리
Pub/Sub	직접 구현	기본 제공
채팅방 구조	구현 복잡	`/topic` 으로 간단
적합한 상황	간단한 1:1, IoT	채팅방, 브로드캐스트

4. 순수 WebSocket 구현

Node.js 서버

npm install ws

const WebSocket = require('ws');
const wss = new WebSocket.Server({ port: 8080 });

// userId → socket 매핑
const clients = new Map();

wss.on('connection', (ws) => {
  ws.on('message', (data) => {
    const msg = JSON.parse(data);

    // 최초 연결 시 유저 등록
    if (msg.type === 'register') {
      clients.set(msg.userId, ws);
      return;
    }

    // 특정 유저에게 메시지 전달
    if (msg.type === 'chat') {
      const targetSocket = clients.get(msg.to);
      if (targetSocket && targetSocket.readyState === WebSocket.OPEN) {
        targetSocket.send(JSON.stringify({
          from: msg.from,
          message: msg.message,
          timestamp: new Date().toISOString(),
        }));
      }
    }
  });

  // 연결 종료 시 클라이언트 제거
  ws.on('close', () => {
    for (const [key, value] of clients) {
      if (value === ws) {
        clients.delete(key);
        break;
      }
    }
  });
});

React 클라이언트

import { useEffect, useRef } from 'react';

function Chat() {
  const socketRef = useRef(null);

  useEffect(() => {
    socketRef.current = new WebSocket('ws://localhost:8080');

    socketRef.current.onopen = () => {
      // 연결 직후 유저 등록
      socketRef.current.send(JSON.stringify({
        type: 'register',
        userId: 'userA',
      }));
    };

    socketRef.current.onmessage = (event) => {
      const msg = JSON.parse(event.data);
      console.log('받은 메시지:', msg);
    };

    socketRef.current.onerror = (error) => {
      console.error('WebSocket error:', error);
    };

    return () => socketRef.current.close();
  }, []);

  const sendMessage = () => {
    socketRef.current.send(JSON.stringify({
      type: 'chat',
      from: 'userA',
      to: 'userB',
      message: '안녕하세요!',
    }));
  };

  return <button onClick={sendMessage}>메시지 보내기</button>;
}

5. STOMP + Spring WebSocket

Spring 환경에서는 STOMP(Simple Text Oriented Messaging Protocol)를 함께 사용하는 것이 일반적입니다. Pub/Sub 구조로 채팅방, 브로드캐스트를 쉽게 구현할 수 있습니다.

STOMP 주요 경로

경로	방향	용도
`/app/**`	클라이언트 → 서버	메시지 전송 엔드포인트
`/topic/**`	서버 → 다수 유저	채팅방 브로드캐스트
`/queue/**`	서버 → 특정 유저	1:1 메시지
`/user/queue/**`	서버 → 인증된 특정 유저	Principal 기반 개인 메시지

WebSocket 설정

@Configuration
@EnableWebSocketMessageBroker
public class WebSocketConfig implements WebSocketMessageBrokerConfigurer {

    @Override
    public void registerStompEndpoints(StompEndpointRegistry registry) {
        registry.addEndpoint("/ws-chat")
                .setAllowedOriginPatterns("*")
                .withSockJS();  // 브라우저 호환성 fallback
    }

    @Override
    public void configureMessageBroker(MessageBrokerRegistry registry) {
        registry.setApplicationDestinationPrefixes("/app");
        registry.enableSimpleBroker("/topic", "/queue");
        registry.setUserDestinationPrefix("/user");
    }
}

메시지 DTO

@Getter
@NoArgsConstructor
@AllArgsConstructor
public class ChatMessage {
    private String roomId;
    private String sender;
    private String message;
    private LocalDateTime timestamp;
}

Chat Controller

@Controller
public class ChatController {

    private final SimpMessagingTemplate messagingTemplate;

    public ChatController(SimpMessagingTemplate messagingTemplate) {
        this.messagingTemplate = messagingTemplate;
    }

    // 채팅방 브로드캐스트
    @MessageMapping("/chat.send")
    public void sendToRoom(ChatMessage message) {
        messagingTemplate.convertAndSend(
            "/topic/chat.room." + message.getRoomId(),
            message
        );
    }

    // 1:1 메시지
    @MessageMapping("/chat.private")
    public void sendToUser(ChatMessage message) {
        messagingTemplate.convertAndSendToUser(
            message.getReceiver(),
            "/queue/chat",
            message
        );
    }
}

6. JWT 인증 (Spring + STOMP)

WebSocket도 HTTP와 마찬가지로 인증이 필수입니다. Spring에서는 HandshakeInterceptor와 ChannelInterceptor 두 단계로 JWT를 검증합니다.

HandshakeInterceptor — WS 연결 시점 검증

@Component
public class JwtHandshakeInterceptor implements HandshakeInterceptor {

    private final JwtProvider jwtProvider;

    public JwtHandshakeInterceptor(JwtProvider jwtProvider) {
        this.jwtProvider = jwtProvider;
    }

    @Override
    public boolean beforeHandshake(
            ServerHttpRequest request,
            ServerHttpResponse response,
            WebSocketHandler wsHandler,
            Map<String, Object> attributes) {

        String token = extractToken(request);
        if (token != null && jwtProvider.validate(token)) {
            String userId = jwtProvider.getUserId(token);
            attributes.put("userId", userId);  // 세션에 저장
            return true;
        }
        return false;  // false 반환 시 연결 거부
    }

    @Override
    public void afterHandshake(
            ServerHttpRequest request,
            ServerHttpResponse response,
            WebSocketHandler wsHandler,
            Exception ex) {}

    private String extractToken(ServerHttpRequest request) {
        List<String> auth = request.getHeaders().get("Authorization");
        if (auth != null && !auth.isEmpty()) {
            return auth.get(0).replace("Bearer ", "");
        }
        return null;
    }
}

ChannelInterceptor — STOMP CONNECT 시점 검증

@Component
public class StompAuthInterceptor implements ChannelInterceptor {

    @Override
    public Message<?> preSend(Message<?> message, MessageChannel channel) {
        StompHeaderAccessor accessor =
            MessageHeaderAccessor.getAccessor(message, StompHeaderAccessor.class);

        if (StompCommand.CONNECT.equals(accessor.getCommand())) {
            String userId = (String) accessor.getSessionAttributes().get("userId");
            if (userId != null) {
                // Principal 설정 → /user/queue 경로 사용 가능해짐
                accessor.setUser(new UsernamePasswordAuthenticationToken(userId, null));
            }
        }
        return message;
    }
}

ChannelInterceptor에서 Principal을 설정해야 /user/queue/** 경로가 정상 동작합니다.

설정에 인터셉터 등록

@Override
public void registerStompEndpoints(StompEndpointRegistry registry) {
    registry.addEndpoint("/ws-chat")
            .addInterceptors(jwtHandshakeInterceptor)  // 추가
            .setAllowedOriginPatterns("*")
            .withSockJS();
}

@Override
public void configureClientInboundChannel(ChannelRegistration registration) {
    registration.interceptors(stompAuthInterceptor);   // 추가
}

React STOMP 클라이언트 (JWT 포함)

npm install @stomp/stompjs sockjs-client

import { Client } from '@stomp/stompjs';
import SockJS from 'sockjs-client';

const client = new Client({
  webSocketFactory: () => new SockJS('http://localhost:8080/ws-chat'),

  // JWT를 CONNECT 헤더로 전달
  connectHeaders: {
    Authorization: 'Bearer ' + localStorage.getItem('accessToken'),
  },

  onConnect: () => {
    // 채팅방 구독
    client.subscribe('/topic/chat.room.1', (msg) => {
      const message = JSON.parse(msg.body);
      console.log('받은 메시지:', message);
    });

    // 개인 메시지 구독
    client.subscribe('/user/queue/chat', (msg) => {
      const message = JSON.parse(msg.body);
      console.log('개인 메시지:', message);
    });
  },

  onStompError: (frame) => {
    console.error('STOMP error:', frame);
  },
});

client.activate();

// 메시지 전송
const sendMessage = (roomId, content) => {
  client.publish({
    destination: '/app/chat.send',
    body: JSON.stringify({
      roomId,
      sender: 'userA',
      message: content,
      timestamp: new Date().toISOString(),
    }),
  });
};

7. 확장성 — Redis Pub/Sub

서버가 단일 인스턴스일 때는 SimpleBroker로 충분하지만, 서버가 여러 대로 늘어나면 문제가 생깁니다. User A가 Server 1에 연결되어 있고 User B가 Server 2에 연결되어 있으면, Server 1에서 보낸 메시지가 User B에게 도달하지 않습니다.

해결 방법: Redis Pub/Sub (또는 RabbitMQ)

User A (Server 1) → 메시지 발행 → Redis Channel
                                         ↓
                              모든 서버가 구독 중
                                         ↓
                           Server 2 → User B에게 전달

Spring에서 Redis STOMP 브로커 연동

@Override
public void configureMessageBroker(MessageBrokerRegistry registry) {
    registry.setApplicationDestinationPrefixes("/app");

    // SimpleBroker 대신 외부 브로커 사용
    registry.enableStompBrokerRelay("/topic", "/queue")
            .setRelayHost("localhost")
            .setRelayPort(61613)        // RabbitMQ STOMP 포트
            .setClientLogin("guest")
            .setClientPasscode("guest");

    registry.setUserDestinationPrefix("/user");
}

실무 선택 기준

소규모 / 단일 서버   → SimpleBroker (설정 최소)
중규모 / 다중 서버   → Redis Pub/Sub
대규모 / 메시지 신뢰성 필요 → RabbitMQ / Kafka

8. 실무에서 반드시 고려할 것들

인증 & 보안

WebSocket 연결 시 JWT 검증은 필수입니다. Handshake + STOMP CONNECT 두 단계에서 이중으로 검증하는 것이 권장됩니다. 토큰 만료 시 클라이언트에서 재연결 로직도 구현해야 합니다.

연결 상태 관리

// 재연결 로직 예시 (@stomp/stompjs)
const client = new Client({
  // ...
  reconnectDelay: 5000,       // 5초 후 자동 재연결
  heartbeatIncoming: 4000,    // 서버 heartbeat 주기
  heartbeatOutgoing: 4000,    // 클라이언트 heartbeat 주기
});

메시지 저장 전략

실시간 전송과 DB 저장을 분리해 처리합니다.

WebSocket 전송 (즉시)
    ↕ (비동기)
DB 저장 (비동기 처리 / Kafka 큐 활용)

다중 디바이스 대응

같은 유저가 여러 기기로 접속하는 경우, Map 대신 userId → List<WebSocket> 형태로 관리하거나 Redis에 세션 정보를 공유해야 합니다.

9. 순서 정리

WebSocket을 처음 공부하거나 프로젝트에 적용할 때 아래 순서로 접근하면 이해하기 쉽습니다.

1단계 : WebSocket 기본 개념과 HTTP와의 차이
2단계 : 순수 WebSocket으로 1:1 채팅 구현
3단계 : JWT 인증 추가
4단계 : 채팅방(1:N) 구조 확장
5단계 : STOMP + Spring 적용
6단계 : Redis 연동으로 다중 서버 확장

참고 자료

프론트엔드 로그인 구현 (JWT, AccessToken, RefreshToken)

Sun, 14 Jul 2024 00:00:00 GMT

팀 프로젝트에서 자체 로그인 기능을 구현하면서 JWT 토큰 방식에 대해 깊이 공부하게 되었습니다. 개념은 알고 있었지만 막상 구현하면서 토큰 저장 위치, 자동 갱신 처리, 보안 이슈까지 생각보다 고려할 것이 많았습니다. 이 글에서 그 과정을 정리합니다.

1. JWT란?

JWT(JSON Web Token) 는 당사자 간에 정보를 안전하게 전송하기 위한 컴팩트한 자체 포함 토큰입니다. 사용자가 로그인하면 서버가 "이 사람은 인증된 사용자입니다"라는 증명서를 발급해주고, 이후 API 요청마다 이 증명서를 제시하는 방식입니다.

JWT 구조

header.payload.signature

세 부분이 .으로 구분되며, 각 부분은 Base64URL로 인코딩되어 있습니다.

eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9        ← Header
.eyJ1c2VySWQiOjEsImlhdCI6MTYxNjIzOTAyMn0    ← Payload
.SflKxwRJSMeKKF2QT4fwpMeJf36POk6yJV_adQssw5c ← Signature

부분	내용	특징
Header	토큰 타입 + 해싱 알고리즘	인코딩만 됨 (복호화 가능)
Payload	사용자 정보, 권한, 만료시간 등	인코딩만 됨 — 민감 정보 넣지 말 것
Signature	Header + Payload를 비밀키로 서명	서버의 비밀키 없이 위조 불가

Payload는 누구나 디코딩할 수 있으므로 비밀번호, 카드번호 등 민감한 정보를 절대 담지 말아야 합니다.

JWT 기반 인증의 장점

세션 방식과 달리 서버가 사용자 로그인 상태를 저장하지 않습니다. 토큰 자체에 정보가 담겨 있어 서버가 Stateless하게 유지됩니다. 서버 인스턴스가 여러 개로 늘어나도 세션 공유 없이 인증이 가능합니다.

2. Access Token과 Refresh Token

Access Token만으로 인증을 구현하면 한 가지 치명적인 문제가 있습니다. 토큰이 탈취되면 만료 전까지 공격자가 마음대로 API를 호출할 수 있습니다. 그렇다고 만료 시간을 너무 짧게 설정하면 사용자가 자주 로그인해야 하는 불편함이 생깁니다.

이를 해결하기 위해 역할이 다른 두 가지 토큰을 함께 사용합니다.

Access Token

목적     : API 요청 시 사용자 인증
유효기간 : 짧음 (15분 ~ 1시간 권장)
저장위치 : 메모리(상태) 또는 sessionStorage
역할     : 실제 인가(Authorization) 수행

Refresh Token

목적     : 만료된 Access Token 재발급
유효기간 : 김 (7일 ~ 30일)
저장위치 : HttpOnly Cookie (권장)
역할     : 서버에서 검증 후 새 Access Token 발급

전체 인증 플로우

1. 로그인 요청
   Client → Server: { email, password }

2. 토큰 발급
   Server → Client: Access Token (응답 Body)
                  + Refresh Token (HttpOnly Cookie)
   Server: DB에 Refresh Token 저장

3. API 요청
   Client → Server: Authorization: Bearer <access_token>
   Server: 토큰 유효성 검증 → 요청 처리

4. Access Token 만료 시
   Client → Server: Refresh Token (Cookie 자동 전송)
   Server: Refresh Token 검증 → 새 Access Token 발급
   Client: 새 Access Token으로 원래 요청 재시도

5. Refresh Token도 만료 시
   → 재로그인 필요

6. 로그아웃
   Client: Access Token 삭제
   Server: Refresh Token DB에서 삭제 (Cookie 만료 처리)

3. 토큰 저장 위치 선택

어디에 저장하느냐는 보안에서 가장 중요한 결정 중 하나입니다.

저장 옵션 비교

저장 위치	XSS	CSRF	지속성	권장 용도
localStorage	❌ 취약	✅ 안전	영구	⚠️ 비권장
sessionStorage	❌ 취약	✅ 안전	탭 닫으면 삭제	⚠️ Access Token 임시 저장
메모리 (State)	✅ 안전	✅ 안전	새로고침 시 소실	✅ Access Token 권장
HttpOnly Cookie	✅ 안전	❌ 취약	만료일까지	✅ Refresh Token 권장

권장 조합

Access Token  → 메모리(React State) 또는 sessionStorage
Refresh Token → HttpOnly Cookie (서버에서 Set-Cookie로 설정)

왜 HttpOnly Cookie인가? JS로 접근이 불가능하므로 XSS 공격으로 토큰을 훔칠 수 없습니다. CSRF 대응은 SameSite=Strict 또는 CSRF 토큰으로 처리합니다.

4. 프로젝트 구조

src/
├── api/
│   ├── axios.ts          ← Axios 인스턴스 + 인터셉터
│   └── auth.ts           ← 로그인/로그아웃/갱신 API
├── context/
│   └── AuthContext.tsx   ← 전역 인증 상태 관리
├── hooks/
│   └── useAuth.ts        ← 인증 관련 커스텀 훅
├── components/
│   └── ProtectedRoute.tsx ← 인증 필요 라우트 보호
└── pages/
    ├── Login.tsx
    └── Dashboard.tsx

5. Axios 인스턴스 & 인터셉터

인터셉터는 모든 요청/응답을 중간에서 가로채 공통 처리를 합니다. Access Token 자동 삽입, 만료 시 자동 갱신이 여기서 이뤄집니다.

// src/api/axios.ts
import axios, { AxiosError, InternalAxiosRequestConfig } from 'axios';

const API_BASE_URL = process.env.REACT_APP_API_URL || 'http://localhost:3000';

// 인증이 필요 없는 요청용 (로그인, 회원가입 등)
export const axiosInstance = axios.create({
  baseURL: API_BASE_URL,
  timeout: 10000,
  headers: { 'Content-Type': 'application/json' },
});

// 인증이 필요한 요청용
export const axiosPrivate = axios.create({
  baseURL: API_BASE_URL,
  timeout: 10000,
  headers: { 'Content-Type': 'application/json' },
  withCredentials: true,  // HttpOnly Cookie(Refresh Token) 자동 전송
});

// ── 동시 요청 중 토큰 갱신 중복 방지를 위한 큐 ──
let isRefreshing = false;
let failedQueue: Array<{
  resolve: (token: string) => void;
  reject: (err: unknown) => void;
}> = [];

const processQueue = (error: unknown, token: string | null = null) => {
  failedQueue.forEach(prom => {
    error ? prom.reject(error) : prom.resolve(token!);
  });
  failedQueue = [];
};

// ── Request Interceptor: 모든 요청에 Access Token 자동 삽입 ──
axiosPrivate.interceptors.request.use(
  (config: InternalAxiosRequestConfig) => {
    const accessToken = sessionStorage.getItem('accessToken');
    if (accessToken && config.headers) {
      config.headers.Authorization = `Bearer ${accessToken}`;
    }
    return config;
  },
  (error) => Promise.reject(error)
);

// ── Response Interceptor: 401 발생 시 토큰 자동 갱신 ──
axiosPrivate.interceptors.response.use(
  (response) => response,
  async (error: AxiosError) => {
    const originalRequest = error.config as InternalAxiosRequestConfig & {
      _retry?: boolean;
    };

    if (error.response?.status === 401 && !originalRequest._retry) {
      // 이미 갱신 중이면 대기열에 추가 (동시 요청 처리)
      if (isRefreshing) {
        return new Promise((resolve, reject) => {
          failedQueue.push({ resolve, reject });
        }).then(token => {
          originalRequest.headers.Authorization = `Bearer ${token}`;
          return axiosPrivate(originalRequest);
        });
      }

      originalRequest._retry = true;
      isRefreshing = true;

      try {
        // Refresh Token(Cookie)으로 새 Access Token 요청
        const response = await axiosInstance.post(
          '/auth/refresh',
          {},
          { withCredentials: true }
        );
        const { accessToken } = response.data;

        sessionStorage.setItem('accessToken', accessToken);
        processQueue(null, accessToken);

        // 원래 요청 재시도
        originalRequest.headers.Authorization = `Bearer ${accessToken}`;
        return axiosPrivate(originalRequest);
      } catch (refreshError) {
        // Refresh Token도 만료 → 강제 로그아웃
        processQueue(refreshError, null);
        sessionStorage.removeItem('accessToken');
        window.location.href = '/login';
        return Promise.reject(refreshError);
      } finally {
        isRefreshing = false;
      }
    }

    return Promise.reject(error);
  }
);

_retry 플래그는 무한 갱신 루프를 방지합니다. 갱신 요청 자체가 401을 반환하면 재시도 없이 로그아웃 처리합니다.

6. 인증 API 함수

// src/api/auth.ts
import { axiosInstance, axiosPrivate } from './axios';

export interface LoginCredentials {
  email: string;
  password: string;
}

export interface AuthResponse {
  accessToken: string;
  user: { id: number; email: string; name: string };
}

// 로그인: Access Token은 Body, Refresh Token은 HttpOnly Cookie로 수신
export const login = async (credentials: LoginCredentials): Promise<AuthResponse> => {
  const response = await axiosInstance.post('/auth/login', credentials, {
    withCredentials: true,
  });
  return response.data;
};

// 로그아웃: 서버에서 Refresh Token Cookie 만료 처리
export const logout = async (): Promise<void> => {
  await axiosPrivate.post('/auth/logout');
  sessionStorage.removeItem('accessToken');
};

// Access Token 수동 갱신 (앱 초기화 시 사용)
export const refreshAccessToken = async (): Promise<string> => {
  const response = await axiosInstance.post(
    '/auth/refresh',
    {},
    { withCredentials: true }
  );
  return response.data.accessToken;
};

// 내 정보 조회
export const getCurrentUser = async () => {
  const response = await axiosPrivate.get('/auth/me');
  return response.data;
};

7. Auth Context (전역 인증 상태)

// src/context/AuthContext.tsx
import React, { createContext, useContext, useState, useEffect } from 'react';
import { login as apiLogin, logout as apiLogout, getCurrentUser, refreshAccessToken } from '../api/auth';
import type { LoginCredentials } from '../api/auth';

interface User {
  id: number;
  email: string;
  name: string;
}

interface AuthContextType {
  user: User | null;
  isLoading: boolean;
  isAuthenticated: boolean;
  login: (credentials: LoginCredentials) => Promise<void>;
  logout: () => Promise<void>;
}

const AuthContext = createContext<AuthContextType | undefined>(undefined);

export const AuthProvider: React.FC<{ children: React.ReactNode }> = ({ children }) => {
  const [user, setUser]       = useState<User | null>(null);
  const [isLoading, setIsLoading] = useState(true);

  // 앱 시작 시: 저장된 Access Token으로 사용자 정보 복구
  // 없으면 Refresh Token(Cookie)으로 새 Access Token 발급 시도
  useEffect(() => {
    const initAuth = async () => {
      try {
        let token = sessionStorage.getItem('accessToken');

        if (!token) {
          // 새로고침 후 sessionStorage가 비어있을 때
          // Refresh Token이 Cookie에 있으면 자동으로 재발급
          token = await refreshAccessToken();
          sessionStorage.setItem('accessToken', token);
        }

        const userData = await getCurrentUser();
        setUser(userData);
      } catch {
        // Refresh Token도 없거나 만료 → 비로그인 상태
        sessionStorage.removeItem('accessToken');
      } finally {
        setIsLoading(false);
      }
    };

    initAuth();
  }, []);

  const login = async (credentials: LoginCredentials) => {
    const response = await apiLogin(credentials);
    sessionStorage.setItem('accessToken', response.accessToken);
    setUser(response.user);
  };

  const logout = async () => {
    try {
      await apiLogout();
    } finally {
      sessionStorage.removeItem('accessToken');
      setUser(null);
    }
  };

  return (
    <AuthContext.Provider value={{
      user, isLoading,
      isAuthenticated: !!user,
      login, logout,
    }}>
      {children}
    </AuthContext.Provider>
  );
};

export const useAuth = () => {
  const context = useContext(AuthContext);
  if (!context) throw new Error('useAuth must be used within AuthProvider');
  return context;
};

8. 로그인 페이지

// src/pages/Login.tsx
import React, { useState } from 'react';
import { useNavigate } from 'react-router-dom';
import { useAuth } from '../context/AuthContext';

const Login: React.FC = () => {
  const [email, setEmail]       = useState('');
  const [password, setPassword] = useState('');
  const [error, setError]       = useState('');
  const [isLoading, setIsLoading] = useState(false);

  const { login } = useAuth();
  const navigate  = useNavigate();

  const handleSubmit = async (e: React.FormEvent) => {
    e.preventDefault();
    setError('');
    setIsLoading(true);

    try {
      await login({ email, password });
      navigate('/dashboard');
    } catch (err: unknown) {
      const message = err instanceof Error ? err.message : '로그인에 실패했습니다.';
      setError(message);
    } finally {
      setIsLoading(false);
    }
  };

  return (
    <div className="min-h-screen flex items-center justify-center bg-gray-50">
      <div className="max-w-md w-full p-8 bg-white rounded-lg shadow space-y-6">
        <h2 className="text-center text-3xl font-bold text-gray-900">로그인</h2>

        <form onSubmit={handleSubmit} className="space-y-4">
          {error && (
            <div className="bg-red-50 border border-red-400 text-red-700 px-4 py-3 rounded">
              {error}
            </div>
          )}

          <div>
            <label htmlFor="email" className="block text-sm font-medium text-gray-700">
              이메일
            </label>
            <input
              id="email" type="email" required
              value={email} onChange={(e) => setEmail(e.target.value)}
              className="mt-1 block w-full px-3 py-2 border border-gray-300 rounded-md"
              placeholder="your@email.com"
            />
          </div>

          <div>
            <label htmlFor="password" className="block text-sm font-medium text-gray-700">
              비밀번호
            </label>
            <input
              id="password" type="password" required
              value={password} onChange={(e) => setPassword(e.target.value)}
              className="mt-1 block w-full px-3 py-2 border border-gray-300 rounded-md"
              placeholder="••••••••"
            />
          </div>

          <button
            type="submit" disabled={isLoading}
            className="w-full py-2 px-4 bg-blue-600 text-white rounded-md hover:bg-blue-700 disabled:bg-gray-400"
          >
            {isLoading ? '로그인 중...' : '로그인'}
          </button>
        </form>
      </div>
    </div>
  );
};

export default Login;

9. Protected Route

인증되지 않은 사용자가 보호된 페이지에 접근하면 자동으로 로그인 페이지로 리다이렉트합니다.

// src/components/ProtectedRoute.tsx
import React from 'react';
import { Navigate, Outlet } from 'react-router-dom';
import { useAuth } from '../context/AuthContext';

const ProtectedRoute: React.FC = () => {
  const { isAuthenticated, isLoading } = useAuth();

  // 초기 인증 확인 중 (새로고침 후 토큰 복구 대기)
  if (isLoading) {
    return (
      <div className="min-h-screen flex items-center justify-center">
        <div className="text-xl text-gray-500">로딩 중...</div>
      </div>
    );
  }

  return isAuthenticated ? <Outlet /> : <Navigate to="/login" replace />;
};

export default ProtectedRoute;

10. 라우팅 설정 (App.tsx)

// src/App.tsx
import React from 'react';
import { BrowserRouter, Routes, Route, Navigate } from 'react-router-dom';
import { AuthProvider } from './context/AuthContext';
import ProtectedRoute from './components/ProtectedRoute';
import Login     from './pages/Login';
import Dashboard from './pages/Dashboard';

const App: React.FC = () => (
  <BrowserRouter>
    <AuthProvider>
      <Routes>
        <Route path="/login" element={<Login />} />

        {/* 인증이 필요한 페이지 */}
        <Route element={<ProtectedRoute />}>
          <Route path="/dashboard" element={<Dashboard />} />
          {/* 추가 protected routes here */}
        </Route>

        <Route path="/" element={<Navigate to="/dashboard" replace />} />
      </Routes>
    </AuthProvider>
  </BrowserRouter>
);

export default App;

11. 보안 고려사항

XSS (Cross-Site Scripting) 방어

XSS는 악성 스크립트를 주입해 토큰을 탈취하는 공격입니다.

// 사용자 입력 렌더링 시 반드시 sanitize
import DOMPurify from 'dompurify';

// ❌ 위험 — 사용자 입력을 그대로 렌더링
<div dangerouslySetInnerHTML={{ __html: userInput }} />

// ✅ 안전
<div dangerouslySetInnerHTML={{ __html: DOMPurify.sanitize(userInput) }} />

Access Token을 메모리나 sessionStorage에 저장하는 것만으로도 XSS 피해를 크게 줄일 수 있습니다. localStorage는 XSS로 탈취 가능하므로 토큰 저장에 사용하지 않는 것이 좋습니다.

CSRF (Cross-Site Request Forgery) 방어

CSRF는 사용자가 의도하지 않은 요청을 서버에 보내는 공격입니다. Cookie에 Refresh Token을 저장할 때 필요한 방어 방법입니다.

// 방법 1: SameSite Cookie 설정 (서버에서)
// Set-Cookie: refreshToken=...; HttpOnly; Secure; SameSite=Strict

// 방법 2: CSRF 토큰 함께 전송
axiosPrivate.interceptors.request.use((config) => {
  const csrfToken = document
    .querySelector('meta[name="csrf-token"]')
    ?.getAttribute('content');
  if (csrfToken) {
    config.headers['X-CSRF-Token'] = csrfToken;
  }
  return config;
});

토큰 만료 전 자동 갱신

만료 직전에 미리 갱신해서 UX 중단 없이 세션을 유지할 수 있습니다.

useEffect(() => {
  if (!accessToken) return;

  // Access Token 만료 1분 전 자동 갱신
  const REFRESH_BEFORE = 60 * 1000; // 1분
  const ACCESS_TOKEN_EXPIRY = 15 * 60 * 1000; // 15분

  const timer = setTimeout(async () => {
    try {
      const newToken = await refreshAccessToken();
      sessionStorage.setItem('accessToken', newToken);
    } catch {
      // 갱신 실패 시 로그아웃
      logout();
    }
  }, ACCESS_TOKEN_EXPIRY - REFRESH_BEFORE);

  return () => clearTimeout(timer);
}, [accessToken]);

프로덕션 체크리스트

보안
 ✅ Access Token 유효기간 15분~1시간으로 설정
 ✅ Refresh Token은 HttpOnly Cookie에 저장
 ✅ Cookie에 Secure + SameSite=Strict 설정
 ✅ HTTPS 사용 (필수)
 ✅ Payload에 민감 정보 포함 금지

구현
 ✅ Axios 인터셉터로 토큰 자동 갱신
 ✅ 동시 요청 중 갱신 중복 방지 (failedQueue)
 ✅ _retry 플래그로 무한 루프 방지
 ✅ 로그아웃 시 Access Token 삭제 + 서버에 Refresh Token 만료 요청
 ✅ 초기화 시 Refresh Token으로 Access Token 자동 복구

12. Vue.js에서의 구현 (Composition API)

React 외에 Vue 3에서도 동일한 패턴을 Composable로 구현할 수 있습니다.

// src/composables/useAuth.ts
import { ref, computed } from 'vue';
import { useRouter } from 'vue-router';
import { login as apiLogin, logout as apiLogout } from '@/api/auth';

const user = ref<{ id: number; email: string; name: string } | null>(null);

export const useAuth = () => {
  const router = useRouter();
  const isAuthenticated = computed(() => !!user.value);

  const login = async (email: string, password: string) => {
    const response = await apiLogin({ email, password });
    sessionStorage.setItem('accessToken', response.accessToken);
    user.value = response.user;
    router.push('/dashboard');
  };

  const logout = async () => {
    try {
      await apiLogout();
    } finally {
      sessionStorage.removeItem('accessToken');
      user.value = null;
      router.push('/login');
    }
  };

  return { user, isAuthenticated, login, logout };
};

참고 자료

Next.js 정리

Wed, 10 Jul 2024 00:00:00 GMT

Next.js는 React 기반의 풀스택 웹 프레임워크로, SSR(서버사이드 렌더링), SSG(정적 사이트 생성), API Routes 등을 기본적으로 지원합니다. Vercel이 개발하고 있으며, 현재 가장 많이 사용되는 React 프레임워크 중 하나입니다.

왜 Next.js를 사용하는가?

순수 React(CRA)는 클라이언트에서만 렌더링되는 SPA 방식이라 아래와 같은 문제가 있습니다.

SEO 취약: 초기 HTML이 비어 있어 검색 엔진이 콘텐츠를 읽기 어려움
느린 초기 로딩: JS 번들을 모두 내려받은 후에야 화면이 그려짐
API 서버 별도 필요: 백엔드 기능을 위해 Express 등 별도 서버 구성 필요

Next.js는 이 문제를 서버에서 HTML을 미리 생성하는 방식으로 해결합니다.

초기 세팅

# 프로젝트 생성 (App Router, TypeScript 기준)
npx create-next-app@latest my-app
cd my-app
npm run dev

설치 시 대화형 옵션이 나타납니다:

Would you like to use TypeScript?  → Yes
Would you like to use ESLint?      → Yes
Would you like to use Tailwind CSS? → 선택
Would you like to use App Router?  → Yes (권장)

프로젝트 구조

my-next-app/
├── app/                  ← App Router 루트
│   ├── layout.tsx        ← 전체 공통 레이아웃
│   ├── page.tsx          ← 루트 페이지 (/)
│   ├── globals.css
│   └── [slug]/           ← 동적 라우트
│       └── page.tsx
├── components/           ← 재사용 컴포넌트
├── public/               ← 정적 파일 (이미지, favicon 등)
├── lib/                  ← 유틸 함수, API 호출
├── next.config.js        ← Next.js 설정
├── tsconfig.json
└── package.json

App Router vs Pages Router

Next.js 13부터 도입된 App Router가 현재 공식 권장 방식입니다.

구분	App Router	Pages Router
디렉토리	`app/`	`pages/`
기본 컴포넌트	Server Component	Client Component
레이아웃	`layout.tsx` 중첩	`_app.tsx` 단일
데이터 패칭	`fetch()` 직접 사용	`getStaticProps` 등
로딩/에러 처리	`loading.tsx`, `error.tsx`	직접 구현

라우팅 (App Router 기준)

Next.js는 파일 시스템 기반 라우팅을 사용합니다. 폴더 구조가 곧 URL 구조입니다.

기본 라우팅

app/
├── page.tsx          →  /
├── about/
│   └── page.tsx      →  /about
└── blog/
    └── page.tsx      →  /blog

동적 라우팅

app/
└── blog/
    └── [slug]/
        └── page.tsx  →  /blog/:slug

// app/blog/[slug]/page.tsx
interface Props {
  params: { slug: string }
}

export default function BlogPost({ params }: Props) {
  return <h1>포스트: {params.slug}</h1>
}

중첩 레이아웃

// app/layout.tsx — 모든 페이지에 적용되는 루트 레이아웃
export default function RootLayout({ children }: { children: React.ReactNode }) {
  return (
    <html lang="ko">
      <body>
        <header>공통 헤더</header>
        <main>{children}</main>
        <footer>공통 푸터</footer>
      </body>
    </html>
  )
}

특수 파일

파일명	역할
`page.tsx`	해당 경로의 UI
`layout.tsx`	공통 레이아웃 (children 포함)
`loading.tsx`	로딩 중 표시할 UI
`error.tsx`	에러 발생 시 표시할 UI
`not-found.tsx`	404 페이지

렌더링 방식

SSG (Static Site Generation)

빌드 시 HTML을 미리 생성합니다. 가장 빠르고 CDN 캐싱이 가능합니다.

// App Router에서의 SSG (기본값)
// fetch 시 cache: 'force-cache'가 기본
async function getData() {
  const res = await fetch('https://api.example.com/posts', {
    cache: 'force-cache'  // SSG: 빌드 시 한 번만 fetch
  })
  return res.json()
}

export default async function Page() {
  const data = await getData()
  return <div>{data.title}</div>
}

SSR (Server-Side Rendering)

요청마다 서버에서 HTML을 생성합니다. 항상 최신 데이터를 보여줄 수 있습니다.

// App Router에서의 SSR
async function getData() {
  const res = await fetch('https://api.example.com/posts', {
    cache: 'no-store'  // SSR: 매 요청마다 새로 fetch
  })
  return res.json()
}

export default async function Page() {
  const data = await getData()
  return <div>{data.title}</div>
}

ISR (Incremental Static Regeneration)

SSG로 생성된 페이지를 주기적으로 재생성합니다. 정적 성능 + 데이터 최신성을 모두 잡을 수 있습니다.

// App Router에서의 ISR
async function getData() {
  const res = await fetch('https://api.example.com/posts', {
    next: { revalidate: 60 }  // 60초마다 재생성
  })
  return res.json()
}

export default async function Page() {
  const data = await getData()
  return <div>{data.title}</div>
}

CSR (Client-Side Rendering)

브라우저에서 데이터를 직접 fetch합니다. 자주 변경되는 인터랙티브한 UI에 적합합니다.

'use client'  // Client Component 선언 필수

import { useState, useEffect } from 'react'

export default function Page() {
  const [data, setData] = useState(null)

  useEffect(() => {
    fetch('/api/posts')
      .then(res => res.json())
      .then(setData)
  }, [])

  if (!data) return <p>로딩 중...</p>
  return <div>{data.title}</div>
}

Server Component vs Client Component

App Router의 가장 큰 특징은 기본적으로 모든 컴포넌트가 Server Component라는 점입니다.

구분	Server Component	Client Component
선언	기본값 (별도 선언 없음)	`'use client'` 선언 필요
실행 환경	서버	브라우저
DB/파일 접근	✅ 가능	❌ 불가
useState/useEffect	❌ 불가	✅ 가능
이벤트 핸들러	❌ 불가	✅ 가능
번들 크기	JS 번들에 미포함	JS 번들에 포함

// Server Component (기본값) — DB 직접 접근 가능
async function UserProfile() {
  const user = await db.user.findUnique({ where: { id: 1 } })
  return <p>{user.name}</p>
}

// Client Component — 인터랙션 처리 가능
'use client'
import { useState } from 'react'

function Counter() {
  const [count, setCount] = useState(0)
  return <button onClick={() => setCount(c => c + 1)}>{count}</button>
}

API Routes

Next.js는 백엔드 API도 같은 프로젝트에서 작성할 수 있습니다.

// app/api/posts/route.ts
import { NextRequest, NextResponse } from 'next/server'

// GET /api/posts
export async function GET(request: NextRequest) {
  const posts = [
    { id: 1, title: '첫 번째 포스트' },
    { id: 2, title: '두 번째 포스트' },
  ]
  return NextResponse.json(posts)
}

// POST /api/posts
export async function POST(request: NextRequest) {
  const body = await request.json()
  // DB 저장 로직
  return NextResponse.json({ message: '생성 완료', data: body }, { status: 201 })
}

이미지 최적화

Next.js의 <Image> 컴포넌트는 자동으로 이미지를 최적화합니다.

import Image from 'next/image'

export default function Page() {
  return (
    <Image
      src="/profile.jpg"      // public/ 폴더 기준
      alt="프로필 이미지"
      width={500}
      height={300}
      priority                // LCP 이미지에 사용
    />
  )
}

자동 WebP/AVIF 변환
뷰포트 기반 lazy loading
CLS(레이아웃 이동) 방지를 위한 사전 크기 지정

링크와 내비게이션

import Link from 'next/link'
import { useRouter } from 'next/navigation'  // App Router

export default function Nav() {
  const router = useRouter()

  return (
    <nav>
      {/* 정적 링크 */}
      <Link href="/about">소개</Link>
      <Link href="/blog">블로그</Link>

      {/* 프로그래매틱 이동 */}
      <button onClick={() => router.push('/dashboard')}>
        대시보드로
      </button>
    </nav>
  )
}

환경 변수

# .env.local
DATABASE_URL=postgres://...
NEXT_PUBLIC_API_URL=https://api.example.com  # 클라이언트에서도 접근 가능
SECRET_KEY=my-secret                          # 서버에서만 접근 가능

// 서버에서만 사용
const db = process.env.DATABASE_URL

// 클라이언트에서 사용 (NEXT_PUBLIC_ 접두사 필수)
const apiUrl = process.env.NEXT_PUBLIC_API_URL

미들웨어

요청이 처리되기 전에 실행되는 코드로, 인증 체크나 리다이렉션에 활용합니다.

// middleware.ts (루트에 위치)
import { NextResponse } from 'next/server'
import type { NextRequest } from 'next/server'

export function middleware(request: NextRequest) {
  const token = request.cookies.get('token')

  // 로그인 안 된 경우 로그인 페이지로 리다이렉트
  if (!token && request.nextUrl.pathname.startsWith('/dashboard')) {
    return NextResponse.redirect(new URL('/login', request.url))
  }

  return NextResponse.next()
}

export const config = {
  matcher: ['/dashboard/:path*'],  // 적용할 경로
}

next.config.js 주요 설정

/** @type {import('next').NextConfig} */
const nextConfig = {
  // 외부 이미지 도메인 허용
  images: {
    remotePatterns: [
      {
        protocol: 'https',
        hostname: 'example.com',
      },
    ],
  },

  // 리다이렉트 설정
  async redirects() {
    return [
      {
        source: '/old-path',
        destination: '/new-path',
        permanent: true,
      },
    ]
  },

  // 환경 변수 노출
  env: {
    APP_VERSION: '1.0.0',
  },
}

module.exports = nextConfig

배포

Next.js 프로젝트는 여러 환경에 배포할 수 있습니다.

Vercel (권장, 무료)

npm install -g vercel
vercel

직접 서버 배포

npm run build   # 프로덕션 빌드
npm run start   # 서버 실행

Docker

FROM node:18-alpine
WORKDIR /app
COPY package*.json ./
RUN npm install
COPY . .
RUN npm run build
EXPOSE 3000
CMD ["npm", "start"]

벨만-포드(Bellman-Ford) 알고리즘

Sat, 06 Jul 2024 00:00:00 GMT

벨만-포드(Bellman-Ford) 알고리즘은 한 노드에서 다른 모든 노드까지의 최단 거리를 구하는 알고리즘입니다. 다익스트라와 달리 간선의 가중치가 음수인 경우에도 최단 거리를 구할 수 있으며, 음수 순환(Negative Cycle)의 존재 여부도 감지할 수 있습니다.

벨만-포드 vs 다익스트라

두 알고리즘 모두 단일 출발점 최단 경로를 구하지만, 동작 방식과 적용 가능한 상황이 다릅니다.

아래 그래프를 예시로 비교해봅니다.

노드: 1, 2, 3
간선: 1→3 (비용 10), 1→2 (비용 20), 2→3 (비용 -15)

1번 노드에서 3번 노드까지의 최단 경로는 육안으로 보면 1→2→3 (비용: 20 + (-15) = 5)입니다.

그러나 다익스트라는 방문하지 않은 노드 중 거리가 가장 짧은 노드를 선택하므로, 먼저 비용이 10인 1→3 경로를 선택해버립니다. 음수 간선이 있으면 이처럼 잘못된 결과가 나올 수 있습니다.

반면 벨만-포드는 매 반복마다 모든 간선을 전부 확인하므로 1→2→3 경로를 올바르게 탐색해 최단 거리 5를 구할 수 있습니다.

구분	다익스트라	벨만-포드
탐색 방식	최단 거리 노드 우선 선택	매 반복마다 모든 간선 확인
음수 가중치	❌ 사용 불가	✅ 사용 가능
음수 순환 감지	❌ 불가	✅ 가능
시간 복잡도	O(E log V)	O(VE)

모든 간선의 가중치가 양수라면 다익스트라, 음수 간선이 포함되어 있다면 벨만-포드를 사용합니다.

음수 순환(Negative Cycle)이란?

음수 순환은 순환 경로의 총 비용이 음수인 경우를 말합니다.

예시: 2→3 (비용 2), 3→5 (비용 1), 5→2 (비용 -4)
     2→3→5→2의 총 비용 = 2 + 1 + (-4) = -1

이 경우 순환을 계속 반복할수록 비용이 무한히 줄어들기 때문에 최단 거리를 정의할 수 없습니다. 따라서 벨만-포드 알고리즘은 최단 거리 탐색 이후 음수 순환 존재 여부를 반드시 확인해야 합니다.

동작 단계

출발 노드를 설정하고 거리를 0으로, 나머지 노드의 거리는 무한대(INF)로 초기화합니다.
아래 과정을 (V - 1)번 반복합니다. (V = 정점의 수)
1. 모든 간선 E개를 하나씩 확인합니다.
2. 각 간선을 거쳐 다른 노드로 가는 비용을 계산해 최단 거리 테이블을 갱신합니다.
V번째 반복에서도 거리 테이블이 갱신된다면 음수 순환이 존재하는 것입니다.

V - 1번 반복하는 이유: 최단 경로는 최대 V - 1개의 간선으로 이루어지기 때문입니다. V - 1번 반복 후에는 모든 노드의 최단 거리가 확정됩니다.

동작 예시

아래 그래프에서 1번 노드를 출발점으로 최단 거리를 구합니다.

노드: 1, 2, 3, 4, 5
간선: 1→2 (1), 1→3 (4), 2→3 (2), 2→4 (5), 3→4 (1), 4→5 (-3)

라운드	2	3	4	5
초기	∞	∞	∞	∞
1라운드	1	3	4	∞
2라운드	1	3	4	1
3라운드	1	3	4	1
4라운드	1	3	4	1

4라운드(V - 1번째)에서 더 이상 갱신이 없으므로 음수 순환은 없으며, 최단 거리가 확정됩니다.

Python 구현

import sys

INF = int(1e9)

def bellman_ford(start, v, edges):
    # 최단 거리 테이블 초기화
    distance = [INF] * (v + 1)
    distance[start] = 0

    # V - 1번 반복 (+ 1번은 음수 순환 감지용)
    for i in range(v):
        for cur_node, next_node, edge_cost in edges:
            # 현재 노드에 도달할 수 있고, 더 짧은 경로가 존재하면 갱신
            if distance[cur_node] != INF and distance[next_node] > distance[cur_node] + edge_cost:
                distance[next_node] = distance[cur_node] + edge_cost
                # V번째 라운드에서도 갱신된다면 음수 순환 존재
                if i == v - 1:
                    return None  # 음수 순환 존재

    return distance


# 사용 예시 (BOJ 11657)
def main():
    input_data = sys.stdin.readline
    v, e = map(int, input_data().split())

    edges = []
    for _ in range(e):
        a, b, c = map(int, input_data().split())
        edges.append((a, b, c))

    result = bellman_ford(1, v, edges)

    if result is None:
        # 음수 순환 존재
        print(-1)
    else:
        for i in range(2, v + 1):
            if result[i] == INF:
                print(-1)  # 도달 불가
            else:
                print(result[i])


main()

코드 흐름 설명

for i in range(v):               # V번 반복 (V-1번 탐색 + 1번 음수 순환 감지)
    for cur, nxt, cost in edges: # 모든 간선 확인
        if distance[cur] != INF and distance[nxt] > distance[cur] + cost:
            distance[nxt] = distance[cur] + cost
            if i == v - 1:       # V번째 라운드에서 갱신 = 음수 순환
                return None

핵심 조건인 distance[cur] != INF는 아직 출발점에서 도달하지 못한 노드를 통해 잘못된 갱신이 일어나는 것을 방지합니다.

시간 복잡도

연산	시간 복잡도
전체	O(VE)
V번 반복 × E개 간선 확인	O(V) × O(E) = O(VE)

다익스트라(O(E log V))보다 느리지만, 음수 가중치와 음수 순환까지 처리할 수 있다는 점에서 활용 범위가 넓습니다.

최단 경로 알고리즘 종합 비교

알고리즘	음수 가중치	음수 순환 감지	시간 복잡도	특징
다익스트라	❌	❌	O(E log V)	단일 출발점, 빠름
벨만-포드	✅	✅	O(VE)	단일 출발점, 음수 처리
플로이드-워샬	✅	✅	O(V³)	모든 쌍 최단 경로

TypeScript 실전 정리

Mon, 01 Jul 2024 00:00:00 GMT

JavaScript에 타입을 추가한 TypeScript는 이제 프론트엔드 개발의 사실상 표준이 됐습니다. 단순히 타입 에러를 잡는 것 이상으로, 코드의 의도를 명확히 하고 리팩토링을 안전하게 해주는 도구입니다. 이 포스트에서는 기본 타입부터 제네릭, 유틸리티 타입, 고급 타입까지 실무에서 바로 써먹을 수 있는 내용을 정리합니다.

1. TypeScript 타입 시스템 전체 맵

TypeScript의 타입은 크게 4가지 영역으로 나눌 수 있습니다.

Primitive Types (원시 타입)

const name: string   = "mingyu"
const age: number    = 25
const isActive: boolean = true
const nothing: null  = null
const undef: undefined = undefined
const sym: symbol    = Symbol("id")
const big: bigint    = 9007199254740991n

특수 타입 — any / unknown / never / void

실무에서 가장 자주 혼동되는 타입들입니다.

// any — 타입 검사를 완전히 포기. 사용 지양
let data: any = "hello"
data = 42         // OK
data.foo.bar      // OK (런타임 에러 가능)

// unknown — 타입 안전한 any. 사용 전 반드시 타입 확인 필요
let input: unknown = getInput()
input.toUpperCase()                    // ❌ 컴파일 에러
if (typeof input === "string") {
  input.toUpperCase()                  // ✅ 타입 좁힌 후 사용
}

// never — 절대 도달할 수 없는 타입 (무한 루프, 항상 throw)
function fail(message: string): never {
  throw new Error(message)
}

// void — 반환값이 없는 함수
function log(msg: string): void {
  console.log(msg)
  // return 없음
}

리터럴 타입 & 유니온

// 특정 값만 허용
type Direction = "left" | "right" | "up" | "down"
type StatusCode = 200 | 400 | 404 | 500

// 리터럴 타입으로 정교한 함수 시그니처
function move(direction: Direction, speed: number): void {
  console.log(`Moving ${direction} at speed ${speed}`)
}

move("left", 10)     // ✅
move("diagonal", 10) // ❌ 컴파일 에러

2. interface vs type

interface

객체의 구조를 정의하는 데 최적화된 방식입니다. 선언 병합(Declaration Merging) 이 가능한 것이 가장 큰 특징입니다.

interface User {
  id: number
  name: string
  email: string
  age?: number       // 선택적 프로퍼티
  readonly createdAt: Date  // 읽기 전용
}

// 확장 (상속)
interface AdminUser extends User {
  role: "admin" | "superadmin"
  permissions: string[]
}

// 선언 병합 — 같은 이름으로 두 번 선언하면 합쳐짐
interface Window {
  title: string
}
interface Window {
  version: number
}
// 결과: Window = { title: string; version: number }

type alias

유니온, 인터섹션, 맵드 타입 등 더 복잡한 타입을 표현할 때 사용합니다.

// 유니온 타입
type ID = string | number

// 인터섹션 타입
type AdminUser = User & { role: string }

// 튜플
type Coordinate = [number, number]
type RGB = [number, number, number]

// 함수 타입
type Formatter = (value: string) => string

// 리터럴 유니온
type Theme = "light" | "dark" | "system"

선택 기준

상황	추천
객체 구조, 클래스 구현체 정의	`interface`
라이브러리 공개 API	`interface` (선언 병합 활용)
유니온 / 인터섹션 타입	`type`
맵드 / 조건부 타입	`type`
원시 타입, 튜플, 함수 타입	`type`

3. 제네릭 (Generics)

제네릭은 타입을 파라미터처럼 받아서 재사용 가능한 코드를 만드는 방법입니다.

기본 제네릭 함수

// T는 호출 시 결정되는 타입 플레이스홀더
function identity<T>(arg: T): T {
  return arg
}

identity<string>("hello")  // T = string, 반환값도 string
identity<number>(42)       // T = number, 반환값도 number
identity("auto")           // T 자동 추론 → string

제네릭 인터페이스 & 클래스

// API 응답 래퍼 타입 — 어떤 데이터든 감쌀 수 있음
interface ApiResponse<T> {
  data: T
  status: number
  message: string
  timestamp: string
}

// 사용
type UserResponse  = ApiResponse<User>
type PostsResponse = ApiResponse<Post[]>

// 제네릭 클래스
class Stack<T> {
  private items: T[] = []

  push(item: T): void {
    this.items.push(item)
  }

  pop(): T | undefined {
    return this.items.pop()
  }

  peek(): T | undefined {
    return this.items[this.items.length - 1]
  }

  get size(): number {
    return this.items.length
  }
}

const numStack = new Stack<number>()
numStack.push(1)
numStack.push(2)
numStack.pop()   // 2

제네릭 제약 (extends)

// T가 반드시 length 프로퍼티를 가져야 함
function getLength<T extends { length: number }>(arg: T): number {
  return arg.length
}

getLength("hello")    // ✅ string.length = 5
getLength([1, 2, 3])  // ✅ array.length = 3
getLength(42)         // ❌ number는 length 없음

// keyof 제약 — 실제 키만 허용
function getProperty<T, K extends keyof T>(obj: T, key: K): T[K] {
  return obj[key]
}

const user = { id: 1, name: "Mingyu", age: 25 }
getProperty(user, "name")  // ✅ "Mingyu"
getProperty(user, "email") // ❌ 존재하지 않는 키

여러 개의 타입 파라미터

function merge<T extends object, U extends object>(obj1: T, obj2: U): T & U {
  return { ...obj1, ...obj2 }
}

const result = merge({ name: "Mingyu" }, { age: 25 })
// result: { name: string; age: number }

4. 유틸리티 타입 (Utility Types)

TypeScript에 내장된 타입 변환 도구들입니다. 기존 타입을 변형해 새 타입을 만들 수 있습니다.

// 예제에 사용할 기본 인터페이스
interface User {
  id: number
  name: string
  email: string
  age?: number
  password: string
}

Partial / Required / Readonly

// Partial<T> — 모든 프로퍼티를 선택적으로
type UpdateUserDto = Partial<User>
// { id?: number; name?: string; email?: string; ... }

function updateUser(id: number, data: Partial<User>) {
  // 일부 필드만 업데이트 가능
}

// Required<T> — 모든 선택적 프로퍼티를 필수로
type CompleteUser = Required<User>
// age도 반드시 있어야 함

// Readonly<T> — 모든 프로퍼티를 읽기 전용으로
type ImmutableUser = Readonly<User>
const user: ImmutableUser = { id: 1, name: "Mingyu", email: "...", password: "..." }
user.name = "Kim" // ❌ 컴파일 에러

Pick / Omit

// Pick<T, K> — 특정 키만 선택
type UserPreview = Pick<User, "id" | "name">
// { id: number; name: string }

// Omit<T, K> — 특정 키만 제거
type PublicUser = Omit<User, "password">
// { id: number; name: string; email: string; age?: number }

// API 응답에서 민감한 정보 제외할 때 유용
function getPublicProfile(user: User): PublicUser {
  const { password, ...rest } = user
  return rest
}

Record

// Record<K, V> — 키-값 맵 타입 생성
type UserMap = Record<string, User>
const users: UserMap = {
  "user_1": { id: 1, name: "Mingyu", email: "...", password: "..." },
  "user_2": { id: 2, name: "Gyumin", email: "...", password: "..." },
}

// 상태 타입 정의에도 유용
type PageStatus = Record<"home" | "about" | "blog", "loading" | "ready" | "error">

Exclude / Extract / NonNullable / ReturnType

// Exclude<T, U> — 유니온에서 특정 타입 제거
type WithoutNull = Exclude<string | number | null | undefined, null | undefined>
// string | number

// Extract<T, U> — 유니온에서 특정 타입만 추출
type OnlyStrings = Extract<string | number | boolean, string | boolean>
// string | boolean

// NonNullable<T> — null / undefined 제거
type SafeString = NonNullable<string | null | undefined>
// string

// ReturnType<T> — 함수의 반환 타입 추출
function createUser() {
  return { id: 1, name: "Mingyu" }
}
type CreatedUser = ReturnType<typeof createUser>
// { id: number; name: string }

// Parameters<T> — 함수의 파라미터 타입 추출
function login(email: string, password: string): boolean {
  return true
}
type LoginParams = Parameters<typeof login>
// [email: string, password: string]

5. 타입 가드 & 타입 좁히기 (Type Narrowing)

유니온 타입에서 특정 타입으로 좁히는 방법들입니다.

typeof / instanceof

function format(val: string | number): string {
  if (typeof val === "string") {
    return val.toUpperCase()   // val: string
  }
  return val.toFixed(2)        // val: number
}

function handleError(err: Error | TypeError) {
  if (err instanceof TypeError) {
    console.log("Type Error:", err.message)  // err: TypeError
  }
  throw err  // err: Error
}

in 연산자

interface Cat { meow(): void; purr(): void }
interface Dog { bark(): void; fetch(): void }

function makeSound(pet: Cat | Dog): void {
  if ("meow" in pet) {
    pet.meow()   // pet: Cat
  } else {
    pet.bark()   // pet: Dog
  }
}

사용자 정의 타입 가드 (Type Predicate)

// 반환 타입에 'val is Type' 형식으로 명시
function isUser(val: unknown): val is User {
  return (
    typeof val === "object" &&
    val !== null &&
    "id" in val &&
    "name" in val
  )
}

function processResponse(data: unknown) {
  if (isUser(data)) {
    console.log(data.name)  // data: User — 타입 안전!
  }
}

Discriminated Union (판별 유니온)

// 공통 리터럴 필드('kind')로 타입 구분
interface Circle  { kind: "circle";  radius: number }
interface Square  { kind: "square";  side: number }
interface Triangle{ kind: "triangle"; base: number; height: number }

type Shape = Circle | Square | Triangle

function getArea(shape: Shape): number {
  switch (shape.kind) {
    case "circle":
      return Math.PI * shape.radius ** 2   // shape: Circle
    case "square":
      return shape.side ** 2               // shape: Square
    case "triangle":
      return (shape.base * shape.height) / 2
    default:
      // 모든 케이스를 처리했는지 컴파일 타임에 확인
      const _exhaustive: never = shape
      return _exhaustive
  }
}

6. 고급 타입

맵드 타입 (Mapped Types)

기존 타입의 모든 키를 순회해 새 타입을 만드는 방법입니다. 유틸리티 타입(Partial, Readonly 등)이 내부적으로 이 방식으로 구현되어 있습니다.

// Partial 직접 구현
type MyPartial<T> = {
  [K in keyof T]?: T[K]
}

// Readonly 직접 구현
type MyReadonly<T> = {
  readonly [K in keyof T]: T[K]
}

// 모든 값을 string으로 변환
type Stringify<T> = {
  [K in keyof T]: string
}

// 선택적 → 필수로 (- 연산자로 modifier 제거)
type Concrete<T> = {
  [K in keyof T]-?: T[K]
}

조건부 타입 (Conditional Types)

// T extends U ? X : Y 형태
type IsString<T> = T extends string ? true : false

type A = IsString<string>   // true
type B = IsString<number>   // false

// 실용 예시: 배열 요소 타입 추출
type ElementType<T> = T extends (infer U)[] ? U : never

type E1 = ElementType<string[]>   // string
type E2 = ElementType<number[]>   // number
type E3 = ElementType<string>     // never

// Promise 언래핑
type Awaited<T> = T extends Promise<infer U> ? U : T

type P = Awaited<Promise<string>>   // string
type Q = Awaited<string>            // string (그대로)

템플릿 리터럴 타입

type EventName = "click" | "focus" | "blur"
type HandlerName = `on${Capitalize<EventName>}`
// "onClick" | "onFocus" | "onBlur"

type CSSProperty = "margin" | "padding"
type CSSDirection = "Top" | "Right" | "Bottom" | "Left"
type CSSPropertyWithDirection = `${CSSProperty}${CSSDirection}`
// "marginTop" | "marginRight" | ... | "paddingBottom" | "paddingLeft"

7. 실전 패턴

API 응답 타입 정의

// 성공/실패를 구분하는 Result 타입
type Result<T, E = Error> =
  | { success: true;  data: T }
  | { success: false; error: E }

async function fetchUser(id: number): Promise<Result<User>> {
  try {
    const res = await fetch(`/api/users/${id}`)
    const data = await res.json()
    return { success: true, data }
  } catch (error) {
    return { success: false, error: error as Error }
  }
}

// 사용
const result = await fetchUser(1)
if (result.success) {
  console.log(result.data.name)   // result.data: User
} else {
  console.error(result.error)     // result.error: Error
}

깊은 Readonly (DeepReadonly)

type DeepReadonly<T> = {
  readonly [K in keyof T]: T[K] extends object
    ? DeepReadonly<T[K]>
    : T[K]
}

interface Config {
  server: { host: string; port: number }
  db: { url: string; name: string }
}

const config: DeepReadonly<Config> = {
  server: { host: "localhost", port: 3000 },
  db: { url: "postgres://...", name: "mydb" },
}

config.server.host = "prod.example.com"  // ❌ 중첩 객체도 수정 불가

Builder 패턴 with TypeScript

class QueryBuilder<T extends object> {
  private conditions: Partial<T> = {}

  where<K extends keyof T>(key: K, value: T[K]): this {
    this.conditions[key] = value
    return this  // this를 반환해 메서드 체이닝 가능
  }

  build(): Partial<T> {
    return this.conditions
  }
}

const query = new QueryBuilder<User>()
  .where("name", "Mingyu")
  .where("age", 25)
  .build()
// { name: "Mingyu", age: 25 }

8. 자주 하는 실수

1. as 단언 남용

// ❌ as로 강제 단언 — 런타임 에러 가능
const user = getUser() as User

// ✅ 타입 가드로 안전하게 확인
const data = getUser()
if (isUser(data)) {
  // data: User — 안전
}

2. any 대신 unknown 사용

// ❌ any는 타입 검사를 완전히 포기
function parse(data: any) {
  return data.user.name  // 런타임 에러 가능
}

// ✅ unknown은 사용 전 타입 확인 강제
function parse(data: unknown) {
  if (typeof data === "object" && data !== null && "user" in data) {
    // 여기서만 안전하게 접근 가능
  }
}

3. 옵셔널 체이닝과 타입의 불일치

interface Post {
  author?: {
    name: string
    avatar?: string
  }
}

// ❌ 런타임 에러 가능
function getAvatar(post: Post): string {
  return post.author.avatar  // author가 undefined일 수 있음
}

// ✅ 옵셔널 체이닝 + 기본값
function getAvatar(post: Post): string {
  return post.author?.avatar ?? "default.png"
}

4. 제네릭 타입 추론 방해

// ❌ 반환 타입을 any[]로 직접 명시 → 추론 포기
function getItems(): any[] {
  return [1, "hello", true]
}

// ✅ as const + 반환 타입 자동 추론
function getItems() {
  return [1, "hello", true] as const
  // readonly [1, "hello", true] — 리터럴 타입 유지
}

참고 자료

다익스트라(Dijkstra) 알고리즘

Sun, 05 May 2024 00:00:00 GMT

다익스트라(Dijkstra) 알고리즘은 그래프에서 하나의 출발 노드로부터 다른 모든 노드까지의 최단 경로를 구하는 알고리즘입니다. 매번 방문하지 않은 노드 중 최단 거리인 노드를 선택해 탐색을 반복하는 방식으로 동작합니다.

최소 비용을 구하는 그래프 알고리즘으로는 다익스트라 외에도 벨만-포드, 플로이드-워샬 알고리즘이 있습니다.

동작 단계

출발 노드와 도착 노드를 설정합니다.
최단 거리 테이블을 무한대(inf)로 초기화하고, 출발 노드의 거리는 0으로 설정합니다.
방문하지 않은 노드 중 거리값이 가장 작은 노드를 선택하고 방문 처리합니다.
해당 노드를 거쳐 인접 노드로 가는 비용을 계산해 최단 거리 테이블을 업데이트합니다.
3~4 과정을 모든 노드를 방문할 때까지 반복합니다.

동작 예시

아래 그래프에서 노드 1 → 노드 6까지의 최단 경로를 구해봅니다.

노드: 1, 2, 3, 4, 5, 6
간선: 1-2(2), 1-4(1), 2-3(3), 2-4(2), 4-5(1), 5-6(2), 3-6(5)

단계	선택 노드	2	3	4	5	6
초기	-	∞	∞	∞	∞	∞
1	1	2	∞	1	∞	∞
2	4	2	∞	1	2	∞
3	2	2	5	1	2	∞
4	5	2	5	1	2	4
5	6	2	5	1	2	4

최종 결과: 1 → 4 → 5 → 6, 최단 거리 4

핵심 특징

한 번 방문한 노드의 최단 거리는 이후에 더 작은 값으로 갱신되지 않습니다.
간선의 가중치가 반드시 양수여야 합니다. 음수 가중치가 있으면 이미 방문한 노드가 더 짧은 경로로 갱신될 수 있어 알고리즘이 올바르게 동작하지 않습니다.
음수 가중치가 존재하는 경우에는 벨만-포드 알고리즘을 사용해야 합니다.

구현 방법 1: 순차 탐색

방문하지 않은 노드 중 거리값이 가장 작은 노드를 앞에서부터 순차적으로 탐색해 찾습니다.

시간 복잡도: O(N²) — 노드 수가 N일 때 각 노드마다 N번 순차 탐색

C++ 구현

#include <vector>
#include <climits>
using namespace std;

const int INF = INT_MAX;
int N;  // 노드 개수
int dist[101];
bool visited[101];
int map[101][101];

// 방문하지 않은 노드 중 거리값이 가장 작은 노드 반환
int findSmallestNode() {
    int min_dist = INF;
    int min_idx = -1;
    for (int i = 1; i <= N; i++) {
        if (visited[i]) continue;
        if (dist[i] < min_dist) {
            min_dist = dist[i];
            min_idx = i;
        }
    }
    return min_idx;
}

void dijkstra(int start) {
    // 시작 노드와 인접한 정점에 대해 거리 초기화
    for (int i = 1; i <= N; i++)
        dist[i] = map[start][i];

    dist[start] = 0;
    visited[start] = true;

    for (int i = 0; i < N - 1; i++) {
        int new_node = findSmallestNode();
        visited[new_node] = true;

        for (int j = 1; j <= N; j++) {
            if (visited[j]) continue;
            if (dist[j] > dist[new_node] + map[new_node][j])
                dist[j] = dist[new_node] + map[new_node][j];
        }
    }
}

Python 구현

import sys
INF = sys.maxsize

def dijkstra_sequential(start, n, graph):
    dist = [INF] * (n + 1)
    visited = [False] * (n + 1)
    dist[start] = 0

    for _ in range(n):
        # 방문하지 않은 노드 중 거리값이 가장 작은 노드 선택
        cur = -1
        for i in range(1, n + 1):
            if not visited[i] and (cur == -1 or dist[i] < dist[cur]):
                cur = i

        visited[cur] = True

        for nxt, weight in graph[cur]:
            if dist[cur] + weight < dist[nxt]:
                dist[nxt] = dist[cur] + weight

    return dist

# 사용 예시
n = 6  # 노드 수
graph = [[] for _ in range(n + 1)]
graph[1].extend([(2, 2), (4, 1)])
graph[2].extend([(3, 3), (4, 2)])
graph[4].extend([(5, 1)])
graph[5].extend([(6, 2)])
graph[3].extend([(6, 5)])

dist = dijkstra_sequential(1, n, graph)
print(dist[6])  # 4

구현 방법 2: 우선순위 큐 (개선된 방법)

최소 힙(Min Heap) 기반의 우선순위 큐를 활용해 매번 거리값이 가장 작은 노드를 O(log N)에 꺼냅니다. 순차 탐색 방식보다 훨씬 빠릅니다.

시간 복잡도: O(E log V) — 간선 수 E, 노드 수 V
방문 여부 배열 없이도 동작합니다. 꺼낸 노드의 거리가 현재 저장된 거리보다 크면 그냥 무시하면 됩니다.
우선순위 큐에는 (거리, 노드) 형태로 삽입합니다.

C++ 구현

#include <vector>
#include <queue>
#include <iostream>
using namespace std;

#define INF 99999999

vector<int> dijkstra(int start, int N, vector<pair<int, int>> graph[]) {
    vector<int> dist(N + 1, INF);
    // C++ priority_queue는 최대 힙이므로 거리에 음수를 붙여 최소 힙처럼 사용
    priority_queue<pair<int, int>> pq;

    dist[start] = 0;
    pq.push({0, start});

    while (!pq.empty()) {
        int cur_dist = -pq.top().first;
        int cur_node = pq.top().second;
        pq.pop();

        // 이미 처리된 노드라면 무시
        if (cur_dist > dist[cur_node]) continue;

        for (auto [nxt_node, weight] : graph[cur_node]) {
            int nxt_dist = cur_dist + weight;
            if (nxt_dist < dist[nxt_node]) {
                dist[nxt_node] = nxt_dist;
                pq.push({-nxt_dist, nxt_node});
            }
        }
    }

    return dist;
}

Python 구현

import heapq
import sys
INF = sys.maxsize

def dijkstra(start, n, graph):
    dist = [INF] * (n + 1)
    dist[start] = 0

    # 최소 힙: (거리, 노드)
    heap = [(0, start)]

    while heap:
        cur_dist, cur_node = heapq.heappop(heap)

        # 이미 더 짧은 경로로 처리된 노드라면 무시
        if cur_dist > dist[cur_node]:
            continue

        for nxt_node, weight in graph[cur_node]:
            nxt_dist = cur_dist + weight
            if nxt_dist < dist[nxt_node]:
                dist[nxt_node] = nxt_dist
                heapq.heappush(heap, (nxt_dist, nxt_node))

    return dist

# 사용 예시
n = 6
graph = [[] for _ in range(n + 1)]
graph[1].extend([(2, 2), (4, 1)])
graph[2].extend([(3, 3), (4, 2)])
graph[4].extend([(5, 1)])
graph[5].extend([(6, 2)])
graph[3].extend([(6, 5)])

dist = dijkstra(1, n, graph)
print(dist[6])  # 4

두 구현 방법 비교

구분	순차 탐색	우선순위 큐
시간 복잡도	O(N²)	O(E log V)
적합한 상황	노드 수가 적을 때	노드/간선 수가 많을 때
방문 배열	필요	불필요
구현 난이도	쉬움	보통

노드 수가 적은 경우(N ≤ 1,000)에는 순차 탐색도 충분하지만, 일반적으로는 우선순위 큐 방식을 사용하는 것이 좋습니다.

다익스트라 vs 다른 최단 경로 알고리즘

알고리즘	음수 가중치	시간 복잡도	특징
다익스트라	❌	O(E log V)	단일 출발점 최단 경로
벨만-포드	✅	O(VE)	음수 사이클 감지 가능
플로이드-워샬	✅	O(V³)	모든 쌍 최단 경로

이진 탐색 (Binary Search)

Sun, 17 Mar 2024 00:00:00 GMT

업다운 게임을 떠올려보면 이진 탐색의 원리가 바로 보입니다. 1~100 사이 숫자를 맞출 때 50부터 시작해서 "UP / DOWN"에 따라 절반씩 범위를 좁혀가는 방식이 바로 이진 탐색입니다. 이번 포스트에서는 이진 탐색의 개념부터 구현 방법, Python의 bisect 라이브러리 활용법까지 정리합니다.

1. 이진 탐색이란?

이진 탐색(Binary Search) 은 정렬된 데이터에서 특정 값을 찾는 알고리즘입니다. 탐색 범위를 절반씩 줄여 나가기 때문에 매우 빠릅니다.

전제 조건: 반드시 정렬된 상태여야 합니다.

선형 탐색과의 비교

선형 탐색은 처음부터 하나씩 비교하는 O(n) 방식인 반면, 이진 탐색은 매 단계마다 탐색 범위를 절반으로 줄이는 O(log n) 방식입니다.

	선형 탐색	이진 탐색
시간복잡도	O(n)	O(log n)
정렬 필요 여부	불필요	필수
n = 1,000	최대 1,000번	최대 10번
n = 1,000,000	최대 100만번	최대 20번

n이 100만이어도 단 20번 비교로 탐색이 끝납니다.

2. 동작 원리

배열 [2, 5, 8, 12, 16, 23, 38, 45, 56, 72]에서 target = 23 을 찾는 과정입니다.

초기 상태: left=0, right=9

Step 1: mid = (0+9)//2 = 4  →  arr[4] = 16
        16 < 23  →  left = mid+1 = 5

Step 2: mid = (5+9)//2 = 7  →  arr[7] = 45
        45 > 23  →  right = mid-1 = 6

Step 3: mid = (5+6)//2 = 5  →  arr[5] = 23
        23 == 23  →  Found! index = 5

3번의 비교만으로 10개 배열에서 값을 찾았습니다.

3. Python 구현

반복문 (Iterative)

def binary_search(arr, target):
    left, right = 0, len(arr) - 1

    while left <= right:
        mid = (left + right) // 2

        if arr[mid] == target:
            return mid           # 찾으면 인덱스 반환
        elif arr[mid] < target:
            left = mid + 1       # 오른쪽 절반 탐색
        else:
            right = mid - 1      # 왼쪽 절반 탐색

    return -1  # 없으면 -1 반환


arr = [2, 5, 8, 12, 16, 23, 38, 45, 56, 72]
print(binary_search(arr, 23))   # 5
print(binary_search(arr, 10))   # -1

재귀 (Recursive)

def binary_search_recursive(arr, target, left, right):
    if left > right:
        return -1  # 탐색 범위가 없으면 종료

    mid = (left + right) // 2

    if arr[mid] == target:
        return mid
    elif arr[mid] < target:
        return binary_search_recursive(arr, target, mid + 1, right)
    else:
        return binary_search_recursive(arr, target, left, mid - 1)


arr = [2, 5, 8, 12, 16, 23, 38, 45, 56, 72]
print(binary_search_recursive(arr, 23, 0, len(arr)-1))  # 5

재귀 방식은 코드가 간결하지만, n이 매우 클 경우 Python의 재귀 깊이 제한에 걸릴 수 있습니다. 실무에서는 반복문 방식을 권장합니다.

4. 경계값 탐색 — Lower Bound / Upper Bound

이진 탐색의 가장 실용적인 응용입니다. 중복된 값이 있을 때 가장 왼쪽/오른쪽 위치 를 찾습니다.

Lower Bound (하한) — 같거나 큰 첫 번째 위치

def lower_bound(arr, target):
    """target 이상인 값이 처음 등장하는 인덱스 반환"""
    left, right = 0, len(arr)  # right = len(arr) 주의!

    while left < right:        # left < right (등호 없음)
        mid = (left + right) // 2
        if arr[mid] < target:
            left = mid + 1
        else:
            right = mid        # mid 포함해서 왼쪽 탐색

    return left


arr = [1, 2, 3, 4, 4, 4, 6, 8, 9]
print(lower_bound(arr, 4))   # 3  ← 4가 처음 나오는 위치
print(lower_bound(arr, 5))   # 6  ← 5 이상인 값(6)의 첫 위치

Upper Bound (상한) — 초과하는 첫 번째 위치

def upper_bound(arr, target):
    """target 초과인 값이 처음 등장하는 인덱스 반환"""
    left, right = 0, len(arr)

    while left < right:
        mid = (left + right) // 2
        if arr[mid] <= target:  # <= 에 주의 (lower_bound와 차이)
            left = mid + 1
        else:
            right = mid

    return left


arr = [1, 2, 3, 4, 4, 4, 6, 8, 9]
print(upper_bound(arr, 4))   # 6  ← 4 초과인 값(6)의 첫 위치

특정 값의 개수 구하기

Lower/Upper Bound를 이용하면 O(log n) 으로 특정 값의 개수를 셀 수 있습니다.

def count_value(arr, target):
    return upper_bound(arr, target) - lower_bound(arr, target)

arr = [1, 2, 3, 4, 4, 4, 6, 8, 9]
print(count_value(arr, 4))   # 3  ← 4가 3개
print(count_value(arr, 5))   # 0  ← 5가 없음

5. Python bisect 라이브러리

Python은 이진 탐색을 위한 bisect 내장 라이브러리를 제공합니다. Lower/Upper Bound를 직접 구현하지 않아도 됩니다.

from bisect import bisect_left, bisect_right

bisect_left(a, x)

정렬 상태를 유지하면서 x를 삽입할 수 있는 가장 왼쪽 인덱스 반환 = Lower Bound

from bisect import bisect_left

array = [1, 2, 3, 4, 4, 6, 8, 9]
print(bisect_left(array, 4))   # 3
#  [1, 2, 3, (4), 4, 4, 6, 8, 9]  ← 인덱스 3

bisect_right(a, x)

정렬 상태를 유지하면서 x를 삽입할 수 있는 가장 오른쪽 인덱스 반환 = Upper Bound

from bisect import bisect_right

array = [1, 2, 3, 4, 4, 6, 8, 9]
print(bisect_right(array, 4))  # 5
#  [1, 2, 3, 4, 4, (4), 6, 8, 9]  ← 인덱스 5

범위 내 원소 개수 구하기

from bisect import bisect_left, bisect_right

def count_by_range(a, left_val, right_val):
    """[left_val, right_val] 범위에 포함되는 원소 개수"""
    right_idx = bisect_right(a, right_val)
    left_idx  = bisect_left(a, left_val)
    return right_idx - left_idx

array = [1, 2, 3, 4, 4, 6, 8, 9]

print(count_by_range(array, -1, 3))  # 3  →  1, 2, 3
print(count_by_range(array, 4, 4))   # 2  →  4, 4
print(count_by_range(array, 4, 7))   # 3  →  4, 4, 6

bisect로 정렬 삽입

from bisect import insort_left, insort_right

array = [1, 3, 5, 7]
insort_left(array, 4)   # 정렬 유지하며 삽입
print(array)            # [1, 3, 4, 5, 7]

6. 이진 탐색 응용 — 파라메트릭 서치

이진 탐색은 단순히 값을 찾는 것 외에도 "조건을 만족하는 최솟값/최댓값" 을 구하는 파라메트릭 서치(Parametric Search)에 자주 사용됩니다.

"중간 지점의 값이 조건을 만족하는가?" 를 이진 탐색으로 반복해 최적값을 좁혀 나가는 방식

# 예시: 떡을 최소 M만큼 얻으려면 절단기 높이를 최대 얼마로 설정해야 하는가?
def can_cut(heights, h, target):
    """절단기 높이 h로 잘랐을 때 얻는 떡의 총량 >= target?"""
    total = sum(max(0, rice - h) for rice in heights)
    return total >= target

def solution(heights, target):
    left, right = 0, max(heights)
    answer = 0

    while left <= right:
        mid = (left + right) // 2
        if can_cut(heights, mid, target):
            answer = mid        # 조건 만족 → 더 높은 높이 시도
            left = mid + 1
        else:
            right = mid - 1     # 조건 불만족 → 더 낮은 높이 시도

    return answer

heights = [19, 15, 10, 17]
print(solution(heights, 6))   # 15

7. 주의할 점

1. 반드시 정렬 후 사용

arr = [5, 2, 8, 1, 9]
# ❌ 정렬 없이 이진 탐색 → 잘못된 결과
# ✅ 정렬 후 사용
arr.sort()
result = binary_search(arr, 8)

2. right 초기값에 주의

# 값 탐색 (정확한 인덱스 찾기)
left, right = 0, len(arr) - 1   # right = n-1
while left <= right:             # 등호 포함

# Lower/Upper Bound (경계 탐색)
left, right = 0, len(arr)        # right = n (범위 밖)
while left < right:              # 등호 없음

3. mid 계산 시 오버플로우

Python은 정수 오버플로우가 없지만, 다른 언어에서는 아래처럼 작성합니다.

# ❌ 다른 언어에서 오버플로우 가능
mid = (left + right) // 2

# ✅ 안전한 방식
mid = left + (right - left) // 2

8. 관련 백준 문제

문제	난이도	핵심 기법
1920 수 찾기	Silver IV	이진 탐색 기본
10816 숫자 카드 2	Silver IV	bisect / Lower·Upper Bound
2805 나무 자르기	Silver II	파라메트릭 서치
2110 공유기 설치	Gold IV	파라메트릭 서치
1300 K번째 수	Gold II	이진 탐색 응용

참고 자료

다이나믹 프로그래밍 (Dynamic Programming)

Thu, 04 Jan 2024 00:00:00 GMT

다이나믹 프로그래밍(Dynamic Programming, DP)은 복잡한 문제를 더 작은 하위 문제로 나누어 해결하는 알고리즘 설계 기법입니다. 핵심은 한 번 계산한 결과를 저장해두고 재사용함으로써 중복 계산을 줄이는 것입니다.

알고리즘 설계 기법이란 문제 해결을 위한 전략이나 접근 방식을 의미합니다. 분할 정복, DP, 탐욕 알고리즘, 백트래킹 등이 대표적인 예입니다.

DP vs 단순 재귀

얼핏 비슷해 보이지만 둘은 접근 방향과 중복 처리 방식에서 차이가 있습니다.

구분	단순 재귀	DP
접근 방향	하향식 (Top-Down)	주로 상향식 (Bottom-Up)
중복 계산	그대로 반복	메모이제이션으로 방지
속도	느릴 수 있음	빠름

DP 적용 조건

DP를 사용하려면 아래 두 조건을 모두 만족해야 합니다.

1. 중복되는 부분 문제 (Overlapping Subproblems)

동일한 작은 문제가 반복해서 등장해야 합니다. DP는 이 반복되는 계산 결과를 저장해두고 재활용합니다.

2. 최적 부분 구조 (Optimal Substructure)

부분 문제의 최적 결과가 전체 문제의 최적 결과를 만들어낼 수 있어야 합니다.

예를 들어 A → B까지의 최단 경로를 구할 때, 중간 노드 X를 지난다면 A→X 구간과 X→B 구간이 각각 최단 경로여야만 전체 A→X→B도 최단 경로가 됩니다.

DP 풀이 방법

핵심 두 가지

메모이제이션 배열 만들기 — 결과를 저장할 배열(dp)을 선언하고, 계산할 때마다 값을 저장합니다.
점화식 세우기 — 변수 간의 관계식을 정의합니다. 예: 피보나치 수열의 f(n) = f(n-1) + f(n-2)

Bottom-Up (Tabulation) — 반복문 사용

작은 부분 문제부터 차례대로 해결하며 전체 답을 구합니다. 직관적이고 스택 오버플로우 위험이 없습니다.

Top-Down (Memoization) — 재귀 사용

큰 문제를 재귀로 쪼개 내려가면서, 이미 계산한 값은 저장해두고 재사용합니다. 구현이 간결하지만 재귀 호출 오버헤드가 발생할 수 있습니다.

대표 문제

1. 피보나치 수열 — Top-Down 방식

재귀 + 메모이제이션을 사용해 중복 계산을 방지합니다.

def fibonacci(n, memo={}):
    if n in memo:
        return memo[n]
    if n <= 1:
        return n

    # 결과를 저장해두고 재사용
    memo[n] = fibonacci(n - 1, memo) + fibonacci(n - 2, memo)
    return memo[n]

print(fibonacci(10))  # 55

Bottom-Up 방식으로도 구현할 수 있습니다:

def fibonacci_bottom_up(n):
    if n <= 1:
        return n

    dp = [0] * (n + 1)
    dp[1] = 1

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

    return dp[n]

print(fibonacci_bottom_up(10))  # 55

2. 배낭 문제 (Knapsack Problem) — Bottom-Up 방식

주어진 가방 용량 내에서 최대 가치의 물건을 담는 문제입니다.

def knapsack(weights, values, capacity):
    n = len(weights)

    # dp[i][j] = i번째 물건까지 고려했을 때 용량 j에서의 최대 가치
    dp = [[0] * (capacity + 1) for _ in range(n + 1)]

    for i in range(1, n + 1):
        for j in range(1, capacity + 1):
            if weights[i - 1] > j:
                # 현재 물건을 넣을 수 없는 경우
                dp[i][j] = dp[i - 1][j]
            else:
                # 현재 물건을 넣는 경우 vs 넣지 않는 경우 중 최대값
                dp[i][j] = max(dp[i - 1][j], dp[i - 1][j - weights[i - 1]] + values[i - 1])

    return dp[n][capacity]

weights = [2, 3, 4, 5]
values = [3, 4, 5, 6]
capacity = 7

print(knapsack(weights, values, capacity))  # 9

3. 최장 증가 부분 수열 (LIS) — Bottom-Up 방식

주어진 수열에서 순서를 유지하면서 가장 긴 증가하는 부분 수열의 길이를 구합니다.

def lis(nums):
    n = len(nums)

    # dp[i] = nums[i]를 마지막 원소로 하는 LIS의 길이
    dp = [1] * n

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

    return max(dp)

nums = [10, 9, 2, 5, 3, 7, 101, 18]
print(lis(nums))  # 4  →  [2, 5, 7, 101] 또는 [2, 3, 7, 101]

4. 최단 경로 문제 — Bottom-Up 방식

그래프에서 시작 노드부터 모든 노드까지의 최단 거리를 구합니다. (다익스트라 기반)

import heapq

def shortest_path(graph, start):
    n = len(graph)
    dp = [float('inf')] * n
    dp[start] = 0

    heap = [(0, start)]  # (거리, 노드)

    while heap:
        dist, node = heapq.heappop(heap)

        if dist > dp[node]:
            continue

        for next_node, weight in enumerate(graph[node]):
            if weight != 0 and dp[node] + weight < dp[next_node]:
                dp[next_node] = dp[node] + weight
                heapq.heappush(heap, (dp[next_node], next_node))

    return dp

graph = [
    [0, 4, 2, 0],
    [4, 0, 1, 5],
    [2, 1, 0, 8],
    [0, 5, 8, 0]
]

result = shortest_path(graph, 0)
print(result[3])  # 8  →  0→2→1→3 경로 (2+1+5)

5. 문자열 편집 거리 (Edit Distance) — Bottom-Up 방식

두 문자열 간의 최소 편집 횟수(삽입, 삭제, 대체)를 구합니다.

def edit_distance(str1, str2):
    m, n = len(str1), len(str2)

    # dp[i][j] = str1의 앞 i글자와 str2의 앞 j글자 사이의 최소 편집 거리
    dp = [[0] * (n + 1) for _ in range(m + 1)]

    for i in range(m + 1):
        dp[i][0] = i  # str2가 빈 문자열이면 전부 삭제
    for j in range(n + 1):
        dp[0][j] = j  # str1이 빈 문자열이면 전부 삽입

    for i in range(1, m + 1):
        for j in range(1, n + 1):
            if str1[i - 1] == str2[j - 1]:
                dp[i][j] = dp[i - 1][j - 1]
            else:
                dp[i][j] = 1 + min(
                    dp[i - 1][j],      # 삭제
                    dp[i][j - 1],      # 삽입
                    dp[i - 1][j - 1]   # 대체
                )

    return dp[m][n]

print(edit_distance("kitten", "sitting"))  # 3

Bottom-Up vs Top-Down 비교

구분	Bottom-Up	Top-Down
구현 방식	반복문	재귀 + 메모이제이션
속도	빠름	재귀 오버헤드 있음
스택 오버플로우	없음	깊이 깊으면 위험
불필요한 계산	모든 부분 문제 계산	필요한 것만 계산
직관성	높음	점화식이 명확할 때 더 간결

DP 장단점

장점

중복 계산을 제거해 시간 복잡도를 크게 줄일 수 있습니다.
최적 부분 구조를 보장하는 문제에서 항상 최적해를 구할 수 있습니다.

단점

중간 결과를 저장하기 위해 추가 메모리가 필요합니다.
점화식을 세우는 것이 어렵고, 문제에 따라 접근 방식이 크게 달라집니다.

Ref: 동적계획법(Dynamic Programming)