김신건의 로그 - 위키 / algorithm

Binary Lifting: 2의 지수 doubling

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

트리에서 정점의 2^k 조상 을 O(N log N) 전처리 후 O(log N) 쿼리로 답하는 기법. LCA, k-th ancestor 등에 사용.

전처리

const int LOG = 20;
vector<vector<int>> up(n, vector<int>(LOG));

void dfs(int u, int p) {
    up[u][0] = p;
    for (int k = 1; k < LOG; k++)
        up[u][k] = up[u][k-1] < 0 ? -1 : up[up[u][k-1]][k-1];
    for (int v : adj[u]) if (v != p) {
        depth[v] = depth[u] + 1;
        dfs(v, u);
    }
}

LCA 쿼리

int lca(int u, int v) {
    if (depth[u] < depth[v]) swap(u, v);
    int diff = depth[u] - depth[v];
    for (int k = 0; k < LOG; k++)
        if (diff & (1 << k)) u = up[u][k];
    if (u == v) return u;
    for (int k = LOG - 1; k >= 0; k--)
        if (up[u][k] != up[v][k]) { u = up[u][k]; v = up[v][k]; }
    return up[u][0];
}

O(log N) per query.

응용

LCA in O(log N)
Kth ancestor in O(log N)
Path sum on tree (BIT + LCA)
Functional graph next state

참고

[[lca|LCA]]
[[euler-tour-technique|Euler Tour]]

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

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Binary Search Tree (BST) 는 각 노드가 다음을 만족하는 이진 트리입니다.

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

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

연산

struct Node { int key; Node *l, *r; };

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, nullptr, nullptr};
    if (k < r->key) r->l = insert(r->l, k);
    else if (k > r->key) r->r = insert(r->r, k);
    return r;
}

중위 순회 (inorder) 로 방문하면 키가 정렬된 순서로 출력됩니다.

왜 균형이 필요한가

정렬된 입력을 순서대로 삽입하면 일자 트리 가 되어 O(N) 로 퇴화합니다.

균형 유지 자료구조:

[[avl-tree|AVL Tree]]: 엄격한 균형 (높이 차 <= 1)
Red-Black Tree: 완화된 균형 (색 기반)
[[bbst|Treap]]: 우선순위 무작위화
Splay Tree: 접근 시 회전
[[order-statistics-tree|Order Statistics Tree]]: BST + 서브트리 크기

참고

관련 [[segtree|Segment Tree]] (구간 쿼리)
관련 [[bbst|BBST]] (균형 트리)
관련 [[fenwick-tree|Fenwick Tree]] (prefix sum)

Branch and Bound: 분기 한정

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

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

구성 요소

Branching: 해 공간을 서브문제로 나누기
Bounding: 각 서브문제의 최선 가능한 답 상한/하한 추정
Pruning: 현재 best 보다 나쁠 수 밖에 없는 가지 제거

예시: [[tsp|TSP]]

Bound: 지금까지 비용 + 남은 도시의 MST 하한 + 남은 도시의 최소 간선 두 개.

이 bound 가 현재 best solution 보다 크면 그 가지 버림.

예시: 0-1 [[knapsack|Knapsack]]

Bound: 남은 아이템을 fractional 로 채운 최대 가치.

Best-first vs DFS

DFS: 스택 작음, 메모리 유리
Best-first ([[priority-queue-heap|priority queue]]): 유망한 것부터, 더 빠르지만 큰 큐

참고

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

Brute Force: 완전 탐색

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

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

패턴

모든 부분집합: for mask in 0..2^n
모든 순열: next_permutation 또는 재귀
모든 조합: nested loop 또는 combinations
모든 위치: nested for

언제 유효한가

N ≤ 20 subset (2^N ≤ 10⁶)
N ≤ 10 permutation (10! ≈ 3.6M)
N ≤ 100 quadratic (10⁴)
N ≤ 1000 quadratic (10⁶)

최적화로 발전

가지치기 (pruning) → [[branch-and-bound|Branch and Bound]]
메모이제이션 → DP
비트마스크 → [[dp-bitfield|Bitmask DP]]

참고

[[branch-and-bound|Branch and Bound]]
[[dp-bitfield|DP Bitfield]]

Carmichael Function λ(n)

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Carmichael function λ(n) 은 gcd(a, n) = 1 인 모든 a 에 대해 a^m ≡ 1 (mod n) 을 만족하는 최소 양의 정수 m.

핵심 성질: 항상 λ(n) | φ(n). 즉 [[euler-phi-function|Euler Phi]] 는 항상 유효하지만 tight 하지 않을 수 있음.

계산

λ(1) = 1
λ(2) = 1, λ(4) = 2
λ(2^k) = 2^(k-2) for k ≥ 3
λ(p^k) = p^(k-1)(p-1) for odd prime p
λ(prod p_i^k_i) = lcm(λ(p_i^k_i))

응용

RSA-CRT: 개인 키 지수 e^{-1} mod λ(n) 이 정확한 exponent
Order 문제: 임의 a 의 곱셈적 order 는 λ(n) 의 약수

참고

[[euler-phi-function|Euler Phi Function]]
[[flt|Fermat’s Little Theorem]]

Catalan Number: C_n

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Catalan number:

$$ 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_n 개)

balanced parenthesis n 쌍
binary tree with n internal nodes
Dyck path length 2n (only up-right moves)
triangulation of convex (n+2)-gon
stack-permutations of 1..n

점화식

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

또는 $C_n = \frac{2(2n-1)}{n+1} C_{n-1}$.

참고

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

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

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

3D 점집합의 볼록 껍질: 모든 점을 포함하는 최소 볼록 다면체. 면 (face) 들이 삼각형으로 구성됨.

Incremental Construction

한 번에 한 점씩 추가:

초기 정사면체 (일반 위치의 4 점)
점 P 추가:
- P 에서 보이는 (visible) 면 제거
- 경계 (horizon) 를 따라 새 삼각형 부채 형성

O(N²) worst case, O(N log N) expected with random shuffle.

Gift Wrapping (3D)

각 면을 하나씩 “감싸” 나가는 방식. O(N · F), F = 면 개수. 정확하지만 느림.

