김신건의 로그 - 위키 / algorithm

UTF-8 인코딩

koa (김신건) — Sat, 18 Jul 2026 00:00:00 GMT

정의

UTF-8 은 Unicode code point (0~~0x10FFFF) 를 1~~4 byte 가변 길이로 인코딩하는 방식. 1993년 ISO/IEC 10646 표준의 일부로 도입, 현재 웹에서 가장 널리 쓰이는 문자 인코딩. ASCII (0~0x7F) 는 1 byte 로 동일하게 표현되어 하위 호환성이 완벽.

UTF-8 의 두 가지 핵심 속성:

자기 동기화 (Self-synchronizing): 스트림 중간부터 읽어도 다음 문자 시작점을 1 byte 만에 찾을 수 있음.
ASCII 호환: 영문/숫자/기호 (U+0000~U+007F) 는 UTF-8 과 ASCII 가 동일한 byte 값. 기존 ASCII 시스템과 완전 호환.

문제 상황과 동기

Unicode 는 149,000 개 이상의 문자에 정수 ID(code point) 를 할당했지만, 메모리에 어떻게 저장할 것인가 가 별도 문제.

UTF-32: 모든 code point 를 4 byte 로. 간단하지만 메모리 4배 낭비. ASCII 텍스트도 문자당 4 byte.
UTF-16: BMP(Basic Multilingual Plane, U+0000~U+FFFF) 는 2 byte, 그 이상은 surrogate pair 로 4 byte. Java/C# 내부 표현. 하지만 ASCII 도 2 byte.
UTF-8: ASCII 는 1 byte, 그 외 언어권은 2~4 byte. 웹 페이지의 98% 가 UTF-8 사용. 파일 크기 최적 + ASCII 호환.

핵심 통찰: 선두 바이트의 상위 비트 패턴 으로 총 바이트 수를 알 수 있고, 연속 바이트는 항상 10xxxxxx 형태로 sync 가능.

시각화

{}

인코딩 규칙

flowchart TD
    Input["Unicode code point (U+XXXX)"]
    Input --> R1{"U+0000 ~ U+007F?"}
    R1 -->|Yes| B1["1 byte: 0xxxxxxx (ASCII 호환)"]
    R1 -->|No| R2{"U+0080 ~ U+07FF?"}
    R2 -->|Yes| B2["2 bytes: 110xxxxx 10xxxxxx"]
    R2 -->|No| R3{"U+0800 ~ U+FFFF?"}
    R3 -->|Yes| B3["3 bytes: 1110xxxx 10xxxxxx 10xxxxxx"]
    R3 -->|No| B4["4 bytes: 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx"]

핵심 아이디어

UTF-8 은 자기 동기화(self-synchronizing) 인코딩. 바이트 스트림 중간부터 읽어도 다음 문자 시작점을 찾을 수 있음.

Code point 범위	Byte 1	Byte 2	Byte 3	Byte 4	표현 가능 비트
U+0000 ~ U+007F	`0xxxxxxx`	-	-	-	7 bit
U+0080 ~ U+07FF	`110xxxxx`	`10xxxxxx`	-	-	11 bit
U+0800 ~ U+FFFF	`1110xxxx`	`10xxxxxx`	`10xxxxxx`	-	16 bit
U+10000 ~ U+10FFFF	`11110xxx`	`10xxxxxx`	`10xxxxxx`	`10xxxxxx`	21 bit

선두 바이트: 선두의 0 개수 = 전체 바이트 수 (1바이트는 0 시작으로 구분).
연속 바이트: 항상 10 으로 시작. 선두 바이트와 절대 혼동되지 않음.
Code point 비트는 x 자리에 MSB부터 순서대로 채움.

한글 ‘가’ (U+AC00) 인코딩 예시

U+AC00 = 1010 1100 0000 0000 (binary)

3 byte 범위 (U+0800 ~ U+FFFF):
  Byte 1: 1110xxxx  -> 1110 1010 = 0xEA
  Byte 2: 10xxxxxx  -> 10 110000 = 0xB0
  Byte 3: 10xxxxxx  -> 10 000000 = 0x80

결과: EA B0 80

알고리즘

encode(cp):
    if cp < 0x80:
        output [ cp ]                              # 0xxxxxxx
    else if cp < 0x800:
        output [ 0xC0 | (cp >> 6),                  # 110xxxxx
                 0x80 | (cp & 0x3F) ]               # 10xxxxxx
    else if cp < 0x10000:
        output [ 0xE0 | (cp >> 12),                 # 1110xxxx
                 0x80 | ((cp >> 6) & 0x3F),          # 10xxxxxx
                 0x80 | (cp & 0x3F) ]                # 10xxxxxx
    else:
        output [ 0xF0 | (cp >> 18),                 # 11110xxx
                 0x80 | ((cp >> 12) & 0x3F),         # 10xxxxxx
                 0x80 | ((cp >> 6) & 0x3F),           # 10xxxxxx
                 0x80 | (cp & 0x3F) ]                 # 10xxxxxx

decode(bytes):
    n = leading_ones(bytes[0])  # 선두 1 개수 (0이면 1바이트)
    if n == 0: return bytes[0]
    cp = bytes[0] & (0x7F >> n)  # 선두 바이트에서 x bits 추출
    for i = 1..n-1:
        assert (bytes[i] & 0xC0) == 0x80  # 10xxxxxx 검증
        cp = (cp << 6) | (bytes[i] & 0x3F)
    return cp

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // code point -> UTF-8 bytes hex 출력 #include <bits/stdc++.h> using namespace std; int main() { unsigned cp = 0xAC00; // '가' unsigned char b[4]; int n; if (cp < 0x80) { b[0] = cp; n = 1; } else if (cp < 0x800) { b[0] = 0xC0 | (cp >> 6); b[1] = 0x80 | (cp & 0x3F); n = 2; } else if (cp < 0x10000) { b[0] = 0xE0 | (cp >> 12); b[1] = 0x80 | ((cp >> 6) & 0x3F); b[2] = 0x80 | (cp & 0x3F); n = 3; } else { b[0] = 0xF0 | (cp >> 18); b[1] = 0x80 | ((cp >> 12) & 0x3F); b[2] = 0x80 | ((cp >> 6) & 0x3F); b[3] = 0x80 | (cp & 0x3F); n = 4; } printf("U+%04X -> %d bytes:", cp, n); for (int i = 0; i < n; i++) printf(" %02X", b[i]); printf("\\n"); }, }, { language: “python”, label: “Python”, code: `# chr().encode(‘utf-8’) 로 손쉽게 인코딩 cp = 0xAC00 # ‘가’ encoded = chr(cp).encode(‘utf-8’) print(f”U+{cp:04X} -> {len(encoded)} bytes:”, ’ ‘.join(f’{b:02X}’ for b in encoded))

decode: bytes -> code point

decoded = int.from_bytes(encoded, ‘big’)

UTF-8 decode 규칙으로 복원

n = 0 while decoded >> (7 - n) & 1: n += 1 # leading 1 count if n == 0: result = decoded else: mask = (1 << (7 - n)) - 1 result = decoded & mask # … 실제 decode 는 byte 단위 shift 필요 print(f”decode back: U+{cp:04X}“), }, { language: "java", label: "Java", code: import java.nio.charset.StandardCharsets; public class Main { public static void main(String[] args) { int cp = 0xAC00; // ‘가’ String s = new String(new int[]{cp}, 0, 1); byte[] utf8 = s.getBytes(StandardCharsets.UTF_8); System.out.printf(“U+%04X -> %d bytes:”, cp, utf8.length); for (byte b : utf8) System.out.printf(” %02X”, b & 0xFF); System.out.println(); } }, }, ]} cases={[ { label: "Code Point -> UTF-8 bytes", input: ``, output: U+AC00 -> 3 bytes: EA B0 80`, }, ]} />

복잡도

항목	값
인코딩 (code point -> bytes)	O(1) (최대 4 byte)
디코딩 (bytes -> code point)	O(1)
바이트 수 판별	O(1) (선두 바이트만 확인)
검증 (valid UTF-8 여부)	O(N) (전체 스트림 순회)

변형 / 활용

UTF-8 signature (BOM)

일부 Windows 프로그램이 파일 앞에 EF BB BF (BOM, Byte Order Mark) 를 붙임. Unix/Linux 에서는 불필요하며 오히려 문제.

UTF-8 vs UTF-16 vs UTF-32

항목	UTF-8	UTF-16	UTF-32
ASCII 크기	1 byte	2 byte	4 byte
CJK (한중일)	3 byte	2 byte	4 byte
자기 동기화	가능	불가 (surrogate 깨짐)	가능
웹 점유율	98%	2%	0% 미만

Overlong encoding

code point 를 더 긴 바이트 수로 인코딩하는 것. 예: ASCII ‘A’(0x41) 를 0xC1 0x81 로. 보안 취약점 (유효성 검사 우회) 이므로 모든 구현이 이를 거부해야 함 (RFC 3629).

경쟁 표준 비교

flowchart LR
    Web["웹 / 파일 저장"]
    Java["Java / C# 내부"]
    DB["DB (MySQL utf8mb4)"]
    Emoji["이모지 포함 텍스트"]
    Web -->|"UTF-8 (사실상 표준)"| UTF8["UTF-8"]
    Java -->|"char = 2byte"| UTF16["UTF-16"]
    DB -->|"4byte emoji 지원"| UTF8mb4["UTF-8 (mb4)"]
    Emoji -->|"U+1F600 = 4byte"| UTF8

함정

1. 연속 바이트 검증 누락

디코더가 10xxxxxx 검증을 안 하면 임의 바이트를 문자로 오인. UTF-8 validity 체크 필수.

# 잘못된 bytes 를 무조건 decode 하면 UnicodeDecodeError 또는 오염된 결과
b = bytes([0xEA, 0xFF, 0x80])  # 두 번째 바이트가 10xxxxxx 아님
# Python: b.decode('utf-8') -> UnicodeDecodeError (strict mode)
# b.decode('utf-8', errors='ignore') -> 조용히 건너뜀

2. 5/6 byte sequence (CESU-8 / old UTF-8)

초기 UTF-8 은 5~6 byte (0xFC, 0xFD 선두) 를 허용했으나 RFC 3629 에서 폐지. 상호운용성 문제의 원인.

3. WTF-8 / CESU-8

Oracle / Java 가 쓰는 modified UTF-8 (CESU-8) 은 surrogate pair 를 별도 인코딩. 일반 UTF-8 과 혼동 금지.

4. Windows ANSI vs UTF-8

Windows 의 MultiByteToWideChar(CP_ACP) 는 시스템 로케일 인코딩이지 UTF-8 이 아님. CP_UTF8 명시 필요.

5. MySQL utf8 vs utf8mb4

MySQL 의 utf8 charset 은 최대 3 byte 만 지원 (이모지 4 byte 저장 불가). 반드시 utf8mb4 를 사용해야 한다.

-- 잘못 (이모지 저장 실패)
CREATE TABLE t (col VARCHAR(255) CHARACTER SET utf8);

-- 올바름
CREATE TABLE t (col VARCHAR(255) CHARACTER SET utf8mb4 COLLATE utf8mb4_unicode_ci);

6. len() vs 문자 수

Python len(s) 는 code point 수, len(s.encode('utf-8')) 은 byte 수. 한글 1글자는 code point 1개지만 3 byte.

s = "한글"
print(len(s))               # 2 (code points)
print(len(s.encode('utf-8'))) # 6 (bytes)

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11654	아스키 코드	71.2%	kokoa-lab
BOJ 10809	알파벳 찾기	58.7%	kokoa-lab
BOJ 11720	숫자의 합	62.3%	kokoa-lab
BOJ 10824	네 수	28.5%	kokoa-lab

참고

[[String|문자열]]
[[Regex|정규 표현식]]
[[Parsing|파싱]]

값 / 좌표 압축 (Coordinate Compression)

koa (김신건) — Sat, 18 Jul 2026 00:00:00 GMT

정의

값 / 좌표 압축 (Coordinate Compression) 은 큰 범위의 값 (예: 10^9) 을 정렬된 순서를 유지하며 작은 정수 인덱스 (0..K-1) 로 매핑하는 기법. K = unique value count.

이 기법의 핵심 속성:

순서 보존: 원래 값의 대소 관계가 압축 후에도 동일하게 유지.
가역성: uniq[compressed[i]] == original[i] 로 언제든 복원 가능.
크기 축소: 범위 10^9 → K ≤ N 으로, 희소한 값들을 연속 인덱스로 변환.

문제 상황과 동기

값의 범위가 10^9 이고 입력 크기가 10^5 라면, Fenwick tree 나 segment tree 를 값 자체를 인덱스로 사용할 수 없음. 압축하면 희소한 값들을 연속된 인덱스로 바꾸어 배열 기반 자료구조를 사용 가능.

핵심 통찰: 상대 순서만 중요하지 절대값은 중요하지 않다. 값을 정렬하고 중복 제거한 뒤, 각 값의 순위(index)가 곧 압축된 좌표.

언제 좌표 압축이 필요한가?

flowchart TD
    Start["입력 값 범위가 크다 (10^8 이상)"]
    Start --> Q1{"배열/트리에 값을<br/>직접 인덱스로 쓸 것?"}
    Q1 -->|No| End1["압축 불필요"]
    Q1 -->|Yes| Q2{"입력 크기 N"}
    Q2 -->|"N <= 10^7"| End2["직접 배열 가능"]
    Q2 -->|"N 이 작고 값이 크다"| CC["좌표 압축 적용"]
    CC --> DS["Fenwick, Segment Tree, BIT, 카운팅 배열 등 사용 가능"]

시각화

{}

핵심 아이디어

1. unique = sort(unique(set(original)))   // 정렬 + 중복 제거
2. for each value v in original:
     compressed[v] = lower_bound(unique, v)
     // unique[compressed[v]] == v

압축 후에는 unique[compressed[i]] 로 원래 값을 복원 가능.

알고리즘

compress(a[]):
    sorted = sort unique values of a
    for each x in a:
        idx = lower_bound(sorted, x)
        print idx    // 0-based compressed coordinate

// 예: a = [-5, 10^9, 0, -5, 42]
// sorted = [-5, 0, 42, 10^9]
// compressed = [0, 3, 1, 0, 2]

단계별 흐름

flowchart LR
    A["원본 배열\n[-5, 10^9, 0, -5, 42]"]
    B["유니크 정렬\n[-5, 0, 42, 10^9]"]
    C["이진 탐색 매핑\n[0, 3, 1, 0, 2]"]
    A -->|"sort + unique"| B
    B -->|"lower_bound"| C
    C --> R["Fenwick/SegTree 에 사용"]

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Coordinate compression: O(N log N) #include <bits/stdc++.h> using namespace std;

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

int n; cin >> n;
vector<int> a(n);
for (auto& v : a) cin >> v;

// 1. Extract unique sorted values
vector<int> uniq = a;
sort(uniq.begin(), uniq.end());
uniq.erase(unique(uniq.begin(), uniq.end()), uniq.end());

// 2. Map each original value to compressed index
for (auto& v : a) {
    v = (int)(lower_bound(uniq.begin(), uniq.end(), v)
              - uniq.begin());
    cout << v << " ";
}
cout << "\\n";

// Reconstruct original: uniq[compressed[i]]
// for (auto v : a) cout << uniq[v] << " ";

}, }, { language: "python", label: "Python", code: # Coordinate compression: O(N log N) import sys input = sys.stdin.readline from bisect import bisect_left

n = int(input()) a = list(map(int, input().split()))

1. Extract unique sorted values

uniq = sorted(set(a))

2. Map each value to compressed index

compressed = [bisect_left(uniq, v) for v in a] print(*compressed)

uniq[compressed[i]] == original a[i]`,

},
{
  language: "java",
  label: "Java",
  code: `// Coordinate compression: O(N log N)

public class Main { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader( new InputStreamReader(System.in)); int n = Integer.parseInt(br.readLine()); int[] a = new int[n]; StringTokenizer st = new StringTokenizer(br.readLine()); for (int i = 0; i < n; i++) a[i] = Integer.parseInt(st.nextToken());

    // 1. Extract unique sorted values
    int[] sorted = a.clone();
    Arrays.sort(sorted);
    int k = 1;
    for (int i = 1; i < n; i++)
        if (sorted[i] != sorted[k - 1])
            sorted[k++] = sorted[i];

    // 2. Binary search for compression
    StringBuilder sb = new StringBuilder();
    for (int v : a) {
        int idx = Arrays.binarySearch(sorted, 0, k, v);
        sb.append(idx).append(' ');
    }
    System.out.println(sb);
}

}, }, ]} cases={[ { label: "기본 압축", input: 7 -5 1000000000 0 -5 42 999999999 0, output: 0 4 1 0 2 3 1, }, { label: "중복 없음", input: 5 100 200 300 400 500, output: 0 1 2 3 4`, }, ]} />

복잡도

항목	값
시간	O(N log N)
공간 (unique 배열)	O(K), K = unique value count
압축 크기	K ≤ N
복원 (index → value)	O(1), `uniq[idx]`

변형 / 활용

적용처	설명
Fenwick / Segment Tree	좌표 압축 후 값 범위가 10^9 → 10^5 로 축소
Mo’s algorithm	값 범위를 압축해 카운팅 배열 사용 가능
Sweeping	x, y 좌표를 각각 압축해 격자로 변환
LIS	음수/큰 값 좌표를 순위로 변환해 O(N log N) LIS
2D 압축	x, y 각각 압축해 희소 2D 그리드 구성

LIS 와 조합 예시

LIS (Longest Increasing Subsequence) 에서 좌표 압축을 자주 활용한다.

// 값 범위가 크거나 음수를 포함하는 경우
a = [100, -5, 200, -5, 50]

// 압축 후
compressed = [2, 0, 3, 0, 1]

// 이제 Fenwick tree 크기 = K = 4 로 LIS 계산 가능

2D 압축

2D 좌표 문제에서 x, y 를 각각 독립적으로 압축한다. 결과로 (최대 N)×(최대 N) 크기의 2D 배열/트리를 사용 가능.

points = [(10^9, 10^8), (5, 3), (10^9, 3)]
xs = compress([10^9, 5, 10^9])  -> [1, 0, 1]
ys = compress([10^8, 3, 3])     -> [1, 0, 0]
// 결과: (1,1), (0,0), (1,0) -> 3x2 그리드

함정

1. 중복 제거 누락

unique() 또는 set() 으로 중복을 제거하지 않으면, 같은 값이 여러 인덱스를 가져 Fenwick 트리에서 overflow / 잘못된 결과.

// 잘못된 예: sort만 하고 unique 안 함
vector<int> uniq = a;
sort(uniq.begin(), uniq.end());
// uniq = [-5, -5, 0, 42, 10^9] -- 중복 있음!
// -5 의 lower_bound = 0, -5 의 second occurrence = index 1
// 같은 값 두 개가 다른 인덱스를 가짐 -> 오류

2. lower_bound 대신 map 사용

Python 의 dict 나 C++ 의 unordered_map 을 쓰면 O(1) mapping 이 가능하지만, 순서가 필요한 경우 (구간 쿼리, Fenwick) 는 정렬 배열 + binary search 가 필수.

# 경우에 따라 dict 도 OK (순서 필요 없을 때)
rank = {v: i for i, v in enumerate(sorted(set(a)))}
compressed = [rank[v] for v in a]
# 단: range query 에서는 인덱스 순서가 의미를 가져야 하므로 이 방식이 더 명확

3. 0-based vs 1-based

Fenwick tree 는 1-based index 가 필요. 압축 결과가 0-based (lower_bound 기본) 이면 compressed[i] + 1 사용.

// Fenwick tree 와 함께 사용 시
int idx = lower_bound(uniq.begin(), uniq.end(), v) - uniq.begin();
fenwick.update(idx + 1, 1);  // 1-based!

4. 쿼리 값도 함께 압축해야 할 때

범위 쿼리 [L, R] 에서 L, R 도 압축된 인덱스 공간으로 변환해야 한다. 원본 배열과 쿼리 값을 합쳐서 압축하거나, L 에는 lower_bound, R 에는 upper_bound 를 적절히 사용.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 18870	좌표 압축	-	kokoa-lab
BOJ 1015	수열 정렬	-	kokoa-lab
BOJ 12015	가장 긴 증가하는 부분 수열 2	-	kokoa-lab
BOJ 10815	숫자 카드	-	kokoa-lab

참고

[[Binary Search|이분 탐색]]
[[Fenwick Tree|펜윅 트리]]
[[Mo|Mo’s 알고리즘]]
[[Sweeping|스위핑]]

다각형 넓이 (Polygon Area)

koa (김신건) — Sat, 18 Jul 2026 00:00:00 GMT

정의

다각형 넓이 (Polygon Area) 는 2D 평면 위 단순다각형 (non-self-intersecting polygon) 의 면적을 신발끈 공식 (Shoelace Formula) 으로 O(N) 에 계산하는 알고리즘.

신발끈 공식의 핵심 속성:

단순다각형 범용: 볼록(convex) / 오목(concave) 모두 동작.
방향 무관: 시계(CW) / 반시계(CCW) 방향에 관계없이 절대값 취하면 정확.
부호 있는 넓이: 부호로 다각형 방향(CCW: 양수, CW: 음수) 판별 가능.
정수 좌표 친화적: 중간 계산이 모두 정수. 최종에만 2 로 나누면 됨.

문제 상황과 동기

다각형의 넓이는 기하 문제에서 가장 빈번하게 등장하는 연산.

Naive: 삼각형 분할 후 각각 넓이 합산. O(N) 이지만 구현이 번거롭고 분할 방식을 결정해야 함.
Shoelace: 각 변의 기여도를 외적 하나로 계산. O(N) 에 통일된 공식.

핵심 통찰: 다각형의 부호 있는 넓이는 각 변 (i, i+1) 의 외적의 합의 절반. 즉 0.5 * | sum (x_i * y_{i+1} - x_{i+1} * y_i) |.

이 공식은 다각형이 볼록인지 오목인지, 시계/반시계 방향인지 관계없이 항상 성립.

어디서 쓰이는가?

flowchart TD
    PA["Polygon Area (Shoelace)"]
    PA --> C1["기본 면적 계산"]
    PA --> C2["볼록 껍질 넓이"]
    PA --> C3["다각형 내부 격자점 계산 (Pick 정리)"]
    PA --> C4["무게 중심 (Centroid) 계산"]
    PA --> C5["방향 판별 (CCW/CW)"]
    C3 --> Pick["Pick: A = I + B/2 - 1"]
    C5 --> CH["Convex Hull 내 방향 정렬"]

시각화

{}

핵심 아이디어

다각형의 꼭짓점을 P[0], P[1], ..., P[N-1] (반시계 또는 시계). 각 변 P[i] -> P[i+1] 에 대해, 사다리꼴의 부호 있는 넓이 를 더한다.

S = 0
for i in 0..N-1:
    j = (i + 1) % N
    S += P[i].x * P[j].y
    S -= P[j].x * P[i].y
area = abs(S) / 2

이론적 근거: 그린 정리 (Green’s theorem) 의 이산 버전. 각 변의 사다리꼴 넓이가 모두 더해지면 내부는 중첩되고 외부는 상쇄됨.

부호: S > 0 이면 반시계 방향, S < 0 이면 시계 방향.

삼각형 예시로 직관 이해

P0=(0,0), P1=(3,0), P2=(0,4) (직각삼각형)

S = P0.x*P1.y - P1.x*P0.y   = 0*0 - 3*0   = 0
  + P1.x*P2.y - P2.x*P1.y   = 3*4 - 0*0   = 12
  + P2.x*P0.y - P0.x*P2.y   = 0*0 - 0*4   = 0

S = 12
area = |12| / 2 = 6.0  (맞음! 밑변 3 × 높이 4 / 2 = 6)

알고리즘

polygon_area(P[0..N-1]):
    sum = 0
    for i = 0 to N-1:
        j = (i + 1) % N
        sum += P[i].x * P[j].y
        sum -= P[j].x * P[i].y
    return abs(sum) / 2.0

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Polygon area (shoelace), O(N) #include <bits/stdc++.h> using namespace std; using ll = long long;

struct Point { ll x, y; };

double polygon_area(vector& p) { ll sum = 0; int n = p.size(); for (int i = 0; i < n; i++) { int j = (i + 1) % n; sum += p[i].x * p[j].y; sum -= p[j].x * p[i].y; } return abs(sum) / 2.0; }

int main() { vector poly = {{0,0}, {4,0}, {5,2}, {2,5}, {-1,2}}; cout << fixed << setprecision(1) << polygon_area(poly) << “\n”; vector tri = {{0,0}, {3,0}, {0,4}}; cout << fixed << setprecision(1) << polygon_area(tri) << “\n”; }, }, { language: "python", label: "Python", code: # Shoelace formula, O(N) def polygon_area(poly): n = len(poly) s = 0 for i in range(n): j = (i + 1) % n s += poly[i][0] * poly[j][1] s -= poly[j][0] * poly[i][1] return abs(s) / 2.0

poly = [(0,0), (4,0), (5,2), (2,5), (-1,2)] print(f”{polygon_area(poly):.1f}”) tri = [(0,0), (3,0), (0,4)] print(f”{polygon_area(tri):.1f}“), }, { language: "java", label: "Java", code: import java.util.*; public class Main { static double polygonArea(long[][] p) { long sum = 0; int n = p.length; for (int i = 0; i < n; i++) { int j = (i + 1) % n; sum += p[i][0] * p[j][1]; sum -= p[j][0] * p[i][1]; } return Math.abs(sum) / 2.0; }

public static void main(String[] args) {
    long[][] poly = {{0,0}, {4,0}, {5,2}, {2,5}, {-1,2}};
    System.out.printf("%.1f%n", polygonArea(poly));
    long[][] tri = {{0,0}, {3,0}, {0,4}};
    System.out.printf("%.1f%n", polygonArea(tri));
}

}, }, ]} cases={[ { label: "오각형 + 삼각형", input: ``, output: 19.0 6.0`, }, ]} />

복잡도

항목	값
시간	O(N) (N = 꼭짓점 수)
공간	O(1) 추가 (입력 배열 제외)

변형 / 활용

1. 볼록다각형 여부 (방향 일관성)

Shoelace 의 sum 부호로 다각형이 반시계(양수)인지 시계(음수)인지 판별. 모든 연속 세 점의 CCW 가 방향과 일치하는지 확인.

2. 다각형의 무게 중심

면적으로 가중치를 준 꼭짓점 평균으로 centroid 계산 가능.

cx = sum((x_i + x_{i+1}) * (x_i*y_{i+1} - x_{i+1}*y_i)) / (6 * area)
cy = sum((y_i + y_{i+1}) * (x_i*y_{i+1} - x_{i+1}*y_i)) / (6 * area)

def centroid(poly):
    n = len(poly)
    cx = cy = 0.0
    area = 0.0
    for i in range(n):
        j = (i + 1) % n
        cross = poly[i][0] * poly[j][1] - poly[j][0] * poly[i][1]
        cx += (poly[i][0] + poly[j][0]) * cross
        cy += (poly[i][1] + poly[j][1]) * cross
        area += cross
    area /= 2
    return cx / (6 * area), cy / (6 * area)

3. 오목 다각형에서도 동작

Shoelace 는 내부 영역의 중첩과 상쇄가 자동으로 처리되므로 오목 다각형에서도 올바른 값.

4. 정수 좌표 + long long

좌표가 정수이면 넓이는 .0 또는 .5. 정수 배율 결과가 필요하면 abs(sum) 반환 후 따로 2 로 나누기.

5. Pick’s Theorem 과 조합

격자점 다각형에서 내부 격자점 수 I 를 구하는 데 Shoelace 를 활용.

A = I + B/2 - 1
I = A - B/2 + 1

A = Shoelace 로 계산한 넓이
B = 경계 위의 격자점 수 (각 변의 gcd 합)
I = 내부 격자점 수

함정

1. 오버플로우

x_i * y_j 가 10^6 * 10^6 = 10^12. N=10^5 면 sum 은 10^17 까지 가능. C++ long long (9e18) 은 OK, int 는 무조건 overflow.

// 위험: int 로 합산하면 overflow
int sum = 0;  // WRONG: 10^17 은 int 범위 초과

// 올바름
long long sum = 0;

2. 다각형 방향

입력이 시계(cw)인지 반시계(ccw)인지 모를 수 있음. abs(sum) 으로 절대값 처리.

3. 마지막 변

i=N-1 일 때 j=0 으로 돌아오는 것 ((i+1) % N) 이 중요. 열린 폴리라인이 아닌 닫힌 다각형이어야 함.

4. 정수 나눗셈

C++ 에서 abs(sum) / 2 는 정수 나눗셈. 2.0 으로 나누거나 (double) 캐스팅 필요.

5. 자기 교차 다각형

Shoelace 는 단순다각형 (non-self-intersecting) 에서만 올바르다. 모래시계 모양 (자기 교차) 등에서는 내부/외부 영역이 상쇄되어 실제 넓이보다 작게 나온다.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2166	다각형의 면적	39.5%	kokoa-lab
BOJ 2477	참외밭	44.5%	kokoa-lab
BOJ 1004	어린 왕자	33.2%	kokoa-lab
BOJ 1709	(관련: 원의 넓이)	(수집 안 됨)	kokoa-lab

참고

[[CCW]] (외적의 기초)
[[Convex Hull]] (볼록 껍질에서도 같은 공식)
[[Geometry]] (기하 기본)

Binary Search Tree (BST): 정렬된 이진 트리

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Binary Search Tree (BST) 는 각 노드가 다음 BST 불변식을 만족하는 이진 트리:

왼쪽 서브트리의 모든 키 < 노드 키
오른쪽 서브트리의 모든 키 > 노드 키

연산: 탐색, 삽입, 삭제 모두 평균 O(log N). 최악은 O(N) (편향 트리).

핵심 성질: 중위 순회 (inorder: 왼 -> 루트 -> 오른) 하면 키가 오름차순 정렬된 순서로 출력된다.

문제 상황

정렬 배열:

탐색 O(log N) (이진 탐색)
삽입/삭제 O(N) (원소 shift)

연결 리스트:

삽입/삭제 O(1) (포인터 조작)
탐색 O(N) (선형 탐색)

BST 는 두 자료구조의 트레이드오프를 해결: 탐색/삽입/삭제 모두 평균 O(log N).

시각화

flowchart TD
    A["5"]
    B["3"]
    C["7"]
    D["1"]
    E["4"]
    F["6"]
    G["9"]
    A --> B
    A --> C
    B --> D
    B --> E
    C --> F
    C --> G

탐색(4): 루트(5) -> 왼쪽(3) -> 오른쪽(4) 찾음. 비교 3회.

삽입(8): 루트(5) -> 오른(7) -> 오른(9) -> 9의 왼쪽에 삽입.

중위 순회: 1, 3, 4, 5, 6, 7, 9 (오름차순).

핵심 아이디어

탐색 (search)

현재 노드와 목표 키를 비교해 재귀:

search(node, k):
    if node is null or node.key == k: return node
    if k < node.key: return search(node.left, k)
    else:            return search(node.right, k)

트리 높이 H 에 비례 = O(H). 균형 트리이면 H = O(log N).

삽입 (insert)

탐색과 동일한 경로로 내려가다 null 을 만나면 노드 생성:

insert(node, k):
    if node is null: return new Node(k)
    if k < node.key: node.left  = insert(node.left,  k)
    else:            node.right = insert(node.right, k)
    return node

삭제 (delete)

삭제 케이스 3가지:

자식 없음 (leaf): 그냥 제거.
자식 1개: 자식으로 대체.
자식 2개: inorder successor (오른쪽 서브트리의 최솟값) 를 현재 노드로 복사, successor 삭제.

알고리즘

전체 구현 (C++)

struct Node {
    int key;
    Node *l, *r;
    Node(int k) : key(k), l(nullptr), r(nullptr) {}
};

Node* search(Node* r, int k) {
    if (!r || r->key == k) return r;
    return k < r->key ? search(r->l, k) : search(r->r, k);
}

Node* insert(Node* r, int k) {
    if (!r) return new Node(k);
    if (k < r->key) r->l = insert(r->l, k);
    else if (k > r->key) r->r = insert(r->r, k);
    return r;
}

Node* minNode(Node* r) {
    while (r->l) r = r->l;
    return r;
}

Node* remove(Node* r, int k) {
    if (!r) return nullptr;
    if (k < r->key) r->l = remove(r->l, k);
    else if (k > r->key) r->r = remove(r->r, k);
    else {
        // 삭제 케이스
        if (!r->l) { Node* tmp = r->r; delete r; return tmp; }
        if (!r->r) { Node* tmp = r->l; delete r; return tmp; }
        // 자식 2개: inorder successor
        Node* succ = minNode(r->r);
        r->key = succ->key;
        r->r = remove(r->r, succ->key);
    }
    return r;
}

중위 순회

void inorder(Node* r, vector<int>& res) {
    if (!r) return;
    inorder(r->l, res);
    res.push_back(r->key);
    inorder(r->r, res);
}

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std;

struct Node { int key; Node *l, *r; Node(int k) : key(k), l(nullptr), r(nullptr) {} };

Node* insert(Node* r, int k) { if (!r) return new Node(k); if (k < r->key) r->l = insert(r->l, k); else if (k > r->key) r->r = insert(r->r, k); return r; }

Node* minNode(Node* r) { while (r->l) r = r->l; return r; }

Node* remove(Node* r, int k) { if (!r) return nullptr; if (k < r->key) r->l = remove(r->l, k); else if (k > r->key) r->r = remove(r->r, k); else { if (!r->l) { Node* t = r->r; delete r; return t; } if (!r->r) { Node* t = r->l; delete r; return t; } Node* s = minNode(r->r); r->key = s->key; r->r = remove(r->r, s->key); } return r; }

void inorder(Node* r, vector& v) { if (!r) return; inorder(r->l, v); v.push_back(r->key); inorder(r->r, v); }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