Randomized Incremental (구현 편함)

무작위 셔플 + incremental 로 O(N log N) 기대 시간.

Chan’s Algorithm

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

응용

3D 물체의 최소 감싸는 다면체
최대 이격 두 점 (diameter)
Voronoi diagram, Delaunay triangulation

참고

[[convex-hull|2D Convex Hull]]
[[geometry-3d|3D Geometry]]

Cycle Detection: 그래프 사이클 탐지

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

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

무향 그래프

Union-Find 접근

간선 (u, v) 삽입 시 find(u) == find(v) 이면 사이클.

DSU dsu(n);
for (auto [u, v] : edges) {
    if (dsu.same(u, v)) { /* 사이클! */ }
    else dsu.merge(u, v);
}

DFS 접근

부모가 아닌 방문 완료 정점으로 되돌아가면 사이클.

유향 그래프

DFS + 3 색

흰색: 미방문
회색: DFS 스택 위
검은색: 완료 회색 정점으로 가는 간선 = back edge = 사이클.

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;
}

Kahn’s 활용

[[topological-sorting|위상 정렬]] 로 얻은 순서 크기 < N 이면 사이클 존재.

참고

[[topological-sorting|Topological Sorting]]
[[disjoint-set|Union-Find]]
[[tarjan-scc|Tarjan SCC]] (강한 연결 요소)

DP on Bitmask: 비트마스크 DP

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

부분집합 상태를 비트마스크로 인코딩 하여 DP 를 수행. 원소 수 N ≤ 20 정도에서 유효.

자세한 내용은 [[dp-bitfield|DP Bitfield]] 참조.

대표 예

TSP

dp[mask][i] = 방문한 도시 mask, 현재 i. 전이: 다음 도시 j 로 갈 때 dp[mask | (1<<j)][j] = dp[mask][i] + cost[i][j].

O(2^N · N²).

Assignment Problem

dp[i][mask] = 사람 i 까지 배정, 사용한 태스크 mask.

Hamiltonian Path

dp[mask][i] = mask 를 정확히 방문한 상태로 i 에서 끝나는 경로 존재 여부.

참고

[[dp-bitfield|DP Bitfield]] (자세한 예제)
[[tsp|TSP]]
[[hamiltonian-path|Hamiltonian Path]]
[[dp-sum-over-subsets|SOS DP]]

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

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

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

대표 4 종

1. Convex Hull Trick (CHT)

선형 함수 min/max 를 유지하는 자료구조. dp[i] = min(a[j]·x + b[j]) 형태에 적용.

Li-Chao Tree: 임의 삽입 순서
Kinetic: 온라인
모노톤 CHT: 기울기 정렬된 경우 O(1) push

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

2. Divide-and-Conquer Optimization

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

function<void(int, int, int, int)> solve = [&](int lo, int hi, int optl, int optr) {
    if (lo > hi) return;
    int mid = (lo + hi) / 2;
    int best_k = optl;
    dp[mid] = LLONG_MAX;
    for (int k = optl; k <= min(mid, optr); k++) {
        long long cand = prev[k] + cost(k, mid);
        if (cand < dp[mid]) { dp[mid] = cand; best_k = k; }
    }
    solve(lo, mid - 1, optl, best_k);
    solve(mid + 1, hi, best_k, optr);
};

3. Knuth Optimization

dp[i][j] = min(dp[i][k] + dp[k][j]) + w(i, j) 형태. Quadrangle inequality + monotone 이면 O(N³) → O(N²).

행렬 곱셈 순서, 최적 이진 검색 트리, LP 등.

4. SMAWK / Monge

Monge 행렬 (모든 2×2 부분행렬이 QI 만족) 위 행별 최솟값을 O(N) 에 계산.

참고

[[li-chao-tree|Li-Chao Tree]]
[[dp-bitfield|DP Bitfield]]
[[knapsack|Knapsack DP]]

Dynamic Connectivity: 간선 추가/삭제 연결성

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Dynamic Connectivity 는 간선의 추가와 삭제 가 모두 일어나는 그래프에서 두 정점의 연결 여부를 유지하는 문제입니다.

삽입만 있는 경우

[[disjoint-set|Union-Find]] 로 O(α(N)) amortized.

삭제만 있는 경우

시간 역행으로 삽입 문제로 환원.

삽입 + 삭제

Link-Cut Tree 또는 Euler Tour Tree 로 O(log² N).

Holm-Lichtenberg-Thorup: O(log² N) amortized 온라인
Offline Divide-and-Conquer + Union-Find with rollback: 배치 처리 시 실전 자주 사용

참고

[[disjoint-set|Union-Find]]
[[dynamic-tree|Link-Cut Tree]]
[[euler-tour-technique|Euler Tour Tree]]

Dynamic Segment Tree: 지연 노드 생성

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

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

공간: O(Q log V), Q = 쿼리 수, V = 값 범위

구조

포인터 기반, 또는 map<int, int> 로 자식 인덱스 관리.

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

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

대안

좌표 압축 + 일반 [[segtree|Segment Tree]]: 오프라인 처리 가능하면 대개 더 간단
[[persistent-segtree|Persistent Segtree]]: 버전 추적 필요 시

참고

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

Euler Phi Function: φ(n)

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Euler Phi Function φ(n) 은 1 이상 n 이하 정수 중 n 과 서로소인 정수의 개수.

기존 [[euler-phi|Euler Phi]] 위키 참조. 이 페이지는 alias 확장용 축약.

공식

소수 p: φ(p) = p - 1
p^k: φ(p^k) = p^k - p^(k-1)
곱셈적: gcd(a, b) = 1 이면 φ(ab) = φ(a)φ(b)
일반: φ(n) = n · Π (1 - 1/p) over distinct primes p | n

참고

[[euler-phi|Euler Phi]] (본 위키)
[[euler-totient|Euler Totient]]
[[flt|Fermat’s Little Theorem]]

Euler's Criterion: 이차잉여 판정

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

홀소수 p 에 대해 a 가 mod p 에서 이차잉여 (quadratic residue) 인지 판정:

$$ a^{(p-1)/2} \equiv \begin{cases} 1 & \text{a is QR} \ -1 & \text{a is NR} \end{cases} \pmod{p} $$

Legendre symbol (a/p) 는 위 결과 (또는 0 if p|a).

왜 성립하는가

[[flt|Fermat’s Little Theorem]]: a^(p-1) ≡ 1 (mod p). 그러면 (a^((p-1)/2))² ≡ 1, 즉 a^((p-1)/2) ≡ ±1.

만약 a ≡ b² 이면 a^((p-1)/2) ≡ b^(p-1) ≡ 1.

응용

Tonelli-Shanks: sqrt mod p 계산 (QR 여부 판정에 사용)
Solovay-Strassen 소수 판정

참고

[[flt|Fermat’s Little Theorem]]
[[discrete-sqrt|Tonelli-Shanks]]
[[quadratic-residue|Quadratic Residue]]

Expected Value: 기댓값, Linearity

koa (김신건) — Mon, 29 Jun 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)} $$

Linearity of Expectation

독립 여부 무관: E[X + Y] = E[X] + E[Y].

이것이 경쟁 프로그래밍에서 강력한 이유: 복잡한 이벤트를 지시 변수 합으로 분해.

예시: n 개 편지가 다른 봉투에 무작위 배정

각 편지 i 가 자기 봉투에 갈 확률 = 1/n. 지시변수 X_i (i-th 편지가 자기 봉투) → E[X_i] = 1/n. E[total] = Σ 1/n = 1.

“랜덤 순열의 fixed points 기댓값 = 1” 결과 도출.

응용

뽑기, coupon collector: E[전부 뽑기] = n · H_n ≈ n ln n
무작위 알고리즘 분석 (quicksort, randomized primality)
마르코프 체인 흡수 시간

참고

[[markov-chain|Markov Chain]]
[[expected-value|Linearity of Expectation]]

Fenwick Tree (Binary Indexed Tree): 구간 합 O(log N)

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Fenwick Tree (또는 BIT, Binary Indexed Tree) 는 배열의 prefix sum 을 O(log N) 에 갱신·조회 하는 자료구조입니다. Peter Fenwick 이 1994 년 발표.

핵심 아이디어: 각 인덱스가 자신의 lowbit 만큼의 구간을 담당 하도록 정의하여, prefix 합을 몇 개의 노드 값의 합으로 표현합니다.

왜 [[Segtree|Segment Tree]] 대신 쓰는가

항목	Fenwick Tree	Segment Tree
코드 길이	매우 짧음 (10줄)	김 (30~50줄)
상수	매우 작음	큼
지원 연산	합, XOR 등 역연산 가능한 것	임의 결합 연산 (min, max, gcd)
구간 갱신	별도 트릭 필요	Lazy propagation 자연스럽게 지원

합 쿼리 위주라면 Fenwick 이 압도적입니다.

lowbit 연산

핵심은 x & -x (2의 보수 특성).

x = 6 = 0110 → x & -x = 0010 = 2
x = 12 = 1100 → x & -x = 0100 = 4
x = 8 = 1000 → x & -x = 1000 = 8

의미: x 의 이진표현에서 가장 낮은 1 비트 만 남긴 값. 이것이 Fenwick 배열에서 그 인덱스가 담당하는 구간의 길이입니다.

구조

인덱스 i (1-based) 는 구간 $[i - \text{lowbit}(i) + 1, i]$ 의 합을 담당합니다.

i:  1 2 3 4 5 6 7 8
    │ ┴ │ ┴ ┴ ┴ │ ┴─────
    │   │       │       ┴
    ┴───┴───────┴───────
1 담당: [1,1]
2 담당: [1,2]
3 담당: [3,3]
4 담당: [1,4]
5 담당: [5,5]
6 담당: [5,6]
7 담당: [7,7]
8 담당: [1,8]

코드 (0-based 배열, 1-based Fenwick)

struct Fenwick {
    vector<long long> t;
    int n;

    Fenwick(int n) : n(n), t(n + 1, 0) {}

    void update(int i, long long v) {  // 1-based
        for (; i <= n; i += i & -i) t[i] += v;
    }

    long long query(int i) {  // 1-based, prefix [1..i]
        long long s = 0;
        for (; i > 0; i -= i & -i) s += t[i];
        return s;
    }

    long long range(int l, int r) {  // [l..r]
        return query(r) - query(l - 1);
    }
};

시간 복잡도: 두 연산 모두 O(log N).

Query 흐름 예 (N=8, query(6))

6 = 110

i=6 (110), t[6] 더함. i -= lowbit(6)=2 → i=4
i=4 (100), t[4] 더함. i -= lowbit(4)=4 → i=0
종료.

prefix[6] = t[6] + t[4].

Update 흐름 예 (N=8, update(3, +5))

3 = 011

i=3 (011), t[3]+=5. i += lowbit(3)=1 → i=4
i=4 (100), t[4]+=5. i += lowbit(4)=4 → i=8
i=8 (1000), t[8]+=5. i += lowbit(8)=8 → i=16 > 8, 종료.

응용

1. 역수 세기 (Inversion Count)

배열 $a$ 에서 $i < j$ 지만 $a_i > a_j$ 인 쌍의 개수.

// a 를 오른쪽에서 왼쪽으로 순회
long long inv = 0;
Fenwick f(MAX_VALUE);
for (int i = n - 1; i >= 0; i--) {
    inv += f.query(a[i] - 1);   // 나보다 작은 값이 오른쪽에 몇 개?
    f.update(a[i], 1);
}

2. K-th 원소 (Fenwick 위 이분탐색)

값들에 카운트를 저장하고, prefix 합을 이분탐색으로 뒤져 k 번째 값 찾기. O(log² N).

3. 구간 갱신 + 점 쿼리 (차분 배열 트릭)

update(l, r, v):  fenwick.update(l, +v); fenwick.update(r+1, -v);
query(i):         fenwick.query(i)  // = a[i] 값

4. 구간 갱신 + 구간 쿼리 (Fenwick 2 개)

BIT 두 개 $B_1, B_2$ 로 임의 구간 갱신, 구간 합을 O(log N) 유지 가능.

2D Fenwick

2 차원 부분합에도 확장:

void update(int x, int y, long long v) {
    for (int i = x; i <= n; i += i & -i)
        for (int j = y; j <= m; j += j & -j)
            t[i][j] += v;
}

long long query(int x, int y) {
    long long s = 0;
    for (int i = x; i > 0; i -= i & -i)
        for (int j = y; j > 0; j -= j & -j)
            s += t[i][j];
    return s;
}

O(log² N), 이미지/그리드 계열 문제에 유용.

함정

인덱스 시작: Fenwick 은 반드시 1-based. i > 0 종료 조건을 잊고 0-based 로 쓰면 무한 루프.
역연산 필요: range(l, r) = query(r) - query(l-1) 이 되려면 역연산 (뺄셈, XOR) 이 있어야 함. min/max 는 Fenwick 로 쿼리 불가 → [[segtree|Segment Tree]] 사용.
크기 제한: 좌표 압축 잊지 말 것. 값 범위가 크면 index 로 못 씀.

참고

관련 [[segtree|Segment Tree]]: 임의 연산 지원
관련 [[prefix-sum|Prefix Sum]]: 정적 배열에 O(1) 쿼리
관련 [[merge-sort-tree|Merge Sort Tree]], [[wavelet-tree|Wavelet Tree]]: 더 복잡한 쿼리
cp-algorithms: Fenwick Tree

Geometry Basic: 벡터, CCW, 외적, 내적

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

기하 알고리즘의 밑바탕. 대부분의 2D/3D 기하 문제는 벡터 연산, 내적/외적, CCW 판정 세 가지의 조합으로 풀립니다.

벡터

2D 벡터: 두 점 $A = (a_x, a_y)$ 와 $B = (b_x, b_y)$ 사이의 방향/거리 표현.

$$ \vec{AB} = B - A = (b_x - a_x, b_y - a_y) $$

struct Vec { long long x, y; };

Vec sub(Vec a, Vec b) { return {a.x - b.x, a.y - b.y}; }
Vec add(Vec a, Vec b) { return {a.x + b.x, a.y + b.y}; }

long long dot(Vec a, Vec b)   { return a.x*b.x + a.y*b.y; }
long long cross(Vec a, Vec b) { return a.x*b.y - a.y*b.x; }

[!TIP] 정수 좌표라면 반드시 long long 을 씁니다. 외적은 곱셈 두 개의 뺄셈이라 오버플로 위험이 큽니다.

내적 (Dot Product)

$$ \vec{a} \cdot \vec{b} = a_x b_x + a_y b_y = |\vec{a}||\vec{b}| \cos\theta $$

용도:

각도: $\cos\theta = \frac{\vec{a} \cdot \vec{b}}{|\vec{a}||\vec{b}|}$
직교 판정: $\vec{a} \cdot \vec{b} = 0$ ⟺ 수직
투영: $\vec{a}$ 를 $\vec{b}$ 방향으로 투영한 길이 = $\frac{\vec{a} \cdot \vec{b}}{|\vec{b}|}$

외적 (Cross Product), 핵심 도구

2D 에서 외적은 스칼라 (z 성분만):

$$ \vec{a} \times \vec{b} = a_x b_y - a_y b_x = |\vec{a}||\vec{b}| \sin\theta $$

부호 의미:

값	의미
$> 0$	$\vec{b}$ 가 $\vec{a}$ 의 반시계 (counterclockwise, CCW) 방향
$< 0$	$\vec{b}$ 가 $\vec{a}$ 의 시계 (clockwise, CW) 방향
$= 0$	두 벡터 평행

절댓값 의미: $\vec{a}$, $\vec{b}$ 가 이루는 평행사변형의 넓이. 삼각형이면 이의 절반.

CCW (Counterclockwise Test)

세 점 $A, B, C$ 의 방향 관계 판정. 알고리즘 기하의 만능 도구입니다.

$$ \text{CCW}(A, B, C) = \text{sign}\left( (B - A) \times (C - A) \right) $$

int ccw(Vec a, Vec b, Vec c) {
    long long v = cross(sub(b, a), sub(c, a));
    return (v > 0) - (v < 0);  // 1, -1, 0
}

해석:

반환	배치
+1	A → B → C 가 반시계 (좌회전)
-1	A → B → C 가 시계 (우회전)
0	세 점이 일직선

응용은 광범위: convex hull, 선분 교차, 다각형 내부 판정, 회전 캘리퍼스 등 거의 모든 기하 알고리즘의 기본 연산.

CCW 시각화

graph LR
    subgraph CCW["CCW = +1 (반시계)"]
        A1[A] --> B1[B]
        B1 --> C1[C]
        C1 -.-> A1
    end
    subgraph CW["CCW = -1 (시계)"]
        A2[A] --> B2[B]
        B2 --> C2[C]
        C2 -.-> A2
    end
    subgraph Colinear["CCW = 0 (일직선)"]
        A3[A] --- B3[B] --- C3[C]
    end

선분 교차

두 선분 $AB$ 와 $CD$ 가 교차하는지 판정:

bool segments_intersect(Vec a, Vec b, Vec c, Vec d) {
    int d1 = ccw(a, b, c);
    int d2 = ccw(a, b, d);
    int d3 = ccw(c, d, a);
    int d4 = ccw(c, d, b);

    if (d1 != d2 && d3 != d4) return true;  // 일반 교차

    // 특수: 한 선분이 다른 선분의 끝점을 지나는 경우
    if (d1 == 0 && on_segment(a, b, c)) return true;
    if (d2 == 0 && on_segment(a, b, d)) return true;
    if (d3 == 0 && on_segment(c, d, a)) return true;
    if (d4 == 0 && on_segment(c, d, b)) return true;
    return false;
}

bool on_segment(Vec a, Vec b, Vec c) {
    return min(a.x, b.x) <= c.x && c.x <= max(a.x, b.x)
        && min(a.y, b.y) <= c.y && c.y <= max(a.y, b.y);
}

삼각형/다각형 넓이

삼각형 $A, B, C$ 의 넓이:

$$ \text{Area} = \frac{1}{2} \left| (B - A) \times (C - A) \right| $$

다각형 ([[polygon-area|Shoelace formula]]): 정점 $P_0, P_1, …, P_{n-1}$ 에 대해

$$ \text{Area} = \frac{1}{2} \left| \sum_{i=0}^{n-1} (x_i y_{i+1} - x_{i+1} y_i) \right| $$

다각형 내부 점 판정

Ray casting: 점에서 임의 방향으로 반직선을 그어 다각형 변과 몇 번 교차하는지 세기.

홀수 → 내부
짝수 → 외부

또는 winding number: 모든 변에서 CCW 부호를 세어 총합을 봄. 이쪽이 볼록 다각형에서 더 간단.

함정

정밀도: double 로 외적 계산은 위험. 정수 좌표 → long long 이 원칙.
오버플로: 좌표가 $10^9$ 이상이면 곱셈 후 $10^{18}$ 넘을 수 있음. __int128 또는 좌표 축소.
일직선 케이스: CCW=0 일 때 하위 로직 (on-segment 등) 을 반드시 처리해야 함. 잊으면 교차 판정 등이 오동작.
각도 비교: atan2 는 double, 정밀도 문제 있음. 정수 좌표에서 각도 정렬은 사분면 + 외적으로 처리.

참고

관련 [[polygon-area|Shoelace, 다각형 넓이]]
관련 [[convex-hull|Convex Hull]] (CCW 로 구현)
관련 [[rotating-calipers|Rotating Calipers]]
cp-algorithms: Basic Geometry

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

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

단봉 (unimodal) 함수 위에서 최소/최대를 찾는 탐색. 이분 탐색을 단봉 함수용으로 확장.

삼분 탐색 (Ternary Search)

구간 [l, r] 을 세 등분하여 두 내부점 m1 = l + (r-l)/3, m2 = r - (r-l)/3 비교. 불량한 쪽 1/3 을 버림. O(log₃ range).

double ternary(double l, double r) {
    for (int iter = 0; iter < 200; iter++) {
        double m1 = l + (r - l) / 3;
        double m2 = r - (r - l) / 3;
        if (f(m1) < f(m2)) r = m2;   // 최대화 가정
        else l = m1;
    }
    return (l + r) / 2;
}

Golden-section

두 내부점을 황금비 (φ = (1 + √5) / 2) 로 나누면 매 반복마다 이전 계산 재사용 가능 → 함수 호출 절반.

정수 삼분 탐색

이산 단봉 함수에서 세 등분 점을 정수화. while (r - l > 2).

참고

[[binary-search|이분 탐색]]
[[convex-hull-trick|Convex Hull Trick]]

Graph DP: 트리/DAG 위 DP

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

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

Tree DP

루트 트리에서 자식 서브트리 결과를 조합.

void dfs(int u, int p) {
    dp[u] = 1;   // 자기 자신
    for (int v : adj[u]) if (v != p) {
        dfs(v, u);
        dp[u] += dp[v];   // 서브트리 크기 예
    }
}

Rerooting (모든 루트 답)

Tree DP 는 특정 루트 기준. 모든 정점을 루트로 했을 때의 답이 필요하면 rerooting.

두 번의 DFS:

임의 루트 r 로 down DP: dp_down[u] = u 서브트리 정보
Down 정보 이용 up DP: dp[u] = u 를 루트로 한 전체 답

O(N).

DAG DP

DAG 는 [[topological-sorting|위상 정렬]] 후 순서대로 계산.

longest path: dp[v] = max(dp[u] + w) for u -> v
path 수 세기: dp[v] = sum(dp[u]) for u -> v

참고

[[topological-sorting|Topological Sorting]]
[[tree-diameter|Tree Diameter]]
[[dp-bitfield|DP Bitfield]]

Hamiltonian Path: 모든 정점 한 번씩

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Hamiltonian Path 는 그래프의 모든 정점을 정확히 한 번씩 방문하는 경로. 시작 = 끝이면 Hamiltonian Cycle.

일반 그래프에서 NP-complete. Euler path (모든 간선을 한 번씩) 와 대비: Euler 는 다항 시간.

Bitmask DP (N ≤ 20)

상태: dp[mask][v] = “방문 집합 = mask, 현재 v” 도달 가능한가.

dp[1 << s][s] = true;   // s 에서 시작
for (int mask = 0; mask < (1 << n); mask++)
    for (int u = 0; u < n; u++) {
        if (!dp[mask][u] || !(mask & (1 << u))) continue;
        for (int v : adj[u])
            if (!(mask & (1 << v)))
                dp[mask | (1 << v)][v] = true;
    }
// 전체 마스크에서 도달 가능한 v 가 있으면 Hamiltonian path 존재

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

참고

[[tsp|Traveling Salesman Problem]]
[[dp-bitfield|DP Bitfield]]

Hash Table: 해시 기반 딕셔너리

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Hash Table 은 해시 함수로 키를 배열 인덱스에 매핑하여 평균 O(1) 삽입/탐색/삭제를 제공합니다.

충돌 해결

Chaining

각 버킷에 연결 리스트/트리 저장. 최악 O(N).

Open Addressing

Linear probing: (h + i) mod m
Quadratic probing: (h + i²) mod m
Double hashing: (h1 + i·h2) mod m

Load factor ~0.5-0.7 유지, 넘으면 rehash.

언어별 구현

언어	자료형	내부
C++	`unordered_map`	chaining
Java	`HashMap`	chaining + tree (수 많으면)
Python	`dict`	open addressing (compact + insertion-ordered)
Go	`map`	chaining
Rust	`HashMap`	SipHash (기본), open addressing

함정

최악 O(N): 적대적 입력 대비 랜덤화 해시 (SipHash, aHash)
iteration 순서: Python 3.7+ 는 삽입 순서 보장, 다른 언어는 임의

참고

[[binary-search-tree|BST]] (정렬 필요 시 대체)
[[bloom-filter|Bloom Filter]] (근사 존재 확인)

Huffman Coding: 최적 접두 부호

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Huffman Coding 은 문자의 빈도가 주어졌을 때 평균 부호 길이를 최소화 하는 접두 부호 (prefix code) 를 만드는 그리디 알고리즘. David Huffman (1952) 이 MIT 학생 시절 발표.