int n; cin >> n;
Node* root = nullptr;
for (int i = 0; i < n; i++) {
    int x; cin >> x;
    root = insert(root, x);
}
// 삭제
int d; cin >> d;
root = remove(root, d);
// 중위 순회 출력
vector<int> res;
inorder(root, res);
for (int i = 0; i < (int)res.size(); i++) {
    cout << res[i];
    if (i + 1 < (int)res.size()) cout << " ";
}
cout << "\\n";

}, }, { language: "python", label: "Python", code: import sys input = sys.stdin.readline

class Node: def init(self, key): self.key = key self.l = self.r = None

def insert(node, k): if node is None: return Node(k) if k < node.key: node.l = insert(node.l, k) elif k > node.key: node.r = insert(node.r, k) return node

def min_node(node): while node.l: node = node.l return node

def remove(node, k): if node is None: return None if k < node.key: node.l = remove(node.l, k) elif k > node.key: node.r = remove(node.r, k) else: if node.l is None: return node.r if node.r is None: return node.l s = min_node(node.r) node.key = s.key node.r = remove(node.r, s.key) return node

def inorder(node, res): if node is None: return inorder(node.l, res) res.append(node.key) inorder(node.r, res)

n = int(input()) vals = list(map(int, input().split())) root = None for v in vals: root = insert(root, v) d = int(input()) root = remove(root, d) res = [] inorder(root, res) print(*res), }, ]} cases={[ { label: "삽입 후 삭제", input: 6 5 3 7 1 4 9 3, output: 1 4 5 7 9`, }, ]} />

복잡도

연산	평균	최악 (편향)
탐색	O(log N)	O(N)
삽입	O(log N)	O(N)
삭제	O(log N)	O(N)
중위 순회	O(N)	O(N)
공간	O(N)	O(N)

왜 균형이 필요한가

정렬된 입력 1, 2, 3, ..., N 을 순서대로 삽입하면 오른쪽으로만 뻗는 일자 트리 가 되어 높이 H = N, 모든 연산이 O(N) 로 퇴화.

flowchart TD
    A1["1"]
    A2["2"]
    A3["3"]
    A4["4"]
    A1 --> |"right"| A2
    A2 --> |"right"| A3
    A3 --> |"right"| A4

이를 해결하는 균형 BST:

자료구조	균형 전략	사용
[[avl-tree	AVL Tree]]	높이 차 <= 1, 회전
Red-Black Tree	색 기반 완화 균형	C++ STL set/map
[[bbst	Treap]]	우선순위 무작위화
Splay Tree	최근 접근 노드 루트로	캐시 패턴 편향 시
[[order-statistics-tree	OST]]	BST + 서브트리 크기

함정

1. 중복 원소 처리

k < r->key / k > r->key 만 처리하면 중복은 삽입 무시. 중복 허용이 필요하면 k <= r->key 로 왼쪽에 넣거나 카운터 필드 추가.

[!WARNING] 중복 원소를 왼/오른쪽에 일관성 없이 넣으면 삭제 시 버그 발생. 방향을 통일해야 한다.

2. 삭제 후 inorder successor 재귀 삭제

Node* s = minNode(r->r);
r->key = s->key;
r->r = remove(r->r, s->key);  // s->key 로 삭제해야 정확

s 포인터를 직접 삭제하면 안 된다. remove 재귀로 처리해야 구조 유지.

3. 메모리 누수 (C++)

delete r 을 leaf 삭제 시점에 해야 한다. 재귀 삭제 시 자식 포인터가 남아 있으면 누수.

4. 랜덤 입력 가정

BST 평균 O(log N) 는 입력이 랜덤 순서일 때만. 정렬/역순 입력이면 O(N). 실전에서는 균형 BST 사용 권장.

BOJ 연습 문제

번호	제목	비고
BOJ 5639	이진 검색 트리	전위 순회로 BST 복원
BOJ 2104	부분배열 고르기	BST 응용
BOJ 1991	트리 순회	전위/중위/후위 순회

참고

[[avl-tree|AVL Tree]] (엄격한 균형)
[[bbst|Treap / BBST]] (균형 BST)
[[order-statistics-tree|Order Statistics Tree]] (BST + rank/select)
[[segtree|Segment Tree]] (구간 쿼리)
[[fenwick-tree|Fenwick Tree]] (prefix sum)

Branch and Bound: 분기 한정

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Branch and Bound (B&B) 는 완전 탐색을 하되, 상한/하한을 계산해 유망하지 않은 서브트리를 가지치기 하는 기법. 최적화 문제에 적용.

백트래킹이 “실행 불가능한 해를 가지치기” 한다면, B&B 는 최적 해를 넘지 못하는 경우도 추가 제거.

문제 상황과 동기

왜 필요한가

N 도시를 방문하는 최단 경로 ([[tsp|TSP]]) 는 완전 탐색 시 O(N!) 가지. N=20 이면 2.4 × 10^18 가지로 현실적으로 불가능.

Naive: 모든 경우 탐색, TLE
Backtracking: 불가능한 해만 제거, 여전히 느림
B&B: 현재 best 보다 나쁠 수밖에 없는 경로도 즉시 제거, 실용적

핵심 통찰: bound 함수가 낙관적 추정을 잘할수록 가지치기 효과 극대화.

구성 요소

Branching: 해 공간을 서브문제로 나누기
Bounding: 각 서브문제에서 달성 가능한 최선 추정 (낙관적)
Pruning: 현재 best 보다 bound 가 나쁘면 해당 가지 제거

시각화

탐색 트리 구조

flowchart TD
    Root["루트: 초기 상태"] --> A["가지 A"]
    Root --> B["가지 B"]
    Root --> C["가지 C"]
    A --> A1["가지치기 (bound 초과)"]
    A --> A2["계속 탐색"]
    B --> B1["가지치기 (bound 초과)"]
    B --> B2["가지치기 (bound 초과)"]
    C --> C1["리프: 해 발견, best 갱신"]
    A2 --> A21["계속 탐색"]
    A2 --> A22["가지치기 (bound 초과)"]

    style A1 fill:#ffcccc
    style B1 fill:#ffcccc
    style B2 fill:#ffcccc
    style A22 fill:#ffcccc
    style C1 fill:#ccffcc

빨간 노드는 가지치기(pruning). 초록 노드가 최적 해.

백트래킹 vs B&B

flowchart LR
    BT["백트래킹"] -->|"제약 조건 위반 시 컷"| BT2["실행 불가능한 해 제거"]
    BnB["B and B"] -->|"bound >= best 시 컷"| BnB2["최적 불가능한 경우도 제거"]
    BnB2 --> Result["더 강력한 가지치기"]

핵심 아이디어

best = 초기 상한 (greedy 등으로 구함)
우선순위 큐 Q (bound 기준 best-first)
Q.push(초기 노드)

while Q 가 비지 않을 때:
    node = Q.pop()
    if node.bound >= best:
        continue      # pruning
    if node 가 완성된 해:
        best = min(best, node.cost)
        continue
    for child in branch(node):
        child.bound = compute_bound(child)
        if child.bound < best:
            Q.push(child)

return best

Key invariant: bound 는 실제 최적 해보다 항상 낙관적(optimistic) 이어야 함. 너무 보수적이면 올바른 해를 가지치기.

알고리즘

TSP 의 Bound 계산

현재까지 이동 비용 + 남은 도시로 가는 하한 추정:

남은 도시와 현재/시작 도시를 잇는 MST 가중치
각 도시의 최소 진출 간선 합

bound = current_cost
      + sum(min outgoing edge of remaining cities)
      + MST(remaining cities)

0/1 Knapsack 의 Bound 계산

남은 아이템을 무게 대비 가치 순으로 정렬, fractional 로 채운 최대 가치:

bound = current_value
      + fractional_knapsack(remaining_capacity, remaining_items)

Fractional 이므로 정수 해의 상한을 낙관적으로 추정.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// 0/1 Knapsack Branch and Bound #include <bits/stdc++.h> using namespace std;

struct Item { int w, v; }; struct Node { int level, value, weight; double bound; bool operator<(const Node& o) const { return bound < o.bound; } };

int n, W; vector items;

double compute_bound(const Node& node) { if (node.weight >= W) return 0; double bound = node.value; int j = node.level + 1; int totw = node.weight; while (j < n && totw + items[j].w <= W) { totw += items[j].w; bound += items[j].v; j++; } if (j < n) bound += (double)(W - totw) / items[j].w * items[j].v; return bound; }

int knapsack_bnb() { sort(items.begin(), items.end(), [](const Item& a, const Item& b) { return (double)a.v / a.w > (double)b.v / b.w; });

priority_queue<Node> pq;
Node root{-1, 0, 0, 0};
root.bound = compute_bound(root);
pq.push(root);

int best = 0;
while (!pq.empty()) {
    Node cur = pq.top(); pq.pop();
    if (cur.bound <= best) continue;

    Node next;
    next.level = cur.level + 1;
    if (next.level >= n) continue;

    // 현재 아이템 포함
    next.weight = cur.weight + items[next.level].w;
    next.value  = cur.value  + items[next.level].v;
    if (next.weight <= W && next.value > best)
        best = next.value;
    next.bound = compute_bound(next);
    if (next.bound > best) pq.push(next);

    // 현재 아이템 미포함
    next.weight = cur.weight;
    next.value  = cur.value;
    next.bound  = compute_bound(next);
    if (next.bound > best) pq.push(next);
}
return best;

}

int main() { n = 4; W = 15; items = {{2, 10}, {4, 10}, {6, 12}, {9, 18}}; cout << knapsack_bnb() << “\n”; // 38 }, }, { language: "python", label: "Python", code: # 0/1 Knapsack Branch and Bound import heapq

def knapsack_bnb(n, W, weights, values): items = sorted(zip(weights, values), key=lambda x: -x[1] / x[0])

def compute_bound(level, val, wt):
    if wt >= W:
        return 0
    bound = val
    j = level + 1
    totw = wt
    while j < n and totw + items[j][0] <= W:
        totw += items[j][0]
        bound += items[j][1]
        j += 1
    if j < n:
        bound += (W - totw) / items[j][0] * items[j][1]
    return bound

best = 0
# (-bound, level, value, weight)
heap = [(-compute_bound(-1, 0, 0), -1, 0, 0)]

while heap:
    neg_bd, level, val, wt = heapq.heappop(heap)
    bd = -neg_bd
    if bd <= best:
        continue

    nlevel = level + 1
    if nlevel >= n:
        continue

    w, v = items[nlevel]

    # 포함
    nwt, nval = wt + w, val + v
    if nwt <= W:
        best = max(best, nval)
    nb = compute_bound(nlevel, nval, nwt)
    if nb > best:
        heapq.heappush(heap, (-nb, nlevel, nval, nwt))

    # 미포함
    nb = compute_bound(nlevel, val, wt)
    if nb > best:
        heapq.heappush(heap, (-nb, nlevel, val, wt))

return best

n, W = 4, 15 weights = [2, 4, 6, 9] values = [10, 10, 12, 18] print(knapsack_bnb(n, W, weights, values)) # 38`, }, ]} cases={[ { label: “기본 배낭 문제”, input: “n=4, W=15, items={(w=2,v=10),(w=4,v=10),(w=6,v=12),(w=9,v=18)}”, output: “38”, }, { label: “모든 아이템 수용 가능”, input: “n=2, W=100, items={(w=2,v=10),(w=4,v=10)}”, output: “20”, }, ]} />

복잡도

항목	값
최악 시간	O(2^N)
실전 시간	가지치기 효과로 훨씬 빠름
공간 (DFS)	O(N) 스택
공간 (Best-first)	O(2^N) 최악 큐

가지치기 효과는 bound 품질에 의존. 좋은 초기 해를 greedy 로 구하면 효과 배가.

DFS vs Best-first

방식	탐색 순서	메모리	빠른 해 발견
DFS B&B	재귀	O(N)	느림
Best-first	우선순위 큐	O(2^N) 최악	빠름

메모리 제약 있으면 DFS, 해 품질이 중요하면 best-first.

A* 와의 관계

[[a-star|A*]] 는 best-first B&B 에서 각 노드의 비용이 g(n) + h(n) 인 특수 경우. B&B 는 더 일반적인 개념.

함정

1. Bound 가 낙관적이지 않으면 최적 해 놓침

bound 함수는 반드시 실제 최적의 하한(최소화) 또는 상한(최대화) 이어야 함. bound 가 실제보다 보수적이면 정답을 가지치기해 WA.

2. 초기 해가 없으면 가지치기 불가

처음에 greedy 로 좋은 초기 해를 구해야 효율적 pruning 가능. 초기 best = 0 이면 모든 가지 탐색.

3. Best-first 는 메모리 폭발 위험

큐에 노드가 지수적으로 쌓일 수 있음. 반복 심화 B&B (ID-BnB) 도 대안.

4. Bound 계산 비용이 과도하면 역효과

TSP bound 로 MST 계산이 O(N^2) 이면, 노드마다 계산하는 오버헤드가 큼. 간단한 greedy bound 와 trade-off.

5. 정수 vs 실수 비교

bound 가 실수(double) 인 경우 bound > best 비교에 부동소수점 오차 주의.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2098	외판원 순회	41.3%	kokoa-lab
BOJ 9663	N-Queens	62.3%	kokoa-lab
BOJ 15649	N과 M (1)	63.1%	kokoa-lab
BOJ 1987	알파벳	41.2%	kokoa-lab

참고

[[brute-force|Brute Force]]
[[dp-bitfield|DP Bitfield]]
[[a-star|A*]]
[[knapsack|Knapsack]]
[[tsp|TSP]]

Brute Force: 완전 탐색

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Brute Force (완전 탐색) 는 문제의 모든 후보 해를 하나씩 검증하는 접근. 최적은 아니지만 정확하고 명확하며, 큰 문제에도 부분 검증 도구로 사용.

핵심 원칙: 모든 가능성을 빠짐없이 탐색하되, 불필요한 탐색은 가지치기로 제거.

문제 상황

완전 탐색이 유효한 상황:

N ≤ 20: 부분집합 열거 (2^N ≤ 10^6)
N ≤ 10: 순열 열거 (10! ≈ 3.6×10^6)
N ≤ 8: 순열 열거 (8! = 40,320, 매우 빠름)
N ≤ 1000: 이중 루프 (10^6)
N ≤ 500: 삼중 루프 (1.25×10^8, 타이트)

완전 탐색으로 정답을 구한 뒤, 최적화 알고리즘의 정답 검증 도구로도 활용.

시각화

완전 탐색에서 최적화로의 발전 경로:

flowchart TD
    BF["완전 탐색 (Brute Force)"]
    P["가지치기 추가 (Pruning)"]
    BB["Branch and Bound"]
    Memo["메모이제이션 추가"]
    DP["동적 프로그래밍 (DP)"]
    Bit["비트마스크 인코딩"]
    BitmaskDP["Bitmask DP"]

    BF -->|"반복 계산 제거"| Memo
    BF -->|"탐색 공간 제한"| P
    P --> BB
    Memo --> DP
    BF -->|"집합 상태 인코딩"| Bit
    Bit --> BitmaskDP

핵심 아이디어

패턴 1: 부분집합 열거 (2^N)

for mask = 0 to (1<<N)-1:
    subset = {i : mask & (1<<i) != 0}
    check(subset)

패턴 2: 순열 열거 (N!)

arr = [0, 1, ..., N-1]
do:
    check(arr)
while next_permutation(arr)

패턴 3: 재귀 백트래킹

function backtrack(state, depth):
    if depth == N:
        check(state)
        return
    for choice in choices:
        if is_valid(state, choice):
            state.add(choice)
            backtrack(state, depth + 1)
            state.remove(choice)

패턴 4: 중첩 루프

for i = 0 to N-1:
    for j = i+1 to N-1:
        check(i, j)

알고리즘

가지치기 (Pruning)

현재 부분 해가 최적 해보다 나쁠 수 없을 때 탐색 중단:

function backtrack(state, depth, current_cost):
    if current_cost >= best_cost: return  # 가지치기
    if depth == N:
        best_cost = min(best_cost, current_cost)
        return
    for choice in choices:
        backtrack(state + choice, depth + 1, current_cost + cost(choice))

Meet in the Middle

N이 40 정도일 때: 절반씩 나눠 2^20 × 2 = 2×10^6 으로 해결.

left_results = enumerate_all(first_half)
right_results = enumerate_all(second_half)
sort(right_results)
for each l in left_results:
    binary_search(right_results, target - l)

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std;

int n; vector arr;

// 패턴 1: 부분집합 열거 void subset_enumeration() { for (int mask = 0; mask < (1 << n); mask++) { cout << ”{ ”; for (int i = 0; i < n; i++) if (mask & (1 << i)) cout << arr[i] << ” ”; cout << ”}\n”; } }

// 패턴 2: 순열 열거 void permutation_enumeration() { sort(arr.begin(), arr.end()); do { for (int x : arr) cout << x << ” ”; cout << “\n”; } while (next_permutation(arr.begin(), arr.end())); }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

cin >> n;
arr.resize(n);
for (int i = 0; i < n; i++) cin >> arr[i];

int mode;
cin >> mode;

if (mode == 1) subset_enumeration();
else permutation_enumeration();

return 0;

}, }, { language: "python", label: "Python", code: from itertools import permutations

def subset_enumeration(arr): n = len(arr) for mask in range(1 << n): subset = [arr[i] for i in range(n) if mask >> i & 1] print(’{’, *subset, ’}’)

def permutation_enumeration(arr): for perm in sorted(permutations(arr)): print(*perm)

def main(): n = int(input()) arr = list(map(int, input().split())) mode = int(input())

if mode == 1:
    subset_enumeration(arr)
else:
    permutation_enumeration(arr)

main(), }, { language: "java", label: "Java", code: import java.util.*;

public class Main { static int n; static int[] arr;

// 부분집합 열거
static void subsetEnumeration() {
    for (int mask = 0; mask < (1 << n); mask++) {
        System.out.print("{ ");
        for (int i = 0; i < n; i++)
            if ((mask & (1 << i)) != 0)
                System.out.print(arr[i] + " ");
        System.out.println("}");
    }
}

// 순열 열거 (재귀)
static void permute(int[] a, int k) {
    if (k == n) {
        for (int x : a) System.out.print(x + " ");
        System.out.println();
        return;
    }
    for (int i = k; i < n; i++) {
        int tmp = a[k]; a[k] = a[i]; a[i] = tmp;
        permute(a, k + 1);
        tmp = a[k]; a[k] = a[i]; a[i] = tmp;
    }
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    n = sc.nextInt();
    arr = new int[n];
    for (int i = 0; i < n; i++) arr[i] = sc.nextInt();
    int mode = sc.nextInt();

    if (mode == 1) subsetEnumeration();
    else permute(arr, 0);
}

}, }, ]} cases={[ { label: "N=3 부분집합 열거", input: 3 1 2 3 1, output: { } { 1 } { 2 } { 1 2 } { 3 } { 1 3 } { 2 3 } { 1 2 3 }, }, { label: "N=3 순열 열거", input: 3 1 2 3 2, output: 1 2 3 1 3 2 2 1 3 2 3 1 3 1 2 3 2 1`, }, ]} />

복잡도

탐색 유형	복잡도	N 한계 (10^8 기준)
부분집합	O(2^N)	N ≤ 26
순열	O(N!)	N ≤ 12
조합 C(N,K)	O(C(N,K))	상황별
이중 루프	O(N²)	N ≤ 10^4
삼중 루프	O(N³)	N ≤ 500
Meet in Middle	O(2^(N/2))	N ≤ 40

최적화로 발전

1. 가지치기 → [[branch-and-bound|Branch and Bound]]

현재 부분 해가 최적 해보다 나쁠 수 없을 때 탐색 중단. 최악 복잡도는 동일하지만 실제로 훨씬 빠름.

2. 메모이제이션 → DP

같은 부분 문제를 반복 계산하면 메모이제이션으로 DP 변환. 지수 → 다항식 복잡도.

3. 비트마스크 → [[dp-bitfield|Bitmask DP]]

집합 상태를 비트마스크로 인코딩하면 O(N!) → O(2^N · N²) (TSP 예시).

4. [[BFS|너비 우선 탐색]] 결합

상태 공간 탐색에서 BFS로 최단 경로 탐색.

함정

1. 시간 초과 (TLE)

N=20 순열 (20! ≈ 2.4×10^18)은 절대 불가. N 제약 확인 필수.

[!WARNING] 완전 탐색 전 반드시 복잡도 계산. N=15 순열 (15! ≈ 1.3×10^12)도 TLE.

2. 중복 탐색

순열에서 같은 원소가 있으면 중복 제거 필요. next_permutation은 정렬된 배열에서 시작해야 모든 순열을 정확히 한 번씩 생성.

3. 가지치기 조건 오류

가지치기 조건이 너무 강하면 정답을 놓침. 너무 약하면 효과 없음.

4. 재귀 깊이 초과

Python에서 재귀 깊이 기본 1000. sys.setrecursionlimit(10**6) 설정 필요.

5. 인덱스 범위 오류

부분집합 열거에서 1 << N이 int 범위를 초과할 수 있음. N=31 이상이면 1LL << N 사용.

BOJ 연습 문제

번호	제목	유형
BOJ 1182	부분수열의 합	부분집합 열거
BOJ 9663	N-Queen	백트래킹
BOJ 15649	N과 M (1)	순열
BOJ 2309	일곱 난쟁이	부분집합
BOJ 1759	암호 만들기	조합
BOJ 1208	부분수열의 합 2	Meet in Middle

Bubble Sort

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Bubble Sort (버블 정렬) 는 인접한 두 원소를 비교해 잘못된 순서면 교환하는 작업을 배열을 통과하며 반복하는 정렬. 한 번의 통과 (pass) 마다 가장 큰 원소가 마지막으로 떠오른다 (bubble up) 해서 이름이 붙음.

알고리즘 교육의 단골이지만, 실무에서는 거의 쓰이지 않는다 (O(n²)). 다만 한 번의 통과로 정렬 완료 여부를 알 수 있다는 점 때문에 거의 정렬된 입력에 한해 빠를 수 있다.

전체 비교는 [[정렬 알고리즘]] 참고.

시각화

{}

아래는 한 번의 pass 에서 최댓값이 오른쪽으로 “떠오르는” 흐름:

flowchart LR
    Init["i=0, swapped=false"] --> J["j=0"]
    J --> CMP{"arr[j] > arr[j+1]?"}
    CMP -->|"Yes"| SWAP["swap + swapped=true"]
    CMP -->|"No"| NJ["j++"]
    SWAP --> NJ
    NJ --> JEnd{"j < n-i-1?"}
    JEnd -->|"Yes"| CMP
    JEnd -->|"No"| SC{"swapped?"}
    SC -->|"false"| Done["조기 종료"]
    SC -->|"true"| Next["i++, 다음 pass"]
    Next --> Init

알고리즘

bubbleSort(arr):
  n = length(arr)
  for i = 0 to n-1:
    swapped = false
    for j = 0 to n-i-2:
      if arr[j] > arr[j+1]:
        swap(arr[j], arr[j+1])
        swapped = true
    if not swapped:
      break  // 이미 정렬됨, 조기 종료

핵심 동작

매 통과마다 가장 큰 값이 끝으로 떠오른다.

[5, 2, 8, 1, 4]   초기
[2, 5, 8, 1, 4]   5 > 2, swap
[2, 5, 8, 1, 4]   5 < 8
[2, 5, 1, 8, 4]   8 > 1, swap
[2, 5, 1, 4, 8]   8 > 4, swap   ← 8 이 끝으로 떠올랐다

다음 통과는 마지막 원소 제외하고:
[2, 5, 1, 4, |8|]

n-1 번의 통과 후 정렬 완료. 단, 한 통과에서 교환이 한 번도 없으면 이미 정렬된 것이므로 조기 종료 가능.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std;

void bubbleSort(vector& arr) { int n = arr.size(); for (int i = 0; i < n - 1; i++) { bool swapped = false; for (int j = 0; j < n - i - 1; j++) { if (arr[j] > arr[j+1]) { swap(arr[j], arr[j+1]); swapped = true; } } if (!swapped) break; // 이미 정렬됨 } }

int main() { vector arr = {64, 34, 25, 12, 22, 11, 90}; int n = arr.size(); cout << “Before: ”; for (int x : arr) cout << x << ” ”; cout << “\n”; bubbleSort(arr); cout << “After: ”; for (int x : arr) cout << x << ” ”; cout << “\n”; }, }, { language: "python", label: "Python", code: def bubble_sort(arr: list) -> None: n = len(arr) for i in range(n - 1): swapped = False for j in range(n - i - 1): if arr[j] > arr[j+1]: arr[j], arr[j+1] = arr[j+1], arr[j] swapped = True if not swapped: break # 이미 정렬됨

arr = [64, 34, 25, 12, 22, 11, 90] print(“Before:”, arr) bubble_sort(arr) print(“After: ”, arr), }, ]} cases={[ { label: "기본 실행", input: "", output: Before: 64 34 25 12 22 11 90 After: 11 12 22 25 34 64 90, }, { label: "이미 정렬된 입력 (조기 종료)", input: "", output: Before: 1 2 3 4 5 After: 1 2 3 4 5`, }, ]} />

복잡도

항목	값	설명
시간 (최선)	O(n)	이미 정렬됨 (early exit)
시간 (평균)	O(n²)
시간 (최악)	O(n²)	역순 입력
공간	O(1)	in-place
안정성	✓ Stable	같은 키는 교환 안 함
In-place	✓

다른 O(n²) 정렬과의 비교

알고리즘	비교 횟수	교환 횟수	특징
Bubble	O(n²)	O(n²)	안정. 거의 정렬된 입력 빠름
[[Insertion Sort]]	O(n²)	O(n²)	안정. 거의 정렬된 입력 가장 빠름
[[Selection Sort]]	O(n²)	O(n)	불안정. 교환 비용 비쌀 때 유리

[!CAUTION] 셋 다 O(n²) 지만 상수항이 다르다. 실측 평균:

Insertion Sort > Selection Sort > Bubble Sort (Bubble 이 가장 느림)

Insertion 이 캐시 친화적이라 가장 빠름

변형

Cocktail Shaker Sort

양방향으로 통과. 작은 값은 앞으로, 큰 값은 뒤로 동시에 이동.

forward pass:  큰 값을 끝으로
backward pass: 작은 값을 앞으로

순방향만 하는 Bubble 보다 빨라지는 입력이 있지만 여전히 O(n²).

Comb Sort

처음에는 멀리 떨어진 원소끼리 비교 (gap 사용), 점차 gap 을 줄임. Shell Sort 와 비슷한 발상으로 O(n²) 평균 → O(n log n) 평균 가능.

왜 가르치는가

실용성보다는 교육적 가치:

가장 쉬운 정렬 알고리즘, 한눈에 이해
swap, in-place, stability 같은 개념의 첫 접점
O(n²) 의 직관, 두 중첩 루프
early termination 같은 최적화 사고

거의 정렬된 입력에 빠른 이유

const arr = [1, 2, 4, 3, 5, 6, 7, 8]; // 3, 4 만 어긋남

// 1 회 통과: 3, 4 교환 → swapped = true
// 2 회 통과: 교환 없음 → swapped = false → 조기 종료
// 총 2n 비교, 1 swap → O(n)

이 경우 Insertion Sort 도 마찬가지로 O(n). 둘 다 거의 정렬된 입력에 강하다.

실무 사용 사례 (드뭄)

임베디드 / 펌웨어: 코드 크기가 극단적으로 작아야 할 때 (수십 바이트)
교육 / 예제 코드
테스트용 reference implementation, 다른 정렬 알고리즘의 결과 검증

그 외에는 사실상 사용되지 않는다.

함정

1. 내부 루프 범위 오류

j < n - i - 1 에서 -1 을 빠뜨리면 arr[j+1] 이 범위를 벗어남. 매 pass 마다 이미 확정된 뒤쪽을 비교할 필요 없음을 명심.

2. swapped 플래그 위치

swapped = false 를 내부 루프 전에 초기화해야 함. 외부 루프 전에 하면 첫 pass 이후 항상 false 가 되어 조기 종료가 절대 발생하지 않음.

3. 안정성 보장 조건

arr[j] > arr[j+1] 에서 등호 없이 strict 비교를 해야 stable. >= 로 비교하면 같은 원소도 교환해 unstable 이 됨.

4. 역순 입력이 최악

역순 배열: 1번째 pass = n-1 비교, 2번째 pass = n-2 비교 … 총 n*(n-1)/2 비교 + 교환. Insertion Sort 도 비슷하지만 이동 비용이 다름: Bubble 은 인접 swap (O(1) per swap), Insertion 은 shift (O(1) per element, 더 효율적).

5. 비교 횟수 최소화가 목표가 아닐 때

교환 비용이 비교 비용보다 훨씬 비싼 경우 (예: 대용량 객체 이동): [[Selection Sort]] 가 교환 횟수 O(n) 으로 더 유리.

BOJ 연습 문제

번호	제목	연관
BOJ 1517	버블 소트	Bubble Sort swap 횟수 = 역전쌍 수. Merge Sort 로 O(n log n) 계산
BOJ 2750	수 정렬하기	정렬 기본 구현 연습
BOJ 25305	커트라인	정렬 후 k번째 원소 탐색

[!IMPORTANT] BOJ 1517 “버블 소트” 는 실제로 Bubble Sort 를 구현하는 문제가 아니다. O(n^2) 으로는 TLE. Bubble Sort swap 횟수 = 역전쌍 (inversion pair) 수라는 성질을 활용해 Merge Sort / BIT / Segment Tree 로 O(n log n) 에 계산해야 한다.

참고

[[정렬 알고리즘]]
[[Insertion Sort]]
[[Selection Sort]]
[[Quick Sort]]
Knuth, TAOCP Vol. 3 §5.2.2
“Bubble Sort: An Archaeological Algorithmic Analysis” (Owen Astrachan, 2003)

Catalan Number: C_n

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Catalan number 는 조합론에서 자주 등장하는 수열. 닫힌 형식(closed form):

$$ C_n = \frac{1}{n+1} \binom{2n}{n} = \frac{(2n)!}{(n+1)!, n!} $$

초기값: C_0 = 1, C_1 = 1, C_2 = 2, C_3 = 5, C_4 = 14, C_5 = 42, C_6 = 132, C_7 = 429.

문제 상황과 동기

“경우의 수를 구하라” 문제에서 아래 패턴이 보이면 Catalan number 의심:

n 쌍의 괄호를 올바르게 배치하는 경우의 수
n+1 개 잎을 가진 완전 이진 트리의 개수
n+2 각형의 삼각 분할 개수
격자 경로 중 대각선을 넘지 않는 단조 경로 (Dyck path)
n 개의 원소를 스택으로 정렬 가능한 순열 수

핵심 통찰: 구조의 첫 번째 닫힘 지점을 기준으로 좌/우 분할하면 Catalan 점화식이 자연스럽게 등장.

시각화

점화식의 직관

n 쌍 괄호에서 맨 첫 ( 와 짝을 이루는 ) 의 위치를 k 로 고정:

flowchart TD
    Full["C(n)개 괄호 배열"] --> Split["첫 닫힘 위치 k로 분할"]
    Split --> Inner["안쪽: C(k)가지"]
    Split --> Outer["나머지: C(n-1-k)가지"]
    Inner --> Combine["모든 k에 대해 곱하여 합산"]
    Outer --> Combine
    Combine --> Formula["C(n+1) = 합(C(k) x C(n-k))"]

이 분해가 Catalan 점화식의 본질:

$$ C_{n+1} = \sum_{i=0}^{n} C_i \cdot C_{n-i} $$

등가 점화식:

$$ C_n = \frac{2(2n-1)}{n+1} \cdot C_{n-1} $$

이진 트리 재귀 분해

flowchart TD
    Root["루트 노드"] --> L["왼쪽 서브트리: k개 잎"]
    Root --> R["오른쪽 서브트리: n-k개 잎"]
    L --> Lv["C(k)가지"]
    R --> Rv["C(n-k)가지"]
    Lv --> Sum["C(n) = 합(C(k) x C(n-1-k))"]
    Rv --> Sum

n+1 개 잎 이진 트리를 루트에서 좌/우 분할하면 동일 점화식 유도.

응용 (모두 C_n 개)

구조	파라미터	개수
올바른 괄호 배열	n 쌍	C_n
완전 이진 트리	n+1 개 잎	C_n
볼록 다각형 삼각 분할	n+2 각형	C_n
Dyck 경로	길이 2n	C_n
스택 정렬 가능 순열	1..n	C_n
단조 격자 경로 (대각 이하)	n x n 격자	C_n

핵심 아이디어

DP 점화식

$$ dp[0] = 1 $$ $$ dp[i] = \sum_{k=0}^{i-1} dp[k] \cdot dp[i-1-k] $$

시간 O(N^2), 공간 O(N).

이항계수로 직접 계산

$$ C_n = \binom{2n}{n} \cdot \frac{1}{n+1} $$

모듈러 역원 (p 소수):

$$ C_n \bmod p = \binom{2n}{n} \cdot (n+1)^{-1} \bmod p $$

알고리즘

점화식 반복

dp[0] = 1
for i in 1..n:
    dp[i] = 0
    for k in 0..i-1:
        dp[i] += dp[k] * dp[i-1-k]

비율 점화식 (정수 나눗셈, 단조로움 활용)

C_0 = 1
C_n = C_{n-1} * 2*(2n-1) / (n+1)

항상 정수로 나누어 떨어짐 (귀납법으로 증명). 모듈러 없이 큰 수 계산 시 유용.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Catalan number: DP + 이항계수 두 방법 #include <bits/stdc++.h> using namespace std; const long long MOD = 1e9 + 7;

long long power(long long a, long long b, long long mod) { long long res = 1; a %= mod; for (; b; b >>= 1) { if (b & 1) res = res * a % mod; a = a * a % mod; } return res; }

// 방법 1: DP vector catalan_dp(int n) { vector dp(n + 1, 0); dp[0] = 1; for (int i = 1; i <= n; i++) for (int k = 0; k < i; k++) dp[i] = (dp[i] + dp[k] * dp[i - 1 - k]) % MOD; return dp; }

// 방법 2: 이항계수 + 모듈러 역원 long long catalan_binom(int n) { vector fact(2 * n + 2); fact[0] = 1; for (int i = 1; i <= 2 * n + 1; i++) fact[i] = fact[i-1] * i % MOD; long long binom = fact[2*n] % MOD * power(fact[n], MOD-2, MOD) % MOD * power(fact[n], MOD-2, MOD) % MOD; return binom * power(n + 1, MOD - 2, MOD) % MOD; }