접두 부호: 어떤 부호도 다른 부호의 접두어가 아님. 구분자 없이 디코딩 가능.

알고리즘

각 문자를 리프 노드로 하고 빈도를 우선순위로 하는 min-heap 준비.
Heap 에서 최소 두 노드를 pop, 두 빈도의 합을 값으로 하는 새 내부 노드 생성 (두 노드를 자식으로).
새 노드를 heap 에 push.
Heap 크기가 1 이 될 때까지 반복.
완성된 트리의 루트에서 각 리프까지의 경로가 부호 (왼쪽=0, 오른쪽=1).

#include <queue>
struct Node { char ch; int freq; Node *l, *r; };
struct Cmp { bool operator()(Node* a, Node* b) { return a->freq > b->freq; } };

Node* build(map<char, int>& freq) {
    priority_queue<Node*, vector<Node*>, Cmp> pq;
    for (auto [c, f] : freq) pq.push(new Node{c, f, nullptr, nullptr});
    while (pq.size() > 1) {
        Node* a = pq.top(); pq.pop();
        Node* b = pq.top(); pq.pop();
        pq.push(new Node{0, a->freq + b->freq, a, b});
    }
    return pq.top();
}

O(N log N) - N 은 문자 종류 수.

예시

빈도: a=5, b=9, c=12, d=13, e=16, f=45

결과 부호 (평균 길이 ~2.24 bit):

f: 0
c: 100
d: 101
a: 1100
b: 1101
e: 111

최적성 증명

Sibling property: 같은 부모의 두 자식은 항상 heap 에서 가장 낮은 두 원소. 이 성질이 최적 부호를 그리디하게 유도.

응용

DEFLATE (gzip, PNG): LZ77 + Huffman
JPEG: DCT 계수 부호화
HTTP/2 [[hpack|HPACK]]: 헤더 압축에 정적 Huffman table
MP3: 오디오 부호화

한계

문자 하나씩 부호화. 확률이 극단적 (0.9 인 문자) 이면 손실 큼 → Arithmetic Coding 이 더 최적
정적 빈도: 스트리밍은 Adaptive Huffman 이 필요

참고

관련 [[priority-queue-heap|Priority Queue]]
관련 [[hpack|HPACK]] (HTTP/2 헤더 압축)
관련 [[greedy|Greedy]]

Implicit Treap: 배열 인덱스 기반 Treap

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Implicit Treap 은 [[bbst|Treap]] 에서 키 대신 서브트리 크기 (위치) 로 인덱싱하는 변형입니다. 배열의 삽입/삭제/이동/구간 반전 등을 O(log N) 에 지원합니다.

특징

split(t, k): k 번째까지 왼쪽, 나머지 오른쪽
merge(a, b): 두 배열 이어붙임
reverse(l, r): 구간 반전 (lazy propagation)
insert/erase at position: O(log N)

응용

편집기 (rope): 임의 위치 삽입/삭제
구간 회전, 뒤집기 문제
LIS 유사 dynamic 문제

참고

[[bbst|Treap]]
[[binary-search-tree|BST]]

Inclusion and Exclusion: 포함배제 원리

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

$$ \left| \bigcup_{i=1}^{n} A_i \right| = \sum \lvert A_i \rvert - \sum \lvert A_i \cap A_j \rvert + \sum \lvert A_i \cap A_j \cap A_k \rvert - \dots $$

부호가 교대로 바뀌며 홀수 개 교집합 - 짝수 개 교집합.

응용

오일러 phi

$\varphi(n) = n \prod_{p | n} (1 - 1/p)$ 는 포함배제의 예.

mod 카운팅

n 이하 중 어느 소수의 배수도 아닌 수의 개수:

$$ \sum_{S \subseteq {p_1, …, p_k}} (-1)^{|S|} \lfloor n / \prod S \rfloor $$

Derangement

$D_n = n! \sum_{k=0}^{n} \frac{(-1)^k}{k!}$

참고

[[euler-phi-function|Euler Phi]]
[[combinatorics|조합론]]
[[mobius-inversion|Mobius Inversion]]

Johnson's Algorithm: sparse APSP

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Johnson’s algorithm 은 sparse graph 의 all-pairs shortest paths 를 O(V·E log V + V²) 에 계산. Bellman-Ford + Dijkstra 조합.

알고리즘

임시 정점 s 추가, 모든 정점에 가중치 0 간선 연결
Bellman-Ford 로 h[v] = dist(s, v) 계산
각 간선 (u, v) 재가중: w’(u, v) = w(u, v) + h[u] - h[v] ≥ 0
재가중 그래프에서 각 정점을 소스로 Dijkstra 실행
원래 거리 복원: d(u, v) = d’(u, v) - h[u] + h[v]

핵심: Bellman-Ford 로 potential 을 만든 뒤 non-negative 재가중, Dijkstra 사용 가능하게 함.

복잡도 비교

방법	복잡도	조건
Floyd-Warshall	O(V³)	Any
Johnson	O(VE log V)	negative allowed
Dijkstra × V	O(V² log V + VE)	non-negative

Sparse (E = O(V)) 일 때 Johnson 이 Floyd-Warshall 보다 빠름.

참고

[[floyd-warshall|Floyd-Warshall]]
[[dijkstra|Dijkstra]]
[[bellman-ford|Bellman-Ford]]

Markov Chain: 상태 전이 확률

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Markov Chain 은 다음 상태가 오직 현재 상태에만 의존하는 확률 과정. memoryless property.

전이확률 행렬 P: P[i][j] = P(다음 = j | 현재 = i). 각 행 합 = 1.

N-step 전이

$P^n$ 의 (i, j) 원소 = i 에서 j 로 n 스텝에 도달할 확률.

[[matrix-exponentiation|Matrix Exponentiation]] 으로 O(K³ log n) 에 계산.

Stationary Distribution

π P = π 인 확률벡터 π. irreducible + aperiodic 이면 유일 존재.

PageRank

웹 페이지 랭킹은 stationary distribution 문제로 환원 (Google, 1998).

응용

랜덤 워크 분석
MCMC (베이지안 추론)
유전 알고리즘
[[federated-learning|Federated Learning]] 수렴 분석

참고

[[matrix-exponentiation|Matrix Exponentiation]]
[[expected-value|Expected Value]]

Matrix Exponentiation: 선형 점화식 fast

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

선형 점화식을 행렬 곱으로 표현한 뒤, 행렬 거듭제곱을 log 시간에 계산하여 N 번째 항을 O(K³ log N) 에 얻는 기법. K = 상태 차원.

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} $$

using Mat = vector<vector<long long>>;
const long long MOD = 1e9 + 7;

Mat mul(const Mat& A, const Mat& B) {
    int n = A.size();
    Mat C(n, vector<long long>(n, 0));
    for (int i = 0; i < n; i++)
        for (int k = 0; k < n; k++) if (A[i][k])
            for (int j = 0; j < n; j++)
                C[i][j] = (C[i][j] + A[i][k] * B[k][j]) % MOD;
    return C;
}

Mat pow(Mat A, long long p) {
    int n = A.size();
    Mat R(n, vector<long long>(n, 0));
    for (int i = 0; i < n; i++) R[i][i] = 1;
    while (p) { if (p & 1) R = mul(R, A); A = mul(A, A); p >>= 1; }
    return R;
}

O(K³ log N).

응용

Fibonacci 를 O(log N)
그래프 경로 수: 인접행렬^k 의 (u, v) 원소 = u→v 길이 k 경로 수
DFA 상태 전이

Kitamasa

일반 K-차 선형 점화식은 [[polynomial-division-kitamasa|Polynomial Division]] 기법으로 O(K² log N) 까지 낮출 수 있음.

참고

[[polynomial-division-kitamasa|Kitamasa]]
[[fast-power|Fast Power]]
[[linear-algebra|Linear Algebra]]

Maximum Flow: Ford-Fulkerson, Edmonds-Karp, Dinic

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Maximum Flow (최대 유량) 문제는 방향 그래프 $G = (V, E)$ 와 소스 $s$, 싱크 $t$ 가 주어졌을 때, 각 간선의 용량 제약 아래에서 $s$ 에서 $t$ 로 흘려보낼 수 있는 유량의 최댓값을 찾는 문제입니다.

간선 용량 $c(u, v) \geq 0$
유량 보존: 중간 정점 $v$ 는 $\sum_u f(u, v) = \sum_w f(v, w)$
용량 제약: $0 \leq f(u, v) \leq c(u, v)$
목표: $|f| = \sum_v f(s, v)$ 최대화

응용 (매우 광범위)

매칭: 이분 매칭 → 최대 유량으로 환원
분리: 최소 컷 = 최대 유량 (max-flow min-cut)
project selection, image segmentation, baseball elimination
k-connectivity, edge disjoint paths

Max Flow 로 환원되는 문제는 놀랄 만큼 많습니다. 문제에서 “동시에 다녀야 한다”, “어느 하나만 선택”, “그룹 분리” 등의 힌트가 있으면 유량 화합을 의심.

핵심 개념

Residual Graph (잔여 그래프)

핵심 트릭. 유량 $f$ 가 흐르고 있을 때, 잔여 용량 $c_f(u, v) = c(u, v) - f(u, v)$ + 역방향 취소 간선 $c_f(v, u) = f(u, v)$.

역방향 간선의 의미: 이미 흘린 유량을 취소 하고 다른 경로로 재배치할 수 있게 하는 것. 이것 없으면 그리디 (첫 경로가 최선인 척) 가 최적을 놓칠 수 있습니다.

Augmenting Path (증가 경로)

잔여 그래프에서 $s \to t$ 로 가는 경로. 그 경로의 최소 잔여 용량만큼 유량을 흘려보낼 수 있습니다.

Max-Flow Min-Cut 정리

최대 유량 = 최소 컷 용량. Ford & Fulkerson 1956.

s-t 컷 $(S, T)$: $s \in S, t \in T$ 로 정점을 두 집합으로 분할
컷 용량 = $\sum_{u \in S, v \in T} c(u, v)$
최소 컷의 용량 = 최대 유량

이 대응이 유량 알고리즘의 이론적 근간이며, 최소 컷을 구할 때도 max-flow 알고리즘을 그대로 씁니다.

Ford-Fulkerson (일반 프레임워크)

f ← 0
while (잔여 그래프에서 s→t 경로 P 존재):
    Δ ← min(c_f(u,v) for (u,v) in P)
    P 를 따라 f 를 Δ 만큼 증가
return |f|

경로 선택 방식 에 따라 알고리즘이 달라집니다.

유리수 용량, 무한 루프 위험

임의로 경로를 선택하면 비유리수 용량에서는 종료가 보장되지 않습니다. 따라서 실무에서는 항상 정수 (또는 유리수) 용량이라고 가정합니다.

Edmonds-Karp

BFS 로 shortest augmenting path (간선 수 기준) 를 선택.

시간 복잡도: $O(V \cdot E^2)$

const int INF = 1e9;
int n;                      // 정점 수
vector<vector<int>> capacity;  // capacity[u][v]
vector<vector<int>> adj;    // 양방향 저장 (역방향 잔여 간선 위해)

int bfs(int s, int t, vector<int>& parent) {
    fill(parent.begin(), parent.end(), -1);
    parent[s] = s;
    queue<pair<int,int>> q;
    q.push({s, INF});
    while (!q.empty()) {
        auto [cur, flow] = q.front(); q.pop();
        for (int next : adj[cur]) {
            if (parent[next] == -1 && capacity[cur][next] > 0) {
                parent[next] = cur;
                int new_flow = min(flow, capacity[cur][next]);
                if (next == t) return new_flow;
                q.push({next, new_flow});
            }
        }
    }
    return 0;
}

int max_flow(int s, int t) {
    int flow = 0;
    vector<int> parent(n);
    int new_flow;
    while ((new_flow = bfs(s, t, parent))) {
        flow += new_flow;
        int cur = t;
        while (cur != s) {
            int prev = parent[cur];
            capacity[prev][cur] -= new_flow;
            capacity[cur][prev] += new_flow;
            cur = prev;
        }
    }
    return flow;
}