int main() { auto dp = catalan_dp(10); for (int i = 0; i <= 10; i++) cout << “C(” << i << ”) = ” << dp[i] << “\n”; cout << “C(10) via binom = ” << catalan_binom(10) << “\n”; }, }, { language: "python", label: "Python", code: # Catalan number: DP + 비율 점화식 MOD = 10**9 + 7

def catalan_dp(n): dp = [0] * (n + 1) dp[0] = 1 for i in range(1, n + 1): for k in range(i): dp[i] = (dp[i] + dp[k] * dp[i - 1 - k]) % MOD return dp

def catalan_ratio(n): """C_n = C_{n-1} * 2(2n-1) / (n+1). 항상 정수로 나누어 떨어짐.""" c = 1 result = [1] for i in range(1, n + 1): c = c * 2 * (2 * i - 1) // (i + 1) result.append(c % MOD) return result

DP 방식

dp = catalan_dp(10) for i, v in enumerate(dp): print(f”C({i}) = {v}“)

비율 점화식 (모듈러 없이 정확한 정수)

rat = catalan_ratio(10) print(“비율 점화식:”, rat), }, { language: "java", label: "Java", code: // Catalan number DP

public class Main { static final long MOD = 1_000_000_007L;

public static void main(String[] args) {
    int n = 10;
    long[] dp = new long[n + 1];
    dp[0] = 1;
    for (int i = 1; i <= n; i++) {
        for (int k = 0; k < i; k++) {
            dp[i] = (dp[i] + dp[k] * dp[i - 1 - k]) % MOD;
        }
    }
    for (int i = 0; i <= n; i++) {
        System.out.println("C(" + i + ") = " + dp[i]);
    }
}

}, }, ]} cases={[ { label: "C(0) ~ C(10)", input: "n = 10", output: C(0) = 1 C(1) = 1 C(2) = 2 C(3) = 5 C(4) = 14 C(5) = 42 C(6) = 132 C(7) = 429 C(8) = 1430 C(9) = 4862 C(10) = 16796`, }, ]} />

복잡도

방법	시간	공간
DP 점화식	O(N^2)	O(N)
이항계수 (팩토리얼 전처리)	O(N)	O(N)
비율 점화식	O(N)	O(N)

큰 N 에서 모듈러 연산 필요. C_30 이 이미 long long 범위를 초과.

함정

1. n+2각형 삼각분할은 C_n 이지 C_{n+2} 아님

6각형 삼각분할 수 = C_4 = 14. n = (꼭짓점 수) - 2.

2. 비율 점화식의 모듈러 주의

C_n = C_{n-1} * 2*(2n-1) / (n+1) 는 정수지만, 모듈러 연산 후 나눗셈은 역원 필요.

# 틀린 방법 (모듈러 후 나눗셈)
c = c * 2 * (2*i-1) % MOD // (i+1)   # WRONG

# 올바른 방법 1: 모듈러 전에 정수 나눗셈 (정확히 나누어짐)
c = c * 2 * (2*i-1) // (i+1) % MOD   # OK

# 올바른 방법 2: 모듈러 역원
c = c * 2 * (2*i-1) % MOD * pow(i+1, MOD-2, MOD) % MOD  # OK

3. 스택 정렬 불가능 순열 수

1..n 을 스택으로 정렬 가능한 순열: C_n 개. 불가능한 순열: n! - C_n 개.

4. 오버플로우

Python 은 자동 bigint, C++/Java 는 MOD 없이 long long 으로 C_18 부터 오버플로우.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 10422	괄호	41.7%	kokoa-lab
BOJ 1720	타일 코드	45.2%	kokoa-lab
BOJ 2622	삼각형만들기	52.3%	kokoa-lab
BOJ 11722	가장 긴 감소하는 부분 수열	49.6%	kokoa-lab

참고

[[combinatorics|조합론]]
[[pascal-triangle|Pascal Triangle]]

Convex Hull 3D: 3차원 볼록 껍질

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

3D 점집합의 볼록 껍질 (Convex Hull): 모든 점을 포함하는 최소 볼록 다면체.

면 (face) 들이 삼각형으로 구성된 다면체
각 면의 법선 벡터 (outward normal) 가 외부를 향함
다면체 내부의 어느 두 점을 이어도 선분이 다면체 안에 존재

2D 볼록 껍질의 3D 확장. 2D 에서 “볼록 다각형”이면, 3D 에서 “볼록 다면체”.

문제 상황

3D 점집합이 주어질 때 볼록 껍질을 구해야 하는 상황:

3D 물체의 최소 감싸는 다면체 구하기
두 점집합 사이 최소 거리 (GJK 알고리즘의 기반)
Delaunay Triangulation, Voronoi Diagram 계산

2D 와의 차이:

2D: 볼록 껍질 = 일련의 선분 (edges)
3D: 볼록 껍질 = 삼각형 면들의 집합 (triangulated surface)
면의 방향 (orientation) 을 올바르게 유지해야 함

시각화

flowchart LR
    Input["3D 점집합"] --> Init["초기 사면체\n일반 위치 4점으로 시작"]
    Init --> Loop["점 P 추가 반복"]
    Loop --> Vis["P 에서 보이는 face 찾기\n법선 벡터 내적 테스트"]
    Vis --> Del["보이는 face 제거"]
    Del --> Horizon["horizon edge 추출"]
    Horizon --> NewFace["P 와 horizon 으로\n새 face 생성"]
    NewFace --> Loop
    Loop --> Done["모든 점 처리 완료"]

핵심 아이디어

핵심 연산: 외적 (Cross Product)

두 벡터 $\mathbf{a} = (a_x, a_y, a_z)$, $\mathbf{b} = (b_x, b_y, b_z)$ 의 외적:

$$ \mathbf{a} \times \mathbf{b} = (a_y b_z - a_z b_y, ; a_z b_x - a_x b_z, ; a_x b_y - a_y b_x) $$

삼각형 면 ABC 의 outward normal $\mathbf{n} = \overrightarrow{AB} \times \overrightarrow{AC}$.

점 P 의 face 가시성 판단

점 P 에서 면 F (정점 A, B, C, outward normal $\mathbf{n}$) 가 보이는가?

$$ (\mathbf{P} - \mathbf{A}) \cdot \mathbf{n} > 0 \implies \text{보임 (visible)} $$

보이는 면은 새 점을 추가할 때 제거 대상.

Horizon Edge

가시 면과 불가시 면 사이의 경계 에지. 새 점 P 에서 이 에지들을 이어 새 삼각형 팬 (fan) 을 형성.

일반 위치 (General Position)

4점 이상이 같은 평면에 없을 것
3점 이상이 같은 직선에 없을 것

일반 위치 가정이 없으면 퇴화 케이스 (degenerate case) 처리가 복잡해짐.

알고리즘

Incremental Construction

한 번에 한 점씩 추가:

convex_hull_3d(points):
    shuffle(points)  // 무작위 셔플로 O(N log N) 기대 시간
    CH = tetrahedron(points[0..3])  // 초기 사면체
    for P in points[4:]:
        visible_faces = [f for f in CH.faces if is_visible(P, f)]
        if not visible_faces:
            continue  // P 가 이미 CH 내부
        horizon = get_horizon_edges(visible_faces)
        remove visible_faces from CH
        for edge (A, B) in horizon:
            CH.add_face(A, B, P)  // 새 삼각형
    return CH

O(N^2) worst case
O(N log N) expected (무작위 셔플 후)

Gift Wrapping (3D)

2D gift wrapping 의 3D 확장. 각 에지에서 다음 면을 “감싸서” 찾음.

gift_wrapping_3d(points):
    start_edge = find_initial_edge()
    queue = [start_edge]
    visited_edges = set()
    while queue:
        e = queue.pop()
        if e in visited_edges: continue
        P = find_visible_point(e, points)  // e 왼쪽에서 가장 왼쪽 점
        new_face = (e.A, e.B, P)
        add new_face
        queue += [e.B, P], [P, e.A]  // 새 에지
        visited_edges.add(e)

O(N * F), F = 최종 면 개수. H = O(N) 최악 케이스.

Chan’s Algorithm

O(N log H), H = 볼록 껍질 면 수. 이론적 최적.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++: 핵심 연산”, code: `#include <bits/stdc++.h> using namespace std; typedef long long ll; struct P3 { ll x, y, z; };

P3 sub(P3 a, P3 b) { return {a.x-b.x, a.y-b.y, a.z-b.z}; } P3 cross(P3 a, P3 b) { return {a.yb.z-a.zb.y, a.zb.x-a.xb.z, a.xb.y-a.yb.x}; } ll dot(P3 a, P3 b) { return a.xb.x + a.yb.y + a.z*b.z; }

// 삼각형 face ABC 에서 점 P 가 보이는지 (outward normal 기준) // normal = (B-A) x (C-A) bool visible(P3 A, P3 B, P3 C, P3 P) { P3 n = cross(sub(B, A), sub(C, A)); return dot(n, sub(P, A)) > 0; }

int main() { int n; cin >> n; vector pts(n); for (auto& p : pts) cin >> p.x >> p.y >> p.z;

// 가시성 테스트 예시
P3 A={0,0,0}, B={1,0,0}, C={0,1,0}, Q={0,0,1};
cout << "Q visible from ABC: " << visible(A,B,C,Q) << "\\n";
// 외적 예시
P3 ab = sub(B, A), ac = sub(C, A);
P3 n = cross(ab, ac);
cout << "Normal: " << n.x << " " << n.y << " " << n.z << "\\n";
return 0;

}, }, { language: "python", label: "Python: 핵심 연산", code: def sub(a, b): return (a[0]-b[0], a[1]-b[1], a[2]-b[2]) def cross(a, b): return (a[1]*b[2]-a[2]*b[1], a[2]*b[0]-a[0]*b[2], a[0]*b[1]-a[1]*b[0]) def dot(a, b): return a[0]*b[0] + a[1]*b[1] + a[2]*b[2]

def visible(A, B, C, P): """삼각형 ABC 에서 점 P 가 보이는지 (outward normal 기준)""" ab = sub(B, A) ac = sub(C, A) n = cross(ab, ac) return dot(n, sub(P, A)) > 0

A = (0,0,0); B = (1,0,0); C = (0,1,0); Q = (0,0,1) print(“Q visible from ABC:”, visible(A, B, C, Q)) # True

ab = sub(B, A); ac = sub(C, A) n = cross(ab, ac) print(“Normal:”, n) # (0, 0, 1), }, ]} cases={[ { label: "기본", input: 3 0 0 0 1 0 0 0 1 0, output: Q visible from ABC: 1 Normal: 0 0 1`, }, ]} />

복잡도

알고리즘	시간	공간	비고
Incremental	$O(N^2)$ worst	$O(N)$	구현 쉬움
Incremental + 셔플	$O(N \log N)$ expected	$O(N)$	실전 추천
Gift Wrapping	$O(N \cdot F)$	$O(F)$	F: 면 수
Chan’s Algorithm	$O(N \log H)$	$O(N)$	이론적 최적
Divide & Conquer	$O(N \log N)$	$O(N)$	구현 복잡

볼록 껍질 면 수 F = O(N) (Euler’s formula 에 의해 V - E + F = 2, V+E+F = O(N)).

함정

[!WARNING] 일반 위치 가정: 4점이 같은 평면 (coplanar) 이면 초기 사면체 형성 불가. 랜덤 섭동 (perturbation) 으로 해결.

[!WARNING] 수치 오차: 부동소수점 사용 시 visible() 판단이 틀릴 수 있음. 정수 좌표라면 long long 외적으로 정확하게 처리.

[!CAUTION] 법선 방향: face 의 outward/inward normal 일관성 유지 필수. 방향 혼동 시 내부/외부 판단이 뒤집힘.

흔한 실수

초기 사면체의 4점이 한 평면에 있는 경우 처리 안 함
horizon edges 추출 시 방향 (winding order) 을 잘못 잡음
무작위 셔플 없이 incremental 하면 O(N^2) worst case 에 걸림
2D CH 와 달리 3D 에서는 단순 스택 기반 알고리즘 없음

BOJ 연습 문제

번호	제목	키워드
BOJ 1168	요세푸스 문제 2	선형 자료구조 응용
BOJ 9240	로버트 후드	2D CH, 3D CH 기초
BOJ 4181	Convex Hull	2D CH 구현

[!NOTE] BOJ 에서 3D CH 자체를 요구하는 문제는 드물고, 3D CH 의 핵심 서브루틴 (외적, 가시성 판단) 이 더 자주 등장.

참고

[[convex-hull|2D Convex Hull]]
[[geometry-3d|3D Geometry]]
[[geometry|기하 알고리즘 기초]]
[[angle-sorting|Angle Sorting]]

Cycle Detection: 그래프 사이클 탐지

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

그래프에 사이클이 존재하는가, 또는 어느 사이클인가 를 찾는 문제.

무향 그래프: 한 정점에서 출발해 다시 그 정점으로 돌아오는 경로.
유향 그래프: 방향을 따라가며 이미 방문 중인 정점으로 돌아오는 경로.

문제 상황

위상 정렬, 의존성 검사, DAG 판별 등에서 사이클 존재 여부가 핵심이다.

패키지 의존성: A -> B -> C -> A 이면 설치 불가 (순환 의존).
작업 스케줄링: 작업 간 선후관계에 사이클이 있으면 스케줄 불가능.
코스 선수과목: 수강 순서에 사이클이 있으면 모순.

시각화

무향 그래프 사이클

flowchart LR
    A["1"] --- B["2"]
    B --- C["3"]
    C --- D["4"]
    D --- B

2 - 3 - 4 - 2 가 사이클. Union-Find 에서 4-2 간선 삽입 시 find(4) == find(2) 로 탐지.

유향 그래프 사이클 (DFS 3색)

flowchart LR
    A2["1 (흰)"] -->|"방문"| B2["2 (회색)"]
    B2 -->|"방문"| C2["3 (회색)"]
    C2 -->|"back edge!"| B2

3 -> 2 back edge: 회색(처리 중) 정점으로 가는 간선 = 사이클.

핵심 아이디어

무향 그래프: Union-Find

간선 (u, v) 를 삽입할 때 find(u) == find(v) 이면 u, v 가 이미 같은 컴포넌트 = 사이클.

for each edge (u, v):
    if find(u) == find(v): CYCLE!
    else: union(u, v)

유향 그래프: DFS 3색

흰색 (0): 미방문
회색 (1): 현재 DFS 스택에 있음 (처리 중)
검은색 (2): 처리 완료

회색 정점으로 향하는 간선 = back edge = 사이클 존재.

유향 그래프: Kahn’s 알고리즘

위상 정렬로 처리된 정점 수 < N 이면 사이클 존재 (일부 정점의 indegree 가 0이 되지 않음).

알고리즘

무향 그래프: Union-Find

struct DSU {
    vector<int> par, rank_;
    DSU(int n) : par(n), rank_(n, 0) { iota(par.begin(), par.end(), 0); }

    int find(int x) {
        if (par[x] != x) par[x] = find(par[x]);  // path compression
        return par[x];
    }

    bool same(int a, int b) { return find(a) == find(b); }

    void merge(int a, int b) {
        a = find(a); b = find(b);
        if (a == b) return;
        if (rank_[a] < rank_[b]) swap(a, b);
        par[b] = a;
        if (rank_[a] == rank_[b]) rank_[a]++;
    }
};

bool hasCycle_undirected(int n, vector<pair<int,int>>& edges) {
    DSU dsu(n);
    for (auto [u, v] : edges) {
        if (dsu.same(u, v)) return true;
        dsu.merge(u, v);
    }
    return false;
}

유향 그래프: DFS 3색

vector<int> color;  // 0=흰, 1=회, 2=검

bool dfs(int u, vector<vector<int>>& adj) {
    color[u] = 1;  // 회색: 처리 시작
    for (int v : adj[u]) {
        if (color[v] == 1) return true;              // back edge: 사이클
        if (color[v] == 0 && dfs(v, adj)) return true;
    }
    color[u] = 2;  // 검은색: 처리 완료
    return false;
}

bool hasCycle_directed(int n, vector<vector<int>>& adj) {
    color.assign(n, 0);
    for (int i = 0; i < n; i++)
        if (color[i] == 0 && dfs(i, adj)) return true;
    return false;
}

유향 그래프: Kahn’s 알고리즘

bool hasCycle_kahn(int n, vector<vector<int>>& adj) {
    vector<int> indeg(n, 0);
    for (int u = 0; u < n; u++)
        for (int v : adj[u]) indeg[v]++;

    queue<int> q;
    for (int i = 0; i < n; i++)
        if (indeg[i] == 0) q.push(i);

    int cnt = 0;
    while (!q.empty()) {
        int u = q.front(); q.pop(); cnt++;
        for (int v : adj[u])
            if (--indeg[v] == 0) q.push(v);
    }
    return cnt < n;  // 처리 못한 정점 있으면 사이클
}

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++ (유향 그래프 DFS 3색)”, code: `#include <bits/stdc++.h> using namespace std;

int n, m; vector<vector> adj; vector color; // 0=흰, 1=회, 2=검

bool dfs(int u) { color[u] = 1; for (int v : adj[u]) { if (color[v] == 1) return true; if (color[v] == 0 && dfs(v)) return true; } color[u] = 2; return false; }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

cin >> n >> m;
adj.resize(n + 1);
for (int i = 0; i < m; i++) {
    int u, v; cin >> u >> v;
    adj[u].push_back(v);
}

color.assign(n + 1, 0);
bool cycle = false;
for (int i = 1; i <= n; i++)
    if (color[i] == 0 && dfs(i)) { cycle = true; break; }

cout << (cycle ? "YES" : "NO") << "\\n";

}, }, { language: "python", label: "Python (Kahn's 알고리즘)", code: import sys from collections import deque input = sys.stdin.readline

def solve(): n, m = map(int, input().split()) adj = [[] for _ in range(n + 1)] indeg = [0] * (n + 1) for _ in range(m): u, v = map(int, input().split()) adj[u].append(v) indeg[v] += 1

q = deque()
for i in range(1, n + 1):
    if indeg[i] == 0:
        q.append(i)

cnt = 0
while q:
    u = q.popleft()
    cnt += 1
    for v in adj[u]:
        indeg[v] -= 1
        if indeg[v] == 0:
            q.append(v)

print("YES" if cnt < n else "NO")

solve(), }, ]} cases={[ { label: "사이클 있음", input: 4 4 1 2 2 3 3 4 4 2, output: YES, }, { label: "사이클 없음 (DAG)", input: 3 2 1 2 2 3, output: NO`, }, ]} />

복잡도

방법	시간	공간	적용 대상
Union-Find	O(E * alpha(N))	O(N)	무향 그래프
DFS 3색	O(V + E)	O(V)	유향 그래프
Kahn’s 알고리즘	O(V + E)	O(V)	유향 그래프

Union-Find 는 alpha(N) (역 Ackermann): 사실상 O(1). DFS 3색과 Kahn’s 는 동일 복잡도지만 용도가 다름:

DFS 3색: 사이클 경로 자체를 복원할 때 유리.
Kahn’s: 위상 정렬을 동시에 얻을 때 유리.

함정

1. 무향 그래프에서 부모 방문을 사이클로 혼동

DFS 기반 무향 그래프 사이클 탐지 시, 간선 (u, v) 에서 v 를 방문할 때 부모 방향으로 돌아가는 것을 back edge 로 착각하는 실수.

// 잘못: 부모(par)로 돌아가는 것도 사이클 취급
bool dfs(int u, int par, ...) {
    visited[u] = true;
    for (int v : adj[u]) {
        if (!visited[v]) { dfs(v, u, ...); }
        else return true;  // 부모 방문도 true -> 오류!
    }
}

// 올바름: 부모 제외
bool dfs(int u, int par, ...) {
    visited[u] = true;
    for (int v : adj[u]) {
        if (v == par) continue;  // 부모 방향 skip
        if (!visited[v]) { if (dfs(v, u, ...)) return true; }
        else return true;  // 부모 아닌 방문 완료 정점 = back edge
    }
    return false;
}

[!WARNING] 멀티 그래프 (같은 정점 사이 간선 여러 개) 는 간선 인덱스로 부모를 추적해야 한다.

2. 유향 그래프에서 흰색/검은색 혼동

검은색 (처리 완료) 정점으로 가는 간선은 forward edge 또는 cross edge 로 사이클이 아니다. 오직 회색 (처리 중) 정점으로 가는 back edge 만 사이클.

[!CAUTION] 방문 여부만 체크 (visited[])하면 유향 그래프에서 오답. 반드시 3색 or 스택 상태 구분.

3. Kahn’s 로 경로 복원 불가

Kahn’s 알고리즘은 사이클 존재 여부만 알 수 있고, 어떤 정점이 사이클에 포함되는지 직접 알기 어렵다. 사이클 정점 목록이 필요하면 DFS 3색으로 복원.

BOJ 연습 문제

번호	제목	비고
BOJ 9466	텀 프로젝트	유향 그래프 사이클 (DFS)
BOJ 1516	게임 개발	위상 정렬 + 사이클 없음 보장
BOJ 2252	줄 세우기	위상 정렬 기본
BOJ 10451	순열 사이클	무향 그래프 사이클 카운트

참고

[[topological-sorting|위상 정렬 (Topological Sorting)]]
[[disjoint-set|Union-Find (Disjoint Set)]]
[[tarjan-scc|Tarjan SCC]] (강한 연결 요소)
[[graph|그래프 기초]]
[[dfs|DFS (깊이 우선 탐색)]]

DP on Bitmask: 비트마스크 DP

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

부분집합 상태를 비트마스크로 인코딩하여 DP를 수행하는 기법. 정수 mask의 i번째 비트가 1이면 “원소 i 선택”, 0이면 “미선택”을 의미한다. 원소 수 N ≤ 20 정도의 집합 문제에서 유효하다.

$$ \text{dp}[mask][i] = \text{mask에 속한 원소들을 처리하고 현재 위치가 } i \text{ 일 때의 최적값} $$

비트 연산 기초: [[dp-bitfield|DP Bitfield]] 참조.

문제 상황

“어떤 원소를 선택했는가” 자체가 상태인 최적화 문제:

TSP (Traveling Salesman Problem): 모든 도시를 한 번씩 방문하는 최소 비용 순환 경로
Assignment Problem: 사람과 태스크를 1:1로 매칭하여 비용 최소화
Hamiltonian Path: 모든 정점을 방문하는 경로 존재 여부
Set Cover: 최소 개수의 집합으로 전체 원소를 커버

N ≤ 20이면 2^20 = 1,048,576으로 메모리와 시간 모두 허용 범위.

시각화

N=3 TSP 상태 전이 (도시 0 고정 출발):

flowchart LR
    S["출발: 도시 0만 방문"]
    A["도시 0, 1 방문, 현재 i=1"]
    B["도시 0, 2 방문, 현재 i=2"]
    C["도시 0, 1, 2 방문, 현재 i=2"]
    D["도시 0, 1, 2 방문, 현재 i=1"]
    E["종료 후보: i=2에서 복귀"]
    F["종료 후보: i=1에서 복귀"]

    S -->|"도시 1 선택"| A
    S -->|"도시 2 선택"| B
    A -->|"도시 2 선택"| C
    B -->|"도시 1 선택"| D
    C --> E
    D --> F

N=3 비트마스크 표현:

mask (이진)	십진	선택된 도시
000	0	공집합
001	1	{0}
010	2	{1}
011	3	{0, 1}
100	4	{2}
101	5	{0, 2}
110	6	{1, 2}
111	7	{0, 1, 2}

핵심 아이디어

상태를 (mask, i) 쌍으로 표현:

mask: 현재까지 방문/선택한 원소들의 비트마스크
i: 현재 위치 (마지막으로 선택한 원소)

전이: 미방문 원소 j를 다음에 선택 → (mask | (1<<j), j)

핵심 비트 연산:

i번째 포함 여부: mask & (1 << i) 가 0이 아니면 포함
i번째 원소 추가: mask | (1 << i) 로 새 mask 생성
i번째 원소 제거: mask & ~(1 << i)
전체 집합: (1 << N) - 1 (모든 비트 1)
부분집합 순회: for (int s = mask; s > 0; s = (s-1) & mask)

TSP 점화식

$$ \text{dp}[mask \mid (1 \ll j)][j] = \min\bigl(\text{dp}[mask \mid (1 \ll j)][j],; \text{dp}[mask][i] + \text{cost}[i][j]\bigr) $$

초기: dp[1][0] = 0 (도시 0만 방문, 도시 0에 위치), 나머지 INF. 답: min(dp[(1<<N)-1][i] + cost[i][0]) for i in 1..N-1.

Assignment Problem 변형

dp[i][mask] = i번째 사람까지 처리, 사용된 태스크 집합 = mask.

$$ \text{dp}[i+1][mask \mid (1 \ll j)] = \min(\text{dp}[i+1][mask \mid (1 \ll j)],; \text{dp}[i][mask] + \text{cost}[i][j]) $$

TSP와 달리 외부 루프가 사람 인덱스 i, 내부 루프가 mask. popcount(mask) == i 조건으로 유효 상태만 처리.

부분집합 열거 패턴

모든 부분집합을 열거하는 표준 패턴:

// mask의 모든 부분집합 열거 (공집합 포함)
for (int s = mask; ; s = (s - 1) & mask) {
    process(s);
    if (s == 0) break;
}

모든 mask에 대해 실행하면 O(3^N) (각 원소가 mask 포함/부분집합 포함/부분집합 미포함 3가지).

알고리즘

# TSP 비트마스크 DP
dp[1][0] = 0          # 도시 0 방문, 도시 0 위치
for mask = 1 to (1<<N)-1:
    for i = 0 to N-1:
        if dp[mask][i] == INF: continue
        if not (mask & (1<<i)): continue  # i가 mask에 없으면 무효 상태
        for j = 0 to N-1:
            if mask & (1<<j): continue    # 이미 방문한 도시
            nmask = mask | (1 << j)
            dp[nmask][j] = min(dp[nmask][j], dp[mask][i] + cost[i][j])

full = (1 << N) - 1
answer = min(dp[full][i] + cost[i][0] for i in 1..N-1)  # 원점 복귀

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std; const int INF = 1e9;

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

int n;
cin >> n;
vector<vector<int>> cost(n, vector<int>(n));
for (int i = 0; i < n; i++)
    for (int j = 0; j < n; j++)
        cin >> cost[i][j];

// dp[mask][i]: mask 집합 방문 후 i에 있을 때 최소 비용
vector<vector<int>> dp(1 << n, vector<int>(n, INF));
dp[1][0] = 0;

for (int mask = 1; mask < (1 << n); mask++) {
    for (int i = 0; i < n; i++) {
        if (dp[mask][i] == INF) continue;
        if (!(mask & (1 << i))) continue;
        for (int j = 0; j < n; j++) {
            if (mask & (1 << j)) continue;
            int nmask = mask | (1 << j);
            dp[nmask][j] = min(dp[nmask][j], dp[mask][i] + cost[i][j]);
        }
    }
}

int full = (1 << n) - 1;
int ans = INF;
for (int i = 1; i < n; i++)
    ans = min(ans, dp[full][i] + cost[i][0]);

cout << ans << "\\n";
return 0;

}, }, { language: "python", label: "Python", code: import sys input = sys.stdin.readline

def solve(): n = int(input()) cost = [list(map(int, input().split())) for _ in range(n)] INF = float(‘inf’)

# dp[mask][i]: mask 집합 방문 후 i에 있을 때 최소 비용
dp = [[INF] * n for _ in range(1 << n)]
dp[1][0] = 0

for mask in range(1, 1 << n):
    for i in range(n):
        if dp[mask][i] == INF or not (mask >> i & 1):
            continue
        for j in range(n):
            if mask >> j & 1:
                continue
            nmask = mask | (1 << j)
            cand = dp[mask][i] + cost[i][j]
            if cand < dp[nmask][j]:
                dp[nmask][j] = cand

full = (1 << n) - 1
print(min(dp[full][i] + cost[i][0] for i in range(1, n)))

solve(), }, { language: "java", label: "Java", code: import java.util.*;

public class Main { static final int INF = Integer.MAX_VALUE / 2;

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int[][] cost = new int[n][n];
    for (int i = 0; i < n; i++)
        for (int j = 0; j < n; j++)
            cost[i][j] = sc.nextInt();

    // dp[mask][i]: mask 집합 방문 후 i에 있을 때 최소 비용
    int[][] dp = new int[1 << n][n];
    for (int[] row : dp) Arrays.fill(row, INF);
    dp[1][0] = 0;

    for (int mask = 1; mask < (1 << n); mask++) {
        for (int i = 0; i < n; i++) {
            if (dp[mask][i] == INF) continue;
            if ((mask & (1 << i)) == 0) continue;
            for (int j = 0; j < n; j++) {
                if ((mask & (1 << j)) != 0) continue;
                int nmask = mask | (1 << j);
                dp[nmask][j] = Math.min(dp[nmask][j], dp[mask][i] + cost[i][j]);
            }
        }
    }

    int full = (1 << n) - 1;
    int ans = INF;
    for (int i = 1; i < n; i++)
        ans = Math.min(ans, dp[full][i] + cost[i][0]);

    System.out.println(ans);
}

}, }, ]} cases={[ { label: "4개 도시 TSP", input: 4 0 10 15 20 10 0 35 25 15 35 0 30 20 25 30 0, output: 80, }, { label: "3개 도시", input: 3 0 1 2 1 0 3 2 3 0, output: 6`, }, ]} />

복잡도

항목	값
시간	O(2^N · N²)
공간	O(2^N · N)
N=15	2^15 · 225 ≈ 7.4×10^6 (여유)
N=20	2^20 · 400 ≈ 4.2×10^8 (타이트)
실용 한계	N ≤ 20 (int 기준 메모리 약 80MB)

[!WARNING] N=25 이상은 2^25 ≈ 33M 상태로 메모리와 시간 모두 한계 초과. N 제약 반드시 확인.

함정

1. 배열 크기: 스택 오버플로

// 지역 변수로 선언하면 스택 오버플로
int dp[1 << 20][20];  // 전역 선언 필수 (약 80MB)

2. 출발 도시 고정 누락

TSP는 순환 경로이므로 도시 0 고정 출발이 최적. 모든 도시에서 시작하면 정답이 N배 중복으로 잘못 계산될 수 있다.

3. mask에 i 포함 여부 체크 누락

if (!(mask & (1 << i))) continue;
// 없으면 i가 mask에 없는 잘못된 상태에서 전이 발생

4. 원점 복귀 비용 누락

dp[(1<<N)-1][i]는 i에 있는 비용. 최종 답은 dp[full][i] + cost[i][0]로 원점 복귀 포함.

5. Assignment Problem과 TSP 혼동

Assignment Problem에서는 dp[i][mask] = i번째 사람까지 처리, mask = 사용된 태스크. 전이 방향이 TSP와 다르므로 혼동 주의.

BOJ 연습 문제

번호	제목	유형
BOJ 2098	외판원 순회	TSP (핵심 문제)
BOJ 1194	달이 차오른다, 가자.	BFS + bitmask
BOJ 17471	게리맨더링	지역 분할
BOJ 1562	계단 수	Digit DP + bitmask
BOJ 2234	성곽	지역 합병 bitmask

DP Optimization: CHT, D&C, Knuth, SMAWK

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

일반 DP 를 O(N²) 또는 O(N³) 에서 O(N log N) 또는 O(N) 으로 낮추는 여러 최적화 기법의 총칭입니다. 모두 특정 조건 (monotone, concave, quadrangle inequality) 이 성립할 때만 적용 가능합니다.

기법	원래 복잡도	최적화 후	적용 조건
Convex Hull Trick	O(N²)	O(N log N) / O(N)	선형 함수 min/max, 기울기 단조
Divide and Conquer	O(N²)	O(N log N)	최적 k 단조 증가
Knuth Optimization	O(N³)	O(N²)	Quadrangle Inequality + 단조
SMAWK / Monge	O(N²)	O(N)	Monge 행렬

문제 상황

전형적인 DP 전환 문제를 만났을 때, 아래 형태인지 먼저 확인합니다.

// 형태 A: CHT / SMAWK
dp[i] = min over j<i of { f(j) * x[i] + g(j) }
// f(j) = 기울기, x[i] = 현재 값, g(j) = 절편

// 형태 B: D&C Optimization
dp[i][j] = min over k < j of { dp[i-1][k] + cost(k, j) }
// 최적 k 가 j 에 대해 단조 증가

// 형태 C: Knuth
dp[i][j] = min over i <= k <= j of { dp[i][k] + dp[k][j] + w(i, j) }
// w 가 QI + 단조 만족

시각화

4 가지 기법의 적용 시나리오와 복잡도.

flowchart TD
    Start["DP 전환 문제"]
    Q1{"dp[i] = min f(j)*x[i]+g(j)?"}
    Q2{"최적 k 단조 증가?"}
    Q3{"구간 DP, w가 QI?"}
    Q4{"Monge 행렬?"}

    CHT["CHT\nO(N log N) / O(N)"]
    DnC["D&C Optimization\nO(N log N)"]
    Knuth["Knuth Optimization\nO(N^2)"]
    SMAWK["SMAWK\nO(N)"]
    Naive["Naive O(N^2) / O(N^3)"]

    Start --> Q1
    Q1 -->|"Yes"| CHT
    Q1 -->|"No"| Q2
    Q2 -->|"Yes"| DnC
    Q2 -->|"No"| Q3
    Q3 -->|"Yes"| Knuth
    Q3 -->|"No"| Q4
    Q4 -->|"Yes"| SMAWK
    Q4 -->|"No"| Naive

핵심 아이디어

1. Convex Hull Trick (CHT)

dp[i] = min_{j<i}(a[j] * x[i] + b[j]) 형태. 선형 함수 집합의 최솟값 = 하부 볼록 껍질 (lower envelope).

Li-Chao Tree: 임의 삽입 순서, O(log N) per query/update
단조 CHT (Monotone Stack): 기울기 a[j] 단조 증가이면 O(1) push, O(1)/O(log N) query
Kinetic Heaps: 온라인, 자동 최솟값 추적

전용 [[li-chao-tree|Li-Chao Tree]] 참조.

2. Divide and Conquer Optimization

dp[i][j] = min_{k}(dp[i-1][k] + cost(k, j)) 에서 최적 k 가 j 에 대해 단조 증가 하면 O(N²) → O(N log N).

핵심: 구간 [lo, hi] 의 중간 mid 를 계산하고, 가능한 k 범위를 재귀적으로 좁힘.

3. Knuth Optimization

dp[i][j] = min_{i<=k<=j}(dp[i][k] + dp[k][j]) + w(i,j) 에서 Quadrangle Inequality (QI) 와 단조성 이 성립하면 O(N³) → O(N²).

QI: w(a,c) + w(b,d) <= w(a,d) + w(b,c) (a<=b<=c<=d).

4. SMAWK / Monge

Monge 행렬: 모든 2×2 부분행렬이 QI 를 만족하는 행렬. SMAWK 알고리즘으로 각 행의 최솟값을 O(N) 에 계산.

알고리즘

CHT (단조 스택, 오프라인)

라인 관리 스택 stk:
  add(a, b):  // y = a*x + b 삽입
      새 직선 L
      while stk.size() >= 2:
          if stk[-2] 와 stk[-1] 의 교점 >= stk[-1] 와 L 의 교점:
              stk.pop()
          else: break
      stk.push(L)

  query(x):   // 최솟값 직선의 y값
      while stk.size() >= 2:
          if stk[0].eval(x) >= stk[1].eval(x):
              stk.pop_front()
          else: break
      return stk[0].eval(x)

D&C Optimization

solve(lo, hi, optL, optR):
    if lo > hi: return
    mid = (lo + hi) / 2
    best_k = optL
    dp[i][mid] = INF
    for k in [optL .. min(mid, optR)]:
        cand = dp[i-1][k] + cost(k, mid)
        if cand < dp[i][mid]:
            dp[i][mid] = cand
            best_k = k
    solve(lo, mid-1, optL, best_k)
    solve(mid+1, hi, best_k, optR)

Knuth Optimization

// opt[i][j] = dp[i][j] 의 최적 k
for gap in 1..n:
    for i in 0..n-gap:
        j = i + gap
        dp[i][j] = INF
        for k in opt[i][j-1]..opt[i+1][j]:
            if dp[i][k] + dp[k][j] + w(i,j) < dp[i][j]:
                dp[i][j] = dp[i][k] + dp[k][j] + w(i,j)
                opt[i][j] = k

구현

D&C Optimization

<CodeWithOutput language=“cpp” label=“C++ (D&C Optimization)” outputLanguage=“text” outputLabel=“결과” title=“1D1D DP D&C 최적화 (스캐폴딩)” code={`#include <bits/stdc++.h> using namespace std;

const long long INF = 1e18; int n, m; vector prev_dp, cur_dp;

// cost(k, j): 구체적인 문제마다 다름 long long cost(int k, int j) { // 예: prefix sum 기반 비용 return (long long)(j - k) * (j - k); }

void solve(int lo, int hi, int optL, int optR) { if (lo > hi) return; int mid = (lo + hi) / 2; int best_k = optL; cur_dp[mid] = INF; for (int k = optL; k <= min(mid - 1, optR); k++) { if (prev_dp[k] == INF) continue; long long cand = prev_dp[k] + cost(k, mid); if (cand < cur_dp[mid]) { cur_dp[mid] = cand; best_k = k; } } solve(lo, mid - 1, optL, best_k); solve(mid + 1, hi, best_k, optR); }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cin >> n >> m; prev_dp.resize(n + 1, INF); cur_dp.resize(n + 1, INF); prev_dp[0] = 0; // i번째 분할 for (int i = 1; i <= m; i++) { fill(cur_dp.begin(), cur_dp.end(), INF); solve(1, n, 0, n - 1); swap(prev_dp, cur_dp); } cout << prev_dp[n] << “\n”; return 0; }} output={// n=5, m=2 (2그룹으로 분할) // 예시 cost = (j-k)^2 // dp[5] = 최소 분할 비용 8`} />

Knuth Optimization

// Knuth: 구간 DP O(N^2)
// 전제: w(i,j) 가 QI + 단조 만족
vector<vector<long long>> dp(n+1, vector<long long>(n+1, INF));
vector<vector<int>> opt(n+1, vector<int>(n+1, 0));

for (int i = 0; i <= n; i++) { dp[i][i] = 0; opt[i][i] = i; }

for (int gap = 1; gap <= n; gap++) {
    for (int i = 0; i + gap <= n; i++) {
        int j = i + gap;
        dp[i][j] = INF;
        for (int k = opt[i][j-1]; k <= opt[i+1][j]; k++) {
            long long cand = dp[i][k] + dp[k][j] + w(i, j);
            if (cand < dp[i][j]) {
                dp[i][j] = cand;
                opt[i][j] = k;
            }
        }
    }
}

복잡도

기법	시간	메모리	제약 조건
CHT (단조 스택)	O(N)	O(N)	기울기/쿼리 모두 단조
CHT (Li-Chao Tree)	O(N log N)	O(N)	임의 순서
D&C Optimization	O(N log N)	O(N)	최적 k 단조
Knuth Optimization	O(N²)	O(N²)	QI + 단조
SMAWK	O(N)	O(N)	Monge 행렬

함정

[!WARNING] CHT 에서 기울기 정렬 미확인: 단조 스택 CHT 는 기울기가 단조일 때만 O(1) push. 임의 순서이면 deque 대신 Li-Chao Tree 를 써야 함.

[!WARNING] D&C Optimization 의 optL/optR 범위: solve(lo, mid-1, optL, best_k) 에서 best_k 가 optR 보다 커지지 않도록 주의. min(mid-1, optR) 처리 필요.

[!CAUTION] Knuth 에서 QI 검증 생략: 반례가 있어도 AC 가 나오는 경우가 있어 QI 를 검증하지 않고 제출하는 실수. 반드시 w(a,c) + w(b,d) <= w(a,d) + w(b,c) 를 수식으로 확인.

적용 가능한 기법이 여러 가지라면 CHT > D&C > Knuth 순으로 빠름.
SMAWK 는 구현이 까다로워 실전에서는 LARSSON 또는 Divide Conquer 로 대체하는 경우가 많음.

BOJ

문제	분류
BOJ 4008 특공대	CHT 기본
BOJ 13261 탈옥	D&C Optimization
BOJ 11001 김치	CHT (단조)
BOJ 10067 수열 나누기	D&C Optimization
BOJ 1648 격자 행렬의 비용	Knuth Optimization

Dynamic Segment Tree: 지연 노드 생성

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Dynamic Segment Tree 는 값 범위가 매우 크지만 실제 접근 위치가 희소할 때, 필요한 노드만 동적으로 생성 하는 세그먼트 트리.

공간: O(Q log V), Q = 쿼리 수, V = 값 범위 (최대 10^18).

일반 세그먼트 트리는 O(V) 공간 필요 → V = 10^9 이면 4GB, 불가능. 동적 세그먼트 트리는 실제 접근한 위치만 노드 생성.

문제 상황과 동기

언제 필요한가

좌표 범위가 극단적: 1 <= x <= 10^9, 하지만 쿼리 수 Q <= 10^5
온라인 쿼리: 좌표 압축을 위해 쿼리를 미리 알아야 하지만 불가능한 경우
버전 추적 불필요: Persistent Segtree 보다 구현 단순

방법 비교

방법	전제 조건	공간	복잡도
일반 세그트리	V 작음	O(V)	낮음
좌표 압축 + 세그	오프라인 처리	O(Q)	낮음
동적 세그트리	온라인, V 큼	O(Q log V)	중간
[[persistent-segtree	Persistent Segtree]]	버전 추적 필요	O(Q log V)

시각화

희소 노드 생성 원리

범위 [1, 10^9] 에서 쿼리 3개: 위치 100, 500000000, 900000000.

flowchart TD
    Root["루트 전체 범위"] --> L["왼쪽 절반"]
    Root --> R["오른쪽 절반"]
    L --> LL["왼쪽 1/4"]
    L --> LR["오른쪽 1/4"]
    LL --> Leaf1["위치 100 (생성)"]
    LR --> Leaf2["위치 500000000 (생성)"]
    R --> Leaf3["위치 900000000 (생성)"]

    style Leaf1 fill:#ccffcc
    style Leaf2 fill:#ccffcc
    style Leaf3 fill:#ccffcc

3개 쿼리 = 약 3 x log(10^9) = 약 90개 노드만 생성. 나머지는 nullptr.

포인터 노드 구조

flowchart LR
    Node["Node: sum, left, right"] --> Null["left = nullptr (미접근)"]
    Node --> Child["right = 자식 (접근 시 생성)"]
    Child --> GC["손자 노드들..."]

핵심 아이디어

Lazy node creation: 자식에 실제 접근할 때만 new Node() 생성. nullptr 이면 값은 기본값 0.

두 가지 구현 방식:

포인터 기반: Node* left, *right - 직관적, 동적 메모리 할당
Pool allocator: 배열 풀 미리 확보, 인덱스로 자식 참조 - 캐시 친화, new 오버헤드 없음

실전에서는 Pool allocator 권장 (TLE 방지).

알고리즘

Update (점 업데이트)

update(node, lo, hi, pos, delta):
    if node is null: node = new Node()
    if lo == hi:
        node.sum += delta
        return
    mid = (lo + hi) / 2
    if pos <= mid: update(node.left, lo, mid, pos, delta)
    else: update(node.right, mid+1, hi, pos, delta)
    node.sum = (node.left?.sum or 0) + (node.right?.sum or 0)

Query (구간 합)

query(node, lo, hi, ql, qr):
    if node is null: return 0
    if ql <= lo and hi <= qr: return node.sum
    mid = (lo + hi) / 2
    result = 0
    if ql <= mid: result += query(node.left, lo, mid, ql, qr)
    if qr > mid: result += query(node.right, mid+1, hi, ql, qr)
    return result

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Dynamic Segment Tree - 구간 합 // 범위 [1, 10^9], 포인터 기반 + Pool allocator 두 방법 #include <bits/stdc++.h> using namespace std;

// ===== 방법 1: 포인터 기반 ===== struct NodeP { long long sum = 0; NodeP *l = nullptr, *r = nullptr; };

void update_p(NodeP*& n, long long lo, long long hi, long long pos, long long v) { if (!n) n = new NodeP(); if (lo == hi) { n->sum += v; return; } long long mid = (lo + hi) / 2; if (pos <= mid) update_p(n->l, lo, mid, pos, v); else update_p(n->r, mid+1, hi, pos, v); n->sum = (n->l ? n->l->sum : 0) + (n->r ? n->r->sum : 0); }

long long query_p(NodeP* n, long long lo, long long hi, long long ql, long long qr) { if (!n) return 0; if (ql <= lo && hi <= qr) return n->sum; long long mid = (lo + hi) / 2, res = 0; if (ql <= mid) res += query_p(n->l, lo, mid, ql, qr); if (qr > mid) res += query_p(n->r, mid+1, hi, ql, qr); return res; }

// ===== 방법 2: Pool allocator (실전 권장) ===== const int POOL = 6000000; // Q * log(V) 여유 있게 struct NodeA { long long sum; int l, r; } pool[POOL]; int pcnt = 1; // 0 은 null 역할

void update_a(int n, long long lo, long long hi, long long pos, long long v) { pool[n].sum += v; if (lo == hi) return; long long mid = (lo + hi) / 2; if (pos <= mid) { if (!pool[n].l) pool[n].l = pcnt++; update_a(pool[n].l, lo, mid, pos, v); } else { if (!pool[n].r) pool[n].r = pcnt++; update_a(pool[n].r, mid+1, hi, pos, v); } }

long long query_a(int n, long long lo, long long hi, long long ql, long long qr) { if (!n) return 0; if (ql <= lo && hi <= qr) return pool[n].sum; long long mid = (lo + hi) / 2, res = 0; if (ql <= mid) res += query_a(pool[n].l, lo, mid, ql, qr); if (qr > mid) res += query_a(pool[n].r, mid+1, hi, ql, qr); return res; }

int main() { const long long V = 1e9;

// 포인터 기반
NodeP* root_p = nullptr;
update_p(root_p, 1, V, 100LL, 5);
update_p(root_p, 1, V, 500000000LL, 3);
update_p(root_p, 1, V, 900000000LL, 7);
cout << "포인터: [100, 9e8] = "
     << query_p(root_p, 1, V, 100, 900000000LL) << "\\n";  // 15

// Pool allocator
int root_a = pcnt++;
update_a(root_a, 1, V, 100LL, 5);
update_a(root_a, 1, V, 500000000LL, 3);
cout << "Pool: [1, 5e8] = "
     << query_a(root_a, 1, V, 1, 500000000LL) << "\\n";  // 8

}, }, { language: "python", label: "Python", code: # Dynamic Segment Tree - 딕셔너리 기반 (Python 특성 활용) class DynamicSegTree: def init(self, lo, hi): self.lo = lo self.hi = hi self.nodes = {} # (lo, hi) -> sum

def update(self, pos, val):
    self._update(self.lo, self.hi, pos, val)

def query(self, ql, qr):
    return self._query(self.lo, self.hi, ql, qr)

def _update(self, lo, hi, pos, val):
    key = (lo, hi)
    self.nodes[key] = self.nodes.get(key, 0) + val
    if lo == hi:
        return
    mid = (lo + hi) // 2
    if pos <= mid:
        self._update(lo, mid, pos, val)
    else:
        self._update(mid + 1, hi, pos, val)

def _query(self, lo, hi, ql, qr):
    key = (lo, hi)
    if key not in self.nodes:
        return 0
    if ql <= lo and hi <= qr:
        return self.nodes[key]
    mid = (lo + hi) // 2
    res = 0
    if ql <= mid:
        res += self._query(lo, mid, ql, qr)
    if qr > mid:
        res += self._query(mid + 1, hi, ql, qr)
    return res

사용 예시 (범위 [1, 10^9])

seg = DynamicSegTree(1, 10**9) seg.update(100, 5) seg.update(500_000_000, 3) seg.update(900_000_000, 7)

print(seg.query(1, 10**9)) # 15 print(seg.query(100, 500_000_000)) # 8 print(seg.query(1, 99)) # 0 print(f”노드 수: {len(seg.nodes)}”) # 약 3*30 = 90`, }, ]} cases={[ { label: “희소 업데이트 후 구간 합”, input: “update(100,5), update(500000000,3), update(900000000,7)\nquery(1, 10^9)”, output: “15”, }, { label: “부분 구간 쿼리”, input: “query(100, 500000000)”, output: “8”, }, { label: “빈 구간 쿼리”, input: “query(1, 99)”, output: “0”, }, ]} />

복잡도

항목	값
Update	O(log V)
Query	O(log V)
공간	O(Q log V)

Q = 총 쿼리 수, V = 값 범위. V = 10^9 이면 log V ≈ 30, Q = 2 x 10^5 이면 약 600만 노드.

Lazy Propagation 결합

구간 업데이트 (범위 전체에 값 추가) 가 필요하면 lazy tag 추가:

struct NodeL {
    long long sum = 0, lazy = 0;
    NodeL *l = nullptr, *r = nullptr;
};

void push_down(NodeL* n, long long lo, long long hi) {
    if (!n->lazy) return;
    long long mid = (lo + hi) / 2;
    if (!n->l) n->l = new NodeL();
    if (!n->r) n->r = new NodeL();
    n->l->sum += n->lazy * (mid - lo + 1);
    n->l->lazy += n->lazy;
    n->r->sum += n->lazy * (hi - mid);
    n->r->lazy += n->lazy;
    n->lazy = 0;
}

함정

1. Pool 크기 부족

Q x log(V) 를 넉넉히 잡지 않으면 배열 초과. V = 10^9 이면 log_2 V ≈ 30, 구간 업데이트는 x2 필요.

2. new/delete 반복 시 TLE

포인터 기반에서 매 쿼리마다 new 하면 할당자 오버헤드. Pool 방식 권장.

3. Lazy push 시 nullptr 자식 생성 타이밍

push_down 에서 nullptr 자식을 즉시 생성해야 lazy 값 전파 가능.

4. Pool 인덱스 0 충돌

Pool 기반에서 0 을 null 로 사용하고 실제 노드는 인덱스 1 부터. pcnt = 1 로 초기화.

5. 음수 좌표 범위

범위가 [-10^9, 10^9] 이면 lo, hi 타입을 long long 으로 선언. int 오버플로우 주의.

대안 비교

좌표 압축 + 일반 [[segtree|Segment Tree]]: 오프라인 처리 가능하면 더 빠르고 단순
[[persistent-segtree|Persistent Segtree]]: 버전 추적 (과거 상태 쿼리) 필요 시
BIT (펜윅 트리): 점 업데이트 + 구간 합만 필요하면 구현 단순, 동적 버전은 복잡

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 12899	데이터 구조	47.2%	kokoa-lab
BOJ 3653	영화 수집	42.3%	kokoa-lab
BOJ 1168	요세푸스 문제 2	41.7%	kokoa-lab

참고

[[segtree|Segment Tree]]
[[persistent-segtree|Persistent Segtree]]

Euler's Criterion: 이차잉여 판정

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

홀소수 p에 대해 정수 a가 mod p에서 이차잉여 (Quadratic Residue, QR) 인지 판정하는 기준:

$$ a^{(p-1)/2} \equiv \begin{cases} 1 \pmod{p} & \text{a가 mod p의 이차잉여} \ -1 \pmod{p} & \text{a가 mod p의 비이차잉여} \end{cases} $$

Legendre 기호 $(a/p)$는 위 결과를 -1, 0, 1로 인코딩:

$$ \left(\frac{a}{p}\right) = \begin{cases} 0 & p \mid a \ 1 & a \text{ is QR mod } p \ -1 & a \text{ is NR mod } p \end{cases} $$

문제 상황

이차잉여 판정이 필요한 상황:

제곱근 mod p 계산: $x^2 \equiv a \pmod{p}$ 의 해 존재 여부 먼저 확인
Tonelli-Shanks 알고리즘: QR 여부 판정 후 실제 제곱근 계산
Solovay-Strassen 소수 판정: Euler’s criterion을 합성수 판별에 활용
이차 상호 법칙: Legendre 기호 계산 및 이차 방정식 mod p 풀이

시각화

flowchart TD
    start["입력: 홀소수 p, 정수 a"]
    zero["p 가 a 를 나누는가?"]
    zero_yes["Legendre 기호 = 0"]
    exp["거듭제곱 모듈러 연산 수행"]
    one["결과 = 1 인가?"]
    qr["이차잉여 QR: 제곱근 존재"]
    nr["비이차잉여 NR: 제곱근 없음"]

    start --> zero
    zero -->|"예"| zero_yes
    zero -->|"아니오"| exp
    exp --> one
    one -->|"= 1"| qr
    one -->|"= p-1"| nr

핵심 아이디어

증명

[[flt|Fermat’s Little Theorem]]: $a^{p-1} \equiv 1 \pmod{p}$ (단, $p \nmid a$).

따라서 $\left(a^{(p-1)/2}\right)^2 \equiv 1 \pmod{p}$, 즉 $a^{(p-1)/2} \equiv \pm 1 \pmod{p}$.

QR 방향: $a \equiv b^2 \pmod{p}$ 이면

$$ a^{(p-1)/2} \equiv b^{p-1} \equiv 1 \pmod{p} $$

NR 방향: $\mathbb{Z}_p^*$는 순환군 (원시근 g 존재). $a = g^k$로 쓰면:

k가 짝수: $a = (g^{k/2})^2$ 이므로 QR, $a^{(p-1)/2} \equiv 1$
k가 홀수: NR, $g^{(p-1)/2} \equiv -1$ (원시근 성질)이므로 $a^{(p-1)/2} \equiv -1$

p=7 구체 예시

p=7에서 $(p-1)/2 = 3$. 각 a에 대해 $a^3 \bmod 7$ 계산:

a	$a^3 \bmod 7$	Legendre $(a/7)$	판정
1	1	1	QR ($1^2 \equiv 1$)
2	1	1	QR ($3^2 \equiv 2$)
3	6	-1	NR
4	1	1	QR ($2^2 \equiv 4$)
5	6	-1	NR
6	6	-1	NR

p=7에서 QR: {1, 2, 4}, NR: {3, 5, 6}. QR 개수 = NR 개수 = (p-1)/2 = 3.

Legendre 기호 성질

$$ \left(\frac{ab}{p}\right) = \left(\frac{a}{p}\right)\left(\frac{b}{p}\right) $$

QR × QR = QR
QR × NR = NR
NR × NR = QR

알고리즘

# Euler's Criterion: a가 mod p의 이차잉여인지 판정
function legendre(a, p):
    a = a mod p
    if a == 0: return 0          # Legendre 기호 = 0
    result = pow(a, (p-1)//2, p)
    if result == 1: return 1     # QR
    else: return -1              # NR (result == p-1)

핵심: pow(a, (p-1)//2, p) 는 빠른 거듭제곱으로 O(log p).

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std; typedef long long ll;

// 빠른 거듭제곱 (모듈러) ll power(ll base, ll exp, ll mod) { ll result = 1; base %= mod; while (exp > 0) { if (exp & 1) result = result * base % mod; base = base * base % mod; exp >>= 1; } return result; }

// Euler’s Criterion: Legendre 기호 반환 (-1, 0, 1) int legendre(ll a, ll p) { a %= p; if (a < 0) a += p; if (a == 0) return 0; ll val = power(a, (p - 1) / 2, p); return (val == 1) ? 1 : -1; }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

ll a, p;
cin >> a >> p;

int result = legendre(a, p);
if (result == 0)
    cout << a << " is divisible by " << p << "\\n";
else if (result == 1)
    cout << a << " is a quadratic residue mod " << p << "\\n";
else
    cout << a << " is a non-residue mod " << p << "\\n";

return 0;

}, }, { language: "python", label: "Python", code: def legendre(a, p): """Euler’s Criterion: Legendre 기호 반환 (-1, 0, 1)""" a %= p if a == 0: return 0 val = pow(a, (p - 1) // 2, p) return 1 if val == 1 else -1

def main(): a, p = map(int, input().split()) result = legendre(a, p) if result == 0: print(f”{a} is divisible by {p}”) elif result == 1: print(f”{a} is a quadratic residue mod {p}”) else: print(f”{a} is a non-residue mod {p}”)

main(), }, ]} cases={[ { label: "p=7, a=2 (QR)", input: 2 7, output: 2 is a quadratic residue mod 7, }, { label: "p=7, a=3 (NR)", input: 3 7, output: 3 is a non-residue mod 7, }, { label: "p=7, a=7 (0)", input: 7 7, output: 7 is divisible by 7`, }, ]} />

복잡도

항목	값
시간	O(log p)
공간	O(1)
핵심 연산	빠른 거듭제곱 (모듈러 지수)

응용

1. Tonelli-Shanks 알고리즘

$x^2 \equiv a \pmod{p}$ 의 실제 해를 구하는 알고리즘. Euler’s criterion으로 QR 여부 먼저 확인 후 실행.

[[discrete-sqrt|Tonelli-Shanks]] 참조.

2. Solovay-Strassen 소수 판정

합성수 n에 대해 $a^{(n-1)/2} \not\equiv (a/n) \pmod{n}$ 인 a가 존재하면 n은 합성수. 확률적 소수 판정에 활용.

3. Jacobi 기호 (일반화)

Legendre 기호를 홀수 합성수 n으로 확장:

$$ \left(\frac{a}{n}\right) = \prod_{i} \left(\frac{a}{p_i}\right)^{e_i} \quad (n = \prod p_i^{e_i}) $$

Jacobi 기호가 -1이면 반드시 NR. 1이면 QR이거나 합성수.

4. 이차 방정식 mod p

$ax^2 + bx + c \equiv 0 \pmod{p}$ 의 판별식 $\Delta = b^2 - 4ac$:

$(\Delta/p) = 1$: 두 해 존재
$(\Delta/p) = 0$: 중근
$(\Delta/p) = -1$: 해 없음

함정

1. p가 소수가 아닌 경우

Euler’s criterion은 홀소수 p에서만 성립. 합성수에서는 Jacobi 기호를 사용.

[!WARNING] p가 합성수일 때 $a^{(p-1)/2} \equiv 1 \pmod{p}$ 이어도 QR이 아닐 수 있음.

2. a=0 처리 누락

$p \mid a$ 이면 Legendre 기호 = 0. 이 경우를 별도 처리하지 않으면 오답.

3. 결과 p-1과 -1 혼동

pow(a, (p-1)/2, p) 의 결과가 p-1이면 이는 $-1 \pmod{p}$. NR 판정.

4. 정수 오버플로

C++에서 a * a % p 계산 시 a가 int 범위이면 a * a가 오버플로. long long 사용 필수.

5. 음수 a 처리

a가 음수이면 a %= p 후 음수가 될 수 있음. if (a < 0) a += p; 추가 필요.

BOJ 연습 문제

번호	제목	관련 개념
BOJ 11401	이항 계수 3	모듈러 역원 (FLT 응용)
BOJ 13977	이항 계수와 쿼리	모듈러 지수
BOJ 17831	이차잉여	Euler’s criterion 직접 적용

Expected Value: 기댓값, Linearity

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

확률변수 X 의 기댓값:

$$ E[X] = \sum_x x \cdot P(X = x) \quad \text{(discrete)} $$

$$ E[X] = \int x \cdot f(x) , dx \quad \text{(continuous)} $$

기댓값은 “평균적으로 기대되는 값”. 랜덤 알고리즘 분석, 확률 DP 문제에서 핵심 도구.

문제 상황

복잡한 확률 공간에서 랜덤 변수의 기댓값을 구해야 할 때, 직접 계산하면 경우의 수가 폭발적으로 늘어난다.

예시: n 개 원소의 랜덤 순열에서 고정점 (자기 자리에 오는 원소, fixed point) 의 평균 개수?

순진한 접근: 고정점이 정확히 k 개인 경우를 모두 열거. 포함-배제 원리 필요. 복잡함.

핵심 아이디어: 지시 변수 (indicator variable) 로 분해 + Linearity of Expectation 적용.

시각화

flowchart LR
    R["랜덤 변수 X 계산"] -->|"직접 계산"| D["경우의 수 폭발"]
    R -->|"분해 접근"| L["지시 변수 Xi 합으로 표현"]
    L --> Ei["각 E_Xi 개별 계산"]
    Ei --> S["Linearity 적용해 합산"]
    style D fill:#f9a825,color:#000
    style S fill:#2e7d32,color:#fff

핵심 아이디어

Linearity of Expectation

$$ E[X + Y] = E[X] + E[Y] $$

독립 여부 무관. X, Y 가 상관관계가 있어도 성립한다.

이것이 핵심: 복잡한 합 확률 변수를 단순한 지시 변수들의 합으로 분해 가능.

지시 변수

지시 변수 $X_i$:

$$ X_i = \begin{cases} 1 & \text{이벤트 } i \text{ 발생} \ 0 & \text{아닐 때} \end{cases} $$

$$ E[X_i] = 1 \cdot P(\text{이벤트}_i) + 0 \cdot P(\lnot\text{이벤트}_i) = P(\text{이벤트}_i) $$

분해 패턴

원하는 값 X 를 지시 변수 합으로 표현: $X = \sum_{i} X_i$
Linearity 적용: $E[X] = \sum_{i} E[X_i]$
각 $E[X_i] = P(\text{이벤트}_i)$ 를 개별 계산

각 $P(\text{이벤트}_i)$ 는 원래 문제보다 훨씬 단순한 경우가 많다.

알고리즘

예시 1: Fixed Points in Random Permutation

n 개의 원소를 랜덤 순열 배치, 고정점 개수의 기댓값?

$X_i$: i번째 원소가 고정점이면 1, 아니면 0
$P(X_i = 1) = \frac{1}{n}$ (n 자리 중 자기 자리에 올 확률)
Linearity 적용:

$$ E[X] = \sum_{i=1}^{n} E[X_i] = \sum_{i=1}^{n} \frac{1}{n} = 1 $$

랜덤 순열의 고정점 기댓값 = 1 (n 에 무관).

예시 2: Coupon Collector

n 종류 쿠폰, 매번 1개 랜덤 수집. 전 종류 모으려면 평균 몇 번?

k-1 종류 보유 중, 새 쿠폰 확률 = $\frac{n - k + 1}{n}$
k 번째 새 쿠폰 수집에 필요한 시도 횟수 기댓값:

$$ E[T_k] = \frac{n}{n - k + 1} $$

$$ E[\text{total}] = \sum_{k=1}^{n} \frac{n}{n-k+1} = n \cdot H_n \approx n \ln n $$

여기서 $H_n = 1 + \frac{1}{2} + \ldots + \frac{1}{n}$ 는 조화급수.

예시 3: Quicksort 평균 비교 횟수

임의 pivot 선택 quicksort 의 평균 비교 횟수.

$X_{ij}$: 원소 i 와 j 가 비교되면 1, 아니면 0 ($i < j$).

$P(X_{ij} = 1) = \frac{2}{j - i + 1}$ (i..j 범위에서 i 또는 j 가 먼저 pivot 으로 선택될 확률).

$$ E[\text{비교 횟수}] = \sum_{i < j} \frac{2}{j-i+1} = O(N \log N) $$

구현

<CodeWithOutput variants={[ { language: “python”, label: “Python: Simulation 검증”, code: `import random

def count_fixed_points(perm): return sum(1 for i, x in enumerate(perm) if i == x)

def coupon_steps(n, trials=50000): total = 0 for _ in range(trials): collected = set() steps = 0 while len(collected) < n: collected.add(random.randint(0, n - 1)) steps += 1 total += steps return total / trials

고정점 기댓값 = 1 검증

n = 8 trials = 50000 random.seed(42) fp_total = 0 for _ in range(trials): perm = list(range(n)) random.shuffle(perm) fp_total += count_fixed_points(perm) print(“Fixed points E =”, round(fp_total / trials, 3)) # ~1.0

Coupon Collector E[T] ~ n * H_n

n_c = 5 sim = coupon_steps(n_c) theory = n_c * sum(1.0 / (n_c - k + 1) for k in range(1, n_c + 1)) print(“Coupon n=5 sim=”, round(sim, 2), “theory=”, round(theory, 2)), }, { language: "cpp", label: "C++: Simulation", code: #include <bits/stdc++.h> using namespace std;

int main() { mt19937 rng(42); int n = 8, trials = 50000; double fp = 0; vector perm(n); iota(perm.begin(), perm.end(), 0); for (int t = 0; t < trials; t++) { shuffle(perm.begin(), perm.end(), rng); for (int i = 0; i < n; i++) fp += (perm[i] == i); } printf(“Fixed points E = %.3f\n”, fp / trials); // ~1.0

// Coupon Collector
int nc = 5;
double theory = 0;
for (int k = 1; k <= nc; k++) theory += (double)nc / (nc - k + 1);
printf("Coupon n=%d theory=%.2f\\n", nc, theory);
return 0;

}, }, ]} cases={[ { label: "기본", input: ``, output: Fixed points E = 1.000 Coupon n=5 sim=11.41 theory=11.42`, }, ]} />

복잡도

기댓값 계산은 분석 도구이지, 알고리즘 자체가 아님. 실제 알고리즘 복잡도에 자주 등장하는 공식:

문제 유형	기댓값 공식	비고
Fixed points in permutation	$E = 1$	n 무관
Coupon Collector	$E = n \cdot H_n \approx n \ln n$	조화급수
Quicksort 평균 비교 횟수	$O(N \log N)$	Linearity 분해
Randomized Select	$O(N)$ expected	-
기하 분포 성공까지 횟수	$E = 1/p$	p: 성공 확률
Randomized Primality	$O(k \log N)$	k: 반복 횟수

함정

[!WARNING] 비선형 함수에는 Linearity 없음: $E[X^2] \neq E[X]^2$. 일반적으로 $E[f(X)] \neq f(E[X])$ (Jensen’s inequality).

[!WARNING] 곱셈: $E[XY] = E[X] \cdot E[Y]$ 는 독립일 때만 성립. 상관 있으면 공분산 항 추가됨.

[!CAUTION] 기댓값이 발산할 수 있다. St. Petersburg paradox: 무한 기댓값. 무한 합 수렴 여부를 반드시 확인.

흔한 실수

$E[XY] \neq E[X] \cdot E[Y]$ 를 독립 확인 없이 적용
조건부 기댓값 $E[X \mid A]$ 와 $E[X]$ 혼동
지시 변수로 분해 시 이벤트 겹침 (overlap) 고려 안 함
연속 분포에서 합산을 적분으로 바꾸지 않음

BOJ 연습 문제

번호	제목	키워드
BOJ 11590	기댓값	기댓값 직접 계산
BOJ 14788	슬라임 연구자	기댓값 DP
BOJ 2062	돌멩이 제거	기댓값 + 확률
BOJ 17404	RGB 거리 2	확률 응용
BOJ 15810	풍선 공장	이분 탐색 + 기댓값

참고

[[probability|확률론 기초]]
[[markov-chain|Markov Chain]]
[[randomization|랜덤화 알고리즘]]
[[bayes|베이즈 정리]]
[[birthday|Birthday Problem]]

Golden-section Search: 단봉 함수 최적화

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

단봉 함수 (Unimodal function) 위에서 최소/최대를 찾는 탐색 기법. 이분 탐색을 단봉 조건으로 확장한 알고리즘입니다.

삼분 탐색 (Ternary Search): 구간을 3등분, 매 반복 함수 2회 호출, 1/3 제거
황금 분할 탐색 (Golden-section Search): 황금비로 분점, 매 반복 함수 1회 호출, 이전 값 재사용

단봉 함수 조건: 구간 [l, r] 에서 유일한 최대 (혹은 최소) 점 m 이 존재하고, m 의 왼쪽은 단조 증가, 오른쪽은 단조 감소 (최대화 기준).

문제 상황과 동기

이분 탐색으로 못 쓰는 이유

이분 탐색은 단조 함수 전제. 단봉 함수는 한 번 증가했다 감소하므로 “왼쪽이 작으면 오른쪽에 답이 있다”가 성립하지 않습니다.

단봉 함수 예시:

$f(x) = -(x-3)^2 + 10$ (최대 x=3)
볼록 다각형에서 특정 방향 최대 좌표
구간합의 최대 연속 부분합 (Slope Trick 형태)
기하 최적화: 점과 함수 곡선 간 최단 거리

언제 사용하는가

조건	사용 여부
함수가 단봉 (unimodal) 임이 명확	✅ 사용
구간 [l, r] 이 연속 실수	✅ 삼분 / 황금 분할
구간이 정수 이산	✅ 정수 삼분 탐색
함수가 볼록/오목 (convex/concave)	[[cht

시각화

삼분 탐색: 구간 3등분 후 1/3 제거

flowchart LR
    L["l"] --> M1["m1 = l + (r-l)/3"]
    M1 --> M2["m2 = r - (r-l)/3"]
    M2 --> R["r"]

    Cmp["f(m1) vs f(m2) 비교"]
    M1 --> Cmp
    M2 --> Cmp
    Cmp -->|"f(m1) 작을 때 (최대화)"| NewR["r = m2 (오른쪽 1/3 유지)"]
    Cmp -->|"f(m2) 작을 때 (최대화)"| NewL["l = m1 (왼쪽 1/3 유지)"]

매 반복: 구간이 2/3 로 줄어듭니다. 100회 반복 시 구간 길이 $(2/3)^{100} \approx 2 \times 10^{-18}$.

황금 분할: 이전 분점 재사용

flowchart TD
    Step1["1번째 반복: m1, m2 계산 (f 2회 호출)"]
    Step2["m1 쪽 제거 결정 -> 새 구간 [m1, r]"]
    Step3["2번째 반복: 이전 m2 가 새 m1 역할 (재사용!)"]
    Step4["새 m2 만 추가 계산 (f 1회 호출)"]

    Step1 --> Step2 --> Step3 --> Step4

황금비 $\varphi = \frac{1+\sqrt{5}}{2} \approx 1.618$, $1/\varphi \approx 0.618$.

분점 위치: $m_1 = r - \frac{1}{\varphi}(r-l)$, $m_2 = l + \frac{1}{\varphi}(r-l)$.

$m_2$ 를 버린 경우, 새 구간 $[l, m_2]$ 에서 이전 $m_1$ 이 정확히 새 구간의 황금비 위치가 됩니다. 따라서 $f(m_1)$ 재사용, 새 $m_2$ 만 계산.

핵심 아이디어

삼분 탐색 (Ternary Search)

최대화 기준: $f(m_1) < f(m_2)$ 이면 최대점은 $m_1$ 오른쪽에 있으므로 $l = m_1$ (왼쪽 1/3 제거). 반대면 $r = m_2$.

수렴율: 매 반복마다 구간 1/3 제거 → 같은 정밀도에 삼분은 더 많은 반복 필요.

황금 분할 탐색 (Golden-section Search)

수렴율: 매 반복마다 구간의 $1 - 1/\varphi \approx 38.2%$ 제거. 삼분 탐색의 $33.3%$ 보다 더 작은 제거율이지만, 함수 호출이 절반 이라 동일 호출 횟수 대비 더 빠른 수렴.

기법	반복당 호출	반복당 제거 비율	n회 호출 후 정밀도
삼분 탐색	2	33.3%	$(2/3)^{n/2}$
황금 분할	1 (이후)	38.2%	$(1/\varphi)^{n-1}$

정수 삼분 탐색

이산 도메인 (정수 인덱스) 에서는 while r - l > 2 종료, 나머지 구간 완전 탐색.

알고리즘

실수 삼분 탐색 (최대화)

ternary_max(l, r, f, iter=200):
    repeat iter times:
        m1 = l + (r - l) / 3
        m2 = r - (r - l) / 3
        if f(m1) < f(m2): l = m1
        else: r = m2
    return (l + r) / 2

황금 분할 탐색 (최대화)

golden_max(l, r, f):
    phi_inv = (sqrt(5) - 1) / 2  # 1/phi ≈ 0.618
    m1 = r - phi_inv * (r - l)
    m2 = l + phi_inv * (r - l)
    f1, f2 = f(m1), f(m2)
    repeat 200 times:
        if f1 < f2:
            l = m1; m1 = m2; f1 = f2
            m2 = l + phi_inv * (r - l); f2 = f(m2)
        else:
            r = m2; m2 = m1; f2 = f1
            m1 = r - phi_inv * (r - l); f1 = f(m1)
    return (l + r) / 2

정수 삼분 탐색

int_ternary_max(l, r, g):
    while r - l > 2:
        m1 = l + (r - l) / 3
        m2 = r - (r - l) / 3
        if g(m1) < g(m2): l = m1
        else: r = m2
    return argmax(g, l..r)

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Golden-section Search / Ternary Search #include <bits/stdc++.h> using namespace std;

// 예시 함수: 최대 x=3 에서 f=10 auto f = [](double x) { return -(x-3)(x-3) + 10; }; // 정수 예시: 최대 x=5 에서 g=25 auto g = [](int x) { return -(x-5)(x-5) + 25; };

// 삼분 탐색 (최대화) double ternary_max(double l, double r, int iter = 200) { for (int i = 0; i < iter; i++) { double m1 = l + (r - l) / 3; double m2 = r - (r - l) / 3; if (f(m1) < f(m2)) l = m1; else r = m2; } return (l + r) / 2; }

// 황금 분할 탐색 (최대화) double golden_max(double l, double r) { const double phi = (sqrt(5.0) - 1.0) / 2.0; // 1/phi ≈ 0.618 double m1 = r - phi * (r - l); double m2 = l + phi * (r - l); double f1 = f(m1), f2 = f(m2); for (int i = 0; i < 200; i++) { if (f1 < f2) { l = m1; m1 = m2; f1 = f2; m2 = l + phi * (r - l); f2 = f(m2); } else { r = m2; m2 = m1; f2 = f1; m1 = r - phi * (r - l); f1 = f(m1); } } return (l + r) / 2; }

// 정수 삼분 탐색 (최대화) int int_ternary_max(int l, int r) { while (r - l > 2) { int m1 = l + (r - l) / 3; int m2 = r - (r - l) / 3; if (g(m1) < g(m2)) l = m1; else r = m2; } int best = l; for (int x = l+1; x <= r; x++) if (g(x) > g(best)) best = x; return best; }

int main() { cout << fixed << setprecision(8); double xT = ternary_max(0.0, 10.0); cout << “삼분 탐색 최대 위치: ” << xT << ” f=” << f(xT) << “\n”;

double xG = golden_max(0.0, 10.0);
cout << "황금 분할 최대 위치: " << xG << "  f=" << f(xG) << "\\n";

int xI = int_ternary_max(0, 10);
cout << "정수 삼분 최대 위치: " << xI << "  g=" << g(xI) << "\\n";
return 0;

}, }, { language: "python", label: "Python", code: import math

def f(x): return -(x-3)**2 + 10 # 최대: x=3, f=10 def g(x): return -(x-5)**2 + 25 # 정수 최대: x=5, g=25

def ternary_max(l, r, iters=200): """삼분 탐색 (최대화)""" for _ in range(iters): m1 = l + (r - l) / 3 m2 = r - (r - l) / 3 if f(m1) < f(m2): l = m1 else: r = m2 return (l + r) / 2

def golden_max(l, r): """황금 분할 탐색 (최대화) - 함수 호출 절반""" phi = (math.sqrt(5) - 1) / 2 # 1/phi ≈ 0.618 m1 = r - phi * (r - l) m2 = l + phi * (r - l) f1, f2 = f(m1), f(m2) for _ in range(200): if f1 < f2: l, m1, f1 = m1, m2, f2 m2 = l + phi * (r - l) f2 = f(m2) else: r, m2, f2 = m2, m1, f1 m1 = r - phi * (r - l) f1 = f(m1) return (l + r) / 2

def int_ternary_max(l, r): """정수 삼분 탐색 (최대화)""" while r - l > 2: m1 = l + (r - l) // 3 m2 = r - (r - l) // 3 if g(m1) < g(m2): l = m1 else: r = m2 return max(range(l, r+1), key=g)

xT = ternary_max(0, 10) print(f”삼분 탐색 최대 위치: {xT:.8f} f={f(xT):.4f}”)

xG = golden_max(0, 10) print(f”황금 분할 최대 위치: {xG:.8f} f={f(xG):.4f}”)

xI = int_ternary_max(0, 10) print(f”정수 삼분 최대 위치: {xI} g={g(xI)}”)`, }, ]} cases={[ { label: “실수 최대화 (x=3 에서 f=10)”, input: “f(x) = -(x-3)^2 + 10, 구간 [0, 10]”, output: “삼분 탐색 최대 위치: 3.00000000 f=10.0000\n황금 분할 최대 위치: 3.00000000 f=10.0000”, }, { label: “정수 최대화 (x=5 에서 g=25)”, input: “g(x) = -(x-5)^2 + 25, 구간 [0, 10]”, output: “정수 삼분 최대 위치: 5 g=25”, }, ]} />

복잡도

항목	삼분 탐색	황금 분할
반복당 f 호출	2회	1회 (이후)
n회 f 호출 후 정밀도	$(2/3)^{n/2} \cdot (r-l)$	$(1/\varphi)^{n-1} \cdot (r-l)$
100회 호출 후	$(2/3)^{50} \approx 1.2 \times 10^{-9}$	$(0.618)^{99} \approx 2.2 \times 10^{-21}$
iter=100 삼분	정밀도 $10^{-17}$ (200 호출)	-

황금 분할이 같은 f 호출 횟수로 훨씬 높은 정밀도.

함정

1. 단봉 조건 미확인

[!WARNING] 함수가 단봉이 아닌 경우 (예: 여러 개의 극값) 삼분 탐색은 잘못된 결과를 냅니다. 문제에서 “단봉” 또는 “볼록” 조건을 반드시 확인하세요.

2. 최솟값 vs 최댓값 혼동

최솟값: f(m1) > f(m2) 이면 l = m1. 최댓값과 조건이 반대.

// 최솟값
if (f(m1) > f(m2)) l = m1;
else r = m2;

// 최댓값
if (f(m1) < f(m2)) l = m1;
else r = m2;

3. 정수 삼분 탐색에서 종료 조건 오류

while r - l > 2 가 아닌 r - l > 1 로 쓰면 나머지 구간 탐색이 부족해 최대점을 놓칠 수 있습니다.

4. 이분 탐색과의 혼동

[!CAUTION] 삼분 탐색은 단봉 함수에만 유효. [[binary-search|이분 탐색]] 은 단조 함수 전용. 조건 혼용 금지.

5. 반복 횟수 과소

실수 탐색에서 iter=50 이면 $(2/3)^{50} \approx 1.2 \times 10^{-9}$ 의 정밀도. 보통 문제에서는 $10^{-9}$ 이상 요구하므로 iter=100~200 권장.

6. 황금 분할 초기 f 2회 호출 후 1회

황금 분할도 첫 반복에 f 2회, 이후부터 1회. 첫 m1, m2 계산은 별도 처리 필요.

7. 볼록 다각형 극값 탐색

볼록 다각형에서 특정 방향 최대 꼭짓점 탐색에 삼분 탐색 적용 가능. 단 마지막 꼭짓점과 첫 꼭짓점의 연결이 단봉을 만족하는지 확인.

변형: 최솟값 탐색

함수 부호를 반전하거나 조건을 반대로:

def ternary_min(l, r, iters=200):
    for _ in range(iters):
        m1 = l + (r - l) / 3
        m2 = r - (r - l) / 3
        if f(m1) > f(m2): l = m1  # 최솟값 조건 반전
        else: r = m2
    return (l + r) / 2

BOJ 연습 문제

번호	제목	유형
BOJ 8983	사냥꾼	삼분 탐색 기본
BOJ 11664	선분과 점	실수 삼분 탐색
BOJ 1equa	방정식 근사	이분 + 삼분 혼합
BOJ 13306	트리	파라메트릭 탐색
BOJ 10989	수 정렬하기 3	정수 삼분 탐색 응용

참고

[[binary-search|이분 탐색]] (단조 함수용)
[[ternary-search|Ternary Search]] (삼분 탐색 상세)
[[parametric-search|Parametric Search]] (결정 함수 이분)
[[cht|Convex Hull Trick]] (볼록 함수 특수 최적화)
[[calculus|미적분]] (연속 함수 극값 수학적 접근)

Graph DP: 트리/DAG 위 DP

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Graph DP 는 그래프 구조를 이용한 DP. 사이클 없는 그래프 (트리, DAG) 에서 특히 자연스럽다.

Tree DP: 루트 트리에서 자식 서브트리 결과를 조합
DAG DP: 위상 정렬 후 순서대로 전이 계산
Rerooting: Tree DP 를 모든 정점이 루트일 때의 답으로 확장

문제 상황

배열 DP (1D, 2D) 는 인덱스 순서로 전이. 그래프에서는 인덱스 대신 노드 관계 가 DP 전이를 결정.

트리 문제 예시:

서브트리 크기, 트리 지름, 최대 독립 집합
각 노드를 루트로 했을 때의 트리 전체 답

DAG 문제 예시:

가장 긴 경로 (Longest Path in DAG)
경로 수 세기, 최소/최대 비용 경로

시각화

flowchart TD
    root(("1\n루트")) --> A(("2"))
    root --> B(("3"))
    A --> C(("4"))
    A --> D(("5"))
    B --> E(("6"))
    B --> F(("7"))

DFS 순서: 1 -> 2 -> 4, 5 -> 3 -> 6, 7.

리프 노드부터 계산해 부모에게 전달.

핵심 아이디어

Tree DP: 기본 구조

dfs(u, parent):
    dp[u] = base_value(u)
    for v in adj[u]:
        if v == parent: continue  // 부모 방향 스킵
        dfs(v, u)
        dp[u] = combine(dp[u], dp[v])

combine 은 문제마다 다름:

서브트리 크기: dp[u] += dp[v]
서브트리 최대 독립 집합: 더 복잡 (선택/불선택 두 상태)

Rerooting: 두 번의 DFS

특정 루트 기준 Tree DP 는 O(N). 모든 정점을 루트로 하는 답이 필요하면 rerooting 으로 O(N) 에 해결.

flowchart LR
    DFS1["DFS 1: 임의 루트로\ndown DP 계산"] --> DFS2["DFS 2: up DP 계산\nrerooting 전이"]
    DFS2 --> Result["모든 정점 루트로 했을 때의 답"]

DAG DP

[[topological-sorting|위상 정렬]] 후, in-degree 0 부터 순서대로 계산.

topo_sort(graph) -> order
for u in order:
    for v in adj[u]:
        dp[v] = update(dp[v], dp[u])

알고리즘

Tree DP: 서브트리 크기

int sz[MAXN];
void dfs_sz(int u, int p) {
    sz[u] = 1;
    for (int v : adj[u]) if (v != p) {
        dfs_sz(v, u);
        sz[u] += sz[v];
    }
}

Tree DP: 최대 독립 집합

각 정점에서 “선택” / “불선택” 두 상태:

dp[u][1] = u 를 선택했을 때 최대 크기
dp[u][0] = u 를 선택 안 했을 때 최대 크기

int dp[MAXN][2];
void dfs_mis(int u, int p) {
    dp[u][1] = 1;   // 자신 선택
    dp[u][0] = 0;   // 자신 불선택
    for (int v : adj[u]) if (v != p) {
        dfs_mis(v, u);
        dp[u][1] += dp[v][0];         // 자신 선택하면 자식 불선택
        dp[u][0] += max(dp[v][0], dp[v][1]); // 자신 불선택하면 자식 중 최적
    }
}
// 답: max(dp[root][0], dp[root][1])

Rerooting: 트리의 모든 정점에서의 거리 합

전형적인 rerooting 예제.

long long dist_sum[MAXN];  // u 를 루트로 했을 때 모든 노드까지 거리 합
long long sub_sum[MAXN];   // u 서브트리 노드까지 거리 합 (루트 기준)
long long sub_cnt[MAXN];   // u 서브트리 크기

// DFS 1: 루트 r=0 기준 down DP
void dfs1(int u, int p) {
    sub_cnt[u] = 1;
    sub_sum[u] = 0;
    for (int v : adj[u]) if (v != p) {
        dfs1(v, u);
        sub_cnt[u] += sub_cnt[v];
        sub_sum[u] += sub_sum[v] + sub_cnt[v];  // v 서브트리의 모든 노드가 +1 거리
    }
}

// DFS 2: rerooting (위로 정보 전달)
void dfs2(int u, int p, int N) {
    for (int v : adj[u]) if (v != p) {
        // u 에서 v 로 루트 변경 시:
        // v 서브트리 외 노드 수 = N - sub_cnt[v]
        // 그 노드들의 v 에서의 거리 = dist_sum[u] - (sub_sum[v] + sub_cnt[v]) + (N - sub_cnt[v])
        dist_sum[v] = dist_sum[u]
                    - (sub_sum[v] + sub_cnt[v])   // 제거: v 방향 기여
                    + (N - sub_cnt[v]);            // 추가: 나머지 노드들 +1
        dfs2(v, u, N);
    }
}

DAG DP: 최장 경로

vector<int> order;  // 위상 정렬 순서
long long dp[MAXN]; // dp[u] = u 에서 시작하는 최장 경로

// 위상 정렬 후
for (int u : order) {
    for (auto [v, w] : adj[u]) {
        dp[u] = max(dp[u], dp[v] + w);  // v 로 가는 에지
    }
}
// 답: max(dp[u]) for all u

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++: Tree DP, 서브트리 크기”, code: `#include <bits/stdc++.h> using namespace std;

const int MAXN = 100005; vector adj[MAXN]; int sz[MAXN], dp0[MAXN], dp1[MAXN];

void dfs(int u, int p) { sz[u] = 1; dp0[u] = 0; dp1[u] = 1; for (int v : adj[u]) { if (v == p) continue; dfs(v, u); sz[u] += sz[v]; dp1[u] += dp0[v]; dp0[u] += max(dp0[v], dp1[v]); } }

int main() { int n; cin >> n; for (int i = 0; i < n - 1; i++) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } dfs(1, 0); int root = 1; cout << “서브트리 크기: ” << sz[root] << “\n”; cout << “최대 독립 집합: ” << max(dp0[root], dp1[root]) << “\n”; return 0; }, }, { language: "python", label: "Python: Tree DP", code: import sys sys.setrecursionlimit(200000)

def solve(): n = int(input()) adj = [[] for _ in range(n + 1)] for _ in range(n - 1): u, v = map(int, input().split()) adj[u].append(v) adj[v].append(u)

sz = [1] * (n + 1)
dp0 = [0] * (n + 1)  # 자신 불선택
dp1 = [1] * (n + 1)  # 자신 선택

def dfs(u, p):
    for v in adj[u]:
        if v == p:
            continue
        dfs(v, u)
        sz[u] += sz[v]
        dp1[u] += dp0[v]
        dp0[u] += max(dp0[v], dp1[v])

dfs(1, 0)
print("서브트리 크기:", sz[1])
print("최대 독립 집합:", max(dp0[1], dp1[1]))

solve(), }, ]} cases={[ { label: "기본 (n=7, path graph)", input: 7 1 2 1 3 2 4 2 5 3 6 3 7, output: 서브트리 크기: 7 최대 독립 집합: 4`, }, ]} />