Dinic

BFS 로 level graph 만들고, DFS 로 blocking flow 를 여러 개 한꺼번에 밀어넣기. Edmonds-Karp 보다 훨씬 빠릅니다.

시간 복잡도: $O(V^2 \cdot E)$. 단, 이분 그래프에서는 $O(E \sqrt V)$ (Hopcroft-Karp 계열).

경쟁 프로그래밍에서는 사실상 표준 max-flow 알고리즘.

struct Dinic {
    struct Edge { int to, rev; long long cap; };
    vector<vector<Edge>> g;
    vector<int> level, iter;
    int n;

    Dinic(int n) : n(n), g(n), level(n), iter(n) {}

    void add_edge(int from, int to, long long cap) {
        g[from].push_back({to, (int)g[to].size(), cap});
        g[to].push_back({from, (int)g[from].size() - 1, 0});
    }

    bool bfs(int s) {
        fill(level.begin(), level.end(), -1);
        queue<int> q;
        level[s] = 0; q.push(s);
        while (!q.empty()) {
            int v = q.front(); q.pop();
            for (auto& e : g[v]) if (e.cap > 0 && level[e.to] < 0) {
                level[e.to] = level[v] + 1;
                q.push(e.to);
            }
        }
        return level[n - 1] >= 0;  // t 도달 가능?
    }

    long long dfs(int v, int t, long long f) {
        if (v == t) return f;
        for (int& i = iter[v]; i < (int)g[v].size(); i++) {
            Edge& e = g[v][i];
            if (e.cap > 0 && level[v] < level[e.to]) {
                long long d = dfs(e.to, t, min(f, e.cap));
                if (d > 0) {
                    e.cap -= d;
                    g[e.to][e.rev].cap += d;
                    return d;
                }
            }
        }
        return 0;
    }

    long long max_flow(int s, int t) {
        long long flow = 0;
        while (bfs(s)) {
            fill(iter.begin(), iter.end(), 0);
            long long f;
            while ((f = dfs(s, t, LLONG_MAX)) > 0) flow += f;
        }
        return flow;
    }
};

Push-Relabel (Preflow-Push)

Goldberg & Tarjan 1988. 개념이 다름: preflow (유량 보존 위반 허용) 를 만든 뒤 넘치는 곳을 relabel + push 로 해결.

최악 $O(V^2 \sqrt E)$
상수가 크지만 매우 큰 그래프에서 유리
병렬화 가능
경쟁 프로그래밍에서는 Dinic 이 대부분 충분해서 잘 안 씀

이분 매칭

이분 그래프 최대 매칭 = max-flow 로 환원 가능:

소스 $s$ 를 왼쪽 정점 그룹에 용량 1 로 연결
오른쪽 정점 그룹을 싱크 $t$ 에 용량 1 로 연결
원래 이분 그래프 간선을 용량 1 로 유지
Max-flow 구하기 = 매칭 크기

Hopcroft-Karp 는 이 특수 케이스에서 $O(E \sqrt V)$ 로 개선한 것.

Min Cost Max Flow (MCMF)

간선에 cost 도 있고, 최대 유량을 흘리되 최소 비용. SPFA 기반 (Bellman-Ford 변형) 또는 potential + Dijkstra 로 구현.

응용: assignment problem, transportation problem, 여러 자원 할당.

함정

역방향 간선 잊음: 잔여 그래프의 핵심. 없으면 그리디처럼 잘못된 답.
간선 리스트 저장 (양방향): add_edge 는 정방향 + 역방향 (용량 0) 두 개를 추가. 페어 관리를 위해 rev index 저장.
정수 오버플로: 큰 용량 문제는 long long.
음수 용량: 정의상 없어야 함. 있으면 그래프 모델링 오류.
자기 루프: 유량 0 으로 안전. 하지만 코드 상 처리 필요.

참고

관련 [[bipartite-matching|이분 매칭]]
관련 [[mcmf|Min Cost Max Flow]]
관련 [[shortest-path|Shortest Path]] (Bellman-Ford / SPFA 는 MCMF 에 사용)
cp-algorithms: Dinic
CLRS Ch 26

Median of Stream: 두 힙으로 중앙값 유지

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

스트림으로 들어오는 정수의 중앙값을 O(log N) 에 유지하는 문제.

두 힙 트릭

Max-heap L: 아래 절반
Min-heap R: 위 절반
크기 차 <= 1 유지, top(L) <= top(R) 유지

priority_queue<int> L;                              // max-heap
priority_queue<int, vector<int>, greater<>> R;      // min-heap

void add(int x) {
    if (L.empty() || 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(); }
}

double median() {
    if (L.size() > R.size()) return L.top();
    return (L.top() + R.top()) / 2.0;
}

O(log N) per add, O(1) query.

참고

[[priority-queue-heap|Priority Queue / Heap]]
[[top-k-selection|Top K]]

Minimum Vertex Cover: 최소 정점 덮개

koa (김신건) — Mon, 29 Jun 2026 00:00:00 GMT

정의

Vertex Cover 는 그래프의 모든 간선이 최소 한 정점을 포함하도록 하는 정점 집합. 최소 크기의 vertex cover 를 찾는 문제.

일반 그래프: NP-hard
이분 그래프: König’s Theorem 으로 최대 매칭 = 최소 정점 덮개, [[bipartite-matching|이분 매칭]] 으로 다항 시간

König’s Theorem (이분 그래프)

|최소 vertex cover| = |최대 매칭|

증명: 최대 매칭 M 을 구한 뒤, 다음처럼 vertex cover 구성.

왼쪽에서 M 에 안 걸린 정점 U 부터 alternating BFS
방문된 왼쪽 정점 L’ 과 방문된 오른쪽 정점 R’ 관찰
Vertex cover = (왼쪽 \ L’) ∪ R’

응용

최대 독립 집합 = V \ 최소 vertex cover
최소 경로 덮개 (DAG)

참고

[[bipartite-matching|이분 매칭]]
[[maximum-flow|Maximum Flow]]