복잡도

알고리즘	시간	공간	비고
Tree DP (기본)	$O(N)$	$O(N)$	각 노드 1번 방문
Tree DP (2상태, k상태)	$O(N \cdot k)$	$O(N \cdot k)$	상태 수 k
Rerooting	$O(N)$	$O(N)$	DFS 2번
DAG DP	$O(V + E)$	$O(V)$	위상 정렬 + DP

Tree DP 에서 자식 결합이 O(1) 이면 전체 O(N). 서브트리 결합이 O(k) 이면 전체 O(N * k).

함정

[!WARNING] 재귀 깊이: n = 10^5 인 bamboo tree (경로 그래프) 에서 재귀 DFS 는 스택 오버플로우. 반복 DFS 또는 재귀 제한 증가 필요.

[!WARNING] Rerooting 전이 오류: dist_sum[v] 를 계산할 때 v 서브트리의 기여를 빼고 나머지를 더하는 전이식 방향을 헷갈리기 쉬움. 작은 예시로 손 검증 필수.

[!CAUTION] 간선 방향: DAG DP 에서 에지 방향이 반대이면 위상 정렬 순서와 전이 방향도 반대. 문제 조건 꼼꼼히 확인.

흔한 실수

부모 노드 체크 없이 DFS: 무한 루프 (if v != parent continue)
리프 노드의 dp 초기화를 잊음
Rerooting 에서 두 번째 DFS 에 dist_sum[root] 를 sub_sum[root] 로 초기화 안 함
DAG 의 위상 정렬 전 DP 전이: 방문 안 된 노드의 값 사용

BOJ 연습 문제

번호	제목	키워드
BOJ 1167	트리의 지름	Tree DP, DFS 2회
BOJ 2533	사회망 서비스	Tree DP, 최대 독립 집합
BOJ 2213	트리의 독립 집합	Tree DP, 2상태
BOJ 1149	RGB 거리	선형 DP (Tree DP 기초)
BOJ 14267	회사 문화 1	Tree DP + 위로 전달
BOJ 1516	게임 개발	DAG DP

참고

[[topological-sorting|위상 정렬]]
[[tree-diameter|Tree Diameter]]
[[dp-bitfield|DP Bitfield]]
[[dp|다이나믹 프로그래밍]]
[[dp-tree|Tree DP 심화]]
[[dfs|DFS]]

Hamiltonian Path: 모든 정점 한 번씩

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Hamiltonian Path 는 그래프의 모든 정점을 정확히 한 번씩 방문하는 경로. 시작 = 끝이면 Hamiltonian Cycle.

일반 그래프에서 NP-complete. Euler path (모든 간선을 한 번씩) 와 대비: Euler 는 다항 시간(Hierholzer 알고리즘).

문제 상황

N개의 정점과 M개의 간선으로 이루어진 그래프에서 모든 정점을 정확히 한 번씩 방문하는 경로가 존재하는가?

naive (백트래킹): 모든 정점 순열을 시도. O(N! x N). N=15 이상이면 불가능.

핵심 통찰: “방문한 정점 집합” 자체를 상태로 만들어 DP. dp[mask][v]를 “방문 집합 = mask, 현재 v에 있을 때 도달 가능 여부”로 정의. 상태 수 O(2^N x N), 전이 O(N).

시각화

Bitmask DP 상태 전이 (N=4, 정점 0에서 출발)

flowchart LR
    S["출발: 정점 0만 방문"]
    A["정점 0,1 방문, 현재 위치 1"]
    B["정점 0,2 방문, 현재 위치 2"]
    C["정점 0,1,2 방문, 현재 위치 2"]
    D["정점 0,1,3 방문, 현재 위치 3"]
    E["정점 0,1,2,3 방문 완료"]
    S -->|"0에서 1 이동"| A
    S -->|"0에서 2 이동"| B
    A -->|"1에서 2 이동"| C
    A -->|"1에서 3 이동"| D
    C -->|"2에서 3 이동"| E
    D -->|"3에서 2 이동"| E

Bitmask 표현 (N=4)

mask (이진)	십진	방문 정점 집합
0001	1	{0}
0011	3	{0, 1}
0101	5	{0, 2}
0111	7	{0, 1, 2}
1111	15	{0, 1, 2, 3} (전체)

핵심 아이디어

상태: dp[mask][v] = “방문 집합 = mask, 현재 v에 있는 상태가 도달 가능한가.”

초기: dp[1 << s][s] = true (출발 정점 s 하나만 방문).

전이: 현재 상태 (mask, u)에서 미방문 정점 v로 이동.

if dp[mask][u] and edge(u,v) and v not in mask:
    dp[mask | (1 << v)][v] = true

답: full = (1 << N) - 1인 전체 집합을 포함하는 mask에서 도달 가능한 v가 존재하면 YES.

Hamiltonian Path: any(dp[full][v] for v in 0..N-1) → 경로만 확인
Hamiltonian Cycle: any(dp[full][v] and edge(v, start) for v in 0..N-1) → 시작점 복귀

비트 연산 정리

연산	코드
v 방문 여부 확인	`mask & (1 << v)`
v 추가	`mask
v 제거	`mask & ~(1 << v)`
전체 집합	`(1 << N) - 1`

알고리즘

# Hamiltonian Path Bitmask DP
# 단일 출발점 s 기준

dp[1 << s][s] = true
for mask = 1 to (1<<N) - 1:
    for u = 0 to N-1:
        if not dp[mask][u]: continue
        if not (mask & (1 << u)): continue   # 유효 상태 체크
        for v in adj[u]:
            if mask & (1 << v): continue      # 이미 방문
            dp[mask | (1 << v)][v] = true

full = (1 << N) - 1
answer = any(dp[full][v] for v in 0..N-1)

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std;

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

int n, m;
cin >> n >> m;

vector<vector<int>> adj(n);
for (int i = 0; i < m; i++) {
    int u, v;
    cin >> u >> v;
    adj[u].push_back(v);
    adj[v].push_back(u);  // 무방향 그래프
}

// dp[mask][v]: mask 집합 방문 후 v에 위치 가능한가
int FULL = (1 << n) - 1;
vector<vector<bool>> dp(1 << n, vector<bool>(n, false));

// 모든 정점을 출발점으로 시도
for (int s = 0; s < n; s++)
    dp[1 << s][s] = true;

for (int mask = 1; mask <= FULL; mask++) {
    for (int u = 0; u < n; u++) {
        if (!dp[mask][u]) continue;
        if (!(mask & (1 << u))) continue;
        for (int v : adj[u]) {
            if (mask & (1 << v)) continue;  // 이미 방문
            dp[mask | (1 << v)][v] = true;
        }
    }
}

bool found = false;
for (int v = 0; v < n; v++)
    if (dp[FULL][v]) { found = true; break; }

cout << (found ? "YES" : "NO") << "\\n";
return 0;

}, }, { language: "python", label: "Python", code: import sys input = sys.stdin.readline

def solve(): n, m = map(int, input().split()) adj = [[] for _ in range(n)] for _ in range(m): u, v = map(int, input().split()) adj[u].append(v) adj[v].append(u)

FULL = (1 << n) - 1
# dp[mask][v]: mask 집합 방문 후 v에 위치 가능한가
dp = [[False] * n for _ in range(1 << n)]

for s in range(n):
    dp[1 << s][s] = True

for mask in range(1, FULL + 1):
    for u in range(n):
        if not dp[mask][u]:
            continue
        if not (mask >> u & 1):
            continue
        for v in adj[u]:
            if mask >> v & 1:
                continue  # 이미 방문
            dp[mask | (1 << v)][v] = True

found = any(dp[FULL][v] for v in range(n))
print("YES" if found else "NO")

solve(), }, ]} cases={[ { label: "경로 존재", input: 4 5 0 1 1 2 2 3 0 2 1 3, output: YES, }, { label: "경로 없음", input: 4 2 0 1 2 3, output: NO`, }, ]} />

복잡도

항목	값
시간	O(2^N x N^2)
공간	O(2^N x N)
N=15	2^15 x 225 ~ 7.4M (여유)
N=20	2^20 x 400 ~ 420M (타이트)
실용 한계	N <= 20

[!NOTE] N=20 기준 메모리: bool dp[2^20][20] = 약 20MB. int 사용 시 80MB.

함정

1. 유효 상태 체크 누락

if (!(mask & (1 << u))) continue;
// 이 체크가 없으면 u가 mask에 없는 잘못된 상태에서 전이 발생

2. 출발 정점 범위

Hamiltonian Path는 어떤 정점에서도 시작 가능. 모든 s에 대해 dp[1<<s][s]=true로 초기화. 시작점을 0으로 고정하면 방향 있는 경우에만 유효.

3. 방향 vs 무방향

무방향: adj[u].push_back(v) 와 adj[v].push_back(u) 둘 다
방향: 단방향만. Hamiltonian Cycle 존재 조건이 달라짐.

4. Cycle vs Path 혼동

Cycle: 마지막 정점 v에서 출발점 s로 돌아올 수 있는 간선 존재 확인 필요.

// Hamiltonian Cycle 확인 (출발 s 고정 시)
for (int v = 0; v < n; v++)
    if (dp[FULL][v] && adj_matrix[v][s]) found = true;

5. 백트래킹 vs DP

N <= 12 정도는 백트래킹도 빠름. N=15~20에서 DP가 확실히 유리. N > 20은 모두 불가.

BOJ 연습 문제

번호	제목	난이도	알고리즘
BOJ 1194	달이 차오른다, 가자.	Gold 1	BFS + bitmask
BOJ 2098	외판원 순회	Gold 1	TSP, bitmask DP
BOJ 1987	알파벳	Gold 4	백트래킹
BOJ 17471	게리맨더링	Gold 4	부분집합 + bitmask

참고

[[tsp|TSP]] (Hamiltonian Cycle + 최소 비용)
[[dp-bitfield|Bitmask DP]] (비트 연산 상세)
[[dp-on-bitmask|DP on Bitmask]]

Hash Table: 해시 기반 딕셔너리

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Hash Table 은 해시 함수로 키를 배열 인덱스에 매핑하여 평균 O(1) 삽입/탐색/삭제를 제공하는 자료구조.

키 k를 인덱스 h(k) mod m으로 변환하여 버킷 배열에 저장. 두 키가 같은 인덱스를 가리키면 충돌(collision) 발생.

문제 상황

N개의 키-값 쌍을 저장하고, 임의 키에 대해 빠르게 값을 조회/삽입/삭제해야 한다.

naive (정렬 배열): 이진 탐색으로 O(log N) 조회. 삽입/삭제 O(N).

naive (연결 리스트): 탐색 O(N). 삽입 O(1).

핵심 통찰: 해시 함수로 키를 인덱스로 변환. 충돌이 없다면 O(1) 모든 연산. 충돌을 체이닝 또는 개방 주소법으로 처리.

시각화

Chaining 구조 (버킷 배열 + 연결 리스트)

flowchart LR
    subgraph "버킷 배열"
        B0["버킷 0"]
        B1["버킷 1"]
        B2["버킷 2"]
        B3["버킷 3"]
    end
    C0["apple: 사과"]
    C2a["banana: 바나나"]
    C2b["cherry: 체리"]
    C3["date: 대추"]
    B0 --> C0
    B1 -->|"empty"| X1[" "]
    B2 --> C2a
    C2a -->|"충돌, 체이닝"| C2b
    B3 --> C3

Open Addressing (선형 탐사)

flowchart LR
    In["insert(key, val)\nh = hash(key) mod m"]
    A{"배열[h] 비었나?"}
    B["배열[h]에 저장"]
    C["h = (h+1) mod m\n다음 슬롯 탐색"]
    In --> A
    A -->|"YES"| B
    A -->|"NO, 충돌"| C
    C --> A

핵심 아이디어

Chaining

각 버킷에 연결 리스트/트리 저장. 충돌 시 리스트에 추가.

삽입: O(1) amortized (리스트 헤드에 추가)
탐색: O(1) 평균, O(N) 최악 (해시 충돌 집중 시)
부하율(load factor) alpha = N/M: alpha가 높으면 평균 체인 길이 증가

Open Addressing

충돌 시 배열 내 다른 슬롯 탐색. 별도 메모리 필요 없음.

탐사 방법	다음 슬롯	특징
Linear probing	`(h + i) mod m`	클러스터링 문제
Quadratic probing	`(h + i^2) mod m`	일차 클러스터링 완화
Double hashing	`(h1 + i*h2) mod m`	최적. h2 신중히 선택

부하율 0.5~0.7 유지 권장. 초과 시 rehash(테이블 크기 2배 확장).

해시 함수 선택

정수 키: h(k) = k mod m (m은 소수 추천)
문자열: Polynomial rolling hash h = (c0 + c1*p + c2*p^2 + ...) mod m
적대적 입력 대비: SipHash (C++ unordered_map의 일부 구현), 무작위 salt

알고리즘

# Chaining 삽입
insert(table, key, val):
    h = hash(key) mod m
    table[h].append((key, val))

# Chaining 탐색
search(table, key):
    h = hash(key) mod m
    for (k, v) in table[h]:
        if k == key: return v
    return NOT_FOUND

# Rehash (부하율 초과 시)
rehash(table):
    new_table = new array of size 2*m
    for each entry (key, val) in table:
        new_h = hash(key) mod (2*m)
        new_table[new_h].append((key, val))
    return new_table

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++ (unordered_map)”, code: `#include <bits/stdc++.h> using namespace std;

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

int n, q;
cin >> n >> q;

unordered_map<string, int> table;
table.reserve(1 << 17);  // 초기 버킷 크기 예약 (rehash 방지)

// 삽입
for (int i = 0; i < n; i++) {
    string key;
    int val;
    cin >> key >> val;
    table[key] = val;
}

// 쿼리
for (int i = 0; i < q; i++) {
    string key;
    cin >> key;
    auto it = table.find(key);
    if (it != table.end()) cout << it->second << "\\n";
    else cout << "NOT_FOUND\\n";
}
return 0;

}, }, { language: "python", label: "Python (dict)", code: import sys input = sys.stdin.readline

def solve(): n, q = map(int, input().split())

table = {}

for _ in range(n):
    parts = input().split()
    key, val = parts[0], int(parts[1])
    table[key] = val

for _ in range(q):
    key = input().strip()
    if key in table:
        print(table[key])
    else:
        print("NOT_FOUND")

solve(), }, ]} cases={[ { label: "기본 삽입/조회", input: 3 3 apple 1 banana 2 cherry 3 banana grape apple, output: 2 NOT_FOUND 1, }, { label: "중복 키 갱신", input: 3 1 x 10 x 20 x 30 x, output: 30`, }, ]} />

복잡도

연산	평균	최악	조건
삽입	O(1)	O(N)	충돌 집중 시 최악
탐색	O(1)	O(N)	적대적 해시 입력
삭제	O(1)	O(N)
Rehash	O(N)	O(N)	부하율 초과 시 발생
공간	O(N)	O(N)

[!NOTE] 트리 기반 맵(BST, std::map)은 O(log N) 보장. 정렬 순서가 필요하면 BST, 순수 속도만 필요하면 Hash Table.

언어별 구현

언어	자료형	내부 구현
C++	`unordered_map`, `unordered_set`	chaining (GCC)
Java	`HashMap`, `HashSet`	chaining + tree (Java 8+, bucket >= 8)
Python	`dict`, `set`	open addressing (compact, 삽입 순서 보장 3.7+)
Go	`map`	chaining
Rust	`HashMap`	SipHash 기본, open addressing

함정

1. 최악 O(N): 적대적 입력

같은 해시값을 갖는 키만 삽입하면 체인 길이 O(N). C++ unordered_map의 기본 해시는 예측 가능하여 취약.

해결책:

// 무작위 salt 기반 커스텀 해시
struct custom_hash {
    static uint64_t splitmix64(uint64_t x) {
        x += 0x9e3779b97f4a7c15;
        x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
        x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
        return x ^ (x >> 31);
    }
    size_t operator()(uint64_t x) const {
        static const uint64_t FIXED_RANDOM = chrono::steady_clock::now().time_since_epoch().count();
        return splitmix64(x + FIXED_RANDOM);
    }
};
unordered_map<long long, int, custom_hash> safe_map;

2. 부하율 초과 방치

부하율이 높아지면 충돌 증가로 성능 저하. reserve로 미리 크기 확보하거나 max_load_factor 조정.

table.reserve(1 << 17);
table.max_load_factor(0.25);

3. iteration 순서

Python 3.7+는 삽입 순서 보장, C++ unordered_map은 임의 순서. 순서 의존 코드 주의.

4. Open Addressing 삭제

삭제된 슬롯을 그냥 비우면 이후 탐색 시 체인이 끊김. Tombstone 마커로 표시하거나 backward shift deletion.

5. 정수 키에서 % 연산 오버플로

C++에서 long long 키를 int 버킷 크기로 나누면 문제 없지만, 음수 키는 % 연산이 음수 반환. (h % m + m) % m으로 처리.

BOJ 연습 문제

번호	제목	난이도	알고리즘
BOJ 1920	수 찾기	Silver 4	해시셋 / 이분탐색
BOJ 10546	배부른 마라토너	Bronze 2	해시맵
BOJ 1764	듣보잡	Silver 4	해시셋 교집합
BOJ 1717	집합의 표현	Gold 5	Disjoint Set (해시맵 응용 가능)

참고

[[binary-search-tree|BST]] (정렬 필요 시 대체, O(log N) 보장)
[[bloom-filter|Bloom Filter]] (근사 존재 확인, 메모리 절약)

Huffman Coding: 최적 접두 부호

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Huffman Coding 은 문자의 빈도가 주어졌을 때 평균 부호 길이를 최소화 하는 접두 부호 (prefix code) 를 만드는 그리디 알고리즘. David Huffman (1952) 이 MIT 학생 시절 발표.

접두 부호: 어떤 부호도 다른 부호의 접두어가 아님. 구분자 없이 디코딩 가능.

문제 상황

N 개의 심볼과 각 빈도(혹은 확률)가 주어졌을 때, 각 심볼을 이진 부호로 표현해 전체 메시지의 평균 비트 수를 최소화 하라.

예: a=5, b=9, c=12, d=13, e=16, f=45 (총 100회 등장)

방식	설명	평균 비트/심볼
고정 길이	6개 심볼 -> 최소 3비트 필요	3.00 bit
Huffman	빈도에 따라 가변 길이	2.24 bit
Shannon entropy	이론적 하한	~2.20 bit

고정 길이보다 약 25% 절약. 핵심 통찰: 빈도 높은 심볼에 짧은 부호, 드문 심볼에 긴 부호.

핵심 아이디어

가장 빈도가 낮은 두 심볼을 반복적으로 합쳐 이진 트리를 만든다. 트리 루트에서 각 리프까지의 경로 (왼쪽=0, 오른쪽=1) 가 최적 부호가 된다.

flowchart TD
    A["빈도 계산"] --> B["min-heap 초기화"]
    B --> C["최솟값 두 노드 pop"]
    C --> D["합계로 내부 노드 생성"]
    D --> E["heap 에 push"]
    E --> F{"heap 크기 = 1?"}
    F -->|"No"| C
    F -->|"Yes"| G["루트 반환"]
    G --> H["DFS 로 부호 할당"]

알고리즘

각 문자를 리프 노드로 하고 빈도를 우선순위로 하는 min-heap 준비.
Heap 에서 최소 두 노드를 pop, 두 빈도의 합을 값으로 하는 새 내부 노드 생성 (두 노드를 자식으로).
새 노드를 heap 에 push.
Heap 크기가 1 이 될 때까지 반복.
완성된 트리의 루트에서 각 리프까지의 경로가 부호 (왼쪽=0, 오른쪽=1).

O(N log N) - N 은 문자 종류 수.

예시

빈도: a=5, b=9, c=12, d=13, e=16, f=45

병합 과정:

단계	조작	heap 최솟값 순
초기	-	a:5, b:9, c:12, d:13, e:16, f:45
1	a(5)+b(9) = 14	c:12, d:13, ab:14, e:16, f:45
2	c(12)+d(13) = 25	ab:14, e:16, cd:25, f:45
3	ab(14)+e(16) = 30	cd:25, abe:30, f:45
4	cd(25)+abe(30) = 55	f:45, inner:55
5	f(45)+inner(55) = 100	root:100

완성된 트리 (왼쪽=0, 오른쪽=1):

flowchart TD
    R["root: 100"] --> F["f: 45"]
    R --> N55["55"]
    N55 --> N25["25"]
    N55 --> N30["30"]
    N25 --> C["c: 12"]
    N25 --> D["d: 13"]
    N30 --> N14["14"]
    N30 --> E["e: 16"]
    N14 --> A["a: 5"]
    N14 --> B["b: 9"]

결과 부호 (평균 2.24 bit/symbol):

심볼	빈도	부호	비트 수
f	45	0	1
c	12	100	3
d	13	101	3
e	16	111	3
b	9	1101	4
a	5	1100	4

평균 비트 = (451 + 123 + 133 + 163 + 94 + 54) / 100 = 224/100 = 2.24 bit

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std;

struct Node { char ch; int freq; Node l = nullptr, r = nullptr; }; struct Cmp { bool operator()(Node a, Node b) { return a->freq > b->freq; } };

void encode(Node* nd, string code, map<char,string>& codes) { if (!nd->l && !nd->r) { codes[nd->ch] = code; return; } encode(nd->l, code+“0”, codes); encode(nd->r, code+“1”, codes); }

int main() { map<char,int> freq = {{‘a’,5},{‘b’,9},{‘c’,12},{‘d’,13},{‘e’,16},{‘f’,45}}; priority_queue<Node*, vector<Node*>, Cmp> pq; for (auto [c,f] : freq) pq.push(new Node{c,f}); while (pq.size() > 1) { auto a = pq.top(); pq.pop(); auto b = pq.top(); pq.pop(); auto m = new Node{‘\0’, a->freq + b->freq}; m->l = a; m->r = b; pq.push(m); } map<char,string> codes; encode(pq.top(), "", codes); int bits = 0, total = 0; for (auto [c,f] : freq) { cout << c << ”: ” << codes[c] << “\n”; bits += f * (int)codes[c].size(); total += f; } cout << “avg = ” << fixed << setprecision(4) << (double)bits/total << ” bit/symbol\n”; }, }, { language: "python", label: "Python", code: import heapq

class Node: def init(self, ch, freq): self.ch = ch; self.freq = freq self.left = self.right = None def lt(self, other): return self.freq < other.freq

def huffman(freq: dict) -> dict: heap = [Node(ch, f) for ch, f in freq.items()] heapq.heapify(heap) while len(heap) > 1: a = heapq.heappop(heap) b = heapq.heappop(heap) m = Node(None, a.freq + b.freq) m.left, m.right = a, b heapq.heappush(heap, m) codes = {} def dfs(node, code): if node.ch is not None: codes[node.ch] = code; return dfs(node.left, code + “0”) dfs(node.right, code + “1”) dfs(heap[0], "") return codes

freq = {“a”:5,“b”:9,“c”:12,“d”:13,“e”:16,“f”:45} codes = huffman(freq) total = sum(freq.values()) avg = sum(freq[c]*len(v) for c,v in codes.items()) / total for ch, code in sorted(codes.items(), key=lambda x: (len(x[1]), x[0])): print(f”{ch}: {code}”) print(f”avg = {avg:.4f} bit/symbol”), }, ]} cases={[ { label: "기본 실행", input: "", output: a: 1100 b: 1101 c: 100 d: 101 e: 111 f: 0 avg = 2.2400 bit/symbol`, }, ]} />

복잡도

항목	값	설명
트리 빌드	O(N log N)	min-heap 연산 N-1 회
공간	O(N)	트리 노드 수 = 2N-1
인코딩	O(M)	M = 메시지 심볼 수
디코딩	O(M * depth)	depth <= N, 평균 O(log N)

최적성 증명

Sibling property: 같은 부모의 두 자식은 항상 heap 에서 가장 낮은 두 원소. 이 성질이 최적 부호를 그리디하게 유도.

귀납 스케치: N=2 는 자명. N>2 일 때, 가장 낮은 두 원소를 합치는 것이 최적 트리에서도 같은 깊이의 형제임을 Sibling lemma 로 보임. 합친 노드를 단일 원소로 바꾸면 N-1 인스턴스가 되어 귀납 적용.

응용

DEFLATE (gzip, PNG): LZ77 + Huffman 결합. 가장 널리 사용되는 압축 조합
JPEG: DCT 계수를 Huffman 으로 부호화
HTTP/2 [[hpack|HPACK]]: 헤더 압축에 정적 Huffman 테이블 사용
MP3: 오디오 스펙트럼 계수 부호화

함정

1. 단일 심볼 입력

심볼이 1개면 트리가 루트만 있어 부호가 빈 문자열. 별도 처리(길이 1 부호 강제) 필요.

2. 정적 빈도 가정

표준 Huffman 은 빈도를 미리 알아야 함. 파일 전체를 두 번 읽는다 (1회: 빈도 계산, 2회: 부호화). 스트리밍 환경에는 Adaptive Huffman (FGK, Vitter 알고리즘) 사용.

3. 확률이 극단적일 때 비효율

한 심볼 확률이 0.99 이면 Huffman 은 1비트를 할당하지만, Shannon entropy H ≈ 0.08 bit. Arithmetic Coding 이 entropy 에 더 근접한 압축을 달성.

4. 코드테이블 저장 비용

압축 파일에 Huffman 코드테이블도 같이 저장해야 함. 심볼 종류가 많거나 메시지가 짧으면 오히려 용량이 늘 수 있음.

5. 부동소수점 빈도 주의

Python heapq 나 C++ priority_queue 에서 부동소수점 빈도를 쓰면 동률 처리가 불안정해져 같은 입력에 다른 트리가 나올 수 있음. 정수로 변환하거나 타이브레이킹 기준을 명시하는 것이 안전.

BOJ 연습 문제

번호	제목	핵심
BOJ 1715	카드 정렬하기	Huffman coding 직접 응용, 합병 비용 최소화
BOJ 13904	과제	그리디 + 우선순위 큐
BOJ 19598	최소 회의실 개수	min-heap 활용

참고

관련 [[priority-queue-heap|Priority Queue]]
관련 [[hpack|HPACK]] (HTTP/2 헤더 압축)
관련 [[greedy|Greedy]]
Huffman, “A Method for the Construction of Minimum-Redundancy Codes” (1952)
Shannon, “A Mathematical Theory of Communication” (1948)

Inclusion and Exclusion: 포함배제 원리

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

포함배제 원리 (Principle of Inclusion-Exclusion, PIE) 는 합집합의 크기를 교집합의 크기들을 이용해 계산하는 조합론의 기본 원리입니다.

$$ \left| \bigcup_{i=1}^{n} A_i \right| = \sum_{k=1}^{n} (-1)^{k-1} \sum_{|S|=k} \left| \bigcap_{i \in S} A_i \right| $$

부호가 집합 크기에 따라 교대로 바뀝니다: 홀수 크기 부분집합은 더하고, 짝수 크기 부분집합은 뺍니다.

3개 집합의 경우:

$$ |A \cup B \cup C| = |A| + |B| + |C| - |A \cap B| - |A \cap C| - |B \cap C| + |A \cap B \cap C| $$

문제 상황과 동기

직접 세기가 어려운 경우

“적어도 하나의 조건을 만족하는 경우의 수”는 조건들 간 중복이 있어 직접 세기가 어렵습니다. PIE는 이런 중복을 체계적으로 처리합니다.

자연수 범위 계수: [1, n] 중 소수 p1, p2, …, pk 중 적어도 하나의 배수 수
금지 위치 순열: 특정 위치에 특정 원소가 와서는 안 되는 경우의 수
교란 순열 (Derangement): 어떤 원소도 원래 위치에 없는 순열 수
오일러 파이 함수: n 이하 서로소 수

직관적 이해

3개 원소 A, B, C 가 겹칠 때 단순 합산하면:

A와 B 공통 원소는 2번 계산됨 (빼야 함)
A, B, C 모두 공통 원소는 3번 더하고 3번 빼서 0번 계산됨 (더해야 함)

피차 조정을 반복하면 정확히 1회씩 세는 것이 PIE의 핵심입니다.

시각화

포함배제 단계별 조정

flowchart TD
    S1["1단계: 각 집합 크기 합산 (중복 포함)"]
    S2["2단계: 2개 교집합 차감 (초과 차감)"]
    S3["3단계: 3개 교집합 추가 (정확한 값)"]
    Result["합집합 크기 = 정확한 원소 수"]

    S1 --> S2 --> S3 --> Result

집합 구조와 교집합

flowchart LR
    A["집합 A"] --> AB["A, B 교집합"]
    B["집합 B"] --> AB
    A --> AC["A, C 교집합"]
    C["집합 C"] --> AC
    B --> BC["B, C 교집합"]
    C --> BC
    AB --> ABC["A, B, C 교집합"]
    BC --> ABC

    style AB fill:#ffcccc
    style AC fill:#ffcccc
    style BC fill:#ffcccc
    style ABC fill:#ccffcc

교집합들은 각각 부호를 바꿔가며 더하고 뺍니다.

핵심 아이디어

비트마스크 열거

n 개의 집합이 있을 때, 모든 부분집합을 비트마스크로 열거해 PIE를 계산합니다.

result = 0
for mask = 1 to (1<<n)-1:
    bits = popcount(mask)
    val = intersection size of sets in mask
    if bits % 2 == 1: result += val   # 홀수 크기: 더하기
    else: result -= val               # 짝수 크기: 빼기

n 개의 집합 대상으로 $O(2^n)$ 부분집합 열거. n <= 20 정도에서 실용적.

응용 패턴: 배수 계수

n 이하에서 소수 집합 ${p_1, …, p_k}$ 중 적어도 하나의 배수 수:

$$ \sum_{S \subseteq {p_1,…,p_k}} (-1)^{|S|+1} \left\lfloor \frac{n}{\prod_{p \in S} p} \right\rfloor $$

공집합 제외, 부호는 집합 크기 홀/짝에 따라 +/-.

응용 패턴: 교란 순열

아무 원소도 원래 위치에 없는 순열 수 $D_n$:

$$ D_n = n! \sum_{k=0}^{n} \frac{(-1)^k}{k!} \approx \frac{n!}{e} $$

점화식으로도 계산 가능: $D_n = (n-1)(D_{n-1} + D_{n-2})$, $D_0 = 1$, $D_1 = 0$.

응용 패턴: 오일러 파이 함수

n 이하에서 n 과 서로소인 수의 개수:

$$ \varphi(n) = n \prod_{p \mid n} \left(1 - \frac{1}{p}\right) $$

소인수 집합으로 PIE 적용한 것과 동일합니다.

알고리즘

비트마스크 PIE (n 집합 배수 계수)

PIE(n, primes[k]):
    result = 0
    for mask = 1 to (1<<k)-1:
        prod = 1
        bits = 0
        for i = 0..k-1:
            if mask >> i & 1:
                prod *= primes[i]
                bits++
        if bits % 2 == 1: result += n / prod
        else: result -= n / prod
    return result  # n 이하에서 primes 중 하나라도 배수인 수의 개수

교란 순열 점화식

D(0) = 1, D(1) = 0
D(n) = (n-1) * (D(n-1) + D(n-2))

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// 포함배제 원리: 배수 계수 + 교란 순열 #include <bits/stdc++.h> using namespace std;

// [1, n] 중 primes 중 적어도 하나의 배수 수 (PIE) long long count_multiples(long long n, vector primes) { int k = primes.size(); long long res = 0; for (int mask = 1; mask < (1 << k); mask++) { long long prod = 1; int bits = __builtin_popcount(mask); for (int i = 0; i < k; i++) if (mask >> i & 1) prod *= primes[i]; if (bits % 2 == 1) res += n / prod; else res -= n / prod; } return res; }

// 교란 순열 D(n): 아무 원소도 원래 위치에 없는 순열 수 long long derangement(int n) { if (n == 0) return 1; if (n == 1) return 0; long long a = 1, b = 0; // D(0), D(1) for (int i = 2; i <= n; i++) { long long c = (long long)(i-1) * (a + b); a = b; b = c; } return b; }

// 오일러 파이 함수 phi(n): n 이하 n과 서로소 수 개수 long long euler_phi(long long n) { long long result = n; for (long long p = 2; p * p <= n; p++) { if (n % p == 0) { while (n % p == 0) n /= p; result -= result / p; } } if (n > 1) result -= result / n; return result; }

int main() { // 예시 1: [1, 30] 중 2, 3, 5 의 배수 수 (PIE) vector primes = {2, 3, 5}; long long cnt = count_multiples(30, primes); cout << “[1,30] 중 2,3,5 의 배수 수: ” << cnt << “\n”; // 22

// 예시 2: [1, 30] 중 2, 3, 5 의 배수가 아닌 수
cout << "[1,30] 중 2,3,5 의 배수 아닌 수: " << 30 - cnt << "\\n";  // 8

// 예시 3: 교란 순열
for (int i = 1; i <= 6; i++)
    cout << "D(" << i << ") = " << derangement(i) << "\\n";

// 예시 4: 오일러 파이
cout << "phi(12) = " << euler_phi(12) << "\\n";  // 4 ({1,5,7,11})
return 0;

}, }, { language: "python", label: "Python", code: def count_multiples(n, primes): """PIE: [1, n] 중 primes 중 적어도 하나의 배수 수""" k = len(primes) res = 0 for mask in range(1, 1 << k): bits = bin(mask).count(‘1’) prod = 1 for i in range(k): if mask >> i & 1: prod *= primes[i] if bits % 2 == 1: res += n // prod else: res -= n // prod return res

def derangement(n): """교란 순열 D(n): (n-1)*(D(n-1)+D(n-2)) 점화식""" if n == 0: return 1 if n == 1: return 0 a, b = 1, 0 # D(0), D(1) for i in range(2, n+1): a, b = b, (i-1) * (a + b) return b

def euler_phi(n): """오일러 파이 함수: n 이하 n과 서로소 수 개수""" result = n p = 2 temp = n while p * p <= temp: if temp % p == 0: while temp % p == 0: temp //= p result -= result // p p += 1 if temp > 1: result -= result // temp return result

예시 1: [1, 30] 중 2, 3, 5 의 배수 수

primes = [2, 3, 5] cnt = count_multiples(30, primes) print(f”[1,30] 중 2,3,5 의 배수 수: {cnt}”) # 22 print(f”[1,30] 중 2,3,5 의 배수 아닌 수: {30-cnt}”) # 8

예시 2: 교란 순열

for i in range(1, 7): print(f”D({i}) = {derangement(i)}“)

예시 3: 오일러 파이

print(f”phi(12) = {euler_phi(12)}”) # 4`, }, ]} cases={[ { label: “[1,30] 중 2,3,5 배수 수”, input: “n=30, primes=[2,3,5]”, output: “[1,30] 중 2,3,5 의 배수 수: 22\n[1,30] 중 2,3,5 의 배수 아닌 수: 8”, }, { label: “교란 순열 D(1) - D(6)”, input: “n = 1, 2, 3, 4, 5, 6”, output: “D(1) = 0\nD(2) = 1\nD(3) = 2\nD(4) = 9\nD(5) = 44\nD(6) = 265”, }, { label: “오일러 파이 phi(12)”, input: “n = 12”, output: “phi(12) = 4”, }, ]} />

복잡도

항목	복잡도	조건
비트마스크 PIE	O(2^k)	k = 집합 수
배수 계수	O(2^k)	k = 소수 개수
교란 순열 점화식	O(n)	-
오일러 파이	O(sqrt(n))	단일 n

k <= 20 이면 비트마스크 PIE 가능 (2^20 = 10^6). k > 20 이면 다른 방법 (뫼비우스 함수 등) 필요.

주요 응용 정리

금지 위치 순열 (Forbidden Positions)

n 개 원소, k 개의 금지 위치 쌍 (i, j) 이 있을 때 조건을 모두 피하는 순열 수:

$$ \text{count} = \sum_{S \subseteq \text{forbidden}} (-1)^{|S|} \cdot (\text{S의 조건 동시 만족 순열 수}) $$

Derangement 공식 (직접 PIE)

$$ D_n = \sum_{k=0}^{n} (-1)^k \binom{n}{k} (n-k)! = n! \sum_{k=0}^{n} \frac{(-1)^k}{k!} $$

k 개 원소가 제자리에 있는 경우를 PIE로 제거. $D_n \approx n!/e$ 근사.

에라토스테네스 체 변형

[1, n] 중 집합 P의 소수들로 나누어지지 않는 수의 개수:

$$ \left\lfloor n \right\rfloor - \sum_p \lfloor n/p \rfloor + \sum_{p<q} \lfloor n/pq \rfloor - \cdots $$

[[sieve|에라토스테네스 체]] 와 PIE 조합.

함정

1. 공집합 마스크 포함 오류

[!WARNING] mask = 0 (공집합) 은 교집합 크기가 전체 n 이므로 PIE 합산에서 제외해야 합니다. for mask = 1 to ... 로 시작.

2. 부호 혼동 (홀수/짝수 반전)

홀수 크기 부분집합은 더하고 (부호 +), 짝수 크기는 빼는 (부호 -) 것이 기본. “합집합에서 빼야 할 것”을 구하는 문제에서 부호가 반전됨 주의.

3. 곱이 n 초과 시 0 처리

배수 계수에서 prod > n 이면 n / prod = 0. 곱 계산 시 prod > n 체크로 조기 스킵 가능.

for (int i = 0; i < k; i++) {
    if (mask >> i & 1) {
        if (prod > n / primes[i]) { prod = n + 1; break; }  // 오버플로우 방지
        prod *= primes[i];
    }
}
if (prod > n) continue;

4. 대규모 k 에서 2^k 폭발

[!CAUTION] k >= 30 이면 2^k > 10^9 로 비트마스크 PIE가 불가능합니다. [[mobius-function|뫼비우스 함수]] 기반 알고리즘으로 전환.

5. 교란 순열 오버플로우

$D_{20} \approx 8.95 \times 10^{17}$, long long 한계 (약 $9.2 \times 10^{18}$) 이내. $D_{21}$ 부터 unsigned long long 또는 모듈러 연산 필요.

6. 오일러 파이 vs 배수 계수 혼동

$\varphi(n)$ 은 n 이하 n 과 서로소인 수. count_multiples 는 [1, n] 중 특정 소수 배수. 두 공식이 비슷해 보여도 적용 문맥이 다릅니다.

고급 응용

LGV 정리와의 연결

격자 경로 계수에서 PIE를 체계화한 것이 [[lgv-theorem|Lindstrom-Gessel-Viennot 정리]].

뫼비우스 함수

[[mobius-function|뫼비우스 함수]] $\mu(n)$ 은 PIE의 수론적 일반화. $\mu(n) = (-1)^k$ (k = 서로 다른 소인수 수), $\mu(n) = 0$ (중복 소인수 있으면).

Burnside’s Lemma

대칭을 고려한 계수에서 PIE의 변형. 군론 기반.

BOJ 연습 문제

번호	제목	유형
BOJ 1947	선물 전달	교란 순열
BOJ 1735	분수 합산	서로소
BOJ 1036	36진수	배수 계수
BOJ 1456	거의 소수	에라토스테네스 + 배수
BOJ 2960	에라토스테네스의 체	배수 계수
BOJ 16565	N포커	이항계수 + PIE
BOJ 14182	쌍의 합	집합 계수 PIE

참고

[[euler-phi-function|Euler Phi Function]] (PIE 응용 대표)
[[combinatorics|조합론]] (계수 기초)
[[mobius-function|뫼비우스 함수]] (PIE 수론 일반화)
[[number-theory|수론]] (배수/약수 이론)
[[sieve|에라토스테네스 체]] (소수 배수 열거)

Insertion Sort

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Insertion Sort (삽입 정렬) 는 한 번에 한 원소씩 이미 정렬된 부분에 올바른 위치를 찾아 삽입 하는 정렬. 카드 정리하듯이 한 장씩 적절한 자리에 끼워넣는 동작.

O(n²) 알고리즘 중 실측 가장 빠르다. 작은 입력 (n ≤ 16) 이나 거의 정렬된 입력에서 Quick Sort 같은 O(n log n) 알고리즘보다도 빠를 수 있다. 그래서 Timsort, Introsort, Pdqsort 가 부분 정렬에 모두 Insertion Sort 를 사용한다.

전체 비교는 [[정렬 알고리즘]] 참고.

시각화

{}

key 를 찾아 올바른 자리에 끼워넣는 과정:

flowchart LR
    Start["i=1"] --> Key["key = arr[i], j = i-1"]
    Key --> CMP{"j >= 0 AND arr[j] > key?"}
    CMP -->|"Yes"| Shift["arr[j+1] = arr[j], j--"]
    Shift --> CMP
    CMP -->|"No"| Insert["arr[j+1] = key"]
    Insert --> Inc{"i < n?"}
    Inc -->|"Yes"| Key2["i++, 다음 원소"]
    Inc -->|"No"| Done["정렬 완료"]
    Key2 --> Key

알고리즘

insertionSort(arr):
  for i = 1 to n-1:
    key = arr[i]
    j = i - 1
    while j >= 0 and arr[j] > key:
      arr[j + 1] = arr[j]  // 한 칸씩 오른쪽으로 밀기
      j--
    arr[j + 1] = key       // 빈 자리에 삽입

핵심 동작

배열 앞부분이 이미 정렬된 영역, 나머지가 미처리 영역. 미처리에서 하나씩 꺼내 정렬된 영역의 올바른 위치에 삽입.

[ 정렬됨 | 미처리 ]
[ 5    | 2, 8, 1, 4 ]   초기

[ 2, 5 | 8, 1, 4 ]      2 를 5 앞에 삽입
[ 2, 5, 8 | 1, 4 ]      8 은 이미 5 보다 큼, 그 자리에
[ 1, 2, 5, 8 | 4 ]      1 을 맨 앞으로
[ 1, 2, 4, 5, 8 | ]     4 를 5 앞에 삽입

매 단계에서 정렬된 영역이 정확히 정렬 상태를 유지.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std;

void insertionSort(vector& arr) { int n = arr.size(); for (int i = 1; i < n; i++) { int key = arr[i]; int j = i - 1; while (j >= 0 && arr[j] > key) { arr[j+1] = arr[j]; j—; } arr[j+1] = key; } }

int main() { vector arr = {12, 11, 13, 5, 6}; cout << “Before: ”; for (int x : arr) cout << x << ” ”; cout << “\n”; insertionSort(arr); cout << “After: ”; for (int x : arr) cout << x << ” ”; cout << “\n”; // 역순 입력 (최악) vector rev = {5, 4, 3, 2, 1}; insertionSort(rev); cout << “Reversed: ”; for (int x : rev) cout << x << ” ”; cout << “\n”; }, }, { language: "python", label: "Python", code: def insertion_sort(arr: list) -> None: for i in range(1, len(arr)): key = arr[i] j = i - 1 while j >= 0 and arr[j] > key: arr[j+1] = arr[j] j -= 1 arr[j+1] = key

arr = [12, 11, 13, 5, 6] print(“Before:”, arr) insertion_sort(arr) print(“After: ”, arr)

거의 정렬된 입력 (최선)

near_sorted = [1, 2, 4, 3, 5, 6] insertion_sort(near_sorted) print(“Nearly sorted:”, near_sorted), }, ]} cases={[ { label: "기본 실행", input: "", output: Before: 12 11 13 5 6 After: 5 6 11 12 13 Reversed: 1 2 3 4 5`, }, ]} />

복잡도

항목	값
시간 (최선)	O(n) (이미 정렬됨)
시간 (평균)	O(n²)
시간 (최악)	O(n²) (역순 입력)
공간	O(1)
안정성	✓ Stable
In-place	✓
Online	✓ (한 번에 한 원소씩 처리 가능)

왜 O(n²) 중 가장 빠른가

상수항 작음: inner loop 가 단순한 비교 + 이동 한 번
캐시 친화: 인접 메모리 접근만
거의 정렬된 입력에 O(n) 에 가깝게 동작
분기 예측 친화적: 조건이 단순

정렬된 부분의 활용

Insertion Sort 의 최대 장점은 입력의 부분적 정렬을 직접 활용 한다는 것.

const nearSorted = [1, 2, 3, 5, 4, 6, 7, 8, 9];
// 5, 4 만 어긋남
// insertion sort: 4 를 한 칸 이동 → 1 swap, 끝
// O(n) 실측

이 성질이 Timsort (Python sorted, Java Arrays.sort) 의 기반:

입력에서 자연스러운 run (정렬된 부분) 식별
짧은 run 은 Insertion Sort 로 길이 맞춤
run 들을 Merge Sort 로 합침

하이브리드 알고리즘에서의 역할

알고리즘	Insertion Sort 사용 시점
Timsort	짧은 run 정렬 (n < 64)
Introsort (C++ `std::sort`)	작은 부분 (n ≤ 16)
Pdqsort (Rust)	작은 부분
Dual-Pivot QS (Java)	작은 부분

[!IMPORTANT] n 이 작을 때는 O(n²) 가 O(n log n) 보다 빠르다. 상수항이 결정적. n=20 에서 Insertion 의 비교 횟수 (~200) 가 Quick 의 함수 호출 오버헤드보다 적다.

Binary Insertion Sort

삽입 위치를 이진 탐색 으로 찾음. 비교 횟수는 O(n log n) 이지만 이동 횟수는 여전히 O(n²). 비교 비용이 비싼 경우 (예: 긴 문자열) 에 유리.

일반: O(n) 비교 × O(n) = O(n²)
이진: O(log n) 비교 × O(n) = O(n log n) 비교
       O(n) 이동 × O(n) = O(n²) 이동

총 비용은 여전히 O(n²) 지만 비교 횟수가 줄어든다.

Bubble / Selection 과의 비교

항목	Insertion	Bubble	Selection
실측 속도	가장 빠름	가장 느림	중간
안정성	✓	✓	✗
거의 정렬된 입력	O(n)	O(n) (early exit)	O(n²)
비교 횟수	O(n²)	O(n²)	O(n²)
교환 횟수	O(n²)	O(n²)	O(n)

실무 활용 (의외로 자주)

Insertion Sort 자체로는 작은 입력에 한정되지만, 하이브리드 알고리즘의 부속품 으로 거의 모든 표준 라이브러리에 들어가 있다.

Python sorted(), list.sort() → Timsort 내부
Java Arrays.sort() (객체) → Timsort 내부
C++ std::sort → Introsort 내부 (n ≤ 16 에서)
Rust slice::sort_unstable → Pdqsort 내부

n=8 같은 작은 배열을 정렬할 일이 있으면 Insertion Sort 가 올바른 선택.

함정

1. “삽입” 과 “교환” 혼동

Insertion Sort 는 원소를 shift (이동) 하지 교환하지 않는다. arr[j+1] = arr[j] 로 한 칸씩 밀고, 마지막에 arr[j+1] = key 로 삽입. Bubble Sort 처럼 swap 을 반복하는 것보다 효율적 (이동 1회 vs swap 3회).

2. 인덱스 경계

j >= 0 조건을 반드시 확인. arr[j] 가 범위를 벗어나기 전에 while 루프를 종료해야 함. C++ 에서 j 가 int 가 아닌 size_t (unsigned) 이면 j >= 0 가 항상 true 가 되어 무한 루프.

3. 역순 입력이 최악

역순 배열에서 i번째 원소를 삽입하려면 최대 i번 shift. 총 n*(n-1)/2 shift = O(n^2). Bubble Sort 와 같은 최악이지만 shift 연산이 swap 보다 빠르므로 실측에서는 Bubble 보다 빠름.

4. 비교 비용이 비싼 경우

원소 비교 비용이 크면 (예: 긴 문자열, 복합 키) Binary Insertion Sort 가 유리: 이진 탐색으로 삽입 위치를 O(log i) 에 결정. 이동 횟수는 그대로 O(n^2) 이지만 비교 횟수가 O(n log n) 으로 줄어듦.

5. 안정 정렬 보장 조건

arr[j] > key (strict) 비교를 유지해야 stable. arr[j] >= key 로 바꾸면 같은 키 원소의 상대 순서가 뒤바뀜.

BOJ 연습 문제

번호	제목	연관
BOJ 2750	수 정렬하기	정렬 기본 (Insertion Sort 직접 구현)
BOJ 1377	버블 소트 프로그램 1	최대 shift 횟수 = 원소가 왼쪽으로 이동한 최대 거리
BOJ 11931	수 정렬하기 4	내림차순 정렬

[!NOTE] BOJ 1377 은 Insertion Sort 변형 관점에서 접근 가능: 각 원소가 몇 칸 왼쪽으로 이동했는지의 최댓값이 answer. O(n^2) 시뮬레이션 대신 정렬 전후 위치 차이로 O(n log n) 풀이.

참고

[[정렬 알고리즘]]
[[Bubble Sort]]
[[Selection Sort]]
[[Merge Sort]]
[[Quick Sort]]
Knuth, TAOCP Vol. 3 §5.2.1

Johnson's Algorithm: sparse APSP

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Johnson’s algorithm은 음수 간선이 있는 sparse graph의 all-pairs shortest paths (APSP)를 **O(VE log V)**에 계산. Bellman-Ford로 potential을 구한 뒤 간선을 재가중하여 Dijkstra를 V번 실행.

$$ \text{복잡도: } O(VE \log V) \quad \text{(sparse graph에서 Floyd-Warshall O(V^3)보다 빠름)} $$

문제 상황

APSP 알고리즘 선택 기준:

Floyd-Warshall: 음수 간선 허용, O(V³), dense graph에 적합
Dijkstra × V: 음수 간선 불가, O(V(E + V) log V)
Johnson: 음수 간선 허용, O(VE log V), sparse graph에 최적

음수 사이클이 있으면 최단 경로가 정의되지 않으므로 Bellman-Ford 단계에서 탐지.

시각화

flowchart TD
    G["원본 그래프 G (음수 간선 허용)"]
    step1["임시 정점 s 추가, 가중치 0 간선 연결"]
    step2["Bellman-Ford 실행: h_v = dist(s, v)"]
    step3["간선 재가중: w' = w + h_u - h_v"]
    G2["재가중 그래프 G' (모든 간선 w >= 0)"]
    step4["각 정점 소스로 Dijkstra V회 실행"]
    step5["거리 복원: d = d' - h_u + h_v"]
    APSP["모든 쌍 최단 경로 완성"]

    G --> step1
    step1 --> step2
    step2 --> step3
    step3 --> G2
    G2 --> step4
    step4 --> step5
    step5 --> APSP

핵심 아이디어

왜 Dijkstra가 음수 간선에서 실패하는가

Dijkstra는 “이미 확정된 정점의 거리는 최소”라는 greedy 가정에 의존. 음수 간선이 있으면 나중에 더 짧은 경로가 발견될 수 있어 이 가정이 깨짐.

재가중 (Reweighting)의 핵심

potential 함수 h를 이용해 모든 간선을 비음수로 변환:

$$ w’(u, v) = w(u, v) + h[u] - h[v] $$

성질 1: $w’(u, v) \geq 0$ (Bellman-Ford 최단 경로 조건에 의해)

성질 2: 경로 $u \to v$의 재가중 거리 = 원래 거리 + h[u] - h[v]

따라서 최단 경로의 순서는 변하지 않음. 재가중 후 Dijkstra로 구한 최단 경로를 원래 거리로 복원 가능.

증명: w’(u,v) >= 0

Bellman-Ford로 구한 h는 최단 경로 거리이므로:

$$ h[v] \leq h[u] + w(u, v) \implies w(u, v) + h[u] - h[v] \geq 0 $$

거리 복원

재가중 그래프에서 Dijkstra로 구한 d’[u][v]에서 원래 거리 복원:

$$ d[u][v] = d’[u][v] - h[u] + h[v] $$

알고리즘

# Johnson's Algorithm
1. 임시 정점 s 추가
   for each vertex v: add edge (s, v) with weight 0

2. Bellman-Ford(s)로 h[v] = dist(s, v) 계산
   if 음수 사이클 탐지: "음수 사이클 존재" 출력 후 종료

3. 간선 재가중
   for each edge (u, v, w):
       w'(u, v) = w + h[u] - h[v]

4. 각 정점 u에서 Dijkstra 실행 (재가중 그래프)
   d'[u][v] = Dijkstra(u, G')

5. 원래 거리 복원
   d[u][v] = d'[u][v] - h[u] + h[v]

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std; typedef long long ll; typedef pair<ll,int> pli; const ll INF = 1e18;

int V, E; vector<pair<int,ll>> adj[505];

// Bellman-Ford: s에서 모든 정점까지 최단 거리 // 음수 사이클 있으면 false 반환 bool bellman_ford(int s, vector& dist) { dist.assign(V + 1, INF); dist[s] = 0; for (int i = 0; i < V; i++) { for (int u = 0; u <= V; u++) { if (dist[u] == INF) continue; for (auto [v, w] : adj[u]) { if (dist[u] + w < dist[v]) dist[v] = dist[u] + w; } } } for (int u = 0; u <= V; u++) { if (dist[u] == INF) continue; for (auto [v, w] : adj[u]) if (dist[u] + w < dist[v]) return false; } return true; }

// Dijkstra: src에서 모든 정점까지 최단 거리 vector dijkstra(int src, vector<vector<pair<int,ll>>>& g) { vector dist(V + 1, INF); priority_queue<pli, vector, greater> pq; dist[src] = 0; pq.push({0, src}); while (!pq.empty()) { auto [d, u] = pq.top(); pq.pop(); if (d > dist[u]) continue; for (auto [v, w] : g[u]) { if (dist[u] + w < dist[v]) { dist[v] = dist[u] + w; pq.push({dist[v], v}); } } } return dist; }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

cin >> V >> E;
for (int i = 0; i < E; i++) {
    int u, v; ll w;
    cin >> u >> v >> w;
    adj[u].push_back({v, w});
}

// 임시 정점 V: 모든 정점에 가중치 0 간선
for (int v = 0; v < V; v++)
    adj[V].push_back({v, 0});

vector<ll> h;
if (!bellman_ford(V, h)) {
    cout << "음수 사이클 존재\\n";
    return 0;
}

// 재가중 그래프 구성
vector<vector<pair<int,ll>>> g(V + 1);
for (int u = 0; u < V; u++)
    for (auto [v, w] : adj[u])
        g[u].push_back({v, w + h[u] - h[v]});

// 각 정점에서 Dijkstra 후 거리 복원
for (int u = 0; u < V; u++) {
    auto d = dijkstra(u, g);
    for (int v = 0; v < V; v++) {
        ll dist = (d[v] == INF) ? -1 : d[v] - h[u] + h[v];
        cout << dist;
        if (v < V - 1) cout << " ";
    }
    cout << "\\n";
}

return 0;

}, }, { language: "python", label: "Python", code: import heapq import sys input = sys.stdin.readline INF = float(‘inf’)

def bellman_ford(s, V, adj): dist = [INF] * (V + 1) dist[s] = 0 for _ in range(V): for u in range(V + 1): if dist[u] == INF: continue for v, w in adj[u]: if dist[u] + w < dist[v]: dist[v] = dist[u] + w for u in range(V + 1): if dist[u] == INF: continue for v, w in adj[u]: if dist[u] + w < dist[v]: return None # 음수 사이클 return dist

def dijkstra(src, V, g): dist = [INF] * (V + 1) dist[src] = 0 pq = [(0, src)] while pq: d, u = heapq.heappop(pq) if d > dist[u]: continue for v, w in g[u]: if dist[u] + w < dist[v]: dist[v] = dist[u] + w heapq.heappush(pq, (dist[v], v)) return dist

def main(): V, E = map(int, input().split()) adj = [[] for _ in range(V + 1)] for _ in range(E): u, v, w = map(int, input().split()) adj[u].append((v, w))

for v in range(V):
    adj[V].append((v, 0))

h = bellman_ford(V, V, adj)
if h is None:
    print("음수 사이클 존재")
    return

g = [[] for _ in range(V + 1)]
for u in range(V):
    for v, w in adj[u]:
        g[u].append((v, w + h[u] - h[v]))

for u in range(V):
    d = dijkstra(u, V, g)
    row = []
    for v in range(V):
        dist = -1 if d[v] == INF else int(d[v] - h[u] + h[v])
        row.append(str(dist))
    print(' '.join(row))

main(), }, ]} cases={[ { label: "3정점 음수 간선 그래프", input: 3 4 0 1 -1 0 2 4 1 2 3 2 1 -2, output: 0 -1 2 -1 0 3 -1 -2 0, }, { label: "음수 사이클 탐지", input: 3 3 0 1 1 1 2 -3 2 0 1, output: 음수 사이클 존재`, }, ]} />

복잡도

방법	복잡도	음수 간선	적합한 그래프
Floyd-Warshall	O(V³)	허용	Dense
Johnson	O(VE log V)	허용	Sparse
Dijkstra × V	O(V(E+V) log V)	불가	Sparse

Sparse (E = O(V)) 일 때: Johnson O(V² log V) vs Floyd-Warshall O(V³). Dense (E = O(V²)) 일 때: Johnson O(V³ log V) > Floyd-Warshall O(V³). Dense에는 Floyd-Warshall 사용.

함정

1. 음수 사이클 미탐지

Bellman-Ford 단계에서 음수 사이클을 탐지하지 않으면 잘못된 결과. V번 완화 후 한 번 더 완화 시도로 탐지.

[!WARNING] 음수 사이클이 있으면 최단 경로가 정의되지 않음. 반드시 탐지 후 처리.

2. 임시 정점 인덱스 충돌

기존 정점 0..V-1에 임시 정점 V를 추가. 배열 크기를 V+1로 할당.

3. 거리 복원 공식 오류

재가중 거리 d’[u][v]에서 원래 거리 복원: d[u][v] = d'[u][v] - h[u] + h[v]. 부호 혼동 주의.

4. Dense graph에서 비효율

E = O(V²)이면 Johnson O(V³ log V)로 Floyd-Warshall O(V³)보다 느림. Dense graph에는 Floyd-Warshall 사용.

5. 정수 오버플로

h[u] - h[v]가 음수일 수 있으므로 long long 사용. 재가중 후 w’가 음수가 되면 안 됨.

BOJ 연습 문제

번호	제목	관련 개념
BOJ 11404	플로이드	Floyd-Warshall (비교)
BOJ 1865	웜홀	Bellman-Ford (음수 사이클)
BOJ 1753	최단경로	Dijkstra (기반 알고리즘)
BOJ 11657	타임머신	Bellman-Ford SSSP

Markov Chain: 상태 전이 확률

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Markov Chain 은 다음 상태가 오직 현재 상태에만 의존하는 확률 과정. Memoryless property (Markov property).

$$ P(X_{t+1} = j \mid X_0, X_1, \ldots, X_t) = P(X_{t+1} = j \mid X_t) $$

전이 행렬 (Transition Matrix) $P$: $P_{ij} = P(\text{다음} = j \mid \text{현재} = i)$. 각 행의 합 = 1 (확률 보존).

문제 상황과 동기

전형적인 PS 문제 패턴:

“N 번 이동 후 위치 j 에 있을 확률” → 전이 행렬 거듭제곱
“장기적으로 각 상태에 있는 비율” → 정류 분포
“이 게임에서 파산할 확률” → Gambler’s ruin

시각화

날씨 예측 마르코프 체인

stateDiagram-v2
    Sunny --> Sunny : 0.8
    Sunny --> Cloudy : 0.2
    Cloudy --> Sunny : 0.4
    Cloudy --> Cloudy : 0.6

Sunny = 맑음, Cloudy = 흐림. 전이 행렬:

$$ P = \begin{pmatrix} 0.8 & 0.2 \ 0.4 & 0.6 \end{pmatrix} $$

N-step 전이 흐름

flowchart LR
    V0["초기 분포 v0"] -->|"곱하기 P"| V1["1-step 분포 v1"]
    V1 -->|"곱하기 P"| V2["2-step 분포 v2"]
    V2 -->|"..."| Vn["n-step: v0 * P의 n제곱"]

$v_0 \cdot P^n$ 의 j 번째 원소 = 초기 분포 $v_0$ 에서 출발해 n 스텝 후 상태 j 에 있을 확률.

핵심 아이디어

행렬 거듭제곱 (N-step 전이)

$P^n_{ij}$ = i 에서 j 로 n 스텝에 도달할 확률.

[[matrix-exponentiation|Matrix Exponentiation]] 으로 O(K^3 log N) 에 계산. K = 상태 수.

Stationary Distribution

$\pi P = \pi$ 를 만족하는 확률벡터 $\pi$ (원소 합 = 1).

Ergodic 마르코프 체인 (irreducible + aperiodic) 이면 유일한 정류 분포 존재, 어떤 초기 분포에서도 수렴.

풀이: $\pi (P - I) = 0$ 에서 마지막 방정식을 $\sum \pi_i = 1$ 로 교체 후 선형계 풀기.

Gambler’s Ruin

가진 돈 i, 목표 N, 매 라운드 이길 확률 p:

$$ q_i = p \cdot q_{i+1} + (1-p) \cdot q_{i-1}, \quad q_0 = 1,, q_N = 0 $$

해 ($p \neq 0.5$):

$$ q_i = \frac{(q/p)^N - (q/p)^i}{(q/p)^N - 1} $$

카지노에서 p = 49% 이더라도 목표가 크면 파산 확률이 압도적으로 높은 이유.

알고리즘

N-step 전이

P = K x K 전이 행렬
Pn = matrix_power(P, n)
answer = Pn[start][end]

정류 분포 (Power Iteration)

pi = [1/K, 1/K, ..., 1/K]  # 균등 초기
for t in 1..T:
    pi = pi * P             # 행벡터 x 행렬
# 수렴 후 pi = 정류 분포

수렴 속도 = 두 번째로 큰 고유값의 절댓값 (spectral gap).

PageRank

각 웹 페이지 = 상태, 하이퍼링크 = 전이
댐핑 인수 d = 0.85: $P’ = d \cdot P_{link} + (1-d) \cdot \mathbf{1}/K$
Stationary distribution of P’ = PageRank score

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Markov Chain: 행렬 거듭제곱 + 정류 분포 #include <bits/stdc++.h> using namespace std; using Matrix = vector<vector>;

int K;

Matrix mat_mul(const Matrix& A, const Matrix& B) { Matrix C(K, vector(K, 0)); for (int i = 0; i < K; i++) for (int k = 0; k < K; k++) for (int j = 0; j < K; j++) C[i][j] += A[i][k] * B[k][j]; return C; }

Matrix mat_pow(Matrix M, long long n) { Matrix R(K, vector(K, 0)); for (int i = 0; i < K; i++) R[i][i] = 1.0; // 단위 행렬 while (n > 0) { if (n & 1) R = mat_mul(R, M); M = mat_mul(M, M); n >>= 1; } return R; }

int main() { // 날씨: 0=맑음, 1=흐림 K = 2; Matrix P = {{0.8, 0.2}, {0.4, 0.6}};

// N-step 전이
long long n = 10;
Matrix Pn = mat_pow(P, n);
cout << "맑음 시작, " << n << "일 후:\\n";
printf("  맑음 확률: %.4f\\n", Pn[0][0]);
printf("  흐림 확률: %.4f\\n", Pn[0][1]);

// 정류 분포 (Power iteration)
vector<double> pi(K, 1.0 / K);
for (int t = 0; t < 1000; t++) {
    vector<double> npi(K, 0);
    for (int i = 0; i < K; i++)
        for (int j = 0; j < K; j++)
            npi[j] += pi[i] * P[i][j];
    pi = npi;
}
printf("정류 분포: 맑음=%.4f, 흐림=%.4f\\n", pi[0], pi[1]);
// 정류 분포: 맑음=0.6667, 흐림=0.3333
// 이론값: pi0 = 0.4/(0.2+0.4) = 2/3

}, }, { language: "python", label: "Python", code: # Markov Chain: 전이 행렬 + 정류 분포 import numpy as np

날씨 예측: 0=맑음, 1=흐림

P = np.array([[0.8, 0.2], [0.4, 0.6]])

N-step 전이 (행렬 거듭제곱)

n = 10 Pn = np.linalg.matrix_power(P, n) print(f”맑음 시작, {n}일 후:”) print(f” 맑음 확률: {Pn[0][0]:.4f}”) print(f” 흐림 확률: {Pn[0][1]:.4f}“)

정류 분포 (반복법)

pi = np.array([0.5, 0.5]) for _ in range(1000): pi = pi @ P print(f”정류 분포 (반복): 맑음={pi[0]:.4f}, 흐림={pi[1]:.4f}“)

정류 분포 (고유벡터법)

eigenvalues, eigenvectors = np.linalg.eig(P.T) idx = np.argmin(abs(eigenvalues - 1)) pi_exact = eigenvectors[:, idx].real pi_exact /= pi_exact.sum() print(f”정류 분포 (고유벡터): 맑음={pi_exact[0]:.4f}, 흐림={pi_exact[1]:.4f}“)

Gambler’s Ruin: p=0.49, 초기 자금=50, 목표=100

def gambler_ruin(i, N, p): if p == 0.5: return 1 - i / N r = (1 - p) / p return (rN - ri) / (r**N - 1)

print(f”카지노 p=0.49, i=50, N=100: 파산 확률 = {gambler_ruin(50,100,0.49):.4f}”)`, }, ]} cases={[ { label: “10일 후 날씨 예측”, input: “P=[[0.8,0.2],[0.4,0.6]], start=맑음, n=10”, output: “맑음 확률: 0.6667, 흐림 확률: 0.3333”, }, { label: “정류 분포”, input: “P=[[0.8,0.2],[0.4,0.6]]”, output: “맑음=0.6667, 흐림=0.3333”, }, { label: “Gambler’s ruin”, input: “p=0.49, i=50, N=100”, output: “파산 확률 = 0.8824”, }, ]} />

복잡도

항목	값
N-step 계산	O(K^3 log N)
Power Iteration 수렴	O(K^2 x T)
고유벡터법	O(K^3)
공간	O(K^2)

K = 상태 수. K 가 크면 희소 행렬 표현 + Power Iteration.

응용

MCMC (Markov Chain Monte Carlo)

복잡한 분포에서 직접 샘플링 불가능할 때, 해당 분포를 정류 분포로 갖는 마르코프 체인 구성 후 충분히 진행해 샘플 획득.

Metropolis-Hastings: 제안 분포 q, 수용 확률 $\min(1, p(x’)/p(x))$
Gibbs Sampling: 각 변수를 조건부 분포에서 순서대로 샘플링

랜덤 워크

무방향 그래프에서 각 정점의 방문 비율 = degree / (2E). 정류 분포로 분석.

함정

1. 전이 행렬 방향

행 합 = 1 (행이 현재 상태). 열 합 = 1 로 착각하면 전치 행렬 사용 오류.

2. Reducible vs Irreducible

일부 상태 간 도달 불가능하면 reducible. 정류 분포가 유일하지 않을 수 있음.

3. Periodic 체인

주기 d > 1 이면 수렴 안 하고 진동. 자가 루프 추가로 aperiodic 만들기 가능.

4. 부동소수점 누적 오차

행렬 거듭제곱 반복 시 확률 합이 1 에서 벗어남. 주기적으로 정규화하거나 분수 표현 사용.

5. PS 에서 정수형 행렬

확률 문제를 분수/유리수로 처리하면 정밀도 보장. 모듈러 산술과 결합 가능.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 10830	행렬 제곱	47.3%	kokoa-lab
BOJ 11444	피보나치 수 6	51.2%	kokoa-lab
BOJ 2749	피보나치 수 3	50.0%	kokoa-lab
BOJ 13252	인터넷	32.1%	kokoa-lab

참고

[[matrix-exponentiation|Matrix Exponentiation]]
[[expected-value|Expected Value]]

Matrix Exponentiation: 선형 점화식 fast

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

선형 점화식을 행렬 곱으로 표현한 뒤, 행렬 거듭제곱을 log 시간에 계산하여 N 번째 항을 O(K³ log N) 에 얻는 기법. K = 상태 차원.

시간: O(K³ log N). K 작을 때 효율적
핵심: 반복 제곱법 (binary exponentiation)

문제 상황

점화식의 N 번째 항을 아주 큰 N (≥ 10^18) 에 대해 구해야 할 때.

방법	시간	N 범위
직접 반복	O(K²·N)	N ≤ 10^7
Matrix Exponentiation	O(K³ log N)	N ≤ 10^18
Berlekamp-Massey + Kitamasa	O(K² log N)	N ≤ 10^18, K 클 때

K = 상태 차원 (피보나치 → K=2, k차 선형 점화식 → K=k).

시각화

이진 거듭제곱: A^13 = A^8 × A^4 × A^1 (13 = 1101₂).

flowchart LR
    P["p = 13"]
    B0["p & 1 = 1\nR *= A"]
    S0["A = A * A\n(A^2)"]
    B1["p & 1 = 0"]
    S1["A = A * A\n(A^4)"]
    B2["p & 1 = 1\nR *= A^4"]
    S2["A = A * A\n(A^8)"]
    B3["p & 1 = 1\nR *= A^8"]
    Done["R = A^1 * A^4 * A^8\n= A^13"]

    P --> B0 --> S0 --> B1 --> S1 --> B2 --> S2 --> B3 --> Done

각 비트마다 A 를 제곱, 비트가 1 이면 결과에 곱함. 행렬도 동일하게 적용.

핵심 아이디어

K 차 선형 점화식을 행렬 형태로:

$$ \begin{pmatrix} a_{n+1} \ a_n \ \vdots \ a_{n-k+2} \end{pmatrix} = M^n \begin{pmatrix} a_k \ a_{k-1} \ \vdots \ a_1 \end{pmatrix} $$

전이 행렬 M 의 n 제곱을 binary exponentiation 으로 계산 → O(K³ log N).

모듈러 산술: 결과가 MOD 로 나눈 나머지인 경우, 각 곱셈 후 % MOD 적용.

Fibonacci 예

$$ \begin{pmatrix} F_{n+1} \ F_n \end{pmatrix} = \begin{pmatrix} 1 & 1 \ 1 & 0 \end{pmatrix}^n \begin{pmatrix} F_1 \ F_0 \end{pmatrix} $$

K = 2, 전이 행렬 = 2×2. N = 10^18 도 O(8 log N) = O(240) 번 곱셈.

알고리즘

행렬 곱

mul(A, B):  // K×K 행렬 곱
    C = K×K 영행렬
    for i in 0..K:
        for k in 0..K:
            if A[i][k] == 0: continue  // 스킵 최적화
            for j in 0..K:
                C[i][j] += A[i][k] * B[k][j]
                C[i][j] %= MOD
    return C

반복 제곱법

pow(A, p):  // A^p 계산
    R = K×K 단위 행렬
    while p > 0:
        if p & 1: R = mul(R, A)
        A = mul(A, A)
        p >>= 1
    return R

일반 K차 선형 점화식

점화식 a[n] = c1*a[n-1] + c2*a[n-2] + ... + ck*a[n-k] 의 전이 행렬:

M = [c1  c2  ...  c_{k-1}  ck ]
    [1   0   ...  0        0  ]
    [0   1   ...  0        0  ]
    [         ...             ]
    [0   0   ...  1        0  ]

상태 벡터 [a[n], a[n-1], ..., a[n-k+1]] 에 M 을 곱하면 [a[n+1], ..., a[n-k+2]].

구현

<CodeWithOutput language=“cpp” label=“C++ (행렬 거듭제곱)” outputLanguage=“text” outputLabel=“결과” title=“N번째 피보나치 수 (mod 1e9+7)” code={`#include <bits/stdc++.h> using namespace std;

const long long MOD = 1e9 + 7; const int K = 2; using Mat = array<array<long long, K>, K>;

Mat mul(const Mat& A, const Mat& B) { Mat C{}; for (int i = 0; i < K; i++) for (int k = 0; k < K; k++) { if (!A[i][k]) continue; for (int j = 0; j < K; j++) C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD; } return C; }

Mat matpow(Mat A, long long p) { Mat R{}; for (int i = 0; i < K; i++) R[i][i] = 1; // 단위 행렬 while (p > 0) { if (p & 1) R = mul(R, A); A = mul(A, A); p >>= 1; } return R; }

long long fib(long long n) { if (n <= 0) return 0; if (n == 1) return 1; // [ F(n+1) ] [ 1 1 ]^n [ 1 ] // [ F(n) ] = [ 1 0 ] * [ 0 ] Mat M = {{{1, 1}, {1, 0}}}; Mat R = matpow(M, n - 1); // R * [F(1), F(0)] = R * [1, 0] return R[0][0]; // F(n) }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr); long long n; cin >> n; cout << fib(n) << “\n”; // 검증: fib(10) = 55 for (int i = 1; i <= 10; i++) cout << “F(” << i << ”) = ” << fib(i) << “\n”; return 0; }} output={// 입력: 10 55 F(1) = 1 F(2) = 1 F(3) = 2 F(4) = 3 F(5) = 5 F(6) = 8 F(7) = 13 F(8) = 21 F(9) = 34 F(10) = 55`} />

응용

그래프 경로 수

인접 행렬 A 에서 A^k[u][v] = 정점 u 에서 v 까지 길이 정확히 k 인 경로의 수.

// 길이 k 경로 수
Mat A = /* 인접 행렬 */;
Mat Ak = matpow(A, k);
cout << Ak[u][v] % MOD << "\n";

DFA 상태 전이

문자열 자동자에서 상태 전이 행렬 = 알파벳 크기 × 상태 수. 길이 N 의 수락 문자열 개수를 O(|states|³ log N) 에 계산.

Tribonacci 등 고차 점화식

// a[n] = a[n-1] + a[n-2] + a[n-3]
// 전이 행렬 3x3
Mat M = {{{1,1,1},{1,0,0},{0,1,0}}};

복잡도

연산	시간	메모리
행렬 곱 1회	O(K³)	O(K²)
행렬 거듭제곱	O(K³ log N)	O(K²)
Kitamasa 기법	O(K² log N)	O(K)

K 가 작을수록 실용적. K ≥ 100 이면 Kitamasa 또는 Berlekamp-Massey 고려.

함정

[!WARNING] K 에 따른 시간 복잡도 과소 평가: K = 10 이면 1회 곱셈이 O(1000). N = 10^9, K = 50 이면 O(50³ × 30) = O(375만) 으로 충분하지만, K = 200 이면 O(200³ × 30) = O(240만×1000) → TLE.

[!WARNING] 단위 행렬 초기화 누락: matpow 에서 R 을 단위 행렬로 초기화하지 않으면 A^0 = 영행렬 → 모든 결과 0.

[!CAUTION] MOD 없이 long long 오버플로: K×K 행렬 원소가 최대 MOD-1 ≈ 10^9, 두 원소 곱이 10^18 → long long 최대값 내. 하지만 K 번 누적하면 K × (MOD-1)² → K = 1000 이상이면 __int128 또는 중간 MOD 필요.

N = 0 처리: 관례상 F(0) = 0, F(1) = 1. 문제마다 정의 확인.
비선형 점화식 (예: a[n] = a[n-1]^2) 은 행렬 방법 미적용.

BOJ

문제	설명
BOJ 11444 피보나치 수 6	행렬 거듭제곱 기본, N ≤ 10^18
BOJ 12850 본대 산책 2	인접 행렬 D^(K), 경로 수
BOJ 13430 합 구하기	상태 확장
BOJ 2749 피보나치 수 3	Pisano period 대안 vs 행렬
BOJ 15991 링클링크	DFA 행렬 거듭제곱

Median of Stream: 두 힙으로 중앙값 유지

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

스트림으로 들어오는 정수의 중앙값을 O(log N) 에 유지하는 문제.

중앙값 = 정렬했을 때 가운데 값. 원소가 짝수 개이면 두 중간 값의 평균.

문제 상황

정수가 하나씩 들어올 때마다 현재까지의 중앙값을 출력해야 한다.

naive: 매번 정렬 후 중간 인덱스 반환. O(N log N) per query, 총 O(N^2 log N). N = 10^5이면 불가능.

핵심 통찰: 정렬된 배열을 절반으로 나눠, 아래 절반은 Max-heap, 위 절반은 Min-heap으로 유지. 두 heap의 top을 보면 O(1)로 중앙값을 알 수 있고, 삽입/삭제는 O(log N).

시각화

두 힙 구조

flowchart LR
    subgraph L["L: Max-Heap (아래 절반)"]
        L1["..."]
        L2["L.top (최댓값)"]
    end
    subgraph R["R: Min-Heap (위 절반)"]
        R1["R.top (최솟값)"]
        R2["..."]
    end
    M["중앙값"]
    L2 -->|"L.top <= R.top 보장"| M
    R1 -->|"L.top <= R.top 보장"| M

원소 삽입 흐름 (x 삽입)

flowchart TD
    A["x 입력"]
    B{"x <= L.top ?"}
    C["L에 삽입"]
    D["R에 삽입"]
    E{"L.size > R.size + 1 ?"}
    F{"R.size > L.size ?"}
    G["R에 L.top 이동"]
    H["L에 R.top 이동"]
    I["중앙값 반환"]
    A --> B
    B -->|"YES"| C
    B -->|"NO"| D
    C --> E
    D --> E
    E -->|"YES"| G
    E -->|"NO"| F
    F -->|"YES"| H
    F -->|"NO"| I
    G --> I
    H --> I

핵심 아이디어

Max-heap L: 아래 절반 저장. top = 아래 절반의 최댓값.
Min-heap R: 위 절반 저장. top = 위 절반의 최솟값.
불변식: L.top <= R.top (아래 절반 최댓값 <= 위 절반 최솟값)
크기 균형: |L.size - R.size| <= 1 (원소 수 차이 최대 1)

중앙값 반환:

L.size > R.size: 중앙값 = L.top
L.size == R.size: 중앙값 = (L.top + R.top) / 2.0

삽입 시 균형 유지:

x <= L.top이면 L에, 그렇지 않으면 R에 삽입
L.size가 R.size + 1보다 크면: L.top을 R로 이동
R.size가 L.size보다 크면: R.top을 L로 이동

알고리즘

L: max-heap (아래 절반)
R: min-heap (위 절반)

add(x):
    if L.empty() or x <= L.top():
        L.push(x)
    else:
        R.push(x)

    # 크기 균형 유지
    if L.size() > R.size() + 1:
        R.push(L.top()); L.pop()
    if R.size() > L.size():
        L.push(R.top()); R.pop()

median():
    if L.size() > R.size():
        return L.top()
    return (L.top() + R.top()) / 2.0

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std;

int main() { ios::sync_with_stdio(false); cin.tie(nullptr);

int n;
cin >> n;

priority_queue<int> L;                             // max-heap (아래 절반)
priority_queue<int, vector<int>, greater<int>> R;  // min-heap (위 절반)

while (n--) {
    int x;
    cin >> x;

    // 삽입
    if (L.empty() || x <= L.top()) L.push(x);
    else R.push(x);

    // 크기 균형 유지
    if ((int)L.size() > (int)R.size() + 1) {
        R.push(L.top()); L.pop();
    }
    if ((int)R.size() > (int)L.size()) {
        L.push(R.top()); R.pop();
    }

    // 중앙값 출력
    if (L.size() > R.size()) cout << L.top() << "\\n";
    else cout << (long long)(L.top() + R.top()) / 2 << "\\n";
}
return 0;

}, }, { language: "python", label: "Python", code: import heapq import sys input = sys.stdin.readline

def solve(): n = int(input())

L = []   # max-heap (음수화)
R = []   # min-heap

for _ in range(n):
    x = int(input())

    # 삽입 (Python heapq는 min-heap, max-heap은 음수화)
    if not L or x <= -L[0]:
        heapq.heappush(L, -x)
    else:
        heapq.heappush(R, x)

    # 크기 균형 유지
    if len(L) > len(R) + 1:
        heapq.heappush(R, -heapq.heappop(L))
    if len(R) > len(L):
        heapq.heappush(L, -heapq.heappop(R))

    # 중앙값 출력
    if len(L) > len(R):
        print(-L[0])
    else:
        print((-L[0] + R[0]) // 2)

solve(), }, ]} cases={[ { label: "BOJ 1655 스타일", input: 7 1 5 2 10 -99 7 5, output: 1 2 2 3 2 3 5, }, { label: "단조 증가", input: 4 1 2 3 4, output: 1 1 2 2`, }, ]} />

복잡도

항목	값
삽입 add(x)	O(log N)
중앙값 쿼리 median()	O(1)
공간	O(N)
N개 삽입 + N개 쿼리 합계	O(N log N)

두 힙의 크기 합 = N. 삽입/삭제는 힙 연산이므로 O(log N).

변형

변형	방법
K번째 작은 수 유지	L.size = K, R.size = N-K 로 비율 조정
슬라이딩 윈도우 중앙값	힙 + lazy deletion. 삭제된 원소를 set으로 추적
온라인 중앙값 (정수 범위 제한)	세그먼트 트리 또는 BIT로 O(log V)

함정

1. Python에서 max-heap

Python heapq는 min-heap만 지원. Max-heap 구현 시 음수화:

heapq.heappush(L, -x)   # 삽입
-L[0]                    # top 참조 (음수 되돌리기)
-heapq.heappop(L)        # pop (음수 되돌리기)

2. 크기 균형 순서

삽입 후 L의 크기 체크를 먼저, R의 크기 체크를 나중에 해야 함. 두 조건이 동시에 참이 되는 경우 있음.

3. 짝수 개 중앙값

정수 두 개의 평균이 소수점 이하가 될 수 있음. 문제에 따라 정수 나눗셈(//) 또는 실수 나눗셈(/) 선택.

4. size() 비교 시 타입 주의 (C++)

L.size() > R.size() + 1에서 size()는 size_t(unsigned). R.size()가 0일 때 R.size() - 1은 언더플로우. (int) 캐스팅 권장.

5. 슬라이딩 윈도우 변형

윈도우에서 원소를 제거할 때 힙에서 직접 삭제 불가. Lazy deletion: 삭제 대상을 별도 집합에 기록, top 참조 시 삭제 대상이면 pop 반복.

BOJ 연습 문제

번호	제목	난이도	알고리즘
BOJ 1655	가운데를 말해요	Gold 2	두 힙
BOJ 2696	중앙값 구하기	Gold 2	두 힙
BOJ 13537	수열과 쿼리 1	Platinum 5	머지 소트 트리

참고

[[priority-queue-heap|Priority Queue / Heap]]
[[top-k-selection|Top K 선택]]

Nim Game: XOR 규칙

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Nim 은 여러 돌무더기에서 두 플레이어가 번갈아 한 무더기에서 돌을 임의 개수 가져가는 게임. 마지막 돌을 가져가는 쪽이 승 (normal play convention).

문제 상황과 동기

“N 개의 돌무더기, 두 플레이어, 최적 플레이 시 누가 이기나?” 형태의 게임 이론 문제.

핵심 질문: 주어진 상태가 필승(N-position) 인가 필패(P-position) 인가?

P-position (Previous player wins): 이전 플레이어가 이기는 자리. 현재 플레이어(선공) 입장에서 필패.
N-position (Next player wins): 현재 플레이어(선공)가 이기는 자리. 필승.

시각화

Bouton’s Theorem: XOR 으로 판별

flowchart TD
    S1["상태: heap = 3, 4, 5"] --> X1["XOR = 2, 0이 아님"]
    X1 --> N1["N-position: 선공 승"]
    S2["상태: heap = 1, 2, 3"] --> X2["XOR = 0"]
    X2 --> P2["P-position: 선공 패"]

게임 트리 소규모 예시

돌무더기 2개, 상태 (a, b) 에서 XOR = a XOR b:

flowchart TD
    Root["(2, 3) XOR=1 N-pos"]
    Root --> C["(2, 2) XOR=0 P-pos (필승 이동)"]
    Root --> A["(1, 3) XOR=2 N-pos"]
    Root --> B["(0, 3) XOR=3 N-pos"]
    Root --> D["(2, 1) XOR=3 N-pos"]
    Root --> E["(2, 0) XOR=2 N-pos"]
    C --> C1["(1, 2) XOR=3 N-pos"]
    C --> C2["(0, 2) XOR=2 N-pos"]

    style C fill:#ccffcc
    style Root fill:#ffffcc
    style C1 fill:#ffffcc
    style C2 fill:#ffffcc

(2, 3) 에서 (2, 2) 로 이동하면 XOR = 0 (P-pos). 이후 상대방의 모든 이동은 XOR != 0 으로 만들며, 선공은 항상 XOR = 0 으로 되돌릴 수 있음.

핵심 아이디어

Bouton’s Theorem

P-position (필패) $\Leftrightarrow$ 모든 무더기의 XOR = 0

$$ \text{heap}_1 \oplus \text{heap}_2 \oplus \cdots \oplus \text{heap}_n = 0 \Leftrightarrow \text{P-position} $$

증명 스케치

기저: 모든 무더기 = 0 은 P-position. XOR = 0. (성립)

P에서 N으로: XOR = 0 인 상태에서 한 무더기 $h_i$ 를 $h_i’$ 으로 줄이면 $h_i’ < h_i$, 전체 XOR = $h_i \oplus h_i’ \neq 0$. 즉 P에서의 모든 이동은 N으로. (성립)

N에서 P로: XOR = $x \neq 0$ 이면 $x$ 의 최상위 비트를 1 로 갖는 무더기 $h_i$ 가 반드시 존재. $h_i’ = h_i \oplus x$ 로 설정하면 $h_i’ < h_i$ (크기 감소), 전체 XOR = 0. N에서 P로 가는 이동이 항상 존재. (성립)

최적 이동 계산

N-position 에서 XOR = 0 으로 만드는 이동:

x = xor_sum
for i in 0..n-1:
    new_size = heap[i] XOR x
    if new_size < heap[i]:
        heap[i] = new_size  # 이 무더기를 new_size로 줄임
        break

Misere Nim

마지막 돌을 가져가는 쪽이 패 (normal play 반대):

모든 무더기가 크기 1 이하이면: 1 인 무더기 수가 홀수 = P-position
그 외: 일반 Nim 과 동일 (XOR = 0 이면 P-position)

알고리즘

# Normal Nim 승패 판별
xor_sum = heap[0] XOR heap[1] XOR ... XOR heap[n-1]
if xor_sum == 0:
    P-position (선공 패)
else:
    N-position (선공 승)

# Misere Nim
all_small = all(h <= 1 for h in heaps)
if all_small:
    P-position iff count(h == 1) % 2 == 1
else:
    P-position iff xor_sum == 0

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Nim Game: 승패 판별 + 최적 이동 #include <bits/stdc++.h> using namespace std;

bool nim_winner(vector& heaps) { int x = 0; for (int h : heaps) x ^= h; return x != 0; }

// 최적 이동: (무더기 인덱스, 줄일 개수). N-position 에서만 유효. pair<int,int> nim_optimal(vector heaps) { int x = 0; for (int h : heaps) x ^= h; for (int i = 0; i < (int)heaps.size(); i++) { int ns = heaps[i] ^ x; if (ns < heaps[i]) return {i, heaps[i] - ns}; } return {-1, -1}; }

bool misere_winner(vector& heaps) { bool all_small = true; for (int h : heaps) if (h > 1) { all_small = false; break; } if (all_small) { int ones = 0; for (int h : heaps) ones += h; return ones % 2 == 0; // 홀수 개 1 = P-position = 선공 패 } int x = 0; for (int h : heaps) x ^= h; return x != 0; }

int main() { vector h1 = {3, 4, 5}; cout << “XOR: ” << (3^4^5) << “\n”; cout << (nim_winner(h1) ? “선공 승” : “선공 패”) << “\n”;

auto [idx, rem] = nim_optimal(h1);
cout << "최적: 무더기 " << idx << " 에서 " << rem << "개 제거\\n";

vector<int> h2 = {1, 2, 3};
cout << "XOR: " << (1^2^3) << "\\n";
cout << (nim_winner(h2) ? "선공 승" : "선공 패") << "\\n";

// Misere Nim
vector<int> h3 = {1, 1, 1};
cout << "Misere (1,1,1): " << (misere_winner(h3) ? "선공 승" : "선공 패") << "\\n";

}, }, { language: "python", label: "Python", code: # Nim Game from functools import reduce from operator import xor

def nim_winner(heaps): """True = N-position (선공 승)""" return reduce(xor, heaps, 0) != 0

def nim_optimal(heaps): """XOR=0 으로 만드는 최적 이동 (인덱스, 줄일 개수)""" xsum = reduce(xor, heaps, 0) for i, h in enumerate(heaps): ns = h ^ xsum if ns < h: return i, h - ns return -1, -1

def misere_winner(heaps): """Misere Nim 승패""" all_small = all(h <= 1 for h in heaps) if all_small: return sum(heaps) % 2 == 0 # 홀수 개 1 = P-position = 선공 패 return reduce(xor, heaps, 0) != 0

N-position 예시

heaps = [3, 4, 5] print(f”XOR: {reduce(xor, heaps)}”) # 2 print(“선공 승” if nim_winner(heaps) else “선공 패”) idx, rem = nim_optimal(heaps) print(f”최적: 무더기 {idx} 에서 {rem}개 제거”)

P-position 예시

heaps2 = [1, 2, 3] print(f”XOR: {reduce(xor, heaps2)}”) # 0 print(“선공 승” if nim_winner(heaps2) else “선공 패”)

Misere Nim

print(“Misere (1,1,1):”, “선공 승” if misere_winner([1,1,1]) else “선공 패”), }, { language: "java", label: "Java", code: // Nim Game

public class Main { static boolean nimWinner(int[] heaps) { int x = 0; for (int h : heaps) x ^= h; return x != 0; } static int[] nimOptimal(int[] heaps) { int x = 0; for (int h : heaps) x ^= h; for (int i = 0; i < heaps.length; i++) { int ns = heaps[i] ^ x; if (ns < heaps[i]) return new int[]{i, heaps[i] - ns}; } return new int[]{-1, -1}; } public static void main(String[] args) { int[] h1 = {3, 4, 5}; System.out.println(“선공 ” + (nimWinner(h1) ? “승” : “패”)); int[] move = nimOptimal(h1); System.out.println(“최적: 무더기 ” + move[0] + ” 에서 ” + move[1] + “개 제거”); int[] h2 = {1, 2, 3}; System.out.println(“선공 ” + (nimWinner(h2) ? “승” : “패”)); } }`, }, ]} cases={[ { label: “N-position (선공 승)”, input: “heaps = [3, 4, 5]”, output: “XOR: 2\n선공 승\n최적: 무더기 2 에서 4개 제거”, }, { label: “P-position (선공 패)”, input: “heaps = [1, 2, 3]”, output: “XOR: 0\n선공 패”, }, { label: “Misere Nim (1,1,1)”, input: “heaps = [1, 1, 1]”, output: “Misere (1,1,1): 선공 패”, }, ]} />

복잡도

항목	값
승패 판별	O(N)
최적 이동	O(N)
공간	O(N)

N = 무더기 수. 무더기 크기와 무관하게 O(N).

Sprague-Grundy 확장

Nim 은 Sprague-Grundy 정리의 원형.

Grundy value (Nim-value):

$$ G(\text{pos}) = \text{mex}({G(\text{move}) \mid \text{move} \in \text{reachable}}) $$

mex = Minimum EXcludant (0, 1, 2, … 중 없는 가장 작은 수).

Nim 에서 크기 k 인 무더기: G = k (자명)
복합 게임에서 XOR 합: $G(\text{sum}) = G_1 \oplus G_2 \oplus \cdots$

임의의 impartial game (완전 정보, 두 플레이어, 이동 집합 동일) 은 Nim 무더기로 등가 변환 가능.

조합 게임 이론 용어

개념	설명
Normal play	마지막 이동하면 승
Misere play	마지막 이동하면 패
Impartial game	두 플레이어 이동 집합 동일
Partizan game	이동 집합 플레이어마다 다름 (바둑 등)
Sprague-Grundy	Impartial game = Nim 등가

함정

1. 무더기 크기 0 처리

XOR 에서 0 은 영향 없음. 모두 0 이면 P-position (게임 종료).

2. Misere 와 Normal play 혼동

대부분 PS 문제는 normal play. Misere 조건은 반드시 명시.

3. 무더기 개수 1 인 경우

heap = [k] 이면 XOR = k. k != 0 이면 N-position. 선공이 전부 가져가면 승.

4. “정확히 k 개” 제한 Nim

매 턴 최대 k 개만 가져갈 수 있으면 일반 Nim 과 다름. Grundy 값 = heap mod (k+1).

5. 병렬 게임 (sum of games)

여러 Nim 이 독립적으로 진행되면 XOR 합 사용 가능. 독립적이지 않으면 Sprague-Grundy 수동 계산.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11694	님 게임	68.2%	kokoa-lab
BOJ 9655	돌 게임	75.1%	kokoa-lab
BOJ 9656	돌 게임 2	73.5%	kokoa-lab
BOJ 9657	돌 게임 3	63.4%	kokoa-lab
BOJ 11062	카드 게임	47.5%	kokoa-lab

참고

[[sprague-grundy-theorem|Sprague-Grundy]]
[[game-theory|Game Theory]]

Order Statistics Tree (OST): rank/select 지원 BST

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Order Statistics Tree (OST) 는 각 노드에 서브트리 크기 (size) 를 추가로 저장한 균형 [[binary-search-tree|BST]]. 두 가지 새 연산을 O(log N) 에 지원한다.

rank(x): x 보다 작은 원소 수 (= x 의 0-indexed 순위)
select(k): k 번째 원소 (0-indexed)

일반 BST 에 size 필드만 추가하면 구현 가능하지만, 균형이 깨지면 O(N) 로 퇴화한다. 실전에서는 Treap, AVL, Red-Black Tree 기반으로 구현한다.

문제 상황

정수 집합 {3, 7, 1, 9, 5} 에 대해 다음을 O(log N) 에 처리하고 싶다.

rank(5) = 2 (5보다 작은 원소: 1, 3)
select(3) = 7 (정렬 순서로 3번째: 1, 3, 5, 7, 9 에서 index 3)
삽입/삭제도 O(log N)

정렬 배열이면 이진 탐색으로 rank/select O(log N) 가능하지만, 삽입/삭제가 O(N) (shift). OST 는 세 연산 모두 O(log N).

시각화

flowchart TD
    A["5 (size=5)"]
    B["2 (size=2)"]
    C["8 (size=2)"]
    D["1 (size=1)"]
    E["3 (size=1)"]
    F["7 (size=1)"]
    G["9 (size=1)"]
    A --> B
    A --> C
    B --> D
    B --> E
    C --> F
    C --> G

size = 노드 자신 + 왼쪽 서브트리 크기 + 오른쪽 서브트리 크기.

rank(5) 계산: 루트(5)에서 왼쪽 서브트리 크기 = 2. 즉 rank = 2.

select(3): 루트 왼쪽 크기 = 2. 3 > 2 이므로 오른쪽 서브트리에서 index 0 을 찾음. 오른쪽 루트(8), 왼쪽 크기=1, index 0 == 1 이므로 왼쪽 자식 7 반환.

핵심 아이디어

불변식

모든 노드 n 에 대해:

n->size = (n->l ? n->l->size : 0) + (n->r ? n->r->size : 0) + 1

삽입/삭제 시 조상 노드의 size 를 모두 갱신해야 한다. (재귀 리턴 시 갱신)

select(k) 로직

left_size = n->l ? n->l->size : 0

if k == left_size:    return n  (현재 노드가 k번째)
if k  < left_size:   return select(n->l, k)
else:                return select(n->r, k - left_size - 1)

rank(x) 로직

if x <= n->key:  return rank(n->l, x)
else:            return (n->l ? n->l->size : 0) + 1 + rank(n->r, x)

알고리즘

핵심 구조 및 헬퍼

struct Node {
    int key, size;
    Node *l, *r;
    Node(int k) : key(k), size(1), l(nullptr), r(nullptr) {}
};

int sz(Node* n) { return n ? n->size : 0; }

void update(Node* n) {
    if (n) n->size = sz(n->l) + sz(n->r) + 1;
}

select / rank

Node* select(Node* r, int k) {
    if (!r) return nullptr;
    int lsz = sz(r->l);
    if (k == lsz) return r;
    if (k < lsz) return select(r->l, k);
    return select(r->r, k - lsz - 1);
}

int rank(Node* r, int key) {
    if (!r) return 0;
    if (key <= r->key) return rank(r->l, key);
    return sz(r->l) + 1 + rank(r->r, key);
}

일반 BST 삽입/삭제 시 update(n) 로 size 를 갱신한다.

구현: C++ policy-based tree

경쟁 프로그래밍에서는 GNU PBDS 를 활용한다. 직접 구현보다 훨씬 간단하고 안정적.

<CodeWithOutput variants={[ { language: “cpp”, label: “C++ (GNU PBDS)”, code: `#include <bits/stdc++.h> #include <ext/pb_ds/assoc_container.hpp> #include <ext/pb_ds/tree_policy.hpp> using namespace std; using namespace __gnu_pbds;

typedef tree<int, null_type, less, rb_tree_tag, tree_order_statistics_node_update> OST;

int main() { OST ost; // 삽입 ost.insert(3); ost.insert(1); ost.insert(7); ost.insert(5); ost.insert(9);

// find_by_order(k): k번째 원소 (0-indexed)
cout << *ost.find_by_order(0) << "\\n";  // 1
cout << *ost.find_by_order(2) << "\\n";  // 5

// order_of_key(x): x보다 작은 원소 수 (= rank)
cout << ost.order_of_key(5) << "\\n";  // 2
cout << ost.order_of_key(8) << "\\n";  // 4

// 삭제
ost.erase(7);
cout << ost.size() << "\\n";  // 4

return 0;

}, }, { language: "python", label: "Python (SortedList)", code: # Python: sortedcontainers.SortedList 로 유사 기능 from sortedcontainers import SortedList

sl = SortedList([3, 1, 7, 5, 9])

select: k번째 원소 (0-indexed)

print(sl[0]) # 1 print(sl[2]) # 5

rank: x보다 작은 원소 수

print(sl.bisect_left(5)) # 2 print(sl.bisect_left(8)) # 4

삽입/삭제

sl.remove(7) print(len(sl)) # 4, }, ]} cases={[ { label: "rank/select 예시", input: ``, output: 1 5 2 4 4`, }, ]} />

복잡도

연산	OST (균형)	정렬 배열	일반 BST
삽입	O(log N)	O(N)	O(log N) 평균
삭제	O(log N)	O(N)	O(log N) 평균
rank(x)	O(log N)	O(log N)	O(log N) 평균
select(k)	O(log N)	O(1)	O(log N) 평균
공간	O(N)	O(N)	O(N)

언어별 지원 현황

언어	라이브러리	지원 여부
C++	`__gnu_pbds::tree` (GCC)	✅
Python	`sortedcontainers.SortedList`	유사 (bisect 활용)
Java	`TreeMap.headMap().size()`	유사 (O(log N) 아님)
Rust	`std::collections::BTreeSet`	미지원, 직접 구현

[!IMPORTANT] C++ __gnu_pbds::tree 는 중복 원소를 허용하지 않는다. 중복이 있으면 pair<int,int> 로 wrapping (value, unique_id).

함정

1. 중복 원소

GNU PBDS tree<int, ...> 는 set 기반이라 중복 삽입 무시.

중복 처리: pair<int, int> 로 (값, 고유번호) 저장.

typedef tree<pair<int,int>, null_type, less<pair<int,int>>,
             rb_tree_tag, tree_order_statistics_node_update> OST;

int uid = 0;
ost.insert({5, uid++});
ost.insert({5, uid++});  // 중복 허용

2. size 갱신 누락

직접 구현 시 삽입/삭제 재귀 리턴 경로에서 update(n) 빠뜨리면 rank/select 오류. 회전 시도 포함해서 갱신 필요.

[!WARNING] Treap 회전 시 회전 후 자식부터 update() 해야 부모 size 가 정확해진다.

3. Fenwick Tree 대안

좌표 압축 후 Fenwick Tree 로 rank/select 를 O(log N) 에 처리 가능. 삽입/삭제 범위가 정해진 경우 더 빠름. [[fenwick-tree|Fenwick Tree]] 참조.

BOJ 연습 문제

번호	제목	비고
BOJ 1539	이진 검색 트리	rank/select 연습
BOJ 7469	K번째 수	OST 또는 Merge Sort Tree
BOJ 2042	구간 합 구하기	Fenwick Tree 대안 비교

참고

[[binary-search-tree|BST (이진 탐색 트리)]]
[[bbst|Treap (Balanced BST)]]
[[fenwick-tree|Fenwick Tree]] (좌표 압축 후 rank/select 대체)
[[segtree|Segment Tree]] (구간 쿼리)

Pascal Triangle: 이항계수

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Pascal Triangle 은 각 원소가 위 두 원소의 합인 삼각형. 행 n, 열 k 의 원소가 이항계수 $\binom{n}{k}$.

1
1 1
1 2 1
1 3 3 1
1 4 6 4 1
1 5 10 10 5 1

이항계수 $\binom{n}{k}$: n 개 중 k 개를 순서 없이 선택하는 경우의 수.

$$ \binom{n}{k} = \frac{n!}{k! \cdot (n-k)!} $$

문제 상황

$\binom{n}{k}$ 를 팩토리얼로 직접 계산하면:

$n!$ 이 빠르게 오버플로우
MOD 연산 시 나눗셈 처리 복잡

해결: 점화식 DP 로 MOD 아래서 정확하게 계산.

재귀 점화식:

$$ \binom{n}{k} = \binom{n-1}{k-1} + \binom{n-1}{k} $$

경계 조건: $\binom{n}{0} = \binom{n}{n} = 1$.

시각화

flowchart TD
    C00["C(0,0) = 1"]
    C10["C(1,0) = 1"] --> C20["C(2,0) = 1"]
    C00 --> C10
    C11["C(1,1) = 1"] --> C21["C(2,1) = 2"]
    C10 --> C21
    C00 --> C11
    C11 --> C22["C(2,2) = 1"]
    C21 --> C31["C(3,1) = 3"]
    C20 --> C31
    C21 --> C32["C(3,2) = 3"]
    C22 --> C32
    C20 --> C30["C(3,0) = 1"]
    C22 --> C33["C(3,3) = 1"]

핵심 아이디어

DP 계산

2D 배열 C[i][j]에 파스칼 삼각형 저장. 이전 행에서 두 값을 더하는 O(N^2) 방법.

단일 쿼리라면 1D 배열로 공간 최적화:

배열을 오른쪽에서 왼쪽으로 갱신 → in-place 업데이트

MOD 처리

대부분 문제는 답을 $10^9 + 7$ 로 나눈 나머지 요구.

DP 점화식은 덧셈만 사용하므로 MOD 연산 자연스럽게 적용:

$$ C[i][j] = (C[i-1][j-1] + C[i-1][j]) \bmod M $$

Lucas’ Theorem (대형 n)

n 이 매우 크고 소수 p 로 나눈 나머지를 구할 때:

$$ \binom{n}{k} \equiv \prod_{i} \binom{n_i}{k_i} \pmod{p} $$

여기서 $n = \sum n_i p^i$, $k = \sum k_i p^i$ 는 p 진법 표현.

알고리즘

알고리즘 1: 2D 파스칼 삼각형 (O(N^2) 공간/시간)

// C[i][j] = C(i, j) mod MOD
const int MOD = 1e9 + 7;
vector<vector<long long>> C(n + 1, vector<long long>(n + 1, 0));
for (int i = 0; i <= n; i++) {
    C[i][0] = 1;
    for (int j = 1; j <= i; j++)
        C[i][j] = (C[i-1][j-1] + C[i-1][j]) % MOD;
}
// C[n][k] = C(n, k) mod MOD

알고리즘 2: 1D 공간 최적화 (O(N) 공간)

vector<long long> C(n + 1, 0);
C[0] = 1;
for (int i = 1; i <= n; i++)
    for (int j = i; j >= 1; j--)  // 오른쪽에서 왼쪽으로
        C[j] = (C[j] + C[j-1]) % MOD;
// C[k] = C(n, k) mod MOD

알고리즘 3: 팩토리얼 + 역원 (단일 쿼리 O(N) 전처리)

n 이 크고 다중 쿼리일 때: 팩토리얼과 모듈러 역원을 전처리.

const int MAXN = 2e5 + 5;
const int MOD = 1e9 + 7;
long long fact[MAXN], inv_fact[MAXN];

long long power(long long a, long long b, long long mod) {
    long long res = 1; a %= mod;
    for (; b > 0; b >>= 1) {
        if (b & 1) res = res * a % mod;
        a = a * a % mod;
    }
    return res;
}

void precompute(int n) {
    fact[0] = 1;
    for (int i = 1; i <= n; i++) fact[i] = fact[i-1] * i % MOD;
    inv_fact[n] = power(fact[n], MOD - 2, MOD);
    for (int i = n - 1; i >= 0; i--) inv_fact[i] = inv_fact[i+1] * (i+1) % MOD;
}

long long C(int n, int k) {
    if (k < 0 || k > n) return 0;
    return fact[n] % MOD * inv_fact[k] % MOD * inv_fact[n-k] % MOD;
}

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std; const int MOD = 1e9 + 7;

int main() { int n; cin >> n; // 파스칼 삼각형 출력 vector C(n + 1, 0); C[0] = 1; for (int i = 0; i < n; i++) { vector nxt(n + 1, 0); for (int j = 0; j <= i; j++) { nxt[j] = (nxt[j] + C[j]) % MOD; nxt[j + 1] = (nxt[j + 1] + C[j]) % MOD; } C = nxt; for (int j = 0; j <= i + 1; j++) cout << C[j] << ” \n”[j == i + 1]; } // C(n, k) 출력 int k; cin >> k; cout << C[k] << “\n”; return 0; }, }, { language: "python", label: "Python", code: MOD = 10**9 + 7

def pascal(n): C = [0] * (n + 1) C[0] = 1 rows = [] rows.append(C[:1]) for i in range(1, n + 1): nxt = [0] * (n + 1) for j in range(i + 1): if j > 0: nxt[j] = (nxt[j] + C[j-1]) % MOD nxt[j] = (nxt[j] + C[j]) % MOD C = nxt rows.append(C[:i+1]) return C, rows

n = int(input()) C, rows = pascal(n) for row in rows: print(*row) k = int(input()) print(C[k]), }, ]} cases={[ { label: "기본 (n=5, k=2)", input: 5 2, output: 1 1 1 1 2 1 1 3 3 1 1 4 6 4 1 1 5 10 10 5 1 10`, }, ]} />

성질

성질	수식	의미
행 합	$\sum_{k=0}^{n} \binom{n}{k} = 2^n$	n 개 원소 부분집합 수
홀짝 행 합	$\sum_{k \text{ even}} \binom{n}{k} = 2^{n-1}$	짝수 선택 수
Hockey stick	$\sum_{i=r}^{n} \binom{i}{r} = \binom{n+1}{r+1}$	대각선 합
Vandermonde	$\sum_{k} \binom{m}{k}\binom{n}{r-k} = \binom{m+n}{r}$	합성
대칭	$\binom{n}{k} = \binom{n}{n-k}$	삼각형 대칭

복잡도

방법	시간	공간	용도
2D DP	$O(N^2)$	$O(N^2)$	소규모, n 전체 테이블
1D DP	$O(N^2)$	$O(N)$	공간 절약
팩토리얼 전처리	$O(N)$ 전처리, $O(1)$ 쿼리	$O(N)$	다중 쿼리, 대규모
Lucas’ Theorem	$O(\log_p N)$ 쿼리	$O(p)$	n 극히 크고 소수 MOD

함정

[!WARNING] MOD 로 나눈 후 나눗셈 불가: $\binom{n}{k} \neq \frac{fact[n]}{fact[k] \cdot fact[n-k]}$ MOD 세계에서는 직접 나눗셈 대신 모듈러 역원 사용.

[!WARNING] k > n 이면 0: 경계 조건 $\binom{n}{k} = 0$ $(k > n$ 또는 $k < 0)$ 를 반드시 처리.

[!CAUTION] 오버플로우: fact[n] 을 long long 으로 선언해도 n 이 크면 fact[n] * inv_fact[k] 중간에 오버플로우. 각 곱셈마다 % MOD 적용.

흔한 실수

C[i][j] 인덱스 오류: j > i 일 때 0 처리 안 함
1D DP 갱신 시 왼쪽에서 오른쪽으로 갱신하면 이미 갱신된 값 사용 (오류)
대형 n 에서 DP 테이블 메모리 초과, 팩토리얼 방법 사용 안 함

BOJ 연습 문제

번호	제목	키워드
BOJ 11050	이항 계수 1	기본 계산
BOJ 11051	이항 계수 2	MOD 계산
BOJ 2608	파스칼의 삼각형	삼각형 출력
BOJ 1862	2진수 표현	이항계수 응용
BOJ 13977	이항 계수와 쿼리	팩토리얼 전처리
BOJ 11401	이항 계수 3	큰 n, 역원

참고

[[combinatorics|조합론]]
[[catalan-number|Catalan Number]]
[[inclusion-exclusion|Inclusion-Exclusion]]
[[arithmetic|산술 기초]]

Persistent Segment Tree (영속 세그): 시점별 스냅샷

koa (김신건) — Thu, 16 Jul 2026 00:00:00 GMT

정의

Persistent Segment Tree 는 매 갱신마다 이전 버전을 그대로 유지하면서 새 버전을 만드는 세그먼트 트리입니다. 각 버전은 루트 포인터 로 식별됩니다.

핵심 트릭: path copying. 갱신 경로 (O(log N) 노드) 만 복사하고 나머지는 이전 버전과 공유.

공간: 갱신 1 회당 O(log N) 노드 추가
시간: 조회/갱신 모두 O(log N)

문제 상황

배열에서 아래 두 가지를 동시에 처리해야 할 때:

과거 버전 조회: “버전 v 시점의 구간 합을 구하라”
K-th smallest in range: 구간 [l, r] 에서 k 번째 작은 값을 O(log N) 에

단순 세그먼트 트리는 현재 상태만 저장 → 과거 조회 불가.

방식	갱신 1회 추가 공간	시간	과거 조회
배열 전체 복사	O(N)	O(log N)	✅
Persistent Segment Tree	O(log N)	O(log N)	✅
기본 세그먼트 트리	O(1)	O(log N)	❌

시각화

버전 0 에서 위치 i 를 갱신해 버전 1 을 만드는 path copying 과정.

flowchart TD
    subgraph v0["버전 0"]
        A0["루트 v0"]
        B0["내부 v0-L"]
        C0["내부 v0-R"]
        D0["리프 i v0"]
        E0["리프 i+1 v0"]
    end
    subgraph v1["버전 1, 위치 i 갱신"]
        A1["루트 v1 (새 노드)"]
        B1["내부 v1-L (새 노드)"]
        D1["리프 i v1 (새 노드)"]
    end
    A0 --> B0 & C0
    B0 --> D0 & E0
    A1 -->|"복사된 경로"| B1
    A1 -->|"공유"| C0
    B1 -->|"복사된 경로"| D1
    B1 -->|"공유"| E0
    style A1 fill:#d4edda
    style B1 fill:#d4edda
    style D1 fill:#d4edda

초록 노드만 새로 할당. C0, E0 는 두 버전이 공유해 공간을 절약.

핵심 아이디어

path copying: 갱신이 필요한 루트에서 리프까지의 경로만 새 노드로 복사. 나머지 자식은 이전 버전 노드를 그대로 가리킴.

버전 v 루트: root[v]
버전 v+1 생성:
  1. 루트 노드 새로 할당 (기존 복사)
  2. 갱신 방향 자식: 재귀적으로 새 노드 생성
  3. 반대 방향 자식: 이전 버전 노드 포인터 그대로 유지
  4. root[v+1] = 새 루트

두 버전의 차이로 범위 쿼리: query(root[l-1], root[r], ...) 처럼 두 버전 PST 의 합 차이를 이용하면 구간 통계를 O(log N) 에 계산.

알고리즘

Build

build(l, r):
    id = 새 노드 할당
    if l == r: return id
    m = (l + r) / 2
    node[id].left  = build(l, m)
    node[id].right = build(m+1, r)
    return id

Update (path copying)

update(prev, l, r, pos, val):
    id = 새 노드 (pool[prev] 복사)
    node[id].sum += val
    if l == r: return id
    m = (l + r) / 2
    if pos <= m:
        node[id].left  = update(node[prev].left,  l, m, pos, val)
    else:
        node[id].right = update(node[prev].right, m+1, r, pos, val)
    node[id].sum = node[node[id].left].sum + node[node[id].right].sum
    return id

Query (두 버전 차이)

query(u, v, l, r, L, R):
    // node[v] - node[u] = 이 두 버전 사이 갱신 합
    if L <= l and r <= R:
        return node[v].sum - node[u].sum
    m = (l + r) / 2
    res = 0
    if L <= m: res += query(node[u].left,  node[v].left,  l, m, L, R)
    if R > m:  res += query(node[u].right, node[v].right, m+1, r, L, R)
    return res

K-th Smallest in Range

좌표 압축 후, a[1..i] 에 값 삽입한 누적 PST 를 구축.

kth(u, v, l, r, k):
    // [l-1 버전]과 [r 버전] 차이로 구간 원소 카운트
    if l == r: return l   // 좌표 압축값 -> 실제 값 복원
    m = (l + r) / 2
    left_cnt = node[node[v].left].sum - node[node[u].left].sum
    if k <= left_cnt:
        return kth(node[u].left,  node[v].left,  l, m, k)
    else:
        return kth(node[u].right, node[v].right, m+1, r, k - left_cnt)

구현

<CodeWithOutput language=“cpp” label=“C++ (PST, K-th Smallest)” outputLanguage=“text” outputLabel=“결과” title=“BOJ 7469: K번째 수 (구간 k-th smallest)” code={`#include <bits/stdc++.h> using namespace std;

const int MAXN = 6000005; struct Node { int l, r, sum; } pool[MAXN]; int root[100005], sz;

int build(int l, int r) { int id = ++sz; pool[id] = {0, 0, 0}; if (l == r) return id; int m = (l + r) >> 1; pool[id].l = build(l, m); pool[id].r = build(m + 1, r); return id; }

int update(int prev, int l, int r, int pos) { int id = ++sz; pool[id] = pool[prev]; pool[id].sum++; if (l == r) return id; int m = (l + r) >> 1; if (pos <= m) pool[id].l = update(pool[prev].l, l, m, pos); else pool[id].r = update(pool[prev].r, m+1, r, pos); return id; }

int kth(int u, int v, int l, int r, int k) { if (l == r) return l; int m = (l + r) >> 1; int left_cnt = pool[pool[v].l].sum - pool[pool[u].l].sum; if (k <= left_cnt) return kth(pool[u].l, pool[v].l, l, m, k); return kth(pool[u].r, pool[v].r, m+1, r, k - left_cnt); }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n, q; cin >> n >> q; vector a(n+1); vector coords; for (int i = 1; i <= n; i++) { cin >> a[i]; coords.push_back(a[i]); } sort(coords.begin(), coords.end()); coords.erase(unique(coords.begin(), coords.end()), coords.end()); int M = (int)coords.size(); auto comp = [&](int x) { return (int)(lower_bound(coords.begin(), coords.end(), x) - coords.begin()) + 1; }; root[0] = build(1, M); for (int i = 1; i <= n; i++) root[i] = update(root[i-1], 1, M, comp(a[i])); while (q—) { int l, r, k; cin >> l >> r >> k; int idx = kth(root[l-1], root[r], 1, M, k); cout << coords[idx-1] << “\n”; } return 0; }} output={// 예: n=5, a=[1,5,2,6,3], 쿼리: l=2 r=5 k=2 // 구간 [2,5] = {5,2,6,3} 정렬 -> {2,3,5,6} // 2번째 = 3 3`} />

복잡도

연산	시간	추가 공간
Build	O(N)	O(N)
Update 1회	O(log N)	O(log N) 노드
Query	O(log N)	O(1)
K-th 1회	O(log N)	O(1)

전체 공간: O((N + Q) log N). 좌표 압축 값 범위 M 에 대해 초기 build O(M).

pool 배열 크기: 최소 M + Q * log(M). 실전에서는 N * 40 이 안전.

함정

[!WARNING] pool 크기 과소 추정: 갱신 1 회당 log N 노드 소모. N = 10^5, Q = 10^5, log N ≈ 17 이면 최소 340 만. 여유 있게 600 만 이상 잡는다.

[!WARNING] kth 에서 버전 순서 혼동: kth(root[l-1], root[r], ...) 에서 root[l-1] 이 “빼는” 기준 버전. 순서가 바뀌면 left_cnt 가 음수가 되어 WA.

[!CAUTION] 좌표 압축 없이 값 범위가 클 때: 값 범위 1~10^9 이면 build 단계가 O(10^9) → MLE/TLE. 반드시 좌표 압축하거나 [[dynamic-segtree|Dynamic Segtree]] 를 사용.

merge sort tree 는 구현이 단순하지만 O(log²N). PST 는 O(log N) 이지만 pool 관리 필요.
다차원 PST 는 공간 복잡도가 기하급수로 늘어남 (실전에서 대부분 [[wavelet-tree|Wavelet Tree]] 대체).

BOJ

문제	설명
BOJ 7469 K번째 수	구간 k-th smallest, 대표 문제
BOJ 16978 수열과 쿼리 22	과거 버전 구간 합 조회
BOJ 13557 수열과 쿼리 10	구간 최대 부분합 + 버저닝
BOJ 8904 2차원 랜덤 게임	머지 소트 트리 vs PST 비교