김신건의 로그 - 위키

[DB] Transaction Isolation Levels: 완벽 가이드

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

정의

Transaction Isolation Level (트랜잭션 격리 수준) = 동시에 실행되는 여러 트랜잭션이 서로의 변경을 어디까지 볼 수 있는지 규정하는 수준. ACID 의 I.

격리를 완전히 없애면 최대 처리량, 완전히 직렬화하면 최상의 정합성. DB 는 이 사이 4단계 (ANSI SQL 표준) 를 제공한다. 더 강한 격리 = 더 많은 이상 현상 방지 = 더 낮은 동시성. 실무는 이 트레이드오프를 이해하고 상황에 맞게 고르는 문제다.

이 문서의 흐름

각 격리 수준을 낮은 것부터 하나씩 짚는다. 각 수준에서:

이 수준은 무엇을 보장하는가
하지만 여기서도 어떤 문제가 발생하는가 (애니메이션으로 시각화)
그 문제의 해결법과 대안 (다음 수준으로 올릴지, 다른 기법으로 우회할지)

격리 수준 매트릭스 (전체 지도)

먼저 어떤 이상 현상이 어느 수준에서 방지되는지 한눈에.

{}

이상 현상	READ UNCOMMITTED	READ COMMITTED	REPEATABLE READ	SERIALIZABLE
Dirty Read	발생	✓ 방지	✓ 방지	✓ 방지
Non-Repeatable Read	발생	발생	✓ 방지	✓ 방지
Phantom Read	발생	발생	△ 엔진별	✓ 방지
Lost Update	발생	발생	△ SI는 감지	✓ 방지
Write Skew	발생	발생	발생	✓ 방지

엔진별 차이가 매우 크다. 특히 REPEATABLE READ 는 같은 이름이라도 완전히 다른 것. 아래에서 자세히.

Level 1: READ UNCOMMITTED

이 수준의 정의

커밋되지 않은 값까지 다른 트랜잭션에 노출된다. 어떤 격리도 없다시피 하는 상태.

ANSI 4단계 중 가장 낮음
락을 거의 사용 안 함 → 최대 동시성
그러나 정합성은 최하

발생하는 문제: Dirty Read

트랜잭션 A 가 UPDATE 만 하고 아직 COMMIT 안 한 시점에 트랜잭션 B 가 그 값을 읽어 간다. A 가 ROLLBACK 하면 B 는 실존하지 않는 값 을 본 것.

{}

시나리오 (위 애니메이션):

-- 초기: balance = 500
-- T1
SET TRANSACTION ISOLATION LEVEL READ UNCOMMITTED;
BEGIN;
UPDATE accounts SET balance = 1000 WHERE id = 1;
-- 아직 COMMIT 안 함

-- T2 (별도 세션)
BEGIN;
SELECT balance FROM accounts WHERE id = 1;
-- 결과: 1000  ← 미커밋 값 (dirty)!

-- T1
ROLLBACK;
-- balance 는 다시 500 이 됨. T2 가 봤던 1000 은 유령.

왜 문제인가:

T2 는 1000 을 보고 다음 판단 (송금 승인, 통계 계산 등) 을 내림
실제 커밋된 적 없는 값에 기반한 결정 → 데이터 일관성 파괴
ROLLBACK 이 잦다면 유령 데이터가 시스템 곳곳에 남음

해결법 / 대안

접근	방법	언제?
격리 올림	READ COMMITTED 이상 사용	대부분의 실무 (권장)
MVCC 엔진 채택	PostgreSQL, MySQL, Oracle 등	구조적으로 dirty read 가 불가능
read-only 명시	`SET TRANSACTION READ ONLY;`	대략적 통계, 리포트
replica 분리	Analytics 는 replica DB 로	최신성 덜 중요한 워크로드

[!IMPORTANT] PostgreSQL 은 READ UNCOMMITTED 를 지정해도 내부적으로 READ COMMITTED 로 승격. MVCC 특성상 dirty read 가 원천 불가능. 즉 PostgreSQL 에서 이 수준을 “쓰는” 것은 명목상만 의미 있음.

READ UNCOMMITTED 를 실제 쓰는 경우가 있나?

SQL Server 의 WITH (NOLOCK) hint 로 유사 효과. 대시보드 스냅샷 등에 종종 쓰이지만 공식적으로 지양.
Analytics/OLAP 워크로드는 대개 replica 로 분리하는 편이 낫다.
결국 거의 안 씀. 실무에서는 이 수준을 이해하되 실제 사용은 피한다.

Level 2: READ COMMITTED

이 수준의 정의

커밋된 값만 읽는다. Dirty Read 는 완전히 방지.

PostgreSQL, Oracle, SQL Server 의 기본값
MVCC 엔진에서는 문장 (statement) 마다 새 스냅샷을 잡음
락 사용 최소 → 높은 동시성

-- PostgreSQL 기본
BEGIN;
SELECT balance FROM accounts WHERE id = 1;  -- 이 시점의 committed 값만 봄
COMMIT;

발생하는 문제: Non-Repeatable Read

같은 트랜잭션 안에서 같은 SELECT 를 두 번 실행했는데 결과가 다르다. 두 SELECT 사이에 다른 tx 가 UPDATE + COMMIT 하면 발생.

{}

시나리오 (위 애니메이션):

-- 초기: balance = 500
-- T1
SET TRANSACTION ISOLATION LEVEL READ COMMITTED;
BEGIN;
SELECT balance FROM accounts WHERE id = 1;   -- 500

-- T2 (별도 세션): UPDATE + COMMIT 완료

-- T1 (계속)
SELECT balance FROM accounts WHERE id = 1;   -- 1000  ← 같은 tx인데 다름!
COMMIT;

왜 문제인가:

트랜잭션 안에서 계산에 쓴 값이 중간에 바뀜
예: 총액 = 첫 SELECT, 수수료 = 두번째 SELECT * 0.1 조합에서 총액과 수수료 비율이 불일치
리포트 생성 중 값이 흔들리면 통계가 왜곡됨

해결법 / 대안

접근	방법	트레이드오프
격리 올림	REPEATABLE READ 이상	같은 값 보장, 성능 약간 손해
명시적 락	`SELECT ... FOR UPDATE` (row lock)	정확, 대기 시간 발생
원자 연산	`UPDATE ... SET x = x - 100`	애초에 read-modify-write 안 함
애플리케이션 캐싱	첫 결과 저장, 재사용	코드 복잡, 지양

-- 옵션 1: REPEATABLE READ 로 올림
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;

-- 옵션 2: FOR UPDATE 로 row 잠금
SELECT balance FROM accounts WHERE id = 1 FOR UPDATE;
-- 이후 tx 끝까지 다른 tx의 UPDATE는 대기

-- 옵션 3: 원자 UPDATE 로 변경
UPDATE accounts SET balance = balance - 100 WHERE id = 1;
-- read-modify-write 자체를 피함

[!TIP] 일반 CRUD 웹 서비스는 READ COMMITTED 로 충분. Non-Repeatable Read 가 실제 문제가 되는 상황은 리포트, 잔액 계산 등 같은 값을 여러 번 참조하는 로직. 그런 부분만 골라 REPEATABLE READ 나 FOR UPDATE 를 붙이는 편이 낫다.

Level 3: REPEATABLE READ

이 수준의 정의

같은 트랜잭션 안에서 같은 row 는 항상 같은 값. ANSI 정의로는 Non-Repeatable Read 만 방지하고 Phantom Read 는 허용. 하지만 실제 엔진마다 다르다.

MySQL InnoDB 의 기본값
PostgreSQL 은 명시적으로 지정 시 사용
MVCC 엔진에서는 트랜잭션 시작 시점의 스냅샷을 tx 끝까지 유지

엔진별 실제 구현:

엔진	구현 방식	Non-Rep	Phantom	Lost Update	Write Skew
MySQL InnoDB	2PL + next-key lock (범위 잠금)	✓	✓ 방지	✗	✗
PostgreSQL	Snapshot Isolation (MVCC)	✓	✓ 사실상 방지	△ 감지	✗
Oracle	미지원 (READ COMMITTED / SERIALIZABLE 만)	-	-	-	-
SQL Server	2PL	✓	✗	✗	✗

[!IMPORTANT] 같은 REPEATABLE READ 라도 엔진마다 완전히 다르다. MySQL RR 은 사실상 SERIALIZABLE 에 가까운 락 사용, PostgreSQL RR 은 Snapshot Isolation (락 없이 스냅샷). 이름 하나로 여러 개념을 뭉뚱그린 대표적 사례.

발생하는 문제: Phantom Read (ANSI 정의상)

같은 WHERE 조건을 두 번 실행했는데 row 개수가 다르다. UPDATE 가 아니라 INSERT/DELETE 가 원인.

{}

시나리오 (위 애니메이션):

-- 초기: orders 에 amount > 100 인 row 3개
-- T1
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
BEGIN;
SELECT COUNT(*) FROM orders WHERE amount > 100;  -- 3

-- T2 (별도 세션)
BEGIN;
INSERT INTO orders (id, amount) VALUES (999, 200);
COMMIT;

-- T1 (계속)
SELECT COUNT(*) FROM orders WHERE amount > 100;
-- ANSI 정의상: 4 (phantom!)
-- MySQL InnoDB: 3 (next-key lock으로 방지)
-- PostgreSQL: 3 (snapshot으로 방지)
COMMIT;

왜 문제인가:

WHERE 범위에 해당하는 row 개수를 두 번 재는 로직에서 결과가 달라짐
예: 재고 검색 → 예약 처리 → 재확인 시 새 항목이 튀어나옴
리포트 통계, 배치 처리에서 count/sum 이 흔들림

해결법 / 대안

엔진	상황	조치
MySQL InnoDB	REPEATABLE READ (기본)	이미 방지됨 (next-key lock). 별도 조치 불필요
PostgreSQL	REPEATABLE READ (SI)	이미 방지됨 (snapshot). 스냅샷 시점 이후 insert 는 안 보임
Oracle / SQL Server (2PL)	REPEATABLE READ	SERIALIZABLE 로 올리거나 `SELECT ... FOR UPDATE` 로 범위 잠금
모든 엔진	안전 확실 필요	SERIALIZABLE 또는 predicate lock

MySQL 의 next-key lock 이란?

[gap lock][row lock][gap lock][row lock][gap lock]...

WHERE 조건에 매칭되는 인덱스 범위 전체에 lock. 새 row 가 그 범위에 INSERT 되지 못하게 막아 phantom 방지. 강력하지만 예상치 못한 deadlock 이 잦음.

PostgreSQL 의 SI 는?

트랜잭션 시작 시점의 스냅샷만 계속 봄. T2 가 나중에 INSERT + COMMIT 해도 T1 의 스냅샷에는 없으므로 count 가 그대로.

[!WARNING] PostgreSQL REPEATABLE READ 는 Snapshot Isolation 이지 진짜 Serializable 이 아니다. 아래 Write Skew 절에서 다룰 함정이 있다. 정합성이 극단적으로 중요하면 SERIALIZABLE 로 올려야 함.

Level 4: SERIALIZABLE

이 수준의 정의

개념적으로 트랜잭션이 하나씩 직렬 실행된 것과 같은 결과. 모든 이상 현상을 방지.

가장 강한 격리 수준
성능 대가 큼 (엔진마다 다름)
진짜 필요한 경우에만 (금융, 재고, 티켓팅 등)

엔진별 구현 방식:

엔진	구현	특징
PostgreSQL 9.1+	SSI (Serializable Snapshot Isolation)	성능 손해 적음, 충돌 시 abort → retry 필요
MySQL InnoDB	Strict 2PL (모든 SELECT 이 shared lock 획득)	대기 많음, deadlock 위험
SQL Server	2PL (SERIALIZABLE 힌트)	MySQL 유사
CockroachDB	SSI 변형	기본이 SERIALIZABLE

SERIALIZABLE 을 쓸 때 알아야 할 것

abort → retry 패턴 필수 (특히 PostgreSQL SSI):

import time
import psycopg2

for attempt in range(5):
    try:
        with conn.cursor() as cur:
            cur.execute("BEGIN ISOLATION LEVEL SERIALIZABLE")
            # ... 비즈니스 로직 ...
            cur.execute("COMMIT")
        break
    except psycopg2.errors.SerializationFailure:
        conn.rollback()
        time.sleep(0.01 * (2 ** attempt))  # 지수 backoff
        if attempt == 4:
            raise

왜 abort 가 필요한가: SSI 는 각 tx 가 자유롭게 진행하다가 커밋 직전에 충돌 감지. 감지되면 한쪽을 강제 abort (SQLSTATE 40001). 애플리케이션은 이를 잡아 재시도해야 함.

성능 트레이드오프

일반 워크로드에서 READ COMMITTED 대비:

PostgreSQL SSI: 약 10-20% 느림
2PL 기반 (MySQL, SQL Server): 최대 수 배 느림 (경합 심한 경우)

[!TIP] “무조건 SERIALIZABLE” 은 나쁜 선택. 대부분 상황은 READ COMMITTED + 필요한 로직에 SELECT FOR UPDATE 또는 원자 UPDATE 조합이 최적. SERIALIZABLE 은 진짜로 write skew 위험이 있는 로직 에만.

ANSI 표준을 벗어난 이상 현상들

ANSI SQL-92 표준의 4단계 매트릭스는 3가지 이상 현상만 정의했다. Berenson et al. (1995) 논문이 이 결함을 지적하며 2가지를 추가했다.

Lost Update (읽고 → 계산 → 쓰기 경쟁)

같은 데이터를 두 tx 가 read-modify-write 하는 사이, 한쪽의 UPDATE 가 사라진다.

{}

시나리오 (위 애니메이션):

-- 초기: count = 10
-- T1
BEGIN;
SELECT count FROM counters WHERE id = 1;   -- 10
-- 로컬 계산: 10 + 1 = 11
UPDATE counters SET count = 11 WHERE id = 1;
COMMIT;

-- T2 (T1과 병렬)
BEGIN;
SELECT count FROM counters WHERE id = 1;   -- 10 (T1 커밋 전에 SELECT)
-- 로컬 계산: 10 + 1 = 11
UPDATE counters SET count = 11 WHERE id = 1;   -- T1이 쓴 값 위에 덮어씀
COMMIT;

-- 결과: count = 11 (기대치는 12)

어느 수준에서 발생하는가: READ COMMITTED, REPEATABLE READ 모두 가능. PostgreSQL 의 SI (REPEATABLE READ) 는 first-writer-wins 로 감지해서 두번째 UPDATE 에서 에러를 냄. SERIALIZABLE 은 항상 방지.

해결법 (권장 순서):

-- ① 원자 UPDATE (가장 단순, 항상 우선)
UPDATE counters SET count = count + 1 WHERE id = 1;
-- 단일 UPDATE 문은 atomic. race condition 없음.

-- ② 낙관적 lock (version 컬럼)
UPDATE counters SET count = count + 1, version = version + 1
WHERE id = 1 AND version = <읽었을 때의 값>;
-- 0 row affected 면 race 발생 → 애플리케이션에서 재시도

-- ③ 비관적 lock (SELECT FOR UPDATE)
BEGIN;
SELECT count FROM counters WHERE id = 1 FOR UPDATE;  -- row 잠금
UPDATE counters SET count = count + 1 WHERE id = 1;
COMMIT;

-- ④ SERIALIZABLE 로 격리 올림
BEGIN ISOLATION LEVEL SERIALIZABLE;
-- 충돌 시 abort 재시도

-- ⑤ 별도 원자 저장소 (예: Redis INCR)

방법	언제?	단점
원자 UPDATE	단순 counter/누계, 사용 가능하면 항상	복잡 로직 못 표현
낙관적 lock	충돌 드물게	실패 시 재시도 로직
비관적 lock	충돌 잦음	대기 시간 ↑, deadlock 위험
SERIALIZABLE	정확성 우선	abort 재시도 필요
Redis 등 별도 저장소	극한 성능	이중 저장 복잡성

Write Skew (Snapshot Isolation 의 치명적 함정)

각자의 스냅샷 안에서는 조건이 참이지만, 두 tx 의 결과를 합치면 불변량이 깨진다.

Lost Update 와 다른 점: Lost Update 는 같은 row 를 두 tx 가 UPDATE 해서 하나가 사라짐. Write Skew 는 다른 row 를 각자 UPDATE 해서 first-writer-wins 감지가 안 됨.

{}

시나리오: 병원 온콜 스케줄 (위 애니메이션)

규칙: 최소 1명은 항상 on-call
현재 Alice, Bob 두 명이 on-call
둘 다 아파서 동시에 off-call 요청

-- 초기: on-call 2명 (alice, bob)
-- T1 (Alice의 세션)
BEGIN ISOLATION LEVEL REPEATABLE READ;
SELECT COUNT(*) FROM doctors WHERE on_call = true;  -- 2, 조건 OK
UPDATE doctors SET on_call = false WHERE id = 'alice';
COMMIT;   -- 성공

-- T2 (Bob의 세션, T1과 동시)
BEGIN ISOLATION LEVEL REPEATABLE READ;
SELECT COUNT(*) FROM doctors WHERE on_call = true;  -- 2 (자기 스냅샷), 조건 OK
UPDATE doctors SET on_call = false WHERE id = 'bob';
COMMIT;   -- 성공 (T1이 alice 를 건드렸을 뿐 bob 은 안 건드렸으므로)

SELECT COUNT(*) FROM doctors WHERE on_call = true;  -- 0 !! 규칙 위반

왜 SI 가 못 막나: 두 tx 가 다른 row 를 UPDATE 했으므로 write-write 충돌이 없음. SI 의 first-writer-wins 는 같은 row 에 대해서만 감지. 각자의 스냅샷 안에서는 count(on_call) >= 1 조건이 참이었지만, 실제로는 결합되어 위반됨.

해결법:

-- ① SERIALIZABLE (PostgreSQL SSI는 이를 자동 감지)
BEGIN ISOLATION LEVEL SERIALIZABLE;
SELECT COUNT(*) FROM doctors WHERE on_call = true;
UPDATE doctors SET on_call = false WHERE id = 'alice';
COMMIT;
-- 동시 T2 시도 시 ERROR: could not serialize access due to read/write dependencies
-- → 애플리케이션은 재시도

-- ② SELECT ... FOR UPDATE 로 predicate 잠금
BEGIN;
SELECT COUNT(*) FROM doctors WHERE on_call = true FOR UPDATE;
-- 이제 다른 tx는 on_call=true 인 row 를 UPDATE 할 수 없음
UPDATE doctors SET on_call = false WHERE id = 'alice';
COMMIT;

-- ③ materializing the conflict (강제 write-write 충돌 만들기)
CREATE TABLE on_call_lock (locked BOOLEAN);
INSERT INTO on_call_lock VALUES (true);

BEGIN;
UPDATE on_call_lock SET locked = true;  -- 모든 tx가 이 row 를 UPDATE → 충돌 감지 가능
SELECT COUNT(*) FROM doctors WHERE on_call = true;
UPDATE doctors SET on_call = false WHERE id = 'alice';
COMMIT;

[!IMPORTANT] Write Skew 는 ANSI 표준에 없다. Berenson et al. 이 SI 의 함정을 지적하며 도입한 개념. PostgreSQL SSI (9.1+) 가 이를 자동 감지하는 유일한 격리 수준. MySQL SERIALIZABLE 은 strict 2PL 로 결과적으로 방지하지만 방법이 다름.

PostgreSQL SSI (Serializable Snapshot Isolation)

PostgreSQL 9.1 부터 도입된 SSI 는 Snapshot Isolation 위에 predicate lock 추적을 얹어 진정한 serializability 를 달성한다.

flowchart TD
    T1[T1 시작 스냅샷] --> Read1[T1 SELECT / UPDATE]
    T2[T2 시작 스냅샷] --> Read2[T2 SELECT / UPDATE]
    Read1 --> Track[predicate + row 접근 기록]
    Read2 --> Track
    Track --> Commit{둘 commit 시도}
    Commit --> Cycle{의존성 순환 감지?}
    Cycle -->|예| Abort[한쪽 abort<br/>SQLSTATE 40001]
    Cycle -->|아니오| OK[둘 다 commit]
    Abort --> Retry[애플리케이션 재시도]

핵심 아이디어:

각 tx 는 자기 스냅샷 위에서 자유롭게 실행 (락 최소)
백그라운드에서 predicate lock 추적 (T1 이 이 범위를 읽었다, T2 는 이 row 를 썼다)
커밋 시점에 rw-dependency 순환 있으면 한쪽 abort
애플리케이션은 40001 잡아서 재시도

장점: throughput 손해 적음 (2PL 대비 큰 차이), 정확성 완벽. 단점: 재시도 코드 필수. false positive 가능하지만 정확성에는 영향 없음.

MVCC 기반 스냅샷 격리의 원리

각 트랜잭션은 시작 시점의 스냅샷 을 잡고, 그 시점 이후의 변경은 자기에게 보이지 않는다.

PostgreSQL 은 각 row (tuple) 에 hidden column xmin, xmax 를 저장:

row 1: (id=1, name='Alice', xmin=100, xmax=0)
        → T200 이 UPDATE
row 1: (id=1, name='Alice', xmin=100, xmax=200)  ← 옛 버전
row 1: (id=1, name='Bob',   xmin=200, xmax=0)    ← 새 버전

트랜잭션 T150 은:

xmin ≤ 150 이고 (xmax = 0 or xmax > 150) 인 tuple 만 봄
즉, “내 스냅샷 시점에 살아 있던” 버전만 봄

자세한 구현은 [[mvcc]] 참조.

실무 가이드

언제 어느 수준을?

시나리오	권장 수준	이유
일반 CRUD, 짧은 tx	READ COMMITTED	성능 좋음, dirty read 만 방지
배치 리포트 (일관 스냅샷)	REPEATABLE READ	같은 값 여러 번 사용
잔액 계산, 재고 확인	REPEATABLE READ + FOR UPDATE	phantom 안전
금융 거래, 티켓 발권	SERIALIZABLE	write skew 방지
Analytics (최신성 덜 중요)	READ COMMITTED READ ONLY	최대 동시성

격리 수준 명시 방법

-- 세션 전체
SET SESSION TRANSACTION ISOLATION LEVEL SERIALIZABLE;

-- 트랜잭션 하나만
BEGIN;
SET TRANSACTION ISOLATION LEVEL REPEATABLE READ;
-- ...
COMMIT;

-- PostgreSQL: 시작과 동시에
BEGIN ISOLATION LEVEL SERIALIZABLE;

-- 프로그램 레벨 (JDBC 예시)
connection.setTransactionIsolation(Connection.TRANSACTION_SERIALIZABLE);

프레임워크 예시

# Django
from django.db import transaction
from django.db import connection

@transaction.atomic
def transfer(from_id, to_id, amount):
    with connection.cursor() as cursor:
        cursor.execute("SET TRANSACTION ISOLATION LEVEL SERIALIZABLE")
    # ... 로직 ...

// Spring
@Transactional(isolation = Isolation.SERIALIZABLE)
public void transfer(Long from, Long to, BigDecimal amount) { ... }

자세한 프레임워크별 사용은 [[django-transactions]], [[spring-transaction]] 참조.

실제 DB 엔진 매핑

엔진	기본 격리	SERIALIZABLE 구현	특징
PostgreSQL	READ COMMITTED	SSI (Serializable Snapshot Isolation)	RR = Snapshot Isolation
MySQL InnoDB	REPEATABLE READ	Strict 2PL	RR 에서 next-key lock 으로 phantom 방지
Oracle	READ COMMITTED	SI 유사 (완전 SS 아님)	RR 미지원
SQL Server	READ COMMITTED	2PL	RCSI 옵션 (MVCC), Snapshot 옵션 별개
CockroachDB	SERIALIZABLE	SSI 변형	기본이 SS
MongoDB	(트랜잭션은 SS)	SI	단일 문서는 원자적
DynamoDB	(item 원자성)	TransactWriteItems (SSI 유사)	트랜잭션 API 사용 시
Cassandra	(트랜잭션 미지원)	LWT (Lightweight Transactions)	Paxos 기반 우회

흔한 함정

[!WARNING]

“REPEATABLE READ 라니 안전하겠지” = MySQL 과 PostgreSQL 의 RR 은 완전히 다른 것. Write Skew 는 어느 쪽에서도 발생.

SERIALIZABLE 만 박고 abort 처리 없음 = 부하 시 40001 폭증하여 요청 실패. 재시도 코드 필수.

READ COMMITTED 로 잔액 계산 = tx 안에서도 잔액이 바뀔 수 있음. 은행 앱에서 문제.

MySQL RR + gap lock deadlock = 의도치 않은 범위 잠금으로 데드락 폭증. SHOW ENGINE INNODB STATUS\G 로 진단.

낙관적 lock 없이 read-modify-write = 트래픽 증가 시 lost update 폭증.

SELECT FOR UPDATE 를 잔뜩 걸음 = 대기 시간 폭증 + deadlock. 필요한 최소 범위만.

긴 트랜잭션 (long-running tx) = VACUUM 방해, snapshot 유지 비용, lock 대기 폭증. 5분 넘으면 검토.

격리 수준을 애플리케이션 코드에서 매번 바꿈 = 세션 풀에서 오염 (다음 요청이 이전 설정 상속). 명시적 리셋 필요.

Anti-Pattern: Lock 으로 모든 것 해결 시도

-- ✗ 나쁜 예: 모든 SELECT 에 FOR UPDATE
SELECT * FROM users FOR UPDATE;
SELECT * FROM orders FOR UPDATE;
SELECT * FROM products FOR UPDATE;
-- → deadlock 폭증, 대기 시간 ↑

개선:

필요한 곳만 SELECT … FOR UPDATE (충돌 실제 발생하는 row 만)
순서 일관성 (항상 users → orders → products 순으로 lock)
SSI 로 전환 (retry 로 처리)
원자 UPDATE 가능하면 그것으로

[DRF] Filtering: django-filter, SearchFilter, OrderingFilter

koa (김신건) — Wed, 01 Jul 2026 00:00:00 GMT

정의

Filtering = 쿼리 파라미터로 결과 제한. 3가지 backend + custom.

3가지 내장 Backend

flowchart TD
    Q{Filter Backend}
    Q --> DF["DjangoFilterBackend<br/>(django-filter, 완전 필터)"]
    Q --> SF["SearchFilter<br/>(전문 검색 like)"]
    Q --> OF["OrderingFilter<br/>(정렬)"]

설치 + 설정

pip install django-filter

INSTALLED_APPS = [..., 'django_filters']

REST_FRAMEWORK = {
    'DEFAULT_FILTER_BACKENDS': [
        'django_filters.rest_framework.DjangoFilterBackend',
        'rest_framework.filters.SearchFilter',
        'rest_framework.filters.OrderingFilter',
    ]
}

1. DjangoFilterBackend

간단한 필드 매칭

class ArticleList(generics.ListAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    filterset_fields = ['author', 'category', 'is_published']

GET /articles/?author=1&category=tech&is_published=true

상세 FilterSet

import django_filters

class ArticleFilter(django_filters.FilterSet):
    title = django_filters.CharFilter(lookup_expr='icontains')
    min_views = django_filters.NumberFilter(field_name='views', lookup_expr='gte')
    max_views = django_filters.NumberFilter(field_name='views', lookup_expr='lte')
    published_after = django_filters.DateFilter(field_name='published_at', lookup_expr='gte')
    tag = django_filters.CharFilter(method='filter_tag')
    ordering = django_filters.OrderingFilter(
        fields=(
            ('title', 'title'),
            ('views', 'views'),
            ('published_at', 'published_at'),
        )
    )

    class Meta:
        model = Article
        fields = ['author', 'category']

    def filter_tag(self, queryset, name, value):
        return queryset.filter(tags__name__iexact=value)


class ArticleList(generics.ListAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    filterset_class = ArticleFilter

GET /articles/?title=django&min_views=100&published_after=2026-01-01&tag=python

Lookup expressions

Lookup	의미
`exact` (기본)	`field=x` → WHERE field = x
`iexact`	대소문자 무시
`contains` / `icontains`	LIKE
`startswith` / `endswith`	prefix/suffix
`gt`, `gte`, `lt`, `lte`	크기 비교
`in`	field__in
`range`	범위
`date`, `year`, `month`, `week`	날짜 부분
`isnull`	NULL 여부
`regex` / `iregex`	정규식

class ArticleList(generics.ListAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    filter_backends = [filters.SearchFilter]
    search_fields = ['title', 'body', 'author__username', 'tags__name']

GET /articles/?search=django+rest

Prefix 조정

Prefix	의미
없음	`icontains` (기본)
`^`	`istartswith`
`=`	`iexact`
`@`	`full text search` (Postgres)
`$`	`iregex`

search_fields = ['=username', '^title', '@body']

3. OrderingFilter

class ArticleList(generics.ListAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    filter_backends = [filters.OrderingFilter]
    ordering_fields = ['created_at', 'views', 'title']
    ordering = ['-created_at']       # 기본 정렬

GET /articles/?ordering=-views
GET /articles/?ordering=title,-views    # 다중

다중 Backend 조합

class ArticleList(generics.ListAPIView):
    queryset = Article.objects.all()
    serializer_class = ArticleSerializer
    filter_backends = [
        DjangoFilterBackend,
        filters.SearchFilter,
        filters.OrderingFilter,
    ]
    filterset_class = ArticleFilter
    search_fields = ['title', 'body']
    ordering_fields = ['created_at', 'views']

GET /articles/?category=tech&search=django&ordering=-views

Custom Filter Backend

from rest_framework import filters

class IsOwnerFilterBackend(filters.BaseFilterBackend):
    def filter_queryset(self, request, queryset, view):
        return queryset.filter(owner=request.user)


class ArticleList(generics.ListAPIView):
    filter_backends = [IsOwnerFilterBackend, ...]

PostgreSQL Full-Text Search

from django.contrib.postgres.search import SearchVector, SearchQuery, SearchRank

class ArticleList(generics.ListAPIView):
    serializer_class = ArticleSerializer

    def get_queryset(self):
        q = self.request.query_params.get('q', '')
        if q:
            vector = SearchVector('title', weight='A') + SearchVector('body', weight='B')
            query = SearchQuery(q)
            return Article.objects.annotate(
                rank=SearchRank(vector, query),
            ).filter(rank__gte=0.1).order_by('-rank')
        return Article.objects.all()

자세한 건 [[postgresql]] 의 full-text.

OpenAPI 문서화

django-filter 는 OpenAPI schema 자동:

filterset_class = ArticleFilter
# → OpenAPI 에 파라미터 자동 추가

자세한 건 [[drf-schemas-openapi]].

다른 프레임워크

Framework	필터링
DRF	django-filter, SearchFilter
Rails	ransack, filterrific
Spring Data	Specification, Querydsl
FastAPI	수동 Query params
NestJS	nestjs-typeorm-crud

흔한 함정

[!WARNING]

filter_fields (옛 이름) = deprecated. filterset_fields.

큰 filterset_class + 많은 필드 = OpenAPI schema 폭발.

search_fields 에 큰 컬럼 = 매 요청 full-table scan. GIN 인덱스.

ordering 사용자 입력 신뢰 = 임의 필드 정렬 → 성능. ordering_fields 화이트리스트.

[DRF] Schemas + OpenAPI: 자동 문서화

koa (김신건) — Wed, 01 Jul 2026 00:00:00 GMT

정의

OpenAPI (전 Swagger) = REST API를 기계 가독 스펙으로 기술하는 표준. DRF는 이 스펙을 ViewSet / Serializer 로부터 자동 추출할 수 있어, Postman 없이 브라우저에서 API를 탐색 + 실행 가능.

이 페이지는 DRF Documenting your API 를 기반으로, 실무에서 자주 쓰는 drf-spectacular 를 중심으로 정리한다.

왜 API 문서화가 필요한가

flowchart LR
    NoDoc["문서 없음"] --> A1["프론트, Postman 매번 시도"]
    NoDoc --> A2["백엔드, Slack으로 스펙 공유"]
    NoDoc --> A3["변경 시 fault 전파, 늦게 발견"]

    Doc["OpenAPI 문서"] --> B1["프론트, 자동 완성 + type 생성"]
    Doc --> B2["QA, 자동 테스트 케이스 생성"]
    Doc --> B3["변경 즉시 감지 (CI)"]

목적	얻는 것
탐색	브라우저에서 endpoint 목록 + 파라미터 확인
테스트	Try it out 으로 즉시 호출
타입 생성	TypeScript, Kotlin 등 client SDK 자동 생성
계약 (Contract)	프론트/백 합의된 스펙, breaking change 방지
온보딩	신규 개발자 학습 시간 단축

도구 선택

flowchart TD
    Q{DRF 문서화 도구}
    Q --> Spec["drf-spectacular ★ 사실상 표준"]
    Q --> Yasg["drf-yasg (legacy, 유지보수 저조)"]
    Q --> Native["DRF 내장 (제한적)"]

도구	상태	특징
drf-spectacular	활발	OpenAPI 3.1, type hint 인식, Sane defaults
drf-yasg	deprecated 권장	OpenAPI 2.0, 여전히 인기 있지만 3.1 미지원
DRF 내장 SchemaGenerator	기본 포함	OpenAPI 3.0 하지만 커스텀 어려움
coreapi (2020 이전)	사용 금지	DRF 3.10에서 제거됨

[!TIP] 2026년 현재 drf-spectacular 를 기본으로 선택하는 것이 안전. drf-yasg 는 유지보수 프로젝트만.

drf-spectacular 설치 (5분 완성)

pip install drf-spectacular

# settings.py
INSTALLED_APPS = [
    ...,
    'rest_framework',
    'drf_spectacular',
]

REST_FRAMEWORK = {
    'DEFAULT_SCHEMA_CLASS': 'drf_spectacular.openapi.AutoSchema',
}

SPECTACULAR_SETTINGS = {
    'TITLE': 'My API',
    'DESCRIPTION': '내 서비스 REST API 문서',
    'VERSION': '1.0.0',
    'SERVE_INCLUDE_SCHEMA': False,   # /api/schema/ 자체는 문서에서 숨김
    'COMPONENT_SPLIT_REQUEST': True, # request/response schema 분리
}

# urls.py
from drf_spectacular.views import (
    SpectacularAPIView,
    SpectacularSwaggerView,
    SpectacularRedocView,
)

urlpatterns = [
    ...,
    # OpenAPI 3.1 스펙 (JSON/YAML)
    path('api/schema/', SpectacularAPIView.as_view(), name='schema'),

    # 두 종류 UI (원하는 것 하나만 쓰거나 둘 다)
    path('api/docs/', SpectacularSwaggerView.as_view(url_name='schema'), name='swagger-ui'),
    path('api/redoc/', SpectacularRedocView.as_view(url_name='schema'), name='redoc'),
]

브라우저에서 http://localhost:8000/api/docs/ 접속 → Swagger UI 자동 렌더링.

Swagger UI vs Redoc

flowchart TD
    Q{UI 선택}
    Q --> S["Swagger UI"]
    Q --> R["Redoc"]

    S --> S1["Try it out 지원 (실제 호출)"]
    S --> S2["개발자 도구 스타일"]

    R --> R1["3열 레이아웃, 읽기 편함"]
    R --> R2["문서/스펙 공유용에 적합"]

항목	Swagger UI	Redoc
스타일	아코디언	3열, 문서 스타일
Try it out	예	아니오
검색	예	예
커스텀 CSS	부분적	자유
용도	개발자 테스트	외부 공개 문서

자동 추출 되는 것

DRF ViewSet + Serializer 만 잘 짜면 아래가 자동 문서화:

class UserViewSet(viewsets.ModelViewSet):
    """유저 리소스 관리."""      # ← 이 docstring이 태그 description
    queryset = User.objects.all()
    serializer_class = UserSerializer
    permission_classes = [IsAuthenticated]
    filterset_fields = ['is_staff', 'is_active']
    search_fields = ['username', 'email']

    @action(detail=True, methods=['post'])
    def deactivate(self, request, pk=None):
        """유저 비활성화."""      # ← action의 description
        ...

자동 추출되는 요소:

Endpoint 경로 ← Router URL
HTTP method ← list/create/retrieve/…
Request body schema ← Serializer fields
Response schema ← Serializer fields
Query params ← filterset_fields, search_fields, ordering_fields
Path params ← <int:pk> etc.
Authentication ← authentication_classes
Description ← docstring

`@extend_schema` 로 커스터마이즈

from drf_spectacular.utils import extend_schema, OpenApiParameter, OpenApiExample

class UserViewSet(viewsets.ModelViewSet):

    @extend_schema(
        summary='유저 검색',
        description='이름 또는 이메일로 유저를 검색합니다. 최소 2자 이상 필요.',
        parameters=[
            OpenApiParameter(
                name='q',
                type=str,
                location=OpenApiParameter.QUERY,
                description='검색어',
                required=True,
            ),
        ],
        responses={
            200: UserSerializer(many=True),
            400: OpenApiExample(name='잘못된 요청', value={'detail': '검색어 부족'}),
        },
        tags=['users'],
    )
    @action(detail=False, methods=['get'])
    def search(self, request):
        ...

주요 인자:

summary = endpoint 한 줄 요약
description = 긴 설명 (Markdown 지원)
parameters = query/header/path param 명시
request = request body serializer
responses = status code별 응답 serializer
tags = 그룹핑
deprecated = 곧 제거 예정 표시
exclude = 문서에서 숨김

Enum 필드 문서화

from drf_spectacular.utils import extend_schema_field
from drf_spectacular.types import OpenApiTypes

class UserSerializer(serializers.ModelSerializer):
    role = serializers.ChoiceField(
        choices=['admin', 'user', 'guest'],
        help_text='유저 역할',
    )

DRF ChoiceField → OpenAPI enum 으로 자동 변환.

Nested Serializer 문서화

class ProfileSerializer(serializers.ModelSerializer):
    class Meta:
        model = Profile
        fields = ['bio', 'avatar_url']

class UserSerializer(serializers.ModelSerializer):
    profile = ProfileSerializer(read_only=True)      # ← nested schema 자동 추론

    class Meta:
        model = User
        fields = ['id', 'username', 'profile']

SerializerMethodField 타입 힌트

class UserSerializer(serializers.ModelSerializer):
    is_online = serializers.SerializerMethodField()

    @extend_schema_field(OpenApiTypes.BOOL)     # ← 타입 힌트 없으면 unknown
    def get_is_online(self, obj):
        return obj.last_seen and (now() - obj.last_seen).seconds < 300

[!WARNING] SerializerMethodField 는 반환 타입이 문서에 나오지 않는다. @extend_schema_field 로 명시.

인증 문서화

SPECTACULAR_SETTINGS = {
    ...,
    'SECURITY': [{'jwtAuth': []}],
    'APPEND_COMPONENTS': {
        'securitySchemes': {
            'jwtAuth': {
                'type': 'http',
                'scheme': 'bearer',
                'bearerFormat': 'JWT',
            },
        },
    },
}

Swagger UI 우측 상단 “Authorize” 버튼으로 JWT 토큰 입력 → 이후 요청에 자동 헤더 추가.

자세한 인증 방식은 [[drf-authentication]].

여러 개 응답 (union)

@extend_schema(
    responses={
        200: UserSerializer,
        202: OpenApiExample(name='pending', value={'status': 'pending'}),
        400: OpenApiExample(name='invalid', value={'detail': 'error'}),
        429: OpenApiExample(name='throttled', value={'detail': 'Rate limit'}),
    }
)
def create(self, request):
    ...

요청 예시

from drf_spectacular.utils import OpenApiExample, extend_schema

@extend_schema(
    examples=[
        OpenApiExample(
            'Simple case',
            summary='간단한 유저 생성',
            description='기본 필드만 사용',
            value={'username': 'koa', 'email': 'koa@example.com'},
            request_only=True,
        ),
        OpenApiExample(
            'With profile',
            value={'username': 'koa', 'email': 'koa@example.com', 'profile': {'bio': '개발자'}},
            request_only=True,
        ),
    ]
)
def create(self, request):
    ...

Swagger UI에서 예시 드롭다운으로 선택 가능.

Serializer 재사용 (같은 이름 충돌 방지)

class UserCreateSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['username', 'email', 'password']

class UserReadSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ['id', 'username', 'email']


class UserViewSet(ModelViewSet):
    queryset = User.objects.all()

    def get_serializer_class(self):
        if self.action == 'create':
            return UserCreateSerializer
        return UserReadSerializer

drf-spectacular 는 자동으로 두 스키마를 UserCreate / UserRead 로 분리 문서화.

Schema 파일 export

# YAML로 저장 (버전 관리)
python manage.py spectacular --file schema.yml

# 검증
python manage.py spectacular --validate --file schema.yml

CI에 넣어두면 스펙 breaking change 를 조기 감지.

Client SDK 자동 생성

OpenAPI 스펙만 있으면 다양한 언어 client 를 코드 생성:

# TypeScript
npx openapi-typescript schema.yml -o api-types.ts

# Kotlin
openapi-generator-cli generate -i schema.yml -g kotlin -o ./kotlin-client

프론트에서:


type UserResponse = paths['/api/users/{id}/']['get']['responses']['200']['content']['application/json'];

백엔드 스펙과 프론트 타입이 자동 동기화. Breaking change → 컴파일 에러.

다른 프레임워크 문서화 대응

도구	자동 문서화
DRF + drf-spectacular	ViewSet + Serializer 자동
FastAPI	내장 (Pydantic type hint 기반)
Django Ninja	내장 (Pydantic type hint 기반)
NestJS	@nestjs/swagger 데코레이터 명시
Spring Boot	springdoc-openapi 자동
Express	swagger-jsdoc 주석 명시
Rails	rswag, apipie-rails

FastAPI/Ninja 는 type hint 만으로 자동. DRF는 Serializer 정의가 문서 기반.

실무 팁

1. 태그로 그룹핑

class UserViewSet(ModelViewSet):
    ...
    @extend_schema(tags=['User Management'])
    def list(self, request):
        ...

Swagger UI에서 카테고리별 아코디언.

2. CORS 문제

Swagger UI 에서 Try it out 시도 → CORS 에러 자주 발생.

INSTALLED_APPS += ['corsheaders']
MIDDLEWARE = [
    'corsheaders.middleware.CorsMiddleware',
    ...,
]
CORS_ALLOWED_ORIGINS = ['http://localhost:8000']

3. 문서 접근 권한 제한

# 프로덕션은 문서 접근 제한
if not DEBUG:
    urlpatterns = [
        path('api/schema/', permission_required('is_staff')(SpectacularAPIView.as_view())),
    ]

4. 버전별 문서 분리

# v1 / v2 각각 별도 스키마
SPECTACULAR_SETTINGS = {
    'SERVERS': [
        {'url': '/api/v1', 'description': 'v1'},
        {'url': '/api/v2', 'description': 'v2 (신규 권장)'},
    ],
}

자세한 API 버전 관리는 [[drf-versioning-content-negotiation]].

흔한 함정

[!WARNING]

Serializer 없는 endpoint = 문서에 body 안 나옴. @extend_schema(request=...) 명시.

SerializerMethodField 타입 안 명시 = OpenAPI type: unknown. @extend_schema_field.

@action 에 methods 만 명시 = summary/description 없어 문서 초라. docstring 사용.

문서 URL 프로덕션 개방 = 내부 endpoint 노출. 접근 제한 필수.

drf-yasg 를 새 프로젝트에 도입 = OpenAPI 2.0 만 지원. drf-spectacular 사용.

[DRF] Testing: APIClient, APITestCase, force_authenticate

koa (김신건) — Wed, 01 Jul 2026 00:00:00 GMT

정의

DRF의 테스트 도구는 Django TestCase 위에 API 특화 helper 를 얹은 것. APIClient 로 real endpoint 를 호출하거나 APIRequestFactory 로 View 단위 테스트가 가능.

테스트 도구 계층

flowchart TD
    Q{테스트 종류}
    Q --> Unit["단위 (Serializer, custom logic)"]
    Q --> Slice["View 단위 (APIRequestFactory)"]
    Q --> Int["통합 (APIClient, DB 포함)"]
    Q --> E2E["End-to-End (playwright, cypress)"]

    Unit --> U1["빠름 (ms)"]
    Slice --> S1["View 로직만"]
    Int --> I1["실제 URL + DB, 권장"]
    E2E --> E1["프론트 포함, 느림"]

도구	층	속도	DB
`TestCase` + Serializer 직접	단위	ms	아니오 (or 필요 시)
`APIRequestFactory`	View	빠름	아니오 (mock)
`APIClient` (DRF)	통합	중간	예
Django `Client`	통합 (form only)	중간	예

[!TIP] DRF 프로젝트는 APIClient 를 기본으로 쓴다. 실제 URL 라우팅 + 인증 + 응답 렌더링 모두 검증.

설치

pip install pytest pytest-django factory-boy freezegun

# pytest.ini
[pytest]
DJANGO_SETTINGS_MODULE = myproject.settings.test
python_files = tests.py test_*.py

1. APIClient (통합 테스트)

from rest_framework.test import APITestCase
from rest_framework import status

class UserAPITest(APITestCase):
    def setUp(self):
        self.user = User.objects.create_user('koa', password='pw')

    def test_list_users(self):
        self.client.force_authenticate(user=self.user)
        response = self.client.get('/api/users/')
        self.assertEqual(response.status_code, status.HTTP_200_OK)
        self.assertEqual(len(response.data['results']), 1)

    def test_create_requires_auth(self):
        response = self.client.post('/api/users/', {'username': 'new'})
        self.assertEqual(response.status_code, status.HTTP_401_UNAUTHORIZED)

self.client = APIClient 인스턴스.

`force_authenticate` (권장)

# ★ 가장 자주 쓰는 인증 helper
self.client.force_authenticate(user=self.user)
# → JWT 발급, 헤더 첨부 등 우회. 유닛 테스트에 이상적.

self.client.force_authenticate(user=None)  # 로그아웃

DRF 인증 클래스 무시 하고 request.user 를 직접 주입. 가장 빠름.

세션 로그인

self.client.login(username='koa', password='pw')
# 또는
self.client.force_login(self.user)   # Django 스타일

SessionAuthentication 검증까지 하고 싶을 때.

토큰 인증

# TokenAuthentication
token = Token.objects.create(user=self.user)
self.client.credentials(HTTP_AUTHORIZATION=f'Token {token.key}')

# JWTAuthentication
from rest_framework_simplejwt.tokens import RefreshToken
refresh = RefreshToken.for_user(self.user)
self.client.credentials(HTTP_AUTHORIZATION=f'Bearer {refresh.access_token}')

실제 인증 파이프라인 을 통과. E2E 시나리오 검증에 적합.

HTTP 메서드

# GET
response = self.client.get('/api/users/', {'q': 'koa'})    # ?q=koa 자동

# POST (JSON 자동)
response = self.client.post('/api/users/', {'username': 'new'}, format='json')

# PATCH
response = self.client.patch('/api/users/1/', {'username': 'updated'}, format='json')

# DELETE
response = self.client.delete('/api/users/1/')

# 헤더
response = self.client.get('/api/users/', HTTP_X_CUSTOM='value')

[!IMPORTANT] format='json' 명시 권장. 안 하면 form-urlencoded 로 보내져 nested 객체 실패.

응답 검증

def test_get_user(self):
    response = self.client.get('/api/users/1/')

    self.assertEqual(response.status_code, 200)
    self.assertEqual(response.data['username'], 'koa')
    self.assertIn('email', response.data)
    self.assertIsInstance(response.data['groups'], list)

    # 헤더
    self.assertEqual(response['Content-Type'], 'application/json')

    # JSON 직렬화된 문자열
    self.assertEqual(response.json(), {'id': 1, 'username': 'koa', ...})

2. APIRequestFactory (View 단위)

from rest_framework.test import APIRequestFactory

class UserViewTest(TestCase):
    def setUp(self):
        self.factory = APIRequestFactory()
        self.user = User.objects.create_user('koa', password='pw')

    def test_view_directly(self):
        view = UserViewSet.as_view({'get': 'list'})
        request = self.factory.get('/api/users/')
        force_authenticate(request, user=self.user)
        response = view(request)

        self.assertEqual(response.status_code, 200)

URL 라우팅 없이 View 직접 호출. 빠르지만 pipeline 일부만 검증.

3. Serializer 단위 테스트

def test_valid_serializer():
    data = {'username': 'koa', 'email': 'koa@example.com'}
    serializer = UserSerializer(data=data)
    assert serializer.is_valid()
    assert serializer.validated_data['username'] == 'koa'


def test_invalid_email():
    data = {'username': 'koa', 'email': 'not-an-email'}
    serializer = UserSerializer(data=data)
    assert not serializer.is_valid()
    assert 'email' in serializer.errors

4. pytest-django 사용

import pytest

@pytest.fixture
def api_client():
    from rest_framework.test import APIClient
    return APIClient()

@pytest.fixture
def user(db):
    return User.objects.create_user('koa', password='pw')

@pytest.fixture
def auth_client(api_client, user):
    api_client.force_authenticate(user=user)
    return api_client

def test_list_users(auth_client):
    response = auth_client.get('/api/users/')
    assert response.status_code == 200

fixture 조합 이 재사용성 극대화. pytest.ini 의 --reuse-db 로 DB 재생성 없이 반복 실행.

5. Factory Boy (테스트 데이터)

# factories.py
import factory
from django.contrib.auth.models import User

class UserFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = User

    username = factory.Sequence(lambda n: f'user{n}')
    email = factory.LazyAttribute(lambda o: f'{o.username}@example.com')
    is_active = True


# 사용
def test_many_users():
    UserFactory.create_batch(50)
    assert User.objects.count() == 50


# 관계
class ArticleFactory(factory.django.DjangoModelFactory):
    class Meta:
        model = Article
    title = factory.Faker('sentence')
    author = factory.SubFactory(UserFactory)

fixtures/*.json 대신 factory 로 동적 생성.

응답 status code 매트릭스

@pytest.mark.parametrize('user_type,expected_status', [
    ('anonymous', 401),
    ('regular', 403),
    ('admin', 200),
])
def test_admin_endpoint(api_client, user_type, expected_status):
    if user_type == 'regular':
        api_client.force_authenticate(user=UserFactory())
    elif user_type == 'admin':
        api_client.force_authenticate(user=UserFactory(is_staff=True))

    response = api_client.get('/api/admin/stats/')
    assert response.status_code == expected_status

parametrize 로 권한 매트릭스 완전 커버.

권한 테스트 패턴

class PostPermissionTest(APITestCase):
    def setUp(self):
        self.author = UserFactory()
        self.other = UserFactory()
        self.post = Post.objects.create(author=self.author, title='...')

    def test_author_can_delete(self):
        self.client.force_authenticate(self.author)
        response = self.client.delete(f'/api/posts/{self.post.pk}/')
        self.assertEqual(response.status_code, 204)

    def test_other_cannot_delete(self):
        self.client.force_authenticate(self.other)
        response = self.client.delete(f'/api/posts/{self.post.pk}/')
        self.assertEqual(response.status_code, 403)

자세한 권한 개념은 [[django-drf-permissions]].

Throttle 테스트

from django.core.cache import cache

class ThrottleTest(APITestCase):
    def setUp(self):
        cache.clear()   # ★ throttle 카운트 초기화

    def test_burst_limit(self):
        with self.settings(REST_FRAMEWORK={
            'DEFAULT_THROTTLE_RATES': {'login': '2/min'},
        }):
            for _ in range(2):
                self.assertEqual(self.client.post('/api/login/', ...).status_code, 200)
            self.assertEqual(self.client.post('/api/login/', ...).status_code, 429)

[!WARNING] setUp 에서 cache.clear() 필수. 안 하면 이전 테스트 카운트 남음.

시간 조작 (freezegun)

from freezegun import freeze_time

@freeze_time('2026-06-25 12:00:00')
def test_expired_token():
    token = RefreshToken.for_user(user)

    with freeze_time('2026-07-25 12:00:00'):    # 30일 후
        response = api_client.get('/api/me/', HTTP_AUTHORIZATION=f'Bearer {token.access_token}')
        assert response.status_code == 401

JWT 만료, 세션 timeout 등 시간 종속 테스트.

Mocking 외부 API

from unittest.mock import patch

@patch('myapp.services.send_email')
def test_signup_sends_email(mock_send):
    response = api_client.post('/api/signup/', {'email': 'a@b.c'})
    assert response.status_code == 201
    mock_send.assert_called_once_with('a@b.c', ...)

DB Snapshot

def test_no_extra_queries():
    # N+1 감시
    with self.assertNumQueries(3):
        response = self.client.get('/api/articles/')

DRF 응답이 예상보다 많은 쿼리를 하면 실패. Performance regression 방어.

자세한 N+1 개념은 [[django-orm-advanced]].

Coverage 측정

pip install coverage
coverage run -m pytest
coverage report
coverage html    # htmlcov/index.html

목표: serializer/view 는 90%+, permission/utility 는 100%.

다른 프레임워크 테스트 도구

Framework	테스트 도구
DRF	`APIClient`, `APIRequestFactory`, pytest-django
FastAPI	`TestClient` (Starlette)
Spring	MockMvc, `@WebMvcTest`
Rails	ActionDispatch, RSpec, request specs
Express	supertest
NestJS	@nestjs/testing + supertest

흔한 함정

[!WARNING]

format='json' 누락 = form-urlencoded 로 전송, nested 데이터 실패.

cache.clear() 안 함 (Throttle 테스트) = flaky test.

self.client.login() 을 JWT 라우트에 = 세션이라 401. force_authenticate 사용.

setUp 에서 heavy DB 초기화 = 매 테스트마다 실행. fixture 로 격리.

assertEqual(response.data, dict) = OrderedDict 차이로 실패 가능. json.loads(response.content) 로 정규화.

[Voice AI] Agent 패턴: Supervisor, Handoff, ReAct, HITL

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

복잡한 음성 에이전트 = 여러 sub-agent + 조정 패턴. 단일 LLM 으로 처리하기 어려운 흐름.

[!IMPORTANT] 각 sub-agent 내부는 VAD → STT → LLM → TTS 순차 파이프라인 위에서 동작. 본 페이지의 패턴은 상위 조정 (orchestration) 레이어.

4가지 핵심 패턴

flowchart TB
    Q[Agent Patterns]
    Q --> S[Supervisor]
    Q --> H[Handoff]
    Q --> R[ReAct]
    Q --> HITL[Human-in-the-Loop]

1. Supervisor

flowchart TB
    User --> Sup[Supervisor Agent]
    Sup --> Choose{어느 sub-agent?}
    Choose -->|결제 문의| Pay[Payment Agent]
    Choose -->|환불| Ref[Refund Agent]
    Choose -->|기술 지원| Tech[Tech Agent]
    Pay --> Sup
    Ref --> Sup
    Tech --> Sup
    Sup --> User

class SupervisorAgent:
    """질의 → 적절 sub-agent 라우팅"""

    sub_agents = {
        "payment": PaymentAgent(),
        "refund": RefundAgent(),
        "tech_support": TechAgent(),
    }

    async def handle(self, user_input: str) -> str:
        # LLM 으로 의도 분류
        intent = await self._classify_intent(user_input)
        agent = self.sub_agents[intent]
        return await agent.handle(user_input)

    async def _classify_intent(self, text: str) -> str:
        result = await llm.structured_output(
            schema=IntentSchema,
            messages=[{"role": "user", "content": text}],
        )
        return result.intent

작은 분류 모델 (gpt-4o-mini, Haiku) 가 intent classifier, 세부 agent 가 더 큰 모델.

2. Handoff

sequenceDiagram
    User->>Booking: 예약 문의
    Booking->>Booking: 예약 처리
    Note over Booking: 결제 단계
    Booking->>Payment: HANDOFF (context 전달)
    Payment->>User: "결제 진행하겠습니다"
    User->>Payment: 카드 정보
    Payment->>Payment: 결제 처리
    Payment-->>Booking: HANDOFF BACK
    Booking->>User: "예약 + 결제 완료"

OpenAI Swarm 의 handoff 패턴:

from swarm import Swarm, Agent

booking_agent = Agent(
    name="Booking",
    instructions="식당 예약을 도와줍니다.",
    functions=[lookup_restaurant, check_availability, transfer_to_payment],
)

payment_agent = Agent(
    name="Payment",
    instructions="결제를 처리합니다.",
    functions=[charge_card, transfer_to_booking],
)

def transfer_to_payment():
    return payment_agent

def transfer_to_booking():
    return booking_agent

client = Swarm()
response = client.run(agent=booking_agent, messages=messages)

Function return 으로 agent 교체. 깔끔.

3. ReAct (Reason + Act)

Thought: 사용자가 "내일 오후 회의 잡아줘" 라고 했다.
Action: search_calendar(date="내일")
Observation: 14:00-15:00 비어있음
Thought: 14시에 잡으면 되겠다. 참석자는 누구?
Action: ask_user("참석자는 누구신가요?")
Observation: "민수씨와 영희씨요"
Thought: 그들의 가용성 확인 필요
Action: check_availability(["민수", "영희"], "내일 14:00")
Observation: 모두 OK
Thought: 회의 생성
Action: create_meeting(...)
Observation: 회의 생성됨, ID=m_42
Thought: 사용자에게 알림
Action: respond("내일 오후 2시에 민수씨, 영희씨와 회의 잡았습니다.")

async def react_loop(user_input, max_steps=10):
    messages = [{"role": "user", "content": user_input}]
    for step in range(max_steps):
        response = await llm.chat(messages, tools=tools)

        if response.finish_reason == "stop":
            return response.content   # 최종 답변

        if response.tool_calls:
            for tc in response.tool_calls:
                result = await execute_tool(tc)
                messages.append({"role": "tool", "tool_call_id": tc.id, "content": result})

    raise ReActLoopExceededError()

음성에서는 너무 많은 step = 지연 폭증. max_steps 3-5 권장.

4. Human-in-the-Loop (HITL)

sequenceDiagram
    User->>Agent: "1억 송금"
    Agent->>HITL: critical action approval request
    HITL->>Human[운영자]: 알림 ("승인 필요")
    Human-->>HITL: approve / reject
    HITL-->>Agent: result
    Agent->>User: "송금 완료" 또는 "보안 확인 필요"

@agent.tool
async def transfer_money(amount: int, to: str):
    if amount > 10_000_000:
        approval = await request_human_approval(
            action=f"송금 {amount:,}원 → {to}",
            timeout=30,
        )
        if not approval:
            return "송금이 보류되었습니다. 보안팀 확인 후 처리됩니다."

    await bank_api.transfer(amount, to)
    return f"{amount:,}원이 송금되었습니다."

고위험 작업 (금액 큰 송금, 데이터 삭제, 외부 noti) 에 인간 승인.

패턴 조합

flowchart TB
    User --> Sup[Supervisor]
    Sup -->|일반| Single[Single Agent + ReAct]
    Sup -->|복잡 → 전문| Hand[Handoff Chain]
    Hand --> Risk{고위험?}
    Risk -->|예| HITL[HITL Approval]
    HITL --> Exec[실행]

LangGraph 예시 (다중 agent + state machine)

from langgraph.graph import StateGraph, END

class State(TypedDict):
    user_input: str
    intent: str
    result: str

def classify(state):
    state["intent"] = classify_intent(state["user_input"])
    return state

def payment(state):
    state["result"] = handle_payment(state["user_input"])
    return state

def refund(state):
    state["result"] = handle_refund(state["user_input"])
    return state

graph = StateGraph(State)
graph.add_node("classify", classify)
graph.add_node("payment", payment)
graph.add_node("refund", refund)

graph.set_entry_point("classify")
graph.add_conditional_edges(
    "classify",
    lambda s: s["intent"],
    {"payment": "payment", "refund": "refund", "other": END},
)
graph.add_edge("payment", END)
graph.add_edge("refund", END)

app = graph.compile()

흔한 함정

[!WARNING]

모든 query 에 ReAct = 단순 FAQ 도 3-step. 의도 분류 후 복잡한 것만.

Handoff 후 context 손실 = 사용자가 같은 정보 반복. handoff 시 summary 전달.

너무 많은 sub-agent = supervisor 가 분류 어려움. 5-7개 이내.

HITL 없이 critical action = 사고. 임계 정의 + 자동 승인 vs 인간.

[Voice AI] LLM Serving: vLLM, PagedAttention, continuous batching

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

LLM Serving = 자체 호스팅 LLM 을 낮은 TTFT + 높은 throughput 으로 제공. 음성 에이전트의 LLM 단계 지연 결정.

도구	특징
vLLM	PagedAttention, 표준. 한국에서도 압도적
TGI (Hugging Face)	안정, 옛 표준
SGLang	structured output 강함, 2024+
LMDeploy	InternLM, 중국
TensorRT-LLM	NVIDIA 전용, 최고 성능

PagedAttention

flowchart LR
    Q1[Request 1<br/>'안녕'] --> KV1[KV cache]
    Q2[Request 2<br/>'오늘 날씨'] --> KV2[KV cache]
    KV1 --> Page[Memory Pages (16 tokens 단위)]
    KV2 --> Page
    Page --> GPU[GPU memory]

기존 (LLaMA, TGI 옛)	PagedAttention (vLLM)
요청 시작 시 최대 길이 만큼 KV cache 예약	Page 단위 동적 할당
짧은 응답도 2K-32K 토큰 메모리	실제 사용 만큼만
GPU 메모리 심한 단편화	< 4% 낭비
Throughput 낮음	2-4x 향상

운영체제의 Virtual Memory + paging 의 LLM inference 적용. 모든 modern serving 의 기본.

Continuous Batching

flowchart TB
    Static["Static batching:<br/>요청 8개 모일 때까지 대기<br/>한 batch 끝날 때까지 다음 안 받음"]
    Cont["Continuous batching:<br/>매 step 마다 batch 재구성<br/>새 요청 즉시 합류, 완료된 거 즉시 빠짐"]
    Static --> Slow[GPU idle 많음, latency 높음]
    Cont --> Fast[GPU 100% 활용, latency 낮음]

step 단위 dynamic batching = vLLM, TGI 등의 2026 표준.

TTFT (Time-to-First-Token) vs TPS

flowchart LR
    Req[Request 도착] -->|prefill (전체 prompt 처리)| F1[First token]
    F1 -->|decode (1 토큰씩)| T2[Token 2]
    T2 -->|decode| T3[Token 3]
    Note["TTFT = prefill 시간<br/>TPS = decode 속도"]

지표	의미	목표
TTFT	첫 토큰까지	< 200ms (음성)
TPS	초당 토큰	> 50 tok/s
Throughput	동시 요청 처리	GPU 효율

음성 에이전트 = TTFT 가 결정적. sentence aggregator 가 첫 문장 받으면 TTS 시작.

SSE 스트리밍 (Server-Sent Events)

GET /v1/chat/completions
Accept: text/event-stream

data: {"choices": [{"delta": {"content": "안"}}]}\n\n
data: {"choices": [{"delta": {"content": "녕"}}]}\n\n
data: {"choices": [{"delta": {"content": "하세요"}}]}\n\n
data: [DONE]\n\n

from openai import AsyncOpenAI
client = AsyncOpenAI(base_url="http://localhost:8000/v1")

stream = await client.chat.completions.create(
    model="llama-3.1-8b-instruct",
    messages=messages,
    stream=True,
)

async for chunk in stream:
    delta = chunk.choices[0].delta.content
    if delta:
        sentence_aggregator.feed(delta)

자세한 SSE 는 [[SSE]] 의 일반.

vLLM 시작

pip install vllm

# OpenAI 호환 server
python -m vllm.entrypoints.openai.api_server \
    --model meta-llama/Llama-3.1-8B-Instruct \
    --max-model-len 8192 \
    --gpu-memory-utilization 0.9 \
    --enable-chunked-prefill \
    --enable-prefix-caching \
    --port 8000

옵션	의미
`--max-model-len`	최대 context
`--gpu-memory-utilization`	GPU 메모리 사용률 (0.9 권장)
`--enable-chunked-prefill`	긴 prompt 를 청크로 분할 (latency 균형)
`--enable-prefix-caching`	같은 prefix 의 KV cache 재사용 (system prompt!)
`--tensor-parallel-size N`	N GPU 분산
`--pipeline-parallel-size N`	pipeline 분산

Prefix Caching (system prompt 재사용)

flowchart LR
    Req1["Req 1: SYS+'안녕'"] --> Cache[Prefix Cache (SYS)]
    Req2["Req 2: SYS+'오늘'"] --> Cache
    Req3["Req 3: SYS+'주문'"] --> Cache
    Note["같은 system prompt 의 KV cache 재사용<br/>→ TTFT 60-90% 단축"]

모든 요청이 같은 긴 system prompt 면 prefix caching 으로 prefill 시간 거의 0. 음성 에이전트의 고정 페르소나 prompt 와 완벽 매칭.

Quantization

종류	메모리	정확도
FP16	100%	기준
FP8 (H100+)	50%	~99%
INT8 (smoothquant)	50%	~98%
INT4 (AWQ, GPTQ)	25%	~95%
INT4 + KV cache FP8	작음	~93%

# AWQ 4-bit 모델
python -m vllm.entrypoints.openai.api_server \
    --model TheBloke/Llama-3.1-8B-Instruct-AWQ \
    --quantization awq

자세한 quantization 은 [[quantization]] 참고.

모델 크기 vs 음성 적합성

모델	한국어	TTFT (8B GPU)	적합
Llama-3.1 8B Instruct	보통	150ms	일반
Llama-3.1 70B AWQ	우수	400ms	복잡 task
Qwen2.5 7B Instruct	우수	130ms	한국어 강함
EXAONE 3 7.8B	최우수 (한국어)	150ms	한국어 voice agent
Phi-3.5 mini (3.8B)	보통	60ms	edge, latency critical
GPT-4o-mini (API)	우수	200ms (API)	일반
Gemini Flash 2.0 (API)	우수	250ms (API)	일반

흔한 함정

[!WARNING]

prefix caching 없이 큰 system prompt = 매 요청 prefill 1초+. 활성화 필수.

streaming 안 함 = 응답 끝나길 기다림. 항상 stream=True.

GPU memory util 너무 높음 (0.95+) = OOM 위험. 0.85-0.9.

연속 batching 없는 옛 서빙 = throughput 1/5. vLLM 으로.

[Voice AI] Pipecat vs LiveKit Agents: 프레임워크 비교

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

2026 시점 voice agent 프레임워크 4가지 선택지:

	Pipecat	LiveKit Agents	Vapi / Retell	자체 구축
카테고리	OSS framework	OSS SFU + framework	Managed	직접
운영	self-host	self-host 또는 LiveKit Cloud	호스팅	self
학습 곡선	중간	중간	낮음	높음
비용	인프라만	인프라만 (LK Cloud 옵션)	비쌈 ($0.13-0.30/min)	인프라
유연성	높음	높음	낮음 (블랙박스)	최고
시간	1-2주	1-2주	1-2일	1-3개월

Pipecat

flowchart LR
    Frame[Frame] --> P1[Input Processor (mic)]
    P1 --> P2[VAD Processor]
    P2 --> P3[STT Processor]
    P3 --> P4[LLM Processor]
    P4 --> P5[Aggregator]
    P5 --> P6[TTS Processor]
    P6 --> P7[Output Processor (speaker)]

Frame 이 processor 파이프라인을 흐름. Linux pipe 의 기능적 추상. 컴포넌트 한 줄 교체.

from pipecat.pipeline.pipeline import Pipeline
from pipecat.services.deepgram import DeepgramSTTService
from pipecat.services.openai import OpenAILLMService
from pipecat.services.cartesia import CartesiaTTSService
from pipecat.transports.services.daily import DailyTransport
from pipecat.vad.silero import SileroVADAnalyzer

transport = DailyTransport(room_url, token, "Bot", DailyParams(
    audio_in_enabled=True,
    audio_out_enabled=True,
    vad_analyzer=SileroVADAnalyzer(),
))

pipeline = Pipeline([
    transport.input(),
    DeepgramSTTService(api_key="..."),
    OpenAILLMService(api_key="...", model="gpt-4o-mini"),
    CartesiaTTSService(api_key="...", voice_id="..."),
    transport.output(),
])

runner = PipelineRunner()
await runner.run(PipelineTask(pipeline))

Pipecat 의 Frame 종류

Frame	의미
`AudioRawFrame`	오디오 청크
`TextFrame`	텍스트
`TranscriptionFrame`	전사
`LLMResponseStartFrame` / `EndFrame`	LLM 응답 경계
`TTSStartFrame` / `EndFrame`	TTS 시작/종료
`UserStartedSpeakingFrame`	사용자 발화 시작
`UserStoppedSpeakingFrame`	종료
`InterruptionFrame`	끼어들기

Frame 종류 추가 = 새 processor 추가. 확장이 깔끔.

LiveKit Agents

flowchart TB
    User1["사용자 1"] -->|WebRTC| SFU[LiveKit SFU]
    User2["사용자 2"] -->|WebRTC| SFU
    SFU -->|Room API| Agent["Voice Agent<br/>(headless participant)"]
    Agent --> STT
    Agent --> LLM
    Agent --> TTS

LiveKit SFU 가 WebRTC + room 인프라. Agent 가 room 에 headless participant 로 합류 → 다중 사용자 회의 / 룸 기반 voice agent 자연스러움.

from livekit.agents import VoiceAssistant, AutoSubscribe, JobContext, WorkerOptions, cli
from livekit.agents.llm import ChatContext
from livekit.plugins import openai, silero, deepgram, cartesia

async def entrypoint(ctx: JobContext):
    await ctx.connect(auto_subscribe=AutoSubscribe.AUDIO_ONLY)

    initial_ctx = ChatContext().append(
        role="system",
        text="당신은 친절한 한국어 음성 어시스턴트입니다. 짧게 답하세요."
    )

    assistant = VoiceAssistant(
        vad=silero.VAD.load(),
        stt=deepgram.STT(language="ko"),
        llm=openai.LLM(model="gpt-4o-mini"),
        tts=cartesia.TTS(voice="...", language="ko"),
        chat_ctx=initial_ctx,
        min_endpointing_delay=0.5,
        allow_interruptions=True,
    )

    assistant.start(ctx.room)
    await assistant.aclose()

Pipecat vs LiveKit Agents 결정

flowchart TD
    Q1{시나리오}
    Q1 -->|1:1 콜봇, 전화| Pipecat
    Q1 -->|다중 사용자 방, WebRTC 우선| LK[LiveKit Agents]
    Q1 -->|화상 회의 + AI 참여자| LK
    Q1 -->|복잡한 frame 변환| Pipecat
    Q1 -->|이미 LiveKit SFU 운영| LK

	Pipecat	LiveKit Agents
Transport	Daily, Twilio, Plivo, FastAPI 등 다양	LiveKit SFU 중심
추상 단위	Frame + Processor	Function 기반
회의 / 룸	단순	강력 (Multi-participant)
Python	우선	Python + Node + Go
학습	약간 가파름	친절한 docs

Managed (Vapi, Retell)

flowchart LR
    You[당신] -->|시스템 프롬프트만| Vapi[Vapi / Retell]
    Vapi -->|호스팅 파이프라인| Tel[Twilio 전화]
    Vapi -->|기본 STT/LLM/TTS| Pipeline

	장점	단점
Vapi	5분 만에 PoC	블랙박스, $0.13-0.30/min
Retell	빠른 시작, 음성 좋음	동일, latency 가시성 낮음

Build vs Buy 기준 (Hamming AI 가이드)

flowchart TD
    Q{기준}
    Q -->|"월 < 10K 분"| Buy[Vapi / Retell]
    Q -->|"월 10-50K 분"| Mid[Pipecat / LiveKit (자체)]
    Q -->|"월 > 50K 분"| Build[자체 + 깊은 최적화]
    Q -->|"엄격한 컴플라이언스 (HIPAA, FINRA)"| Build
    Q -->|"500ms 미만 지연 필수"| Build
    Q -->|"기존 system 깊은 통합"| Build
    Build --> Save["최대 80% 비용 절감 가능"]

[!IMPORTANT] PoC = Vapi/Retell. 확장 시 → Pipecat/LiveKit 마이그레이션 흐름이 일반.

복원력 설계

flowchart TB
    Q[복원력 요소]
    Q --> Fail[Independent failure points: STT, LLM, TTS]
    Q --> Strat[전략]
    Strat --> Retry[Retry + backoff]
    Strat --> Fallback[Fallback (다른 vendor)]
    Strat --> Graceful[Graceful: "잠시 후 다시"]
    Strat --> Health["Health check + circuit breaker"]

각 단계 독립 실패 → 우아하게 처리. 자세한 건 [[retry-with-backoff]] / [[circuit-breaker]].

흔한 함정

[!WARNING]

Managed 만 사용 = 비용 폭증 + 가시성 0. 1000분+ 면 self-host.

Pipecat 의 Frame 무시 = 직접 콜백으로 짜다가 경합 / 순서 문제. Frame 모델 활용.

LiveKit 의 transcription frame = STT 결과가 partial vs final 분리 안 보임. 명시 처리.

자체 구축 시 turn detection = VAD 만으로 한계. 시맨틱 모델 필요. Pipecat / LK 가 내장한 이유.

[Voice AI] 음성 에이전트 아키텍처: Cascading / Streaming / S2S + Latency Budget

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

실시간 음성 AI 의 3가지 패턴. 각자 지연 vs 유연성 vs 비용 트레이드오프.

3 패턴 비교

flowchart TB
    subgraph Cascading["1. Cascading (순차)"]
        C1[STT] --> C2[LLM] --> C3[TTS]
        Note1["2-4초 지연 (직렬)"]
    end
    subgraph Streaming["2. Streaming (병행)"]
        S1[STT chunks] -.partial.-> S2[LLM streaming]
        S2 -.tokens.-> S3[TTS streaming]
        Note2["< 1초 지연 (병행)"]
    end
    subgraph S2S["3. Speech-to-Speech"]
        D1[Audio In] --> D2[Multimodal Model]
        D2 --> D3[Audio Out]
        Note3["< 300ms (직접 처리)"]
    end

	Cascading	Streaming	S2S
종단 지연	2-4초	< 1초	< 300ms
구현 난이도	쉬움	중간	어려움 (제약)
유연성	최고 (각 단계 교체)	높음	낮음 (벤더 lock)
비용	낮음	중간	높음
Function calling	OK	OK	제한
톤/감정 보존	X	X	예
한국어	모델 마다	모델 마다	일부 (Realtime API 한국어)
사용	MVP / 일반	프로덕션 표준	고급 UX

1. Cascading (순차)

sequenceDiagram
    User->>STT: 발화 (3초)
    Note over STT: 발화 종료 대기 + 전사 (500ms)
    STT->>LLM: 전체 텍스트
    Note over LLM: 응답 생성 (1500ms)
    LLM->>TTS: 전체 응답
    Note over TTS: 음성 합성 (800ms)
    TTS->>User: 음성 시작
    Note over User,TTS: 총: ~3초 지연

async def cascaded_pipeline(audio_url):
    transcript = await stt.transcribe(audio_url)   # 발화 끝나길 기다림
    response = await llm.chat(transcript)           # 전체 응답
    audio = await tts.synthesize(response)          # 전체 합성
    return audio

MVP 에는 OK. 프로덕션은 streaming 으로 진화.

2. Streaming (현재 표준)

sequenceDiagram
    User->>STT: 발화 (3초)
    par
        STT-->>LLM: partial "안녕"
        STT-->>LLM: partial "안녕하세요"
        STT-->>LLM: FINAL "안녕하세요, 오늘 회의"
        LLM-->>TTS: 토큰 "오늘은"
        LLM-->>TTS: 토큰 "수요일입니다"
        TTS-->>User: 오디오 청크 1
        TTS-->>User: 오디오 청크 2
    end
    Note over User: 음성 종료 후 < 1초 응답

async def streaming_pipeline(audio_stream):
    async for transcript_chunk in stt.stream(audio_stream):
        if transcript_chunk.is_final:
            async for token in llm.stream(transcript_chunk.text):
                sentence = aggregator.feed(token)
                if sentence:
                    async for audio_chunk in tts.stream(sentence):
                        yield audio_chunk

[!IMPORTANT] 모든 단계 스트리밍 + sentence aggregator. 2026 시점 프로덕션 음성 AI 의 표준.

3. Speech-to-Speech (S2S)

sequenceDiagram
    User->>Realtime: 오디오 stream (WebRTC / WS)
    Note over Realtime: GPT-4o / Gemini Live<br/>(직접 오디오 처리)
    Realtime-->>User: 오디오 stream (< 300ms)

모델	출시	한국어	특징
OpenAI Realtime API (GPT-4o)	2024-10	우수	WebRTC / WS, function calling 부분
Gemini Live (gemini-live-2.5)	2024-12	우수	Google AI Studio
Moshi (Kyutai)	OSS	영어	full-duplex, 자체 호스팅

[!CAUTION] S2S 의 function calling 제약 = enterprise 시스템 연동 어려움. function 이 필수면 cascading + streaming 채택. [arXiv 참조].

Latency Budget (지연 예산)

flowchart LR
    Mic["마이크 (사용자 발화 끝)"] -->|VAD endpointing 200-500ms| STT
    STT -->|"STT (100-500ms)"| LLM
    LLM -->|"LLM TTFT (200-2000ms)"| TTS
    TTS -->|"TTS TTFA (200-800ms)"| Speaker
    Speaker -->|<= 1000ms| User

단계	일반	최적
Network (Mic → Server)	30-100ms	20ms
VAD endpointing	500ms	200ms (시맨틱)
STT (final)	200-500ms	100ms
LLM TTFT (Time-to-First-Token)	500-2000ms	200ms
Sentence aggregation	50-200ms	0 (streaming)
TTS TTFB	200-800ms	90ms (Cartesia)
Network (Server → Speaker)	30-100ms	20ms
총	2-4초	< 700ms

[!IMPORTANT] 800ms 가 “로봇 같지 않게 느껴지는” 임계. 사람 평균 응답 300-500ms. 모든 단계 동시 최적화 필요.

단계별 최적화

flowchart TB
    Opt[지연 줄이기]
    Opt --> S1[STT: 시맨틱 endpointing, partial 안 기다림]
    Opt --> S2[LLM: 작은 모델, TTFT 최우선, KV-cache]
    Opt --> S3[TTS: streaming + Cartesia급 모델]
    Opt --> Net[Network: WebRTC < WebSocket < HTTP]
    Opt --> Hop[Hop 축소: 같은 region, edge]

결정 트리

flowchart TD
    Q1{지연 요구}
    Q1 -->|< 300ms 필수| S2S_check{Function calling 필수?}
    Q1 -->|< 1초 OK| Stream[Streaming pipeline]
    Q1 -->|2-3초 OK + MVP| Cascade[Cascading]
    S2S_check -->|아니오| S2S[S2S 모델]
    S2S_check -->|예| Stream

한국 시장 권장

시나리오	권장
콜봇 (상담)	Streaming: CLOVA STT + GPT-4o-mini + CLOVA Voice
고급 음성 AI	Streaming: Deepgram + GPT-4o + Cartesia
비용 절감	Cascading: Whisper + GPT-3.5 + Edge TTS
톤/감정 critical	S2S: GPT-4o Realtime

흔한 함정

[!WARNING]

STT/LLM/TTS 각자 다른 region = network hop 누적 → 500ms+. 같은 region.

batch 모델로 시작했다가 latency 못 맞춤 = 처음부터 streaming 모델.

LLM 응답 끝나길 기다리고 TTS 시작 = TTS 의 streaming 의미 없음.

VAD 없이 STT = STT 가 전사 못 끝남. 발화 종료 감지 필수.

[Voice AI] 음성 우선 프롬프트 + Function Calling + Structured Output

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

음성 우선 프롬프트 설계

음성 답변 = 귀로 듣는다. 텍스트 답변과 완전 다르게 짜야 한다.

flowchart LR
    Text["텍스트 답변 (긴 답변 OK)"] --> A1["**bold**, # 헤딩, 표"]
    Voice["음성 답변 (짧고 자연스럽게)"] --> A2["1-2 문장, 의문문으로 turn 넘김"]
    A1 --> Diff
    A2 --> Diff
    Diff{둘은 완전 다름}

음성 프롬프트의 핵심 원칙

원칙	의미
짧게	한 답변 1-2 문장. 50-80 글자
자연스럽게	”$5 = ‘오 달러’” (숫자 정규화 사전 정의)
마크다운 금지	`*`, `#`, `-` 등 모두 음성에 안 들어감*
listicle 분해	”1, 2, 3…” 대신 대화로 분배
turn 넘기기	질문으로 끝내거나 “도와드릴까요?”
에스컬레이션	”사람 상담원 연결해드릴까요?” 명시

SYSTEM_PROMPT = """
당신은 친절한 한국어 콜센터 상담원입니다.

응답 규칙:
- 한 응답은 *1-2 문장* 으로 짧게
- 자연스러운 구어체 사용 ("입니다" 보다 "이에요")
- 숫자는 풀어쓰기 (예: "100만 원" 보다 "백만 원")
- 마크다운, 영어 약어, 코드 사용 금지
- 모르는 정보면 "확인이 어렵네요. 사람 상담원 연결해드릴까요?"
- 답변 끝에 *질문* 으로 turn 을 사용자에게 넘김

페르소나:
- 침착하고 공감하는 톤
- 고객을 "고객님" 으로 호칭
- 절대 "AI" 라고 본인을 칭하지 말 것
"""

Function / Tool Calling

sequenceDiagram
    autonumber
    User->>Agent: "내 주문 상태 확인해줘"
    Agent->>LLM: prompt + tool definitions
    LLM-->>Agent: function_call: get_order_status(user_id=42)
    Agent->>API: GET /orders?user=42
    API-->>Agent: { status: "shipped", eta: "내일" }
    Agent->>LLM: tool_result
    LLM-->>Agent: "고객님 주문은 배송 중이며, 내일 도착 예정이에요."
    Agent->>TTS: 음성 합성
    TTS->>User: 음성 응답

OpenAI Function Calling

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_order_status",
            "description": "사용자의 주문 상태를 조회합니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "user_id": {"type": "integer", "description": "사용자 ID"},
                    "order_id": {"type": "string", "description": "주문 ID (선택)"}
                },
                "required": ["user_id"]
            }
        }
    },
    {
        "type": "function",
        "function": {
            "name": "transfer_to_human",
            "description": "사람 상담원에게 연결합니다",
            "parameters": {
                "type": "object",
                "properties": {
                    "reason": {"type": "string"},
                    "priority": {"type": "string", "enum": ["low", "high"]}
                },
                "required": ["reason"]
            }
        }
    }
]

response = await client.chat.completions.create(
    model="gpt-4o-mini",
    messages=messages,
    tools=tools,
    tool_choice="auto",
    stream=True,
)

병렬 Function Calling

# 같은 응답에서 여러 함수 동시 호출 가능
{
  "tool_calls": [
    { "id": "call_1", "function": { "name": "get_weather", "arguments": "..." } },
    { "id": "call_2", "function": { "name": "get_traffic", "arguments": "..." } }
  ]
}

# 병렬 실행
results = await asyncio.gather(
    get_weather(...),
    get_traffic(...),
)

직렬 보다 수배 빠름. 독립 호출이면 활용.

결과를 대화에 자연스럽게

@function_tool
async def get_order_status(user_id: int) -> dict:
    order = await db.get_order(user_id)
    return {
        "status": order.status,
        "eta": order.eta,
        # 함수 결과는 *데이터* 만. *음성 문장* 은 LLM 이 합성
    }

# 잘못된 예: 함수가 문장 반환
@function_tool
async def get_order_status_bad(user_id: int) -> str:
    order = await db.get_order(user_id)
    return f"주문 {order.id} 는 {order.status} 상태이며 ETA {order.eta} 입니다."
    # ← TTS 가 "ETA" 를 영어로 발음하거나 어색

Structured Output

LLM 응답을 JSON schema 강제:

class IntentExtraction(BaseModel):
    intent: Literal["order_status", "refund", "complaint", "transfer", "other"]
    user_id: Optional[int]
    order_id: Optional[str]
    urgency: Literal["low", "normal", "high"]

response = await client.chat.completions.parse(
    model="gpt-4o-mini",
    messages=[{"role": "user", "content": user_text}],
    response_format=IntentExtraction,
)

intent = response.choices[0].message.parsed
# intent.intent == "order_status"  ← 타입 안전

슬롯 채우기 (Slot Filling)

# 사용자가 부분 정보만 주면 → 부족한 슬롯 묻기
class BookingRequest(BaseModel):
    restaurant: Optional[str]
    date: Optional[str]
    party_size: Optional[int]
    is_complete: bool = False

# 첫 발화: "내일 5명 예약하고싶어"
# extracted: { date: "내일", party_size: 5, restaurant: None, is_complete: false }

# LLM 이 부족한 정보 *질문*
if not extracted.restaurant:
    response = "어느 식당으로 예약 도와드릴까요?"

페르소나 일관성

PERSONA = """
이름: 민지
성격: 친절, 차분, 약간 유머
역할: 카페 음성 주문 도우미
말투: 격식 있는 존댓말 ("이에요", "괜찮으세요?")
금지: 비속어, 정치/종교, 의료 조언
"""

SYSTEM = f"""
{PERSONA}

응답 규칙:
- 항상 페르소나 일관성 유지
- 메뉴 외 질문은 정중히 거절 + 본업으로 유도
"""

흔한 함정

[!WARNING]

시스템 프롬프트가 길고 마크다운 = TTS 가 안 읽지만, LLM 의 응답이 마크다운 따라함. 출력 형식 명시.

숫자 발음 = “1500000원” → “일오영영영영영원”. 별도 정규화 또는 SSML.

function 결과로 긴 텍스트 반환 = LLM 이 그대로 읽음. 데이터만.

tool calling 중 interruption 허용 = DB write 중간에 끊김. disallow_interruptions.

[Voice AI] Voice RAG: 지연 병목 + 예측적 프리페치

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Voice RAG = 음성 에이전트에 RAG (Retrieval-Augmented Generation) 결합. 벡터 DB 조회 가 지연 누적 의 큰 원인이 되므로 예측적 프리페치 같은 패턴 필수.

기본 흐름

sequenceDiagram
    User->>STT: 발화
    STT->>RAG: 질문 텍스트
    RAG->>Embed: 임베딩
    Embed->>VectorDB: kNN search
    VectorDB-->>RAG: top-K chunks
    RAG->>LLM: prompt + chunks
    LLM-->>TTS: 응답 토큰
    TTS-->>User: 음성

각 단계가 직렬. RAG 추가 200-1000ms → 종단 지연 2초+.

지연 분해

단계	일반	최적
Embedding	50-200ms	30ms (로컬 small 모델)
Vector DB query	30-200ms	10ms (Redis vector, ES kNN)
Re-ranking	100-500ms	50ms (cross-encoder small)
LLM prompt assembly	5-20ms	5ms
RAG overhead	200-1000ms	< 100ms

예측적 프리페치 (Speculative Retrieval)

flowchart LR
    Partial[Partial transcript] --> Predict[가능 의도 예측]
    Predict --> Pre[미리 fetch (병렬)]
    Final[Final transcript] --> Match{예측 매칭?}
    Match -->|예| UsePre[프리페치 결과 사용]
    Match -->|아니오| Re[다시 fetch]

class SpeculativeRAG:
    def __init__(self):
        self.prefetched: Dict[str, Future] = {}

    async def on_partial(self, partial: str):
        """partial 받자마자 예측 fetch 시작"""
        if len(partial.split()) < 3:
            return   # 너무 짧으면 skip

        # 이미 fetch 중인 것이 있고 유사하면 재사용
        if any(self._similar(partial, k) for k in self.prefetched):
            return

        # 미리 fetch (병렬)
        fut = asyncio.create_task(self._retrieve(partial))
        self.prefetched[partial] = fut

    async def on_final(self, final: str) -> List[Chunk]:
        """final 시 prefetched 결과 활용 또는 새로 fetch"""
        # 가장 유사한 prefetched 찾기
        best = max(self.prefetched.keys(),
                   key=lambda k: self._similarity(k, final),
                   default=None)
        if best and self._similarity(best, final) > 0.85:
            return await self.prefetched[best]
        return await self._retrieve(final)

partial 받자마자 추측 fetch → final 시 대부분 즉시 사용 가능. RAG overhead → 0 에 가깝게.

캐시 계층

flowchart TB
    Q[Query] --> L1[L1: in-memory recent (LRU)]
    L1 -.miss.-> L2[L2: Redis semantic cache]
    L2 -.miss.-> L3[L3: Vector DB]
    L3 --> Pop[populate L2 + L1]

Semantic Cache

class SemanticCache:
    """비슷한 질문의 결과 재사용"""
    def __init__(self, similarity_threshold=0.92):
        self.cache = {}   # embedding → result
        self.threshold = similarity_threshold

    async def get(self, query: str):
        emb = await embed(query)
        for cached_emb, result in self.cache.items():
            sim = cosine_similarity(emb, cached_emb)
            if sim > self.threshold:
                return result
        return None

자세한 건 [[Redis Vector Search]] 의 semantic cache.

RAG 인덱스 선택 (음성 환경)

	Pinecone	Redis Vector	ES kNN	Qdrant
Latency (kNN)	30-100ms	5-20ms	20-50ms	10-30ms
운영	managed	익숙	익숙	중간
Hybrid (BM25 + vector)	X	별도	우수 (RRF)	가능

음성 에이전트 + 한국어 hybrid search = ElasticSearch kNN + nori 가 강력.

청크 전략 (음성 친화)

# 일반 RAG: 큰 청크 (500-1000 tokens)
# 음성 RAG: *짧은 청크* (100-300 tokens) → LLM 응답 짧게 유도

def chunk_for_voice(doc: str) -> list[str]:
    """문장 단위 + 의미 단위 분할"""
    sentences = nltk.sent_tokenize(doc, language='korean')
    chunks = []
    cur = ""
    for s in sentences:
        if len(cur) + len(s) > 300:
            chunks.append(cur)
            cur = s
        else:
            cur += " " + s
    if cur:
        chunks.append(cur)
    return chunks

Re-ranking 의 trade-off

flowchart LR
    VS[Vector Search top 50] --> Re[Re-ranker]
    Re --> Top5[top 5]
    Re --> Cost[+100-500ms]

정확도 ↑ vs 지연 ↑. 음성 에이전트는 작은 cross-encoder (Cohere rerank-v3 light, BAAI bge-reranker-base) 권장.

흔한 함정

[!WARNING]

RAG 매 turn 동기 fetch = 매 응답 200-1000ms 증가. 예측적 프리페치.

거대 청크 = LLM 응답이 길어짐. 짧은 청크.

Cross-encoder rerank 무조건 = 500ms+ 부담. trade-off 결정.

결과 그대로 prompt = 토큰 폭증. 요약 또는 selection.

[Algorithm] Karatsuba 곱셈: O(n²) 벽을 깬 분할 정복

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Karatsuba 알고리즘 은 두 큰 정수의 곱셈 을 분할 정복 으로 풀어 O(n^log₂3) ≈ O(n^1.585) 시간에 처리하는 알고리즘. 1962년 Anatoly Karatsuba (당시 23세 학생) 가 Kolmogorov 의 “곱셈은 Ω(n²) 이다” 추측을 반박 한 결과물.

[!IMPORTANT] “곱셈은 더 빨라질 수 없다” 라고 믿어진 수십 년의 추측을 깬 알고리즘. 분할 정복으로 산술 자체를 가속할 수 있다 는 패러다임 전환. 이후 Toom-Cook, FFT 기반 Schönhage-Strassen, 2019 Harvey-Hoeven 의 O(n log n) 으로 이어진다.

동기: O(n²) 의 한계

n자리 정수 곱셈을 손으로 하면 각 자리마다 모든 자리와 곱셈 → O(n²):

        1234
      × 5678
      ──────
        9872     ← 1234 × 8
       8638      ← 1234 × 7
      7404       ← 1234 × 6
     6170        ← 1234 × 5
     ──────
     7006652

n	O(n²) 연산
10	100
100	10,000
1,000	1,000,000
1,000,000 (백만 자리)	10¹² (불가능)

암호학 (RSA, ECC), 컴퓨터 대수 시스템 (Mathematica, SymPy), π 계산 등에서 수백만 자리 곱셈 필요. O(n²) 으로는 불가능.

핵심 아이디어: 3번의 곱셈으로 분해

{}

두 n자리 수 x, y 를 반으로 분할 (m = n/2 자리):

x = a · Bᵐ + b      (a = 상위 m자리, b = 하위 m자리)
y = c · Bᵐ + d

B = 진수 (보통 10, 또는 2³² 같은 워드 크기).

전통 곱셈 (4번):

x · y = (a·Bᵐ + b)(c·Bᵐ + d)
      = ac · B²ᵐ + (ad + bc) · Bᵐ + bd

→ ac, ad, bc, bd 4번의 (n/2)자리 곱셈 + 덧셈/시프트.

Karatsuba 의 통찰:

(a + b)(c + d) = ac + ad + bc + bd
            ad + bc = (a+b)(c+d) - ac - bd

→ ad + bc 를 별도 곱셈 없이 다른 결과의 조합 으로 얻는다!

z₂ = a · c
z₀ = b · d
z₁ = (a + b)(c + d) - z₂ - z₀     ← ad + bc

x · y = z₂ · B²ᵐ + z₁ · Bᵐ + z₀

3번의 (n/2)자리 곱셈 + 몇 번의 덧셈/뺄셈/시프트.

복잡도 분석

flowchart TB
    T["T(n)"]
    T -->|3 곱셈| T1["T(n/2)"]
    T -->|+ O(n) 덧셈| Add[덧셈]
    T -->|3 곱셈| T2["T(n/2)"]
    T -->|3 곱셈| T3["T(n/2)"]
    T1 -->|3 곱셈| T4["T(n/4)"]
    T1 -->|3 곱셈| T5["T(n/4)"]
    T1 -->|3 곱셈| T6["T(n/4)"]

재귀 관계:

T(n) = 3 · T(n/2) + O(n)

Master Theorem (a=3, b=2, f(n)=O(n^1)):

log_b(a) = log₂3 ≈ 1.585
n^log_b(a) = n^1.585 > n^1 = f(n)

→ T(n) = Θ(n^log₂3) ≈ Θ(n^1.585)

시간 복잡도 비교

n	Naive	Karatsuba	FFT	Naive / Karatsuba
10	100	38	33	2.6×
100	10K	1.4K	664	7.2×
1K	1M	50K	10K	20×
10K	100M	1.8M	133K	55×
100K	10B	66M	1.7M	152×
1M	1T	2.4B	20M	416×

n = 1M 자리 (RSA-4096 같은 거대 정수) 에서 Karatsuba 는 400배 이상 빠르다.

알고리즘 (의사 코드)

function karatsuba(x, y):
  # Base case: 작은 수는 일반 곱셈
  if x < BASE or y < BASE:
    return x * y

  n = max(digits(x), digits(y))
  m = ⌈n / 2⌉
  B^m = base^m  # 시프트 단위

  # 1. Divide: x, y 를 각각 상/하위로 분할
  a, b = divmod(x, B^m)   # x = a · B^m + b
  c, d = divmod(y, B^m)   # y = c · B^m + d

  # 2. Conquer: 3번의 재귀 호출 (4번 → 3번)
  z2 = karatsuba(a, c)
  z0 = karatsuba(b, d)
  z1 = karatsuba(a + b, c + d) - z2 - z0

  # 3. Combine: 시프트 + 덧셈
  return z2 · B^(2m) + z1 · B^m + z0

재귀 트리 시각화

{}

위는 일반 분할 정복 의 동작. Karatsuba 도 같은 흐름 이지만 2개가 아닌 3개로 분기.

flowchart TB
    Root["xy (n자리)"]
    Root --> N1["z₂ = a·c<br/>(n/2자리)"]
    Root --> N2["z₀ = b·d<br/>(n/2자리)"]
    Root --> N3["(a+b)(c+d)<br/>(n/2자리)"]
    N1 --> N1a["..."]
    N1 --> N1b["..."]
    N1 --> N1c["..."]
    N2 --> N2a["..."]
    N2 --> N2b["..."]
    N2 --> N2c["..."]
    N3 --> N3a["..."]
    N3 --> N3b["..."]
    N3 --> N3c["..."]

각 노드가 3개로 분기. 깊이 log₂n. 총 노드 수 3^log₂n = n^log₂3.

단계별 추적: 1234 × 5678

입력: x = 1234, y = 5678, n = 4, m = 2, B^m = 100

분할:
  a = 12, b = 34   (1234 = 12·100 + 34)
  c = 56, d = 78   (5678 = 56·100 + 78)

3번의 재귀:
  z₂ = karatsuba(12, 56) = 672
  z₀ = karatsuba(34, 78) = 2652
  (a+b)(c+d) = karatsuba(46, 134) = 6164
  z₁ = 6164 - 672 - 2652 = 2840

조합:
  xy = 672 · 10000 + 2840 · 100 + 2652
     = 6720000 + 284000 + 2652
     = 7006652  ✓

검산: 1234 × 5678 = 7006652  ✓

구현 (5개 언어)

<CodeWithOutput outputLanguage=“text” outputLabel=“동일” title=“Karatsuba: 같은 알고리즘, 5개 언어” variants={[ { label: ‘python’, language: ‘python’, code: `def karatsuba(x: int, y: int) -> int: # base case if x < 10 or y < 10: return x * y

n = max(len(str(x)), len(str(y)))
m = n // 2
B = 10 ** m

a, b = divmod(x, B)
c, d = divmod(y, B)

z2 = karatsuba(a, c)
z0 = karatsuba(b, d)
z1 = karatsuba(a + b, c + d) - z2 - z0

return z2 * (B * B) + z1 * B + z0

print(karatsuba(1234, 5678)) print(karatsuba(12345678, 87654321)), }, { label: 'javascript', language: 'javascript', code: // BigInt 로 임의 크기 정수 지원 function karatsuba(x, y) { if (x < 10n || y < 10n) return x * y;

const n = Math.max(x.toString().length, y.toString().length); const m = BigInt(Math.floor(n / 2)); const B = 10n ** m;

const a = x / B, b = x % B; const c = y / B, d = y % B;

const z2 = karatsuba(a, c); const z0 = karatsuba(b, d); const z1 = karatsuba(a + b, c + d) - z2 - z0;

return z2 * (B * B) + z1 * B + z0; }

console.log(karatsuba(1234n, 5678n).toString()); console.log(karatsuba(12345678n, 87654321n).toString());, }, { label: 'java', language: 'java', code: import java.math.BigInteger;

class Karatsuba { static BigInteger karatsuba(BigInteger x, BigInteger y) { final BigInteger TEN = BigInteger.TEN; if (x.compareTo(TEN) < 0 || y.compareTo(TEN) < 0) return x.multiply(y);

int n = Math.max(x.toString().length(), y.toString().length());
int m = n / 2;
BigInteger B = TEN.pow(m);

BigInteger[] xs = x.divideAndRemainder(B);
BigInteger[] ys = y.divideAndRemainder(B);
BigInteger a = xs[0], b = xs[1];
BigInteger c = ys[0], d = ys[1];

BigInteger z2 = karatsuba(a, c);
BigInteger z0 = karatsuba(b, d);
BigInteger z1 = karatsuba(a.add(b), c.add(d))
                  .subtract(z2).subtract(z0);

return z2.multiply(B.pow(2))
  .add(z1.multiply(B))
  .add(z0);

}

public static void main(String[] args) { System.out.println(karatsuba( BigInteger.valueOf(1234), BigInteger.valueOf(5678))); } }, }, { label: 'rust', language: 'rust', code: // num-bigint crate 사용 use num_bigint::BigInt; use num_traits::Zero;

fn karatsuba(x: &BigInt, y: &BigInt) -> BigInt { let ten = BigInt::from(10); if x < &ten || y < &ten { return x * y; }

let n = x.to_string().len().max(y.to_string().len());
let m = n / 2;
let b = BigInt::from(10).pow(m as u32);

let (a, b_lo) = (x / &b, x % &b);
let (c, d) = (y / &b, y % &b);

let z2 = karatsuba(&a, &c);
let z0 = karatsuba(&b_lo, &d);
let z1 = karatsuba(&(&a + &b_lo), &(&c + &d)) - &z2 - &z0;

z2 * b.pow(2) + z1 * &b + z0

}, }, { label: 'go', language: 'go', code: package main

import ( “fmt” “math/big” )

func karatsuba(x, y *big.Int) *big.Int { ten := big.NewInt(10) if x.Cmp(ten) < 0 || y.Cmp(ten) < 0 { return new(big.Int).Mul(x, y) }

n := max(len(x.String()), len(y.String()))
m := n / 2
B := new(big.Int).Exp(ten, big.NewInt(int64(m)), nil)

a, b := new(big.Int).DivMod(x, B, new(big.Int))
c, d := new(big.Int).DivMod(y, B, new(big.Int))

z2 := karatsuba(a, c)
z0 := karatsuba(b, d)
sum := karatsuba(new(big.Int).Add(a, b),
                 new(big.Int).Add(c, d))
z1 := new(big.Int).Sub(sum, z2)
z1.Sub(z1, z0)

// z2*B^2 + z1*B + z0
res := new(big.Int).Mul(z2, new(big.Int).Mul(B, B))
res.Add(res, new(big.Int).Mul(z1, B))
res.Add(res, z0)
return res

}, }, ]} output={1234 × 5678 = 7006652 12345678 × 87654321 = 1082152022374638`} />

동작 흐름 (sequence)

sequenceDiagram
    autonumber
    participant Caller
    participant K as karatsuba(1234, 5678)
    participant K1 as karatsuba(12, 56)
    participant K2 as karatsuba(34, 78)
    participant K3 as karatsuba(46, 134)

    Caller->>K: 호출
    K->>K: 분할: a=12, b=34, c=56, d=78, m=2
    K->>K1: 재귀 1 (z₂)
    K1-->>K: 672
    K->>K2: 재귀 2 (z₀)
    K2-->>K: 2652
    K->>K3: 재귀 3 ((a+b)(c+d))
    K3-->>K: 6164
    K->>K: z₁ = 6164 - 672 - 2652 = 2840
    K->>K: 조합: 672·10000 + 2840·100 + 2652
    K-->>Caller: 7006652

왜 3 곱셈 이 2 덧셈 보다 가치 있는가?

flowchart TB
    Tradeoff[1번의 곱셈 = 매우 비쌈<br/>1번의 덧셈/뺄셈 = 매우 쌈]
    Naive[Naive: 4 곱셈 + 3 덧셈]
    Karatsuba[Karatsuba: 3 곱셈 + 4 덧셈/뺄셈]
    Tradeoff --> Win[곱셈 1개 절감 >> 덧셈 1개 추가 비용]
    Naive --> Win
    Karatsuba --> Win

n자리 곱셈 = O(n²). n자리 덧셈 = O(n). 큰 n 에서:

4M(n/2) + 3A(n/2)   →  4 · (n/2)² + 3 · (n/2)   ≈  n²
3M(n/2) + 4A(n/2)   →  3 · (n/2)² + 4 · (n/2)   ≈  0.75n²

비율 0.75, 한 단계당. 재귀 깊이 log₂n 곱하면 → n^1.585

Recursion 깊이의 직관

{}

재귀 호출 = 콜 스택 누적. Karatsuba 의 재귀 깊이 = log₂n. n = 10⁶ 면 20단계. 작음.

실전: 언제 Karatsuba?

flowchart TD
    Q1{n이 얼마나 큼?}
    Q1 -->|"n < 100자리"| Naive[Naive O(n²) 권장<br/>(상수 작아 더 빠름)]
    Q1 -->|"100 < n < 10K"| Karat[Karatsuba]
    Q1 -->|"10K < n < 100K"| Toom[Toom-Cook 3, 4]
    Q1 -->|"n > 100K"| FFT[Schönhage-Strassen<br/>또는 FFT]
    Q1 -->|"천만 자리 이상"| HH[Harvey-Hoeven<br/>O(n log n) (2019)]

알고리즘	시간	사용 임계 (GMP)
학교 곱셈	O(n²)	n < ~80 (limb)
Karatsuba	O(n^1.585)	~80 ≤ n < ~450
Toom-Cook 3-way	O(n^1.465)	~450 ≤ n < ~1500
Toom-Cook 4, 5, 6-way	약간 더 빠름	다음 단계
Schönhage-Strassen	O(n log n log log n)	n > ~3000
Harvey-Hoeven (2019)	O(n log n)	이론 (실용성 아직)

[!IMPORTANT] 작은 n 에서는 Naive 가 더 빠르다. Karatsuba 의 상수가 큼 (재귀 + 덧셈/뺄셈 + 메모리 할당). GMP 같은 라이브러리는 자동으로 임계값 결정.

자주 보는 함정

[!WARNING]

(a+b)(c+d) 의 자리수 증가 = m+1 자리 가 될 수 있다 (캐리). 메모리 / 재귀 base case 처리 주의.

Base case 너무 작게 = 재귀 오버헤드 폭증. n < 32 같은 적절한 임계.

음수 부호 처리 = a+b, c+d 모두 양수면 OK. 부호 있는 정수면 별도 처리.

자리수 균등 분할 = m = ⌈n/2⌉ 와 n - m 비균등 분할. 큰 쪽의 자리수에 맞춤.

활용 영역

flowchart LR
    Use[Karatsuba 활용]
    Use --> RSA["RSA / ECC<br/>(수천 자리 정수)"]
    Use --> Crypto["암호학 라이브러리<br/>(OpenSSL, BoringSSL)"]
    Use --> BigInt["언어 BigInt<br/>(Python int, JS BigInt, Java BigInteger)"]
    Use --> Pi["π 계산<br/>(수십억 자리)"]
    Use --> Poly["다항식 곱셈<br/>(같은 원리)"]
    Use --> Matrix["Strassen 행렬 곱셈<br/>(비슷한 아이디어)"]

Strassen 행렬 곱셈 (1969) 도 같은 패러다임: 8개 곱셈을 7개로 줄임 → O(n^log₂7) ≈ O(n^2.807). Karatsuba 의 후예.

다항식 곱셈으로의 일반화

Karatsuba 는 다항식 곱셈 으로 자연 일반화:

P(x) = a·x + b
Q(x) = c·x + d
P(x)·Q(x) = ac·x² + (ad+bc)·x + bd

정수 곱셈은 x = B (진수) 인 다항식 곱셈의 평가. 다항식 곱셈을 빠르게 풀면 정수 곱셈도 빨라진다.

{}

{}

FFT (Fast Fourier Transform) 도 다항식 곱셈 의 분할 정복. Karatsuba 의 점근적 후계자. 자세한 건 [[fft-ntt]].

역사적 의의

gantt
    title 곱셈 알고리즘의 진화
    dateFormat YYYY
    axisFormat %Y

    section 추측의 시대
    Kolmogorov: 곱셈은 Ω(n²) (1956) :milestone, k1, 1956, 1d

    section Karatsuba
    Karatsuba: O(n^1.585) (1960 발견, 1962 출판) :a1, 1960, 2y

    section 가속
    Toom-Cook (1963)         :a2, 1963, 1y
    Schönhage-Strassen (1971) :a3, 1971, 1y
    Fürer (2007 O(n log n 2^O(log* n))) :a4, 2007, 1y

    section 최종
    Harvey-Hoeven O(n log n) (2019) :milestone, hh, 2019, 1d

1960년 Moscow State University 의 세미나에서 Kolmogorov 가 추측 발표 → Karatsuba 가 1주일 안에 반박 해법 제시. Kolmogorov 가 발표는 본인 이름이 아니라 Karatsuba 의 이름으로 진행. 학문적 겸손의 표본.

참고

공식: Karatsuba 1962 (원논문)
GMP threshold: Multiplication Algorithms
2019 Harvey-Hoeven: Integer multiplication in time O(n log n)
CLRS Introduction to Algorithms, “Divide and Conquer” 챕터

비트셋 LCS (Bitset LCS)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Bitset LCS 는 두 문자열 A, B 의 최장 공통 부분 수열 (LCS) 길이를 O(NM/w) 시간에 구하는 기법. 표준 LCS DP 의 O(NM) 를 비트 병렬 (bit-parallel) 로 w=64 배 가속.

w = CPU word size (64). std::bitset 또는 64-bit 정수로 DP 행을 표현해, 한 번에 64 개 DP 전이를 처리.

문제 상황과 동기

표준 LCS DP 는 O(NM) 시간. N = M = 10^5 이면 10^10 연산으로 불가.

naive DP: 2차원 테이블 채우기. O(NM), N=M=10^4 에서 10^8 로 간당간당.
bitset LCS: PyPy 에서 bitset 을 정수로 구현, O(NM/64). N=M=10^5 도 1.5 초 내.

핵심 통찰: LCS 점화식의 if A[i-1] == B[j-1] 부분은 비트 AND + shift 로 한 번에 처리. max(prev, curr-1) 은 비트 OR + mask 로 표현.

Allison-Dix 공식

S[i] = A[0..i] 와 B 의 전체 LCS 길이가 증가하는 위치 집합. 이를 비트셋 M[i] 로 관리.

// 각 문자 c 에 대한 비트마스크 prec[c] = B 에서 c 의 위치들
// DP 는 bitset 연산으로:
for i in 1..N:
    x = prec[A[i-1]] | M[i-1]
    M[i] = M[i-1] | (x - ((x - M[i-1]) & ~x)의 MSB 조작)

실제 구현은 더 간단:

u = M[i-1] | prec[A[i-1]]
v = M[i-1] << 1 | 1
M[i] = M[i-1] | ((u - v) & ~u)

결과 LCS 길이 = popcount(M[N]).

알고리즘

bitset_lcs(A, B):
    N = len(A), M = len(B)
    prec[0..MAX_CHAR] = 0  // 각 문자의 B 내 위치 비트셋
    for j in 0..M-1:
        prec[B[j]] |= (1 << j)

    bitset cur = 0
    for i in 0..N-1:
        u = cur | prec[A[i]]
        v = (cur << 1) | 1
        cur |= ((u - v) & ~u)

    return popcount(cur)  // LCS 길이

핵심 트릭: (u - v) & ~u 는 u 와 v 의 LCS 전이를 한 연산에 계산. 자세한 증명은 Allison-Dix (1986) 참고.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Bitset LCS O(NM/64), Hyyro/Allison-Dix #include <bits/stdc++.h> using namespace std; using ull = unsigned long long;

int lcs_bitset(const string& a, const string& b) { int n = a.size(), m = b.size(); vector prec(26, 0); for (int j = 0; j < m; j++) prec[b[j]-‘A’] |= (1ULL << j);

ull cur = 0;
for (int i = 0; i < n; i++) {
    ull u = cur | prec[a[i]-'A'];
    ull v = (cur << 1) | 1;
    cur |= ( (u - v) & ~u );
}
return __builtin_popcountll(cur);

}

int main() { string a, b; cin >> a >> b; cout << lcs_bitset(a, b) << “\n”; }, }, { language: "python", label: "Python", code: # Bitset LCS using Python int as bitset def lcs_bitset(a: str, b: str) -> int: n, m = len(a), len(b) # prec[char] = bitmask of positions in b prec = [0] * 26 for j, ch in enumerate(b): prec[ord(ch) - 65] |= 1 << j

cur = 0
for i in range(n):
    u = cur | prec[ord(a[i]) - 65]
    v = (cur << 1) | 1
    cur |= ( (u - v) & ~u )
return cur.bit_count()

a = input().strip() b = input().strip() print(lcs_bitset(a, b)), }, { language: "java", label: "Java", code: // Bitset LCS - Java long[] bitset for longer strings

public class Main { static int lcsBitset(String a, String b) { int n = a.length(), m = b.length(); long[] prec = new long[26]; for (int j = 0; j < m; j++) prec[b.charAt(j)-‘A’] |= (1L << j);

    long cur = 0;
    for (int i = 0; i < n; i++) {
        long u = cur | prec[a.charAt(i)-'A'];
        long v = (cur << 1) | 1;
        cur |= ( (u - v) & ~u );
    }
    return Long.bitCount(cur);
}

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    String a = br.readLine();
    String b = br.readLine();
    System.out.println(lcsBitset(a, b));
}

}, }, ]} cases={[ { label: "기본 LCS", input: ABCBDAB BDCAB, output: 4, }, { label: "긴 문자열 (알파벳 26 종)", input: ABCDEFGHIJKLMNOPQRSTUVWXYZ ZYXWVUTSRQPONMLKJIHGFEDCBA, output: 1, }, { label: "같은 문자열", input: HELLOWORLD HELLOWORLD, output: 10`, }, ]} />

복잡도

항목	값
시간 (최선)	O(NM/w)
시간 (평균)	O(NM/w)
시간 (최악)	O(NM/w)
공간	O(Σ + M/w) (알파벳 개수 + 결과 bitset)
w	CPU word size (64)

표준 DP O(NM) 대비 약 64 배 빠름. N=M=10^5 에서 10^10 -> 1.5x10^8 연산으로 실용적.

변형

w-bit 한계 돌파

M > 64 이면 unsigned long long[] 배열로 bitset 확장. (256-bit, 512-bit) 벡터 명령어 (SIMD) 로 더 가속 가능.

Longest Common Substring

bitset 기법은 substring (연속) 에도 적용 가능. shift + AND 로 공통 부분 문자열 탐색.

Edit Distance

비슷한 bit-parallel 기법 (myers_diff) 으로 edit distance O(NM/w) 계산.

함정

1. 알파벳 크기

prec 배열은 알파벳 (또는 문자 집합) 만큼. 대문자 26 개면 충분하지만, 아스키 전체면 더 큰 배열 필요.

2. shift overflow

cur << 1 이 64 비트 넘으면 상위 비트 손실. M=64 이면 (cur << 1) 에서 MSB 가 carry out 되지 않도록 M < 64 로 제한하거나 bitset 배열 사용.

3. traceback 불가

bitset LCS 는 길이만 O(1) 에 구함. 수열 복원 필요시 [[Hirschberg|Hirschberg]] 또는 표준 DP traceback.

4. `(u - v) & ~u` 의미

이 수식이 한 번에 LCS 전이를 표현함. 직관적이지 않으므로 필요시 논문 참고. 틀리면 계산이 훨씬 더 빨라지거나 (의미 없는 값) 느려짐.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 9251	LCS	-	kokoa-lab
BOJ 9252	LCS 2 (traceback)	-	kokoa-lab
BOJ 1958	LCS 3	-	kokoa-lab

참고

[[LCS|최장 공통 부분 수열 (LCS)]]
[[Hirschberg|Hirschberg (O(N) 메모리 LCS)]]
[[Bitset Optimization|비트셋 최적화]]
Allison & Dix, A bit-string longest-common-subsequence algorithm (1986)

덱 활용 구간 최댓값 트릭 (Monotonic Deque Trick)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

덱 트릭 (Deque Trick) 은 덱 (double-ended queue) 에 원소의 인덱스를 단조로운 값 순서 로 유지해, 슬라이딩 윈도우의 최댓값 또는 최솟값을 O(N) 에 구하거나, DP 전이에서 일정 범위의 후보 최적값을 O(1) amortized 로 찾는 최적화 기법.

문제 상황과 동기

슬라이딩 윈도우 최댓값

크기 K 인 슬라이딩 윈도우가 배열을 지나갈 때, 각 위치에서의 최댓값을 Q 번 묻는다.

naive: 매 윈도우마다 K 개 순회. O(NK). N=10^6, K=10^5 면 10^11.
deque trick: 각 원소가 덱에 push/pop 되는 횟수 합 = O(N). 전체 O(N).

핵심 통찰: 새로 들어온 값보다 작은 (최댓값 기준) 값들은 앞으로 절대 최댓값이 될 수 없으므로 덱에서 제거해도 안전하다. 윈도우를 벗어난 값도 제거한다. 이렇게 하면 덱은 항상 내림차순 (최댓값 기준) 이 유지된다.

DP 최적화

다음 형태의 DP 에서 사용한다.

dp[i] = max / min (dp[j] + cost(j, i))   (i - K <= j < i)

여기서 cost(j, i) 가 j 만의 함수 + i 만의 함수 로 분리 가능하고 (cost(j, i) = A[j] + B[i]), 슬라이딩 윈도우 제약이 있을 때, dp[j] + A[j] 를 단조 감소/증가 덱으로 관리하면 O(1) 에 최적 후보를 찾는다.

시각화

{}

핵심 아이디어

덱은 항상 값에 대해 단조 (최댓값이면 내림차순, 최솟값이면 오름차순) 이다.

슬라이딩 윈도우 최댓값
  deque: [인덱스 ...]  (값 a[index] 는 내림차순)
  invariant:
    - 덱 앞: 현재 윈도우에서 가장 큰 값의 인덱스
    - 덱 뒤: 방금 들어온 값의 인덱스 (가장 작은 값)

  push(i):
    1. dq.front() <= i - K -> dq.pop_front()     # 윈도우 이탈
    2. a[dq.back()] <= a[i] -> dq.pop_back()      # 불필요한 후보 제거
    3. dq.push_back(i)

  query_max(): return a[dq.front()]

amortized O(N) 인 이유: 각 원소는 정확히 한 번 push, 최대 한 번 pop_front, 최대 한 번 pop_back. 총 연산 = O(N).

알고리즘

SlidingWindowMax(a[0..N-1], K):
    dq = empty deque
    result = []
    for i = 0..N-1:
        while dq and dq[0] <= i - K:
            dq.pop_front()
        while dq and a[dq[-1]] <= a[i]:
            dq.pop_back()
        dq.append(i)
        if i >= K - 1:
            result.append(a[dq[0]])
    return result

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Sliding window maximum, O(N) #include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n, k; cin >> n >> k; vector<int> a(n); for (auto& v : a) cin >> v; deque<int> dq; for (int i = 0; i < n; i++) { while (!dq.empty() && dq.front() <= i - k) dq.pop_front(); while (!dq.empty() && a[dq.back()] <= a[i]) dq.pop_back(); dq.push_back(i); if (i >= k - 1) cout << a[dq.front()] << ' '; } }, }, { language: “python”, label: “Python”, code: `from collections import deque import sys input = sys.stdin.readline

n, k = map(int, input().split()) a = list(map(int, input().split())) dq = deque() out = [] for i, v in enumerate(a): while dq and dq[0] <= i - k: dq.popleft() while dq and a[dq[-1]] <= v: dq.pop() dq.append(i) if i >= k - 1: out.append(str(a[dq[0]])) sys.stdout.write(’ ‘.join(out)), }, ]} cases={[ { label: "기본", input: 8 3 2 5 4 1 8 3 7 6, output: 5 5 8 8 8 7, }, { label: "내림차순 배열", input: 6 3 9 8 7 6 5 4, output: 9 8 7 6 5`, }, ]} />

DP 최적화 예시

dp[i] = max(dp[i-1], max_{j in [i-K, i-1]} (dp[j] + a[i])) 형태에서, 덱에 dp[j] 를 단조 감소로 유지하며 O(N).

<CodeWithOutput language=“cpp” code={// dp[i] = max(dp[i-1], max_j (dp[j] + penalty) for j in [i-K, i-1]) // Deque trick O(N) instead of O(NK) #include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n, k; cin >> n >> k; vector<long long> a(n), dp(n); for (auto& v : a) cin >> v; deque<int> dq; for (int i = 0; i < n; i++) { while (!dq.empty() && dq.front() < i - k) dq.pop_front(); if (i == 0) dp[i] = a[i]; else dp[i] = max(dp[i-1], (dq.empty() ? a[i] : dp[dq.front()] + a[i])); while (!dq.empty() && dp[dq.back()] <= dp[i]) dq.pop_back(); dq.push_back(i); } cout << dp[n-1] << '\\n'; }} input={5 2 -1 -2 3 -4 5} output={5} inputLanguage=“text” outputLanguage=“text” />

복잡도

항목	값
슬라이딩 윈도우 (시간)	O(N), amortized 1 회당 O(1)
DP 최적화 (시간)	O(N) 또는 O(N log N)
공간	O(N) (덱 + 결과)
자료구조	덱 (deque)

변형 / 활용

응용	설명
슬라이딩 윈도우 최솟값	부등호만 반대로 (`>=`, `>=`)
Monotonic Stack	덱 대신 스택. 윈도우가 아니라 이전/다음 큰 원소 찾기. 같은 단조성 아이디어
DP + Deque	dp[i] = max(dp[j] + f(j) + g(i)) 꼴. g(i) 가 전이 밖으로 분리 가능해야 함
2Pointer + Deque	투 포인터와 결합해 조건 변화에 따른 구간의 extrema 관리

함정

1. 부호 방향 실수

최댓값을 구할 때는 a[dq.back()] <= a[i] 로 작거나 같은 값 제거. 최솟값은 >=. 방향 하나 틀리면 덱이 비어 있거나 결과가 틀린다.

2. 인덱스 vs 값 헷갈림

덱에는 인덱스를 저장해야 한다 (윈도우 이탈 판단에 필요). 값을 저장하면 pop_front 조건을 검사할 수 없다.

3. K 가 1 또는 N 일 때

K=1 이면 항상 a[i] 자체, K=N 이면 최댓값 하나만. 특수 케이스 처리가 필요 없지만 시간 복잡도는 그대로 O(N).

4. DP 에서 cost 분리 불가

cost(j, i) 가 A[j] + B[i] 로 분리되지 않으면 (예: cost = (x_i - x_j)^2) deque trick 적용 불가. 그 경우 [[Convex Hull Trick]] 또는 [[Divide and Conquer Optimization|분할정복 DP 최적화]] 고려.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11003	최솟값 찾기	-	kokoa-lab
BOJ 17298	오큰수	-	kokoa-lab
BOJ 2096	내려가기	-	kokoa-lab
BOJ 1576	-	-	kokoa-lab

참고

[[Convex Hull Trick]]
[[Divide and Conquer Optimization|분할정복 DP 최적화]]
[[Slope Trick]]
[[Knuth Optimization|크누스 최적화]]

분할정복 DP 최적화 (Divide and Conquer Optimization)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

분할정복 DP 최적화 (Divide and Conquer Optimization) 는 dp[i][j] = min(dp[i-1][k] + C[k+1][j]) 꼴의 DP 에서, 최적 분할점 opt[i][j] 가 j 에 대해 단조 비감소 (opt[i][j] <= opt[i][j+1]) 일 때, 분할정복으로 k 탐색 범위를 제한해 시간 복잡도를 O(K N^2) 에서 O(K N log N) 으로 줄이는 기법.

문제 상황과 동기

왜 필요한가

N 개의 원소를 K 개의 그룹으로 나누는 DP:

dp[k][i] = min (dp[k-1][j] + cost(j+1, i))   (0 <= j < i)

naive: 각 dp[k][i] 마다 모든 j 검사. O(K * N^2). N=10^5, K=10 이면 10^11.
D&C 최적화: opt[i] 단조성을 이용, O(K * N log N). 10^5 * log(10^5) * 10 ≈ 2*10^7, 통과.

핵심 통찰: j 의 후보 범위가 단조적이면, 분할정복으로 각 레이어를 O(N log N) 에 채울 수 있다. 전체 문제를 mid 에서의 최적 j 를 찾은 후, 좌/우 반쪽의 j 후보 범위를 각각 [optL, bestK] 와 [bestK, optR] 로 좁혀 재귀한다.

전제 조건

cost(l, r) 가 다음 사각 부등식 (quadrangle inequality) 을 만족하면 opt[i] 가 단조 비감소한다.

cost(a, c) + cost(b, d) <= cost(a, d) + cost(b, c)   (a <= b <= c <= d)

시각화

{}

핵심 아이디어

Opt[i] 가 단조 비감소 (opt[i] <= opt[i+1]) 라면, j 후보 범위를 재귀적으로 좁혀도 안전하다.

dc(k, l, r, optL, optR):
    if l > r: return
    mid = (l + r) / 2
    bestK = optL
    bestVal = INF
    for j = optL .. min(mid-1, optR):
        val = dp[k-1][j] + cost(j+1, mid)
        if val < bestVal:
            bestVal = val
            bestK = j
    dp[k][mid] = bestVal
    dc(k, l, mid-1, optL, bestK)      # 왼쪽: j 범위 [optL, bestK]
    dc(k, mid+1, r, bestK, optR)      # 오른쪽: j 범위 [bestK, optR]

각 레이어 k 에서 모든 호출의 j 순회 합 = O(N log N). (N 개 원소 각각이 log N 번 방문)

알고리즘

DnCDP(a[1..N], K):
    dp[0][0] = 0
    for i = 1..N:
        dp[1][i] = cost(1, i)     # 1개 그룹
    
    for k = 2..K:
        solve(k, 1, N, 0, N)      # 분할정복
    
    return dp[K][N]

solve(k, l, r, optL, optR):
    if l > r: return
    mid = (l + r) / 2
    bestK = optL
    bestVal = INF
    for j = optL .. min(mid-1, optR):
        val = dp[k-1][j] + cost(j+1, mid)
        if val < bestVal:
            bestVal = val
            bestK = j
    dp[k][mid] = bestVal
    solve(k, l, mid-1, optL, bestK)
    solve(k, mid+1, r, bestK, optR)

구현

다음은 배열을 K 개 그룹으로 나누고 각 그룹 합의 제곱을 최소화하는 문제. cost(l, r) = (prefix[r] - prefix[l-1])^2.

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// D&C Optimization: O(K N log N), cost = (sum)^2 #include <bits/stdc++.h> using namespace std; using ll = long long; const ll INF = 1e18;

int N, K; vector a, ps; vector<vector> dp;

ll cost(int l, int r) { ll s = ps[r] - ps[l - 1]; return s * s; }

void dac(int k, int l, int r, int optL, int optR) { if (l > r) return; int mid = (l + r) / 2; int bestK = optL; ll bestVal = INF; for (int j = optL; j <= min(mid - 1, optR); j++) { ll val = dp[k - 1][j] + cost(j + 1, mid); if (val < bestVal) { bestVal = val; bestK = j; } } dp[k][mid] = bestVal; dac(k, l, mid - 1, optL, bestK); dac(k, mid + 1, r, bestK, optR); }

int main() { ios::sync_with_stdio(false); cin.tie(nullptr); cin >> N >> K; a.resize(N + 1); ps.resize(N + 1); for (int i = 1; i <= N; i++) { cin >> a[i]; ps[i] = ps[i - 1] + a[i]; } dp.assign(K + 1, vector(N + 1, INF)); dp[0][0] = 0; for (int i = 1; i <= N; i++) dp[1][i] = cost(1, i); for (int k = 2; k <= K; k++) dac(k, 1, N, 0, N); cout << dp[K][N] << ‘\n’; }, }, { language: "python", label: "Python", code: import sys sys.setrecursionlimit(1 << 25) input = sys.stdin.readline INF = 10 ** 18

N, K = map(int, input().split()) a = [0] + list(map(int, input().split())) ps = [0] * (N + 1) for i in range(1, N + 1): ps[i] = ps[i - 1] + a[i]

def cost(l, r): s = ps[r] - ps[l - 1] return s * s

dp = [[INF] * (N + 1) for _ in range(K + 1)] dp[0][0] = 0

def dac(k, l, r, optL, optR): if l > r: return mid = (l + r) // 2 best_k = optL best_val = INF for j in range(optL, min(mid, optR + 1)): val = dp[k - 1][j] + cost(j + 1, mid) if val < best_val: best_val = val best_k = j dp[k][mid] = best_val dac(k, l, mid - 1, optL, best_k) dac(k, mid + 1, r, best_k, optR)

for i in range(1, N + 1): dp[1][i] = cost(1, i)

for k in range(2, K + 1): dac(k, 1, N, 0, N)

print(dp[K][N]), }, ]} cases={[ { label: "기본", input: 4 2 1 2 3 4, output: 52, }, { label: "다섯 개 원소", input: 5 2 1 3 2 4 2, output: 72`, }, ]} />

복잡도

항목	값
시간 (최선)	O(K N log N)
시간 (평균)	O(K N log N)
시간 (최악)	O(K N^2) (단조성 깨질 때)
공간	O(K N) (dp 테이블)
최적화 전	O(K N^2) -> O(K N log N)

amortized 분석

solve(k, 1, N, 0, N) 호출의 j 순회 횟수: 각 레벨마다 O(N) 합, 깊이 log N. 총 O(N log N). K 개 레이어 곱하면 O(K N log N).

변형 / 활용

변형	설명
Knuth Optimization	구간 DP. opt[i][j-1] ≤ opt[i][j] ≤ opt[i+1][j]. O(N^3) -> O(N^2)
CHT (Convex Hull Trick)	cost 가 직선의 기울기/절편 형태일 때. O(K N)
Aliens Trick	K 제약을 lambda 로 풀기. D&C 와 결합 가능

D&C 최적화는 K 가 작을 때 (K ≤ N) 특히 효과적. K = sqrt(N) 정도까지는 O(N sqrt(N) log N) 으로 양호.

함정

1. cost() 가 O(1) 이 아닌 경우

cost(l, r) 를 O(1) 에 계산할 수 있어야 한다. prefix sum 으로 충분한 cost 함수가 이상적. O(log N) 짜리 cost 면 전체 O(K N log^2 N).

2. opt 단조성 증명 없이 사용

사각 부등식을 만족하지 않는 cost 함수에 적용하면 답이 틀리거나 더 느려짐. cost = (prefix[r] - prefix[l-1])^2 는 만족하지만, cost = abs(prefix[r] - prefix[l-1]) 는 일반적으로 불만족.

3. 재귀 깊이

N=10^5 일 때 재귀 깊이는 log N ≈ 17. 안전하지만 스택 메모리 확인. Python 은 setrecursionlimit 필요.

4. 1-indexed vs 0-indexed

dp[k-1][j] + cost(j+1, mid) 에서 j 는 마지막 그룹의 시작 직전 인덱스. dp[0][0] = 0, dp[0][j>0] = INF. 이 초기화를 빼먹으면 올바른 값이 계산되지 않는다.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 13261	탈출	-	kokoa-lab
BOJ 4008	특공대	-	kokoa-lab
BOJ 6171	땅따먹기	-	kokoa-lab

참고

[[Knuth Optimization|크누스 최적화]]
[[Convex Hull Trick]]
[[Aliens Trick]]
[[Deque Trick|덱 트릭]]

커넥션 프로파일 DP (Broken Profile DP)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

커넥션 프로파일 DP (Broken Profile DP) 는 직사각형 격자를 tile-by-tile 로 처리하면서, 처리된 영역과 아직 처리되지 않은 영역의 경계 (broken profile) 를 bitmask 와 같은 작은 상태로 압축해 DP 에 사용하는 기법. 도미노/트리미노 타일링, 격자 배치 문제에서 널리 쓰인다.

문제 상황과 동기

H x W 격자를 1x2 / 2x1 도미노로 빈틈없이 덮는 경우의 수. Naive: exponential search 2^(HW). H ≤ 10, W ≤ 10 에도 HW 만 100, 완전탐색 불가.

핵심 통찰: 셀 단위 스캔에서 경계면의 모양만 알면 앞으로 필요한 정보가 충분. W 가 작을 때 2^W 가지 mask 로 상태 표현 가능.

시각화

{}

핵심 아이디어

격자 (r, c) 를 row-major 순서로 한 칸씩 처리. 경계선은 W 개의 구역으로 나뉨.

Profile bitmask (W bits):
  bit j (j >= c): cell (r, j) 가 이미 채워졌는가? (horizontal overflow)
  bit j (j < c):  cell (r+1, j) 가 아래에서 채워졌는가? (vertical overflow)

DP transition at cell (r, c):
  if mask bit c == 1:   # 이미 채워짐 (왼쪽에서 horizontal)
      clear bit c, move on
  if mask bit c == 0:   # 빈 칸
      - place vertical    -> set bit c (next row 의 이 칸이 채워짐)
      - place horizontal  -> set bit c+1 (같은 row 오른쪽 칸이 채워짐)

셀이 채워진 후 해당 bit 는 “past” 섹션으로 넘어가 자동으로 “아래에서 덮인” 의미로 전환.

알고리즘

dp[mask] = 현재 위치까지 처리, profile = mask 일 때 경우의 수

initialize dp[0] = 1
for r = 0..H-1:
    for c = 0..W-1:
        for mask = 0..(1<<W)-1:
            if dp[mask] == 0: continue
            if mask & (1 << c):   # already filled
                ndp[mask ^ (1 << c)] += dp[mask]
            else:                 # empty
                ndp[mask | (1 << c)] += dp[mask]           # vertical
                if c+1 < W and !(mask & (1 << (c+1))):
                    ndp[mask | (1 << (c+1))] += dp[mask]   # horizontal
        dp = ndp

answer = dp[0]   # 마지막 row 끝난 후 mask = 0

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Domino tiling: H x W grid, 1x2 / 2x1 dominoes, MOD = 9901 #include <bits/stdc++.h> using namespace std; const int MOD = 9901; int main() { int h, w; cin >> h >> w; int sz = 1 << w; vector<int> dp(sz, 0); dp[0] = 1; for (int r = 0; r < h; r++) { for (int c = 0; c < w; c++) { vector<int> ndp(sz, 0); for (int mask = 0; mask < sz; mask++) { int val = dp[mask]; if (val == 0) continue; if (mask & (1 << c)) { ndp[mask ^ (1 << c)] = (ndp[mask ^ (1 << c)] + val) % MOD; } else { ndp[mask | (1 << c)] = (ndp[mask | (1 << c)] + val) % MOD; if (c + 1 < w && !(mask & (1 << (c + 1)))) { ndp[mask | (1 << (c + 1))] = (ndp[mask | (1 << (c + 1))] + val) % MOD; } } } dp = move(ndp); } } cout << dp[0] << "\\n"; return 0; }, }, { language: “python”, label: “Python”, code: MOD = 9901 h, w = map(int, input().split()) sz = 1 << w dp = [0] * sz dp[0] = 1 for r in range(h): for c in range(w): ndp = [0] * sz for mask in range(sz): val = dp[mask] if val == 0: continue if mask & (1 << c): ndp[mask ^ (1 << c)] = (ndp[mask ^ (1 << c)] + val) % MOD else: ndp[mask | (1 << c)] = (ndp[mask | (1 << c)] + val) % MOD if c + 1 < w and not (mask & (1 << (c + 1))): ndp[mask | (1 << (c + 1))] = (ndp[mask | (1 << (c + 1))] + val) % MOD dp = ndp print(dp[0]), }, { language: “java”, label: “Java”, code: `import java.util.*;

public class Main { static final int MOD = 9901; public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringTokenizer st = new StringTokenizer(br.readLine()); int h = Integer.parseInt(st.nextToken()); int w = Integer.parseInt(st.nextToken()); int sz = 1 << w; int[] dp = new int[sz]; dp[0] = 1; for (int r = 0; r < h; r++) { for (int c = 0; c < w; c++) { int[] ndp = new int[sz]; for (int mask = 0; mask < sz; mask++) { int val = dp[mask]; if (val == 0) continue; if ((mask & (1 << c)) != 0) { ndp[mask ^ (1 << c)] = (ndp[mask ^ (1 << c)] + val) % MOD; } else { ndp[mask | (1 << c)] = (ndp[mask | (1 << c)] + val) % MOD; if (c + 1 < w && (mask & (1 << (c + 1))) == 0) { ndp[mask | (1 << (c + 1))] = (ndp[mask | (1 << (c + 1))] + val) % MOD; } } } dp = ndp; } } System.out.println(dp[0]); } }`, }, ]} cases={[ { label: “2x4 grid”, input: “2 4”, output: “5”, }, { label: “3x3 grid”, input: “3 3”, output: “0”, }, ]} />

복잡도

항목	값
시간	O(H * W * 2^W)
공간	O(2^W)
실용 범위	W ≤ 18 (2^18 = 262k)

변형 / 활용

변형	설명
Plug DP	broken profile 의 일반화. 비도미노 타일, Hamiltonian path 검색
3D tiling	3차원 격자, L-tromino 등 다양한 조각
Grid coloring	인접 조건이 있는 격자 coloring (예: chessboard pattern)
Subset DP	상태 압축 일반 기법. TSP 등과 유사

함정

1. W 가 큰 경우

W > 18 이면 상태 2^W 가 감당 불가. W 큰 case 는 다른 접근 (분할 정복, transfer-matrix + exponentiation) 필요.

2. Horizontal overflow 처리

Horizontal 을 놓을 때 c+1 < W 검사와 함께 !(mask & (1 << (c+1))) (오른쪽 칸이 비었음) 도 반드시 확인.

3. 마지막 행 검증

마지막 셀까지 처리한 후 dp[0] 만 유효. mask != 0 은 아직 피우지 못한 칸이 있거나 vertical 이 경계를 넘은 것.

4. MOD 경계

경우의 수가 폭발적으로 증가하므로 MOD (9901 등) 로 나누는 것 필수.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 1648	격자판 채우기	-	kokoa-lab
BOJ 1823	도미노 채우기	-	kokoa-lab
BOJ 2711	오타맨	-	kokoa-lab

참고

[[DP|동적 계획법]]
[[DP Bitfield|비트 DP]]
[[DP Sum Over Subsets|SOS DP]]
BOJ 1648: 격자판 채우기

덱 DP (슬라이딩 윈도우 최적화)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

덱 DP (Deque DP) 는 점화식 dp[i] = min/max_{j in [i-k, i-1]} (dp[j] + cost(i,j)) 꼴에서 monotonic deque 를 써서 최적 j 후보를 O(N) 에 유지하는 기법. 슬라이딩 윈도우 최댓값/최솟값의 일반화로, 윈도우 내에서 비용까지 포함한 최적 인덱스 를 관리한다.

문제 상황과 동기

dp[i] = max(dp[j] + a[j]) for j < i and i - j <= K. Naive 하면 각 i 에서 K 개 순회 -> O(NK). N=10^6, K=10^5 면 10^11.

핵심 통찰: 윈도우 안의 후보 중 dp[j] + something 이 최대인 j 만 deque 에 유지. 더 이상 최적이 될 수 없는 후보는 pop.

시각화

{}

핵심 아이디어

DP: dp[i] = best(dp[j] + a[i])  for j in [i-K, i-1]
    where best = maximal computed value

Deque invariant:
  1. Index range: front is always within [i-K, i-1]
  2. Value order: dp[deque[0]] >= dp[deque[1]] >= ... (decreasing)
  3. Old index from front when out of range
  4. New candidate deletes from back if inferior

Deque 에는 인덱스 만 저장. dp[deque.front()] 이 항상 현재 i 에 대한 최적값.

알고리즘

deque dq
for i = 0..N-1:
    # 1. 만료된 front 제거
    while dq not empty and dq.front() < i - K:
        dq.pop_front()

    # 2. 현재 dp[i] 계산
    if dq empty:
        dp[i] = a[i]
    else:
        dp[i] = dp[dq.front()] + a[i]

    # 3. dq.back() 이 dp[i] 보다 나쁘면 제거
    while dq not empty and dp[dq.back()] <= dp[i]:
        dq.pop_back()

    # 4. 현재 i 를 후보에 추가
    dq.push_back(i)

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Maximum sum subsequence: pick elements at distance <= K // dp[i] = max sum ending at i, each pair distance ≤ K #include <bits/stdc++.h> using namespace std; int main() { int n, k; cin >> n >> k; vector<int> a(n); for (int i = 0; i < n; i++) cin >> a[i]; vector<long long> dp(n); deque<int> dq; long long ans = 0; for (int i = 0; i < n; i++) { while (!dq.empty() && dq.front() < i - k) dq.pop_front(); dp[i] = a[i]; if (!dq.empty()) dp[i] += dp[dq.front()]; while (!dq.empty() && dp[dq.back()] <= dp[i]) dq.pop_back(); dq.push_back(i); ans = max(ans, dp[i]); } cout << ans << "\\n"; return 0; }, }, { language: “python”, label: “Python”, code: `from collections import deque import sys input = sys.stdin.readline

n, k = map(int, input().split()) a = list(map(int, input().split())) dp = [0] * n dq = deque() ans = 0 for i in range(n): while dq and dq[0] < i - k: dq.popleft() dp[i] = a[i] if dq: dp[i] += dp[dq[0]] while dq and dp[dq[-1]] <= dp[i]: dq.pop() dq.append(i) ans = max(ans, dp[i]) print(ans), }, { language: "java", label: "Java", code: import java.util.*;

public class Main { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringTokenizer st = new StringTokenizer(br.readLine()); int n = Integer.parseInt(st.nextToken()); int k = Integer.parseInt(st.nextToken()); int[] a = new int[n]; st = new StringTokenizer(br.readLine()); for (int i = 0; i < n; i++) a[i] = Integer.parseInt(st.nextToken()); long[] dp = new long[n]; Deque dq = new ArrayDeque<>(); long ans = 0; for (int i = 0; i < n; i++) { while (!dq.isEmpty() && dq.peekFirst() < i - k) dq.pollFirst(); dp[i] = a[i]; if (!dq.isEmpty()) dp[i] += dp[dq.peekFirst()]; while (!dq.isEmpty() && dp[dq.peekLast()] <= dp[i]) dq.pollLast(); dq.offerLast(i); ans = Math.max(ans, dp[i]); } System.out.println(ans); } }, }, ]} cases={[ { label: "기본 예제", input: 8 3 1 -3 5 -2 8 -1 4 -6, output: 13, }, { label: "음수 포함", input: 5 2 -5 -1 -3 -2 -4, output: -1`, }, ]} />

복잡도

항목	값
시간 (최선/평균/최악)	O(N)
공간	O(N) (dp 배열) or O(K) (deque + rolling)
각 원소의 deque push/pop	amortized O(1)

변형 / 활용

변형	설명
Sliding window minimum	부등호 반대 (≤ -> >=). dp 없이 순수 배열 최솟값
DP + sliding window cost	`dp[i] = min(dp[j] + cost(i,j))` 에서 cost 가 분해 가능할 때
Divide and Conquer DP	monotone queue 와 결합, `dp[i][j]` 꼴
1D/1D DP	점화식 차수가 1차원, 최적화 상수가 K 일 때

널리 사용되는 예: BOJ 11003 (최솟값 찾기), BOJ 2096 (내려가기, 슬라이딩 윈도우 DP).

함정

1. 부등호 방향

최댓값: dp[dq.back()] <= dp[i] 이면 pop. 최솟값: >= 로 반대. 혼동하지 않도록.

2. 초기 K 값

i < K 일 때는 윈도우가 충분히 크지 않음. i - k 가 음수가 되지 않도록 조건.

3. 0-1 범위 반영

dp[i] 가 기본값 a[i] (단독 선택) 인지, 아니면 이전 dp 값과 합쳐야 하는지. 문제 정의에 따라.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11003	최솟값 찾기	-	kokoa-lab
BOJ 2096	내려가기	-	kokoa-lab
BOJ 14865	골목길	-	kokoa-lab

참고

[[DP|동적 계획법]]
[[Sliding Window|슬라이딩 윈도우]]
[[Two Pointer|두 포인터]]
[[Segtree|세그먼트 트리]] (대안: range minimum query)

SOS DP (Sum Over Subsets)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

SOS DP (Sum Over Subsets) 는 길이 2^N 의 배열 a 에 대해, 모든 mask (0..2^N-1) 마다 mask 의 부분 집합 (submask) 에 대한 합 을 O(N * 2^N) 에 구하는 DP 기법. “Sum Over Subsets” (부분 집합에 대한 합) 의 약자.

문제 상황과 동기

길이 2^N 배열 a, f[mask] = Σ_{submask ⊆ mask} a[submask].

naive: 각 mask 마다 모든 submask 열거. O(3^N). N=20 이면 3^20 ~ 3.5 * 10^9, 불가.
SOS DP: O(N * 2^N). N=20 이면 20 * 2^20 ~ 2 * 10^7, 1초 내 충분.

핵심 통찰: bit i 하나씩 추가하며, i 번째 bit 가 set 인 mask 의 DP 값을 i 번째 bit 가 없던 mask 의 값으로 보강. “각 bit 를 순서대로, 이미 고려한 bit 들은 자유롭게” 라는 divide-and-conquer 관점.

PS 에서: 포함-배제 DP (subset convolution), bitmask DP 고속화, Zeta/Mobius transform, graph 의 clique / independent set counting.

시각화

{}

핵심 아이디어

상태 정의

dp[mask][i] = mask 의 부분 집합들 중, 하위 i 개 bit (bit 0 ~ i-1) 는 mask 와 정확히 일치하고 나머지 상위 bit 들은 mask 의 부분 집합인 집합에 대한 합.

점화식

dp[mask][0] = a[mask]
dp[mask][i] = dp[mask][i-1]
              (bit i-1 이 0 이면)
            | dp[mask][i-1] + dp[mask ^ (1<<(i-1))][i-1]
              (bit i-1 이 1 이면, i-1 번 bit 를 "자유" 로 만듦)

최종 f[mask] = dp[mask][N].

공간 최적화 (1D in-place)

i 차원 생략. i loop 안에서 mask loop 실행.

for i in 0..N-1:
    for mask in 0..(1<<N)-1:
        if mask & (1<<i):
            f[mask] += f[mask ^ (1<<i)]

이 때 f[mask] 는 i 단계에서 “하위 i 개 bit 자유, 나머지 고정” 의미. i=0 단계: bit 0 자유. i=1 단계: bits 0.1 자유 … i=N-1 단계: 모든 bit 자유 (부분 집합 합 완성).

Zeta / Mobius transform

SOS DP 의 덧셈 버전을 zeta transform (부분 집합 합), 그 역을 Mobius transform (차분 복원). subset convolution (서로소 부분 집합 쌍의 합 곱) 의 기초.

zeta:   f[mask] += f[mask ^ (1<<i)]    (SOS DP 와 동일)
mobius: f[mask] -= f[mask ^ (1<<i)]    (역연산, 음수 주의)

알고리즘

sos_dp(f, N):
    for i in 0..N-1:
        for mask in 0..(1<<N)-1:
            if mask & (1<<i):
                f[mask] += f[mask ^ (1<<i)]
    return f

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // SOS DP: O(N * 2^N) subset sum // Input: N, then 2^N integers (array a) // Output: f[mask] = sum of a[submask] for submask subseteq mask #include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; int sz = 1 << n; vector<long long> f(sz); for (auto& v : f) cin >> v; for (int i = 0; i < n; i++) { for (int mask = 0; mask < sz; mask++) { if (mask & (1 << i)) f[mask] += f[mask ^ (1 << i)]; } } for (auto& v : f) cout << v << ' '; }, }, { language: “python”, label: “Python”, code: # SOS DP: O(N * 2^N) subset sum n = int(input()) f = list(map(int, input().split())) sz = 1 << n for i in range(n): bit = 1 << i for mask in range(sz): if mask & bit: f[mask] += f[mask ^ bit] print(*f), }, ]} cases={[ { label: “N=3 기본”, input: 3 1 2 3 4 5 6 7 8, output: 1 3 4 10 6 14 16 36, }, ]} />

복잡도

항목	값
시간	O(N * 2^N)
공간 (naive 2D)	O(N * 2^N)
공간 (in-place 1D)	O(2^N)
Mobius 변환	동일 복잡도, 덧셈 대신 뺄셈

변형 / 활용

1. Subset Convolution

h[mask] = Σ_{sub ⊆ mask} f[sub] * g[mask ^ sub] (서로소 분할 곱). SOS DP + bit count 분리로 O(N^2 * 2^N).

2. Superset Sum (SOS over supersets)

모든 superset 에 대한 합. 반대 방향: for mask in 0..sz-1: if !(mask & (1<<i)): f[mask] += f[mask | (1<<i)].

3. Divisible / LCM subset counting

약수 관계를 bitmask 로 매핑해서 SOS DP 로 처리.

4. Graph 의 Independent Set Counting

bitmask 가 independent set 을 나타내도록 하여, superset DP 로 clique / independent set 개수.

함정

1. in-place 갱신 순서

mask 를 0..sz-1 순회. bit i 가 set 인 mask 만 갱신하므로, 작은 mask → 큰 mask 순서로 f[mask] 가 누적됨.

2. 오버플로우

a 값과 부분 집합 개수가 크면 64-bit 필요. C++ long long.

3. Mobius 음수

Mobius 변환은 f[mask] -= f[mask ^ (1<<i)]. mod 연산 시 양수 유지: f[mask] = (f[mask] - f[mask ^ bit] + MOD) % MOD.

4. N 제한

SOS DP 는 O(N * 2^N). N=25 (2^25=33M) 까지는 1초 내 가능. N=30 (2^30=1B) 은 불가.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 17451	평행 우주	-	kokoa-lab
BOJ 29350	Сумма по подмножествам	-	kokoa-lab
BOJ 1725	히스토그램	-	kokoa-lab

참고

[[DP Bitfield|비트마스크 DP]]
[[DP|동적 계획법]]

Hirschberg (히르쉬버그) LCS

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Hirschberg 알고리즘 은 두 문자열 A, B 의 LCS 를 O(N) 공간 (메모리) 만 사용해 구하는 분할 정복 DP. 표준 LCS 의 O(NM) 공간을 O(N) 으로 줄이면서도 시간은 O(NM) 유지.

1975 년 D. S. Hirschberg 가 제안. 아이디어: LCS 를 반으로 나누고, 중간 지점에서 분할점을 찾아 재귀.

문제 상황과 동기

표준 LCS 는 O(NM) 공간. N = M = 10^5 면 10^10 int = 40 GB. 메모리 초과.

naive DP: dp[N+1][M+1] 전체 저장. 수열 복원 가능. 공간 O(NM).
공간 최적화 (1 행): prev, curr 만 유지. 길이는 알 수 있지만 traceback 불가.
Hirschberg: O(NM) 시간, O(N) 공간, traceback 으로 수열 복원까지 가능.

핵심 통찰: LCS DP 는 재귀적으로 분할 가능. “A 의 왼쪽 절반과 B 전체” 의 LCS + “A 의 오른쪽 절반과 B 전체” 의 LCS = 전체 LCS. 분할점을 찾아 재귀.

시각화

{}

핵심 아이디어

분할 정복 LCS

lcs(A, B) 의 해를 A 의 중간 mid = N/2 에서 분할:

LCS(A, B) = LCS(A[0..mid], B[..k]) + LCS(A[mid..], B[k..])

k 는 다음 조건을 만족하는 위치:

fwd[mid][k] + rev[N-mid][M-k] = LCS(A, B)

여기서 fwd[i][j] = A[0..i-1], B[0..j-1] 의 LCS 길이. rev[i][j] = A[N-i..N-1], B[M-j..M-1] 의 LCS 길이 (뒤에서부터).

분할점 k 찾기

fwd[mid] 행 (A 의 중간까지, B 전체와의 LCS 길이) 을 O(NM) DP 로 계산. 단, O(M) 공간만 사용 (1 행).
rev[N-mid] 행 (A 의 나머지 절반, B 전체와의 LCS 길이) 을 O(NM) DP 로 계산. (뒤에서부터)
fwd[mid][k] + rev[N-mid][M-k] 가 최대가 되는 k = 분할점.
왼쪽 lcs(A[0..mid], B[0..k]) + 오른쪽 lcs(A[mid..], B[k..]) 재귀.

기저 조건

N = 0 또는 M = 0: 빈 문자열. N = 1: 단일 문자 LCS (선형 탐색, O(M)).

알고리즘

hirschberg(A, B):
    N = len(A), M = len(B)

    if N == 0 or M == 0: return ""
    if N == 1:
        if A[0] in B: return A[0]
        else: return ""

    mid = N // 2
    fwd = lcs_row(A[0..mid], B)     // O(mid * M) 공간 O(M)
    rev = lcs_row_rev(A[mid..], B)  // O((N-mid) * M) 공간 O(M)

    // 분할점 k
    best = -1; k = 0
    for j in 0..M:
        total = fwd[j] + rev[M - j]
        if total > best: best = total; k = j

    return hirschberg(A[0..mid], B[0..k])
         + hirschberg(A[mid..], B[k..])

lcs_row 함수:

lcs_row(A, B):
    prev = [0] * (M + 1)
    for i in 1..len(A):
        curr = [0] * (M + 1)
        for j in 1..M:
            if A[i-1] == B[j-1]: curr[j] = prev[j-1] + 1
            else: curr[j] = max(prev[j], curr[j-1])
        prev = curr
    return prev

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Hirschberg LCS - O(NM) time, O(N) space #include <bits/stdc++.h> using namespace std;

vector lcs_row(const string& a, const string& b) { int m = b.size(); vector prev(m + 1, 0), curr(m + 1, 0); for (char ca : a) { for (int j = 1; j <= m; j++) { if (ca == b[j-1]) curr[j] = prev[j-1] + 1; else curr[j] = max(prev[j], curr[j-1]); } swap(prev, curr); } return prev; }

string hirschberg(const string& a, const string& b) { int n = a.size(), m = b.size(); if (n == 0) return ""; if (n == 1) { return (b.find(a[0]) != string::npos) ? string(1, a[0]) : ""; }

int mid = n / 2;
auto fwd = lcs_row(a.substr(0, mid), b);
string ra = a.substr(mid);
reverse(ra.begin(), ra.end());
string rb = b;
reverse(rb.begin(), rb.end());
auto rev = lcs_row(ra, rb);

int best = -1, k = 0;
for (int j = 0; j <= m; j++) {
    int total = fwd[j] + rev[m - j];
    if (total > best) { best = total; k = j; }
}

return hirschberg(a.substr(0, mid), b.substr(0, k))
     + hirschberg(a.substr(mid), b.substr(k));

}

int main() { string a, b; cin >> a >> b; string ans = hirschberg(a, b); cout << ans.size() << “\n” << ans << “\n”; }, }, { language: "python", label: "Python", code: # Hirschberg LCS - O(NM) time, O(N) space import sys sys.setrecursionlimit(10000) input = sys.stdin.readline

def lcs_row(a: str, b: str): m = len(b) prev = [0] * (m + 1) for ca in a: curr = [0] * (m + 1) for j in range(1, m + 1): if ca == b[j-1]: curr[j] = prev[j-1] + 1 else: curr[j] = prev[j] if prev[j] > curr[j-1] else curr[j-1] prev = curr return prev

def hirschberg(a: str, b: str) -> str: n, m = len(a), len(b) if n == 0: return "" if n == 1: return a[0] if a[0] in b else ""

mid = n // 2
fwd = lcs_row(a[:mid], b)
rev = lcs_row(a[mid:][::-1], b[::-1])

best, k = -1, 0
for j in range(m + 1):
    total = fwd[j] + rev[m - j]
    if total > best:
        best, k = total, j

return (hirschberg(a[:mid], b[:k])
      + hirschberg(a[mid:], b[k:]))

a = input().strip() b = input().strip() ans = hirschberg(a, b) print(len(ans)) print(ans), }, ]} cases={[ { label: "기본", input: ABCBDAB BDCAB, output: 4 BCAB, }, { label: "공통 없음", input: ABCD EFGH, output: 0 , }, { label: "한 문자", input: A B, output: 0 `, }, ]} />

복잡도

항목	값
시간 (최선)	O(NM)
시간 (평균)	O(NM)
시간 (최악)	O(NM)
공간	O(M) (입력 중 짧은 쪽 기준)
Traceback	가능 (수열 복원)

표준 LCS 와 같은 시간 복잡도지만 공간이 O(NM) -> O(N). N=10^5, M=10^5 일 때 메모리 40 GB -> 400 KB.

공간 분석

각 재귀 단계에서 O(M) 배열만 유지. 분할 정복으로 스택 깊이 O(log N).
전체 공간 O(M). traceback 에 추가 배열 불필요.

변형 / 활용

Hirschberg + Bitset LCS

Bitset LCS (O(NM/64)) 의 lcs_row 로 대체해 시간도 가속. 공간 O(N) + 시간 O(NM/64).

병렬화

분할 후 왼쪽/오른쪽 재귀가 독립적. 병렬 실행 가능.

Needleman-Wunsch (생물정보학)

전체 서열 정렬 (global alignment) 에 Hirschberg 기법 적용. 메모리 제한이 큰 게놈 정렬에 필수.

함정

1. 재귀 깊이

N 이 10^5 이면 재귀 깊이 log N ~ 17. Python 은 recursionlimit 확인.

2. 분할점 k 의 유일성

여러 k 가 같은 total 을 만들 수 있음. 아무 k 나 선택해도 LCS 결과는 동일 (최적 중 하나).

3. reverse 연산

뒤에서부터 DP (rev) 를 위해 문자열 reverse. 인덱스 매핑 실수 주의. rev[m - j] 가 올바른 매칭.

4. N = 1 기저 조건

문자 하나짜리 부분 문자열은 선형 탐색. 모든 재귀 단계에서 이 보호 없으면 무한 재귀.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 9251	LCS	-	kokoa-lab
BOJ 9252	LCS 2 (traceback)	-	kokoa-lab
BOJ 1958	LCS 3	-	kokoa-lab
BOJ 5582	공통 부분 문자열	-	kokoa-lab

참고

[[LCS|최장 공통 부분 수열 (LCS)]]
[[Bitset LCS|비트셋 LCS (Hyyro)]]
[[Dynamic Programming|동적 계획법]]
D. S. Hirschberg, A linear space algorithm for computing maximal common subsequences (1975)

크누스 최적화 (Knuth Optimization)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

크누스 최적화 (Knuth Optimization) 는 구간 DP dp[i][j] = min(dp[i][k-1] + dp[k][j]) + C[i][j] 에서 최적 분할점 k = opt[i][j] 의 단조성 을 이용해 시간 복잡도를 O(N^3) 에서 O(N^2) 으로 줄이는 기법.

1971년 Donald E. Knuth 가 Optimal Binary Search Tree (OBST) 의 O(N^2) 해법을 발표하며 처음 사용.

문제 상황과 동기

왜 필요한가

구간 DP: dp[i][j] = min_k (dp[i][k-1] + dp[k][j]) + C[i][j] (i ≤ k ≤ j).

naive: 모든 k 를 검사, O(N) per state. 상태 N^2 개. 총 O(N^3).
N=2000 이면 8*10^9. 절대 통과 불가.

Knuth 최적화의 돌파구: C[i][j] 가 사각 부등식 (quadrangle inequality) 과 단조성 (monotonicity) 을 만족하면, opt[i][j] 가 opt[i][j-1] <= opt[i][j] <= opt[i+1][j] 를 만족한다. 각 dp[i][j] 의 k 탐색 범위가 O(N) 에서 O(1) amortized 로 감소. 전체 O(N^2).

전제 조건

C[i][j] 가 다음 두 조건을 만족해야 한다.

사각 부등식: i ≤ i’ ≤ j ≤ j’ 일 때 C[i][j] + C[i’][j’] ≤ C[i][j’] + C[i’][j]
단조성: i ≤ i’ ≤ j ≤ j’ 일 때 C[i’][j] ≤ C[i][j’] (또는 C[i][j] 가 i 와 j 에 대해 단조 증가)

이 두 조건이 DP 의 최적 분할점 단조성을 보장한다.

시각화

{}

핵심 아이디어

opt[i][j-1] <= opt[i][j] <= opt[i+1][j]

증명 스케치:
  사각 부등식 -> dp 가 사각 부등식을 만족 (induction)
  사각 부등식 -> 단조성 (monotone decision point)
  귀류법: opt[i][j] < opt[i][j-1] 이라면 모순 유도

이 부등식을 이용하면 dp[i][j] 의 k 탐색 범위를 [opt[i][j-1], opt[i+1][j]] 로 제한할 수 있다. 구간 길이 순으로 바깥 루프 (len = 2..N) 를 돌면, 각 i, j 에 대해 검사하는 k 의 총합이 O(N^2) 임이 보장된다.

알고리즘

KnuthDP(a[1..N]):
    for i = 1..N:
        dp[i][i] = 0         # base
        opt[i][i] = i
        ps[i] = ps[i-1] + a[i]  # prefix sum for C

    for len = 2..N:           # 구간 길이
        for i = 1..N-len+1:   # 시작점
            j = i + len - 1   # 끝점
            dp[i][j] = INF
            sum = C(i, j)     # 예: 구간 합
            # k 범위: opt[i][j-1] ~ opt[i+1][j]
            for k = opt[i][j-1] .. opt[i+1][j]:
                val = dp[i][k-1] + dp[k][j] + sum
                if val < dp[i][j]:
                    dp[i][j] = val
                    opt[i][j] = k
    return dp[1][N]

구현

아래는 파일 합치기 (BOJ 11066) 문제. N 개의 파일을 하나로 합치는 최소 비용. Knuth 최적화로 O(N^3) -> O(N^2).

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Knuth Optimization: O(N^2) #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<int> a(n + 1), ps(n + 1); vector<vector<int>> dp(n + 1, vector<int>(n + 1)); vector<vector<int>> opt(n + 1, vector<int>(n + 1)); for (int i = 1; i <= n; i++) { cin >> a[i]; ps[i] = ps[i - 1] + a[i]; dp[i][i] = 0; opt[i][i] = i; } for (int len = 2; len <= n; len++) { for (int i = 1; i + len - 1 <= n; i++) { int j = i + len - 1; dp[i][j] = INF; int sum = ps[j] - ps[i - 1]; int start = opt[i][j - 1]; int end = min(j - 1, opt[i + 1][j]); for (int k = start; k <= end; k++) { int val = dp[i][k] + dp[k + 1][j] + sum; if (val < dp[i][j]) { dp[i][j] = val; opt[i][j] = k; } } } } cout << dp[1][n] << '\n'; }, }, { language: “python”, label: “Python”, code: `import sys input = sys.stdin.readline INF = 10 ** 9

n = int(input()) a = [0] + list(map(int, input().split())) ps = [0] * (n + 1) for i in range(1, n + 1): ps[i] = ps[i - 1] + a[i]

dp = [[0] * (n + 1) for _ in range(n + 1)] opt = [[0] * (n + 1) for _ in range(n + 1)] for i in range(1, n + 1): dp[i][i] = 0 opt[i][i] = i

for length in range(2, n + 1): for i in range(1, n - length + 2): j = i + length - 1 dp[i][j] = INF s = ps[j] - ps[i - 1] start = opt[i][j - 1] end = min(j - 1, opt[i + 1][j]) for k in range(start, end + 1): val = dp[i][k] + dp[k + 1][j] + s if val < dp[i][j]: dp[i][j] = val opt[i][j] = k

print(dp[1][n]), }, ]} cases={[ { label: "기본", input: 4 40 30 30 50, output: 300, }, { label: "큰 값", input: 5 10 20 30 40 50, output: 330`, }, ]} />

복잡도

항목	값
시간 (최선)	O(N^2)
시간 (평균)	O(N^2)
시간 (최악)	O(N^2) (단조성 유지 시)
공간	O(N^2) (dp + opt 테이블)
최적화 전	O(N^3) -> O(N^2)

각 행 i 에 대해 k 검사 범위의 합이 O(N) 이고, 이걸 N 개의 i 에 대해 O(N^2). naive 대비 N 배 향상.

변형 / 활용

문제	C[i][j]	적용
Optimal Binary Search Tree (OBST)	확률 합	Knuth 의 원 논문
파일 합치기 (BOJ 11066)	구간 합	가장 유명한 PS 예제
Matrix Chain Multiplication (일부)	곱셈 비용	조건에 따라 적용 가능
팰린드롬 분할 (BOJ 1509)	분할 비용	변형 Knuth / D&C

함정

1. 사각 부등식 검증 생략

Knuth 가 적용되는지 수학적으로 증명하지 않고 쓰면 틀린다. C[i][j] 가 단순 구간 합이면 항상 성립하지만, 복잡한 비용 함수는 검증 필수.

2. opt 범위의 경계 처리

opt[i+1][j] 가 i+1 > j 인 경우 (i = j) 접근 오류. 항상 opt[i][i] = i 로 초기화하고 opt[i+1][j] 는 opt[i+1][j] 가 정의된 경우만 사용.

3. opt 테이블 초기값

opt[i][i] = i (base). opt[i][j-1] 과 opt[i+1][j] 가 각각 len-1 에서 계산되도록 구간 길이 순으로 순회.

4. dp 테이블 크기와 overflow

파일 합치기처럼 누적 합이 커지면 int overflow. long long 사용.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11066	파일 합치기	-	kokoa-lab
BOJ 13974	파일 합치기 2	-	kokoa-lab
BOJ 1509	팰린드롬 분할	-	kokoa-lab

참고

[[Divide and Conquer Optimization|분할정복 DP 최적화]]
[[Convex Hull Trick]]
[[Aliens Trick]]
[[Deque Trick|덱 트릭]]

불변량 (Invariant)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

불변량 (Invariant) 은 어떤 변환(operation)이 적용되어도 변하지 않는 양이나 성질. 불가능성 증명, 알고리즘의 정당성(correctness) 증명, 종료 조건 분석에 사용. 대표적으로 parity, coloring, sum/mod, algebraic invariant 가 있다.

문제 상황과 동기

“이 상태에서 저 상태로 도달할 수 있는가?” 를 판별할 때, 가능한 모든 연산을 시뮬레이션할 수는 없다.

naive: BFS/DFS로 모든 상태 탐색. 상태 공간이 지수적으로 커짐.
invariant: 항상 보존되는 양 Q를 찾아, Q(initial) != Q(target) 임을 보이면 불가능 증명. O(1) 판별.

핵심 통찰: 변환은 특정 양을 보존한다. 보존되는 양이 다르면 절대 도달할 수 없다.

시각화

{}

핵심 아이디어

초기 상태 S0 = (변수, 구조, ...)
불변량 I(S) 가 모든 가능한 변환 T 에 대해 I(S) = I(T(S)) 를 만족
I(S0) != I(목표) => 목표 도달 불가능

대표적인 불변량:

불변량	적용	예시
Parity (홀짝)	inversion count, bit flip, swap	15-puzzle, permutation sortability
Coloring	checkerboard 2-coloring	domino tiling, chessboard covering
Sum/Mod	합 또는 mod M 보존	물병 문제, number theory
Algebraic	invariant polynomial	graph isomorphism, knot theory

알고리즘

invariant_check(sequence, operation):
    I = compute_invariant(sequence)
    # operation 이 I 를 보존하는지 확인
    for each possible operation:
        assert I == compute_invariant(apply(sequence, operation))
    # 목표 상태의 I 와 비교
    return I == compute_invariant(target)

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // 순열의 inversion parity 계산 // 불변량: 인접 swap 은 inversion parity 를 바꾸지 않는다 #include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector<int> a(n); for (auto& v : a) cin >> v; int inv = 0; for (int i = 0; i < n; i++) for (int j = i + 1; j < n; j++) if (a[i] > a[j]) inv++; cout << (inv % 2 == 0 ? "even" : "odd") << "\\n"; // 15-puzzle: inversions % 2 == 0 이면 solvable (empty row 보정) return 0; }, }, { language: “python”, label: “Python”, code: `# 도미노 체스판: checkerboard coloring invariant

두 칸을 제거했을 때 도미노로 전부 덮을 수 있는가?

def can_cover(r1, c1, r2, c2): # 각 도미노는 검+흰 1개씩 덮음 # 제거된 두 칸이 다른 색이어야 가능 color = lambda r, c: (r + c) % 2 return color(r1, c1) != color(r2, c2)

a, b, c, d = map(int, input().split()) print(1 if can_cover(a, b, c, d) else 0)

BOJ 7538: 서로 다른 색 두 칸만 제거 가능`,

},
{
  language: "java",
  label: "Java",
  code: `// Parity invariant for permutation

public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); int[] a = new int[n]; for (int i = 0; i < n; i++) a[i] = sc.nextInt(); int inv = 0; for (int i = 0; i < n; i++) for (int j = i + 1; j < n; j++) if (a[i] > a[j]) inv++; System.out.println(inv % 2 == 0 ? “even” : “odd”); } }, }, ]} cases={[ { label: "순열 parity", input: 4 3 1 4 2, output: even`, }, ]} />

복잡도

항목	값
불변량 계산	O(N) 또는 O(N log N)
판별	O(1) (initial vs target 비교)
invariant 찾기	문제마다 다름 (경험 + 통찰)
안정성	항상 정확 (necessary & sufficient)

변형 / 활용

변형	설명	활용
Parity invariant	inversion count, XOR parity	15-puzzle, Sorting network
Coloring invariant	그래프 2-coloring, bipartiteness	체스판 tiling, domino covering
Monovariant	단조 변화량 (항상 증가/감소)	종료 증명, potential function
Algebraic invariant	차수, rank, determinant	선형대수, 매트로이드

함정

1. 불변량이 충분 조건이 아닐 때

같은 불변량 값을 가져도 실제로 도달 가능하지 않을 수 있음. parity 만으로 15-puzzle 이 완전히 결정되지는 않음 (empty tile row 도 고려).

2. invariant vs monovariant 혼동

불변량은 변하지 않는 양. Monovariant는 단조 변하는 양 (항상 증가/감소). 후자는 알고리즘 종료 증명에 사용.

3. 불변량을 잘못 선택

너무 강한 불변량은 깨지기 쉽고, 너무 약한 불변량은 useless. 경험적으로 mod 2, sum, XOR 이 자주 통함.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2136	개미	33.7%	kokoa-lab
BOJ 7538	Incomplete chess boards	69.7%	kokoa-lab
BOJ 10424	알고리즘 기말고사	31.8%	kokoa-lab
BOJ 32034	동전 쌍 뒤집기	35.0%	kokoa-lab

참고

[[Permutation Cycle Decomposition|순열 사이클 분해]]
[[Parity|홀짝성]]
[[Graph Traversal|그래프 탐색]]
[[Game Theory|게임 이론]] (Sprague-Grundy 의 mex invariant)

보이어-무어 다수결 투표 (Boyer-Moore Majority Vote)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

보이어-무어 다수결 투표 (Boyer-Moore Majority Vote) 는 배열에서 과반수 (> N/2) 를 차지하는 원소를 O(N) 시간, O(1) 공간으로 찾는 알고리즘. 1982년 Robert S. Boyer와 J Strother Moore가 고안.

문제 상황과 동기

배열 a[0..N-1] 에서 과반수 원소 (N/2 번 이상 나타나는 원소) 를 찾는다.

naive: 각 원소마다 등장 횟수 세기. O(N^2) 또는 hash map 으로 O(N) 시간, O(N) 공간.
핵심 통찰: 서로 다른 두 원소를 짝지으면 둘 다 제거해도 과반수는 변하지 않음. 이를 반복하면 마지막에 남은 원소가 유일한 후보.

자주 등장: 투표 시스템, 센서 데이터 이상 탐지, 스트림 처리.

시각화

{}

핵심 아이디어

Invariant: (candidate, count) 쌍을 유지. count 가 0이면 현재 원소를 새 후보로, 같으면 count++, 다르면 count—.

핵심: 과반수 원소 x 가 존재하면, 다른 모든 원소를 제거해도 x 는 남음.
      count 가 0 이 되는 순간 새 후보를 선택해도, 
      x 의 등장 횟수 > (다른 모든 원소의 합) 이므로 x 가 최종 후보.

주의: 과반수가 존재하지 않을 수도 있으므로 두 번째 pass 에서 검증 필수.

알고리즘

majority_vote(a[0..N-1]):
    # Pass 1: 후보 찾기
    candidate = null
    count = 0
    for i = 0..N-1:
        if count == 0:
            candidate = a[i]
            count = 1
        else if a[i] == candidate:
            count += 1
        else:
            count -= 1
    
    # Pass 2: 검증 (과반수 확인)
    count = 0
    for i = 0..N-1:
        if a[i] == candidate:
            count += 1
    
    if count > N / 2:
        return candidate
    else:
        return -1  # 과반수 없음

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `#include <bits/stdc++.h> using namespace std; int main() { int n; cin >> n; vector a(n); for (int i = 0; i < n; i++) cin >> a[i];

// Pass 1: 후보 찾기
int candidate = -1, count = 0;
for (int i = 0; i < n; i++) {
    if (count == 0) {
        candidate = a[i];
        count = 1;
    } else if (a[i] == candidate) {
        count++;
    } else {
        count--;
    }
}

// Pass 2: 검증
count = 0;
for (int i = 0; i < n; i++) {
    if (a[i] == candidate) count++;
}

if (count > n / 2) {
    cout << candidate << "\\n";
} else {
    cout << -1 << "\\n";
}
return 0;

}, }, { language: "python", label: "Python", code: n = int(input()) a = list(map(int, input().split()))

Pass 1: 후보 찾기

candidate = None count = 0 for x in a: if count == 0: candidate = x count = 1 elif x == candidate: count += 1 else: count -= 1

Pass 2: 검증

count = a.count(candidate) if count > n // 2: print(candidate) else: print(-1), }, { language: "java", label: "Java", code: import java.util.*;

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

    // Pass 1: 후보 찾기
    int candidate = -1, count = 0;
    for (int i = 0; i < n; i++) {
        if (count == 0) {
            candidate = a[i];
            count = 1;
        } else if (a[i] == candidate) {
            count++;
        } else {
            count--;
        }
    }
    
    // Pass 2: 검증
    count = 0;
    for (int i = 0; i < n; i++) {
        if (a[i] == candidate) count++;
    }
    
    if (count > n / 2) {
        System.out.println(candidate);
    } else {
        System.out.println(-1);
    }
}

}, }, ]} cases={[ { label: "과반수 존재", input: 7 2 3 2 1 2 4 2, output: 2, }, { label: "과반수 없음", input: 4 1 2 3 4, output: -1`, }, ]} />

복잡도

항목	값
시간 (Pass 1)	O(N)
시간 (Pass 2)	O(N)
전체 시간	O(N)
공간	O(1) (candidate, count 만 저장)
안정성	N/A (원소 순서 변경 없음)

변형 / 활용

1. 모든 과반수 원소 찾기 (k-majority)

N/k 이상 등장하는 모든 원소 찾기. 최대 k-1 개 후보 유지.

2. 스트림 처리

배열 전체를 메모리에 올릴 수 없을 때, 한 번에 한 원소씩 처리 가능.

3. 분산 환경

각 노드에서 로컬 후보 찾고, 전역 후보 검증.

함정

1. 검증 pass 필수

과반수가 존재하지 않으면 candidate 는 의미 없음. 반드시 두 번째 pass 에서 count > N/2 확인.

2. > N/2 vs >= N/2

알고리즘은 strictly greater than N/2 만 보장. >= N/2 를 원하면 다른 접근 필요.

3. 음수 / 큰 수

hash map 대신 쓰는 이유가 O(1) 공간이므로, 음수나 큰 수도 그대로 처리 가능. 단, 정수 범위 주의.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11652	카드	(수집 안 됨)	kokoa-lab
BOJ 25186	INFP 남진	(수집 안 됨)	kokoa-lab
BOJ 13116	30번	(수집 안 됨)	kokoa-lab
BOJ 1764	듣보잡	(수집 안 됨)	kokoa-lab

참고

[[Hash Set|해시셋]]
[[Sorting|정렬]]

순열 사이클 분해 (Permutation Cycle Decomposition)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

순열 사이클 분해는 순열 p[1..N]을 서로소(disjoint)인 사이클들의 곱으로 표현하는 것. 각 사이클 (a1 a2 … ak) 는 a1 -> p[a1] = a2, a2 -> p[a2] = a3, …, ak -> p[ak] = a1 을 의미.

문제 상황과 동기

순열을 함수 f(i) = p[i] 로 보면, 각 원소의 orbit 을 추적할 수 있다.

응용: 정렬 (swap 으로 정렬하는 최소 횟수 = N - 사이클 수), 치환 암호, 그룹 이론
최소 swap 정렬: 임의의 두 원소를 swap 할 때, N - (#cycles) 번이 최소

핵심 통찰: 순열은 방향 그래프로 볼 때 모든 정점의 out-degree = 1 이며, 각 연결 요소는 정확히 하나의 사이클을 이룬다.

시각화

{}

핵심 아이디어

p = [3, 1, 2, 5, 4]  (1-indexed)

그래프:
  1 -> 3 -> 2 -> 1  (사이클, 길이 3)
  4 -> 5 -> 4       (사이클, 길이 2)

사이클 분해: p = (1 3 2)(4 5)

사이클 분해 알고리즘:

visited[1..N] = false
for i in 1..N:
if not visited[i]:
```
새로운 사이클 시작
```
```
j = i
```
```
while not visited[j]:
```
```
  visited[j] = true
```
```
  사이클에 j 추가
```
```
  j = p[j]
```

알고리즘

find_cycles(p, N):
    visited = [false] * (N + 1)
    cycles = []
    for i = 1..N:
        if not visited[i]:
            cur = []
            j = i
            while not visited[j]:
                visited[j] = true
                cur.append(j)
                j = p[j]
            cycles.append(cur)
    return cycles

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // 순열 사이클 개수 세기, BOJ 10451 // 사이클 수 = N - (서로 다른 사이클 수) #include <bits/stdc++.h> using namespace std; int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int T; cin >> T; while (T--) { int n; cin >> n; vector<int> p(n + 1); for (int i = 1; i <= n; i++) cin >> p[i]; vector<bool> vis(n + 1, false); int cycles = 0; for (int i = 1; i <= n; i++) { if (vis[i]) continue; cycles++; for (int j = i; !vis[j]; j = p[j]) vis[j] = true; } cout << cycles << "\\n"; } return 0; }, }, { language: “python”, label: “Python”, code: # 순열 사이클 개수 (BOJ 10451) import sys input = sys.stdin.readline T = int(input()) for _ in range(T): n = int(input()) p = [0] + list(map(int, input().split())) vis = [False] * (n + 1) cycles = 0 for i in range(1, n + 1): if vis[i]: continue cycles += 1 j = i while not vis[j]: vis[j] = True j = p[j] print(cycles), }, { language: “java”, label: “Java”, code: `// BOJ 10451: Count permutation cycles

public class Main { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int T = Integer.parseInt(br.readLine()); while (T— > 0) { int n = Integer.parseInt(br.readLine()); int[] p = new int[n + 1]; StringTokenizer st = new StringTokenizer(br.readLine()); for (int i = 1; i <= n; i++) p[i] = Integer.parseInt(st.nextToken()); boolean[] vis = new boolean[n + 1]; int cycles = 0; for (int i = 1; i <= n; i++) { if (vis[i]) continue; cycles++; for (int j = i; !vis[j]; j = p[j]) vis[j] = true; } System.out.println(cycles); } } }, }, ]} cases={[ { label: "사이클 개수", input: 2 8 3 2 7 8 1 4 5 6 5 2 1 4 3 5, output: 3 3`, }, ]} />

복잡도

항목	값
시간	O(N)
공간	O(N) (visited 배열)
최소 swap 정렬	O(N) (N - cycles)
안정성	유일한 분해 (disjoint cycles)

변형 / 활용

최소 swap 정렬

임의의 두 원소를 swap 하여 정렬할 때, 최소 swap 횟수 = N - (사이클 수). 각 사이클 (길이 k)는 k-1 번의 swap 으로 정렬 가능.

다음 순열 / 이전 순열

사이클 분해로 다음 순열(Next Permutation)과 이전 순열을 O(N) 에 계산 가능.

치환 행렬

순열 p 는 permutation matrix P 로 표현 가능. 사이클 분해는 P 의 Jordan 표준형과 연관.

함정

1. 1-indexed vs 0-indexed

C++ 배열이 0-indexed 라도 순열 문제는 1-indexed 표기가 편리. p[1..N] 을 사용하고 i 위치 주의.

2. visited 체크 순서

사이클 추적 시 while 순서: vis[j] 체크 후 j = p[j] 갱신. 아니면 무한루프.

3. 사이클 길이 1 처리

자기 자신을 가리키는 원소(p[i] == i) 는 길이 1 사이클. 정렬 관점에서 swap 0 회.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 10451	순열 사이클	63.7%	kokoa-lab
BOJ 10972	다음 순열	33.3%	kokoa-lab
BOJ 10973	이전 순열	35.3%	kokoa-lab
BOJ 9742	순열	17.5%	kokoa-lab

참고

[[Invariant|불변량]] (permutation parity)
[[Functional Graph|함수형 그래프]]
[[DFS|DFS (깊이 우선 탐색)]]

번사이드 보조정리 (Burnside's Lemma)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

번사이드 보조정리 (Burnside’s Lemma, Cauchy-Frobenius Lemma) 는 군 G 가 집합 X 에 작용할 때, 궤도(orbit)의 개수 를 구하는 공식:

|X/G| = (1/|G|) * sum_{g in G} |Fix(g)|

Fix(g): g 에 의해 고정되는(fixed) X 의 원소 집합.
|G|: 군의 크기 (group order).

1845년 Cauchy 최초 발견, Burnside (1897) 가 저서로 널리 알림.

문제 상황과 동기

대칭(symmetry) 이 있는 조합적 대상의 “본질적으로 다른” 개수를 셀 때.

naive: 모든 경우를 나열 후 중복 제거. k^n 가지가 n! 대칭과 합쳐져 폭발.
Burnside: 각 대칭 변환(g) 에 대해 불변인 배치 수를 세고 평균.

핵심 통찰: 대칭 변환 각각에 대해 고정되는 배치 수는 독립적으로 계산 가능. 그 평균이 곧 distinct orbits 수.

시각화

{}

핵심 아이디어

공식의 의미

3단계로 구성:

대칭 변환 나열: 군 G 의 모든 원소 g 를 나열한다.
고정점 계산: 각 g 에 대해 g 를 적용해도 변하지 않는 X 의 원소(배치) 수 |Fix(g)| 를 구한다.
평균: 모두 더한 후 |G| 로 나눈다.

예시: 4개 구슬 목걸이, 2색 (회전만)

회전군 C_4 (4개 회전):

| 회전 | 고정 조건 | |Fix(g)| | |:---|---:|:---| | 0도 (항등) | 모든 2^4 가지 | 16 | | 90도 | 모든 구슬 같은 색 | 2 | | 180도 | 마주보는 쌍 동일 | 4 | | 270도 | 모든 구슬 같은 색 | 2 |

(16 + 2 + 4 + 2) / 4 = 6 가지.

일반식 (회전만)

necklace(n, k) = (1/n) * sum_{r=0}^{n-1} k^{gcd(n, r)}

Polya vs Burnside

정리	관점	입력
Burnside	각 변환의 고정점	`
Polya	각 변환의 순환 구조	`k^{C(g)}` (C(g) = 순환 개수)

알고리즘

burnside_necklace(n, k):
    total = 0
    for r = 0..n-1:
        total += k^{gcd(n, r)}
    return total / n

# D_n (회전 + 반사)
burnside_dihedral(n, k):
    total = burnside_necklace(n, k) * n   # 회전 기여
    # 반사 기여
    if n % 2 == 0:
        total += n/2 * (k^{n/2} + k^{n/2 + 1})
    else:
        total += n * k^{(n+1)/2}
    return total / (2*n)

구현

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

ll modpow(ll base, ll exp, ll mod) { ll res = 1; while (exp) { if (exp & 1) res = res * base % mod; base = base * base % mod; exp >>= 1; } return res; }

int main() { // 회전만: necklace(n, k) int n, k; cin >> n >> k; ll total = 0; for (int r = 0; r < n; r++) total += modpow(k, gcd(n, r), LLONG_MAX); cout << “Necklace (rotation): ” << total / n << “\n”;

// 반사 포함 (Dihedral group D_n)
total = 0;
for (int r = 0; r < n; r++)
    total += modpow(k, gcd(n, r), LLONG_MAX);
if (n % 2 == 1) {
    total += n * modpow(k, (n + 1) / 2, LLONG_MAX);
} else {
    total += n / 2 * modpow(k, n / 2, LLONG_MAX);
    total += n / 2 * modpow(k, n / 2 + 1, LLONG_MAX);
}
cout << "Necklace (dihedral): " << total / (2 * n) << "\\n";
return 0;

}, }, { language: "python", label: "Python", code: # Burnside’s lemma: necklace counting import math

def modpow(base, exp, mod): res = 1 while exp: if exp & 1: res = res * base % mod base = base * base % mod exp >>= 1 return res

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

rotation only

total = sum(k ** math.gcd(n, r) for r in range(n)) print(f”Necklace (rotation): {total // n}“)

dihedral (rotation + reflection)

total = sum(k ** math.gcd(n, r) for r in range(n)) if n % 2 == 1: total += n * k ** ((n + 1) // 2) else: total += n // 2 * k ** (n // 2) total += n // 2 * k ** (n // 2 + 1) print(f”Necklace (dihedral): {total // (2 * n)}“), }, { language: "java", label: "Java", code: import java.util.*;

public class Main { static long modpow(long base, long exp, long mod) { long res = 1; while (exp > 0) { if ((exp & 1) == 1) res = res * base % mod; base = base * base % mod; exp >>= 1; } return res; }

static long gcd(long a, long b) {
    return b == 0 ? a : gcd(b, a % b);
}

public static void main(String[] args) {
    Scanner sc = new Scanner(System.in);
    int n = sc.nextInt();
    int k = sc.nextInt();

    long total = 0;
    for (int r = 0; r < n; r++)
        total += modpow(k, gcd(n, r), Long.MAX_VALUE);
    System.out.println("Necklace (rotation): " + total / n);

    total = 0;
    for (int r = 0; r < n; r++)
        total += modpow(k, gcd(n, r), Long.MAX_VALUE);
    if (n % 2 == 1) {
        total += n * modpow(k, (n + 1) / 2, Long.MAX_VALUE);
    } else {
        total += n / 2 * modpow(k, n / 2, Long.MAX_VALUE);
        total += n / 2 * modpow(k, n / 2 + 1, Long.MAX_VALUE);
    }
    System.out.println("Necklace (dihedral): " + total / (2 * n));
}

}, }, ]} cases={[ { label: "4구슬 2색", input: 4 2, output: Necklace (rotation): 6 Necklace (dihedral): 6, }, { label: "6구슬 3색", input: 6 3, output: Necklace (rotation): 130 Necklace (dihedral): 92`, }, ]} />

복잡도

항목	값
회전만 (C_n)	O(n log k) (거듭제곱)
정다각형 (D_n)	O(n log k)
정육면체 면 색칠	O(1) (고정 24개 변환)

변형 / 활용

정육면체 면 색칠 (k 색)

회전군 크기 = 24. cube_faces(k) = (k^6 + 3*k^4 + 12*k^3 + 8*k^2) / 24. k=2 -> 10 가지.

응용 분야

목걸이/팔찌 색칠: C_n (회전) / D_n (회전+반사)
분자의 이성질체 계수: 화학에서 구조 이성질체 수
그래프 색칠 대칭: 군 작용 궤도 계산
Polya 열거 정리: 가중치 있는 색칠, 생성함수

함정

1. 단순 나누기

k^n / n 이 아닌 이유: 각 변환마다 고정점 개수가 다르다.

2. 반사 대칭 누락

홀수/짝수 n 에 따라 반사축 구조가 다름. 항상 케이스 분기 필요.

3. mod 나눗셈

mod p 에서 |G| 로 나눌 때 modular inverse 사용. p 가 |G| 와 서로소인지 확인.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 9817	Necklace of Beads	73.0%	kokoa-lab
BOJ 12748	색칠 공부 (Large)	65.6%	kokoa-lab
BOJ 18567	Kaleidoscope	88.9%	kokoa-lab

참고

[[Combinatorics|조합론]]

게임 이론 (Game Theory)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

게임 이론 (Game Theory) 은 둘 이상의 플레이어가 정해진 규칙 아래 의사 결정을 내리는 상황을 수학적으로 모델링하는 분야. PS에서는 두 명이 완벽한 플레이를 할 때 승자를 결정하는 조합 게임(combinatorial game)에 집중한다.

문제 상황과 동기

두 플레이어가 번갈아 행동하며, 마지막 행동을 하는 사람이 이기거나(정상 게임) 지는(미저리 게임) 규칙의 게임.

naive: 가능한 모든 게임 트리 전개. 상태 수가 기하급수적.
DP + Nim-XOR: 상태가 작으면 win/loss DP O(N), 돌무더기가 여러 개면 Nim XOR O(N) 로 승패 결정.

핵심 통찰: Impartial game (두 플레이어의 행동이 동일) 은 모두 Nim-heap 하나로 환원 가능 (Sprague-Grundy 정리).

시각화

{}

핵심 아이디어

Win/Loss 상태

Winning state (W): 현재 턴인 플레이어가 이길 수 있는 상태.
Losing state (L): 현재 턴인 플레이어가 무조건 지는 상태.

점화식:

dp[i] = (i번째 상태에서 이기는가?)
dp[i] = true if ∃move to dp[j] = false  (W = 갈 수 있는 L이 존재)
dp[i] = false if all moves go to dp[j] = true (L = 모든 행선지가 W)

Nim 게임

돌무더기 여러 개. 각 더미에서 1개 이상 제거 가능. 정상 규칙(마지막 돌 가져가는 사람 승).

Nim-XOR (Bouton): XOR sum = p1 xor p2 xor ... xor pk. XOR sum != 0 이면 선공 승, 0 이면 후공 승.

nim_win(piles):
    xor_sum = fold(xor, piles)
    return xor_sum != 0

Zero-Sum Game

한 플레이어의 이득이 다른 플레이어의 손실과 정확히 일치하는 게임. Minimax 원칙으로 최적 전략 계산.

알고리즘

# 돌 게임 (N개 돌, 1 or 3개 가져감)
win[0] = false
for i = 1..N:
    win[i] = false
    if i >= 1 and not win[i-1]: win[i] = true
    if i >= 3 and not win[i-3]: win[i] = true

# Nim XOR
xor = 0
for p in piles: xor ^= p
if xor != 0: First wins else Second wins

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// 돌 게임 (N, take 1 or 3) + Nim XOR #include <bits/stdc++.h> using namespace std;

int main() { // 1. 돌 게임 DP (N <= 1000) int N; cin >> N; vector win(N + 1, false); for (int i = 1; i <= N; i++) { if (i >= 1 && !win[i-1]) win[i] = true; if (i >= 3 && !win[i-3]) win[i] = true; } cout << “Stone game winner: ” << (win[N] ? “SK” : “CY”) << “\n”;

// 2. Nim XOR
int k; cin >> k;
long long xsum = 0;
for (int i = 0; i < k; i++) {
    long long p; cin >> p;
    xsum ^= p;
}
cout << "Nim winner: "
     << (xsum ? "koosaga" : "cubelover") << "\\n";
return 0;

}, }, { language: "python", label: "Python", code: # 돌 게임 DP + Nim XOR import sys input = sys.stdin.readline

N = int(input()) win = [False] * (N + 1) for i in range(1, N + 1): if (i >= 1 and not win[i-1]) or (i >= 3 and not win[i-3]): win[i] = True print(“SK” if win[N] else “CY”)

k = int(input()) piles = list(map(int, input().split())) xsum = 0 for p in piles: xsum ^= p print(“koosaga” if xsum else “cubelover”), }, { language: "java", label: "Java", code: import java.util.*;

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()); boolean[] win = new boolean[N + 1]; for (int i = 1; i <= N; i++) { if ((i >= 1 && !win[i-1]) || (i >= 3 && !win[i-3])) win[i] = true; } System.out.println(win[N] ? “SK” : “CY”);

    int k = Integer.parseInt(br.readLine());
    StringTokenizer st = new StringTokenizer(br.readLine());
    long xsum = 0;
    for (int i = 0; i < k; i++)
        xsum ^= Long.parseLong(st.nextToken());
    System.out.println(xsum != 0 ? "koosaga" : "cubelover");
}

}, }, ]} cases={[ { label: "기본", input: 5 2 3 7, output: Stone game winner: SK Nim winner: cubelover, }, { label: "큰 값", input: 1000 4 1 2 3 4, output: Stone game winner: CY Nim winner: koosaga`, }, ]} />

복잡도

항목	값
돌 게임 DP 시간	O(N)
Nim XOR 시간	O(K) (K: 더미 수)
공간	O(N) 또는 O(1)

변형 / 활용

게임 패밀리

종류	설명	대표 문제
Take-away	일정 개수 가져감	돌 게임
Nim	여러 더미, XOR 결정	님 게임
Misere Nim	마지막 돌 가져가는 사람이 짐	nim XOR 후 예외 처리
Green Hackenbush	트리 절단 게임	하켄부시
Dawson’s Kayles	볼링핀 제거	SG 이론 활용

응용

최적 전략 게임 (Minimax): 제로섬 게임에서 최적 행동.
게임 트리 + DP: 상태 공간이 작으면 완전 탐색 DP 로 족보 판정.

함정

1. XOR 이해 오류

XOR sum 이 0 이면 선공 패, != 0 이면 선공 승. misere 에서는 예외 (모든 더미가 1 이하일 때 반대).

2. 상태 정의 누락

DP 정의 시 “현재 턴인 플레이어 기준” 임을 명확히. 실제 판정과 반대로 정의하는 실수.

3. 큰 N / 큰 P

돌 개수가 10^12 면 DP 불가. 패턴 찾아 O(1) 또는 SG 주기성 활용.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 9655	돌 게임	66.4%	kokoa-lab
BOJ 9657	돌 게임 3	46.9%	kokoa-lab
BOJ 11868	님 게임 2	80.3%	kokoa-lab
BOJ 11694	님 게임	36.6%	kokoa-lab

참고

[[Sprague-Grundy Theorem|스프라그-그런디 정리]]
[[DP|다이나믹 프로그래밍]]

Hackenbush (하켄부시 게임)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Hackenbush 는 John H. Conway 가 “On Numbers and Games” (1976) 에서 고안한 combinatorial game. 바닥에 연결된 여러 개의 색깔 가지 (빨강/파랑) 가 있고, Left (파랑) 는 파란 가지를, Right (빨강) 는 빨간 가지를 자른다. 바닥과 연결이 끊긴 부분은 사라진다. 마지막으로 자를 수 있는 플레이어가 이긴다. 각 위치는 surreal number 로 값이 매겨진다.

문제 상황과 동기

combinatorial game theory 에서 위치의 “값”을 어떻게 정의할 것인가? Conway 는 Hackenbush 를 통해 surreal number 를 직관적으로 설명했다.

naive 접근: minimax tree search. 위치 수가 기하급수적으로 증가.
핵심 통찰: Blue-Red Hackenbush 의 각 위치는 surreal number 하나와 대응. 파란 가지 = Left 에게 유리 (+), 빨간 가지 = Right 에게 유리 (-). 가지가 갈라지는 구조는 {L|R} 꼴 surreal number.
의의: 모든 partizan game 의 값을 측정하는 기준을 제공.

시각화

{}

핵심 아이디어

Blue-Red Hackenbush 의 값은 각 edge 의 색과 구조로 결정:

파란 가지 하나: +1 (Left 에게 유리)
빨간 가지 하나: -1 (Right 에게 유리)
chain 구조: 각 edge 의 값을 단순 합산. B-B-R = (+1) + (+1) + (-1) = +1.
branching 구조: {L|R} 형식의 surreal number. L = Left 가 자를 수 있는 위치들의 최대값, R = Right 가 자를 수 있는 위치들의 최소값.

surreal number 의 정의: {L|R} 에서 L < R 일 때 이는 유리수에 대응. 예: {0|} = 1, {|0} = -1, {0|1} = 1/2.

알고리즘

evaluate_chain(s):
    val = 0
    for each char c in s:
        if c == 'B': val += 1
        else: val -= 1
    return val

winner(val):
    if val > 0: "Left (Blue)"
    if val < 0: "Right (Red)"
    if val == 0: "Second player"

branching_value(left_options, right_options):
    # left_options = {L1, L2, ...}, right_options = {R1, R2, ...}
    # simplest surreal number between max(L) and min(R)
    return simplest_surreal(max(left_options), min(right_options))

구현

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

struct Frac { ll num, den; Frac(ll n = 0, ll d = 1) : num(n), den(d) { if (den < 0) { num = -num; den = -den; } ll g = gcd(abs(num), abs(den)); num /= g; den /= g; } Frac operator+(const Frac& o) const { return Frac(num * o.den + o.num * den, den * o.den); } bool operator>(const Frac& o) const { return num * o.den > o.num * den; } bool operator<(const Frac& o) const { return num * o.den < o.num * den; } bool operator==(const Frac& o) const { return num == o.num && den == o.den; } };

int main() { string s; cin >> s; Frac val; for (char c : s) { if (c == ‘B’) val = val + Frac(1); else if (c == ‘R’) val = val + Frac(-1); } cout << “Position value: ” << val.num << ”/” << val.den << “\n”; if (val > Frac(0)) cout << “Winner: Left (Blue)\n”; else if (val < Frac(0)) cout << “Winner: Right (Red)\n”; else cout << “Winner: Second player\n”; return 0; }, }, { language: "python", label: "Python", code: from fractions import Fraction import sys s = sys.stdin.readline().strip() val = Fraction(0, 1) for c in s: if c == ‘B’: val += Fraction(1, 1) elif c == ‘R’: val -= Fraction(1, 1) print(f”Position value: {val}”) if val > 0: print(“Winner: Left (Blue)”) elif val < 0: print(“Winner: Right (Red)”) else: print(“Winner: Second player”)`, }, ]} cases={[ { label: “Blue 3개 chain”, input: “BBB”, output: “Position value: 3\nWinner: Left (Blue)”, }, { label: “혼합 chain”, input: “BBR”, output: “Position value: 1\nWinner: Left (Blue)”, }, { label: “Red 우세”, input: “RRRB”, output: “Position value: -2\nWinner: Right (Red)”, }, { label: “Zero game”, input: “BR”, output: “Position value: 0\nWinner: Second player”, }, ]} />

복잡도

항목	값
시간 (chain 평가)	O(N)
공간	O(1)
가지 평가 (일반)	PSPACE-hard
안정성	-

변형 / 활용

Green Hackenbush: impartial variant. 모든 edge 가 초록색 = 누구나 자를 수 있음. Grundy number 로 평가.
Hackenbush Hotchpotch: 빨강, 파랑, 초록 세 가지 색 혼합.
Surreal number 모델: Hackenbush 위치는 surreal number 체계의 직관적 모델. Conway 의 “On Numbers and Games” 에서 이 게임으로 surreal number 를 설명.
Game theory 교육: partizan game 의 기본 개념을 시각적으로 학습.

함정

1. Branching 구조의 값

단순 chain 의 값이 +1/-1 의 합인 반면, 가지가 갈라지면 {L|R} 형식의 surreal number 가 필요. 예: 파란 가지와 빨간 가지가 같은 높이에서 갈라지면 값은 {1|-1} = 0.

2. Zero game 의 의미

값이 0인 위치는 후수 승. 즉 먼저 자르는 쪽이 진다. “모서리” 위치는 항상 후수 승.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11868	님 게임 2	(수집 안 됨)	kokoa-lab
BOJ 13034	다각형 게임	(수집 안 됨)	kokoa-lab
BOJ 16888	루트 님 게임	(수집 안 됨)	kokoa-lab

참고

[[Grundy Number]]
[[Nim Game]]

스프라그-그런디 정리 (Sprague-Grundy)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

스프라그-그런디 정리 (Sprague-Grundy) 는 모든 impartial combinatorial game (두 플레이어가 같은 행동 가능, 무작위성 없음, 완전 정보) 이 Nim-heap 하나와 동등함을 증명하는 정리. 각 게임 상태는 Grundy number (nimber) 로 표현되며, Grundy number 가 0 이면 패배 상태, 0 이 아니면 승리 상태.

문제 상황과 동기

여러 impartial game 이 동시에 진행될 때 (e.g., Nim 의 여러 더미), 각각을 독립 분석 후 XOR 로 합성.

naive: 전체 상태 공간의 game tree 그리기. 상태 폭발.
SG 이론: 각 부분 게임의 Grundy 수를 XOR. 모든 상태를 Nim 으로 환원.

핵심 통찰: 모든 impartial game 의 상태는 자연수 (Grundy number) 로 완전히 추상화되며, 게임의 합성은 XOR.

시각화

{}

핵심 아이디어

Grundy Number 정의

G(v) = mex({ G(u) | v -> u })

mex: Minimum EXcluded non-negative integer.
v -> u: 상태 v 에서 한 번의 행동으로 도달 가능한 상태 u.
G(v) = 0: losing state (P-position).
G(v) != 0: winning state (N-position).

게임 합성 (Nim-Sum)

여러 독립 게임 G1, G2, ..., Gk 가 동시에 진행될 때:

G_total = G1 xor G2 xor ... xor Gk

G_total = 0 이면 후공 승, != 0 이면 선공 승.

계산 예시 (돌 게임, take {1, 3, 4})

G(0) = 0                  (terminal, no moves)
G(1) = mex({G(0)}) = mex({0}) = 1
G(2) = mex({G(1)}) = mex({1}) = 0
G(3) = mex({G(2), G(0)}) = mex({0, 0}) = 1
G(4) = mex({G(3), G(1), G(0)}) = mex({1, 1, 0}) = 2
G(5) = mex({G(4), G(2), G(1)}) = mex({2, 0, 1}) = 3

알고리즘

compute_grundy(max_state, moves):
    G[0..max_state] = 0
    for s = 1..max_state:
        reachable = empty set
        for m in moves:
            if s >= m:
                reachable.add(G[s - m])
        G[s] = mex(reachable)
    return G

mex(S):
    g = 0
    while g in S: g++
    return g

# 게임 합성
xor_sum = 0
for g in grundy_numbers_of_each_game:
    xor_sum ^= g
winner = "First" if xor_sum != 0 else "Second"

구현

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

int mex(const vector& seen) { int g = 0; while (g < (int)seen.size() && seen[g]) g++; return g; }

int main() { const int MAX = 1000; vector moves = {1, 3, 4}; vector G(MAX + 1, 0);

for (int s = 1; s <= MAX; s++) {
    vector<bool> seen(MAX + 1, false);
    for (int m : moves)
        if (s >= m) seen[G[s - m]] = true;
    G[s] = mex(seen);
}

int N; cin >> N;
if (G[N])
    cout << "G(" << N << ") = " << G[N]
         << " -> First wins\\n";
else
    cout << "G(" << N << ") = 0 -> Second wins\\n";

// 여러 게임 합성
int k; cin >> k;
int xsum = 0;
for (int i = 0; i < k; i++) {
    int p; cin >> p;
    // Nim: Grundy = pile size
    xsum ^= p;
}
cout << "Nim XOR = " << xsum << " -> "
     << (xsum ? "First" : "Second") << "\\n";
return 0;

}, }, { language: "python", label: "Python", code: # Grundy number + Nim XOR def mex(seen): g = 0 while g < len(seen) and seen[g]: g += 1 return g

MAX = 1000 moves = [1, 3, 4] G = [0] * (MAX + 1) for s in range(1, MAX + 1): seen = [False] * (MAX + 1) for m in moves: if s >= m: seen[G[s - m]] = True G[s] = mex(seen)

N = int(input()) if G[N]: print(f”G({N}) = {G[N]} -> First wins”) else: print(f”G({N}) = 0 -> Second wins”)

k = int(input()) piles = list(map(int, input().split())) xsum = 0 for p in piles: xsum ^= p print(f”Nim XOR = {xsum} -> {‘First’ if xsum else ‘Second’}“), }, { language: "java", label: "Java", code: import java.util.*;

public class Main { static int mex(boolean[] seen) { int g = 0; while (g < seen.length && seen[g]) g++; return g; }

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    int MAX = 1000;
    int[] moves = {1, 3, 4};
    int[] G = new int[MAX + 1];

    for (int s = 1; s <= MAX; s++) {
        boolean[] seen = new boolean[MAX + 1];
        for (int m : moves)
            if (s >= m) seen[G[s - m]] = true;
        G[s] = mex(seen);
    }

    int N = Integer.parseInt(br.readLine());
    if (G[N] != 0)
        System.out.println("G(" + N + ") = " + G[N] + " -> First wins");
    else
        System.out.println("G(" + N + ") = 0 -> Second wins");

    int k = Integer.parseInt(br.readLine());
    StringTokenizer st = new StringTokenizer(br.readLine());
    int xsum = 0;
    for (int i = 0; i < k; i++)
        xsum ^= Integer.parseInt(st.nextToken());
    System.out.println("Nim XOR = " + xsum + " -> " + (xsum != 0 ? "First" : "Second"));
}

}, }, ]} cases={[ { label: "기본", input: 5 3 1 2 3, output: G(5) = 3 -> First wins Nim XOR = 0 -> Second, }, { label: "패배 상태", input: 2 2 3 3, output: G(2) = 0 -> Second wins Nim XOR = 0 -> Second`, }, ]} />

복잡도

항목	값
Grundy DP 시간	O(S x M) (S: 상태 수, M: 행동 수)
게임 합성 시간	O(K) (K: 게임 수)
공간	O(S) 또는 O(1)

변형 / 활용

응용 분야

유형	특징
Nim 계열	Grundy = pile size
Take-away 계열	행동 집합에 따라 Grundy 주기적
게임 분할	한 행동이 게임을 두 개로 분할
Green Hackenbush	트리 절단, Grundy = tree height XOR

SG + DP

다각형 게임 (BOJ 13034): N-각형 대각선 긋기. 분할 영역의 Grundy XOR.
격자 게임: 2차원 격자 말 이동. 각 행/열 독립 후 XOR.

함정

1. mex 계산 실수

mex 는 집합에 없는 가장 작은 0 이상 정수. 0부터 순차 확인.

2. 게임 합성 착각

독립적일 때만 XOR 합성 성립. 상태가 연동되면 각각 SG 따로 계산 불가.

3. 큰 상태 공간

MAX 10^6 이상이면 DP 불가. 주기성 찾거나 수식 도출.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11868	님 게임 2	80.3%	kokoa-lab
BOJ 9660	돌 게임 6	53.5%	kokoa-lab
BOJ 13034	다각형 게임	63.4%	kokoa-lab
BOJ 16895	님 게임 3	67.7%	kokoa-lab

참고

[[Game Theory|게임 이론]]

안정 결혼 문제 (Stable Marriage)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

안정 결혼 문제 (Stable Marriage Problem) 는 N 명의 남성과 N 명의 여성이 각자 선호도 목록을 가지고 있을 때, 모든 쌍이 안정적 (stable) 인 매칭을 찾는 문제. Gale-Shapley 알고리즘 (1962, Nobel 2012) 은 O(N^2) 에 항상 안정 매칭을 찾는다. 안정적 = 어떤 (m, w) 도 현재 자신의 짝보다 상대를 더 선호하지 않는 상태.

문제 상황과 동기

naive: 모든 매칭 N! 가지를 검사 -> O(N!), N=10 에도 불가능.
핵심 통찰: 제안 (proposal) 과정을 통해 불안정 쌍을 반복 제거. proposer 쪽이 최적의 결과를 얻는다.
Gale-Shapley: 매 라운드 미매칭 proposer 가 가장 선호하는 상대에게 제안. reject 되면 다음 선호로. 최대 N^2 라운드 이내 종료.

실제 활용: 전국 레지던트 매칭 (NRMP), 학교 배정, 장기 매칭.

시각화

{}

핵심 아이디어

invariant: proposer 의 매칭은 단조 하락 (점점 덜 선호하는 쪽으로). receiver 의 매칭은 단조 상승 (점점 더 선호하는 쪽으로).

프로세스:

모든 남성이 첫 번째 선호 여성에게 제안
여성은 가장 선호하는 제안자와 약혼 (나머지 reject)
reject 된 남성은 다음 선호 여성에게 제안
여성은 현재 약혼자와 새 제안자 중 더 선호하는 쪽 선택
모두 매칭될 때까지 반복 -> 최대 O(N^2) 라운드

알고리즘

Gale-Shapley(M, W, menPref, womenPref):
    womanMatch[1..N] = -1
    manNext[1..N] = 1
    freeMen = queue of all men

    while freeMen not empty:
        m = freeMen.pop()
        w = menPref[m][manNext[m]++]
        if womanMatch[w] == -1:
            womanMatch[w] = m
        else:
            m2 = womanMatch[w]
            if womenPref[w][m] < womenPref[w][m2]:
                womanMatch[w] = m
                freeMen.push(m2)
            else:
                freeMen.push(m)

    return womanMatch  (or manMatch from it)

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Gale-Shapley O(N^2) stable matching #include <bits/stdc++.h> using namespace std; int main() { int N; cin >> N; vector<vector<int>> menPref(N, vector<int>(N)); vector<vector<int>> womenPref(N, vector<int>(N)); for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> menPref[i][j]; for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) cin >> womenPref[i][j]; // 여성의 선호도 순위 lookup table vector<vector<int>> rank(N, vector<int>(N)); for (int w = 0; w < N; w++) for (int r = 0; r < N; r++) rank[w][womenPref[w][r]] = r; vector<int> matchW(N, -1), nxt(N, 0); queue<int> q; for (int m = 0; m < N; m++) q.push(m); while (!q.empty()) { int m = q.front(); q.pop(); int w = menPref[m][nxt[m]++]; if (matchW[w] == -1) { matchW[w] = m; } else { int m2 = matchW[w]; if (rank[w][m] < rank[w][m2]) { matchW[w] = m; q.push(m2); } else { q.push(m); } } } vector<int> matchM(N); for (int w = 0; w < N; w++) matchM[matchW[w]] = w; for (int m = 0; m < N; m++) cout << m << " " << matchM[m] << "\\n"; return 0; }, }, { language: “python”, label: “Python”, code: `def gale_shapley(men_pref, women_pref): N = len(men_pref) rank = [[0] * N for _ in range(N)] for w in range(N): for r, m in enumerate(women_pref[w]): rank[w][m] = r match_w = [-1] * N nxt = [0] * N free_men = list(range(N)) while free_men: m = free_men.pop(0) w = men_pref[m][nxt[m]] nxt[m] += 1 if match_w[w] == -1: match_w[w] = m else: m2 = match_w[w] if rank[w][m] < rank[w][m2]: match_w[w] = m free_men.append(m2) else: free_men.append(m) match_m = [0] * N for w, m in enumerate(match_w): match_m[m] = w return match_m

N = int(input()) men_pref = [list(map(int, input().split())) for _ in range(N)] women_pref = [list(map(int, input().split())) for _ in range(N)] match = gale_shapley(men_pref, women_pref) for m, w in enumerate(match): print(m, w), }, { language: "java", label: "Java", code: import java.util.*; public class Main { public static void main(String[] args) { Scanner sc = new Scanner(System.in); int N = sc.nextInt(); int[][] menPref = new int[N][N]; int[][] womenPref = new int[N][N]; for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) menPref[i][j] = sc.nextInt(); for (int i = 0; i < N; i++) for (int j = 0; j < N; j++) womenPref[i][j] = sc.nextInt(); int[][] rank = new int[N][N]; for (int w = 0; w < N; w++) for (int r = 0; r < N; r++) rank[w][womenPref[w][r]] = r; int[] matchW = new int[N]; Arrays.fill(matchW, -1); int[] nxt = new int[N]; Queue q = new LinkedList<>(); for (int m = 0; m < N; m++) q.add(m); while (!q.isEmpty()) { int m = q.poll(); int w = menPref[m][nxt[m]++]; if (matchW[w] == -1) { matchW[w] = m; } else { int m2 = matchW[w]; if (rank[w][m] < rank[w][m2]) { matchW[w] = m; q.add(m2); } else { q.add(m); } } } int[] matchM = new int[N]; for (int w = 0; w < N; w++) matchM[matchW[w]] = w; for (int m = 0; m < N; m++) System.out.println(m + ” ” + matchM[m]); } }, }, ]} cases={[ { label: "N=4 기본", input: 4 0 1 2 3 1 2 3 0 2 3 0 1 3 0 1 2 0 1 2 3 1 2 3 0 2 3 0 1 3 0 1 2, output: 0 0 1 1 2 2 3 3`, }, ]} />

복잡도

항목	값
시간 (최악)	O(N^2)
시간 (평균)	O(N^2)
공간	O(N^2) (선호도 저장)
안정성	항상 안정 매칭 보장

변형 / 활용

Proposer-optimal / Receiver-pessimal: proposer 가 최적, receiver 가 최악의 안정 매칭. 역할을 바꾸면 반대 결과.
Stable Roommate: 1-set 안정 매칭. 항상 해가 존재하지 않음 (odd cycle 조건).
SM with Ties / Incomplete lists: 선호도에 동점 또는 불완전 목록. NP-hard 변형 존재.
병원 레지던트 매칭 (NRMP): 미국 의사 매칭에 Gale-Shapley 변형 사용.
양방향 시장: 학교 배정, 장기 매칭, 공공 서비스 배치.

함정

1. 전략적 조작

proposer 가 진정한 선호도를 숨기면 더 유리한 결과를 얻을 수 있음 (전략적 제안). receiver 는 전략적 조작이 어려움 (receiver-pessimal 속성).

2. Stable matching 의 유일성

안정 매칭이 유일하지 않음. Gale-Shapley 는 proposer-optimal 을 찾으며, receiver-pessimal 과 다른 해가 존재할 수 있음.

3. 자료구조 선택

여성의 순위 lookup table 없이 매번 womenPref[w] 를 선형 탐색하면 O(N^3). 반드시 rank[w][m] table 을 precompute.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 1348	주차장	(수집 안 됨)	kokoa-lab
BOJ 1671	상어의 저녁식사	(수집 안 됨)	kokoa-lab
BOJ 2188	축사 배정	(수집 안 됨)	kokoa-lab

참고

[[Bipartite Matching]]

각도 정렬 (Angle Sorting)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

각도 정렬 (Angle Sorting / Polar Sort) 은 2차원 평면 위의 점들을 기준점에 대한 극각 (polar angle) 순서로 정렬하는 기법. atan2 함수를 이용한 실수 비교 또는 CCW (외적) 를 이용한 정수 비교로 구현. [[Convex Hull|컨벡스 헐]]의 Graham scan, 점들을 단순 다각형으로 연결하는 문제 등에서 핵심 구성 요소.

문제 상황과 동기

N 개의 점을 기준점 O 를 기준으로 반시계 방향 (또는 시계 방향)으로 정렬해야 할 때.

Naive (atan2): 각 점에 대해 atan2(y, x) 를 계산해 실수 키로 정렬. O(N log N). 간단하지만 부동소수점 오차와 사분면 경계 처리 필요.
CCW comparator: ccw(O, a, b) > 0 만으로 정렬. 모든 연산이 정수. strict weak ordering 을 만족시키려면 사분면 구분이 필수.

핵심 통찰: 기준점 O 를 기준으로 점들을 반평면 (upper/lower) 으로 나누고, 같은 반평면 내에서만 CCW 비교 하면 strict weak ordering 이 성립하며, atan2 없이 정수 연산만으로 정확한 각도 정렬이 가능.

시각화

{}

핵심 아이디어

atan2 방식

sort by atan2(y - O.y, x - O.x)
장점: 직관적, 구현 단순
단점: double 오차, atan2 비용, inf/nan 처리

CCW comparator 방식

bool cmp(a, b):
    // 1. 사분면이 다르면 사분면 기준 정렬
    if quadrant(a) != quadrant(b):
        return quadrant(a) < quadrant(b)
    // 2. 같은 사분면이면 CCW
    if ccw(O, a, b) != 0:
        return ccw(O, a, b) > 0
    // 3. 각도가 같으면 거리순
    return dist(O, a) < dist(O, b)

사분면 판정

quadrant(p):
    if p.y == 0 and p.x >= 0: return 0   // +x축
    if p.y > 0 or (p.y == 0 and p.x < 0): return 1  // upper half
    return 2  // lower half (including -x axis and negative y)

또는 구사과의 관용 코드:

if (half(a) != half(b)) return half(a) < half(b)
if (ccw(a, b) != 0) return ccw(a, b) > 0
return dist2(a) < dist2(b)

여기서 half(p) = (p.y > 0) or (p.y == 0 and p.x < 0).

알고리즘

INPUT: points P[0..N-1], origin O (default 0,0)
OUTPUT: P sorted by polar angle (CCW)

1. 각 점 P[i] 에 대해 quadrant = half(P[i] - O) 계산
2. sort P by key:
   a. quadrant first (upper half < lower half)
   b. if same quadrant: ccw(O, a, b) > 0 (반시계 우선)
   c. if collinear: euclidean distance squared ascending

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // CCW 기반 각도 정렬 (구사과 스타일) #include <bits/stdc++.h> using namespace std; using ll = long long; struct Point { ll x, y; }; int ccw(Point a, Point b, Point c) { ll ret = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); if (ret > 0) return 1; if (ret < 0) return -1; return 0; } ll dist2(Point a, Point b) { ll dx = a.x - b.x, dy = a.y - b.y; return dx * dx + dy * dy; } // upper half = y>0 or (y==0 && x<0) bool half(Point p) { return p.y > 0 || (p.y == 0 && p.x < 0); } int main() { int n; cin >> n; vector<Point> P(n); for (auto& p : P) cin >> p.x >> p.y; Point O = P[0]; // 기준점 (보통 최하단 좌측) // O 가 첫 원소가 되도록 swap 한 후 나머지만 정렬 // 여기서는 O 를 기준으로 모두 정렬 sort(P.begin(), P.end(), [&](Point a, Point b) { if (half(a) != half(b)) return half(a) > half(b); if (ccw(O, a, b) != 0) return ccw(O, a, b) > 0; return dist2(O, a) < dist2(O, b); }); for (auto& p : P) cout << p.x << " " << p.y << "\\n"; }, }, { language: “python”, label: “Python”, code: `# 각도 정렬 (CCW comparator) import sys from functools import cmp_to_key input = sys.stdin.readline

def ccw(ax, ay, bx, by, cx, cy): return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax)

def half(x, y): return y > 0 or (y == 0 and x < 0)

def angle_cmp(O): ox, oy = O def cmp(a, b): ax, ay = a; bx, by = b ha = half(ax - ox, ay - oy) hb = half(bx - ox, by - oy) if ha != hb: return -1 if ha > hb else 1 c = ccw(ox, oy, ax, ay, bx, by) if c != 0: return -1 if c > 0 else 1 da = (ax - ox)**2 + (ay - oy)**2 db = (bx - ox)**2 + (by - oy)**2 return -1 if da < db else 1 if da > db else 0 return cmp

n = int(input()) P = [tuple(map(int, input().split())) for _ in range(n)] O = P[0] P.sort(key=cmp_to_key(angle_cmp(O))) for x, y in P: print(x, y), }, { language: "java", label: "Java", code: // 각도 정렬 (CCW comparator)

public class Main { static class Point { long x, y; Point(long x, long y) { this.x = x; this.y = y; } } static long ccw(Point a, Point b, Point c) { return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); } static boolean half(Point p) { return p.y > 0 || (p.y == 0 && p.x < 0); } static long dist2(Point a, Point b) { long dx = a.x - b.x, dy = a.y - b.y; return dx * dx + dy * dy; } public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int n = Integer.parseInt(br.readLine()); Point[] P = new Point[n]; for (int i = 0; i < n; i++) { StringTokenizer st = new StringTokenizer(br.readLine()); P[i] = new Point(Long.parseLong(st.nextToken()), Long.parseLong(st.nextToken())); } Point O = P[0]; Arrays.sort(P, (a, b) -> { boolean ha = half(new Point(a.x - O.x, a.y - O.y)); boolean hb = half(new Point(b.x - O.x, b.y - O.y)); if (ha != hb) return ha ? -1 : 1; long c = ccw(O, a, b); if (c != 0) return c > 0 ? -1 : 1; return Long.compare(dist2(O, a), dist2(O, b)); }); StringBuilder sb = new StringBuilder(); for (Point p : P) sb.append(p.x).append(’ ‘).append(p.y).append(‘\n’); System.out.print(sb); } }, }, ]} cases={[ { label: "기본 예제", input: "4\n0 0\n1 0\n0 1\n-1 0", output: 0 0 0 1 -1 0 1 0`, }, ]} />

복잡도

항목	값
정렬 시간	O(N log N)
CCW 비용	O(1) (정수 곱셈 2회)
공간	O(N)

변형 / 활용

Graham scan (Convex Hull): 최하단-최좌측 점 기준 각도 정렬 후 스택으로 CCW > 0 인 점만 유지.
단순 다각형 생성 (BOJ 3679): 각도 정렬로 항상 교차 없는 star-shaped 다각형.
시계 정렬: CCW 반환값 부호 반전.
중심 기준 정렬: CCW comparator 의 O 만 변경.

함정

strict weak ordering: ccw(O, a, b) > 0 만 반환하면 non-transitive. 사분면 분할 필수.
기준점과 동일 점: O 와 같은 점은 첫 번째로 분리.
Collinear: 각도가 같으면 거리순 정렬. 용도에 따라 가까운/먼 순 선택.
atan2 문제: [-pi, pi] 반환 → [0, 2pi) 변환 필요. double 비교가 strict weak ordering 깨뜨릴 수 있음.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 1708	볼록 껍질	28.116%	kokoa-lab
BOJ 3679	단순 다각형	26.233%	kokoa-lab
BOJ 2699	격자점 컨벡스헐	57.516%	kokoa-lab

참고

[[Convex Hull|볼록 껍질]]
[[CCW|CCW (시계/반시계 판정)]]
[[Point in Convex Polygon|볼록 다각형 내부 점 판정]]
[[Point in Polygon|다각형 내부 점 판정]]

볼록 껍질 (Convex Hull)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

볼록 껍질 (Convex Hull) 은 주어진 점 집합 P 를 모두 포함하는 최소 크기의 볼록 다각형. 즉 P 의 어떤 점도 다각형 외부에 있지 않고, 다각형의 꼭짓점은 P 의 일부 점.

표기: CH(P)

문제 상황과 동기

N 개의 2D 점이 흩어져 있을 때 이들을 모두 감싸는 최소 볼록 다각형을 찾는다.

Naive: 모든 점 쌍에 대해 직선을 긋고, 모든 점이 한쪽에 있는지 검사. O(N^3).
Graham scan (O(N log N)): 각도 정렬 후 스택.
Andrew’s monotone chain (O(N log N)): x 좌표 정렬 후 상단 / 하단 hull 따로 구성. 구현이 더 간결.

핵심 통찰: 볼록 껍질은 볼록 다각형의 모든 꼭짓점이 CCW 방향을 만족한다. 스택에 넣고 CCW 조건이 깨지면 pop.

시각화

{}

핵심 아이디어

CCW 판정

ccw(a, b, c) = (b - a) x (c - a)
             = (b.x - a.x)*(c.y - a.y) - (b.y - a.y)*(c.x - a.x)
> 0  -> 반시계 (좌회전)
< 0  -> 시계 (우회전)
= 0  -> 일직선

볼록 껍질에서는 모든 인접 세 점이 일관된 방향 (시계 또는 반시계) 을 유지.

Andrew’s Monotone Chain (가장 널리 사용)

1. 점들을 x (같으면 y) 오름차순 정렬          // O(N log N)
2. Lower hull: 왼->오 sweep 하면서 ccw <= 0 이면 pop
3. Upper hull: 오->왼 sweep 하면서 ccw <= 0 이면 pop
4. 합치기 (중복 끝점 제거)

invariant: 스택의 마지막 두 점과 새 점이 항상 ccw > 0 (또는 < 0) 을 만족.

알고리즘

andrew_monotone_chain(P):
    sort(P)                         // x, y 기준
    lower = []
    for p in P:
        while len(lower) >= 2 and ccw(lower[-2], lower[-1], p) <= 0:
            lower.pop()
        lower.append(p)
    upper = []
    for p in reversed(P):
        while len(upper) >= 2 and ccw(upper[-2], upper[-1], p) <= 0:
            upper.pop()
        upper.append(p)
    return lower + upper[1:-1]      // 끝점 중복 제거

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Andrew's monotone chain O(N log N) #include <bits/stdc++.h> using namespace std; using ll = long long; struct Point { ll x, y; }; ll ccw(Point a, Point b, Point c) { return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); } vector<Point> convex_hull(vector<Point>& p) { sort(p.begin(), p.end(), [](auto& a, auto& b) { return a.x < b.x || (a.x == b.x && a.y < b.y); }); vector<Point> hull; auto build = [&](int start, int end, int sign) { for (int i = start; i != end; i += (end - start > 0 ? 1 : -1)) { while ((int)hull.size() - start >= 2) { auto& a = hull[hull.size() - 2]; auto& b = hull.back(); if (ccw(a, b, p[i]) * sign > 0) break; hull.pop_back(); } hull.push_back(p[i]); } }; build(0, p.size(), 1); // lower int lower_sz = hull.size(); build(p.size() - 2, -1, 1); // upper (끝점 제외) hull.pop_back(); // 시작점 중복 제거 return hull; } int main() { vector<Point> pts = {{0,0},{1,1},{2,0},{1,-1},{0,1}}; auto hull = convex_hull(pts); cout << "Convex Hull:\\n"; for (auto& p : hull) cout << "(" << p.x << ", " << p.y << ")\\n"; }, }, { language: “python”, label: “Python”, code: `# Andrew’s monotone chain O(N log N) def ccw(ax, ay, bx, by, cx, cy): return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax)

def convex_hull(points): points = sorted(set(points)) # 중복 제거 + 정렬 if len(points) <= 1: return points lower = [] for p in points: while len(lower) >= 2 and ccw(*lower[-2], *lower[-1], *p) <= 0: lower.pop() lower.append(p) upper = [] for p in reversed(points): while len(upper) >= 2 and ccw(*upper[-2], *upper[-1], *p) <= 0: upper.pop() upper.append(p) return lower[:-1] + upper[:-1]

pts = [(0,0), (1,1), (2,0), (1,-1), (0,1)] hull = convex_hull(pts) print(“Convex Hull:”) for x, y in hull: print(f”({x}, {y})“), }, { language: "java", label: "Java", code: // Andrew’s monotone chain O(N log N)

public class Main { static class Point implements Comparable { long x, y; Point(long x, long y) { this.x = x; this.y = y; } public int compareTo(Point o) { return x != o.x ? Long.compare(x, o.x) : Long.compare(y, o.y); } } static long ccw(Point a, Point b, Point c) { return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); } static List convexHull(List pts) { int n = pts.size(); if (n <= 1) return pts; Collections.sort(pts); List hull = new ArrayList<>(); // lower for (int i = 0; i < n; i++) { while (hull.size() >= 2 && ccw(hull.get(hull.size()-2), hull.get(hull.size()-1), pts.get(i)) <= 0) hull.remove(hull.size()-1); hull.add(pts.get(i)); } int lowerSz = hull.size(); // upper for (int i = n - 2; i >= 0; i—) { while (hull.size() > lowerSz && ccw(hull.get(hull.size()-2), hull.get(hull.size()-1), pts.get(i)) <= 0) hull.remove(hull.size()-1); hull.add(pts.get(i)); } hull.remove(hull.size()-1); // 시작점 중복 제거 return hull; } public static void main(String[] args) { List pts = Arrays.asList( new Point(0,0), new Point(1,1), new Point(2,0), new Point(1,-1), new Point(0,1)); List hull = convexHull(pts); System.out.println(“Convex Hull:”); for (Point p : hull) System.out.println(”(” + p.x + ”, ” + p.y + ”)”); } }, }, ]} cases={[ { label: "기본 예제", input: ``, output: Convex Hull: (0, 0) (0, 1) (1, 1) (2, 0) (1, -1)`, }, ]} />

복잡도

항목	값
시간 (Andrew / Graham)	O(N log N) (정렬이 지배)
시간 (정렬 후)	O(N) (스택 sweep)
공간	O(N) (결과 hull)
안정성	- (유일 결정)

동일 점 (중복) 은 정렬 후 제거. Collinear (일직선) 점은 hull 에 포함할지 말지 선택.

변형 / 활용

1. Graham Scan

각도 정렬 (atan2) 후 같은 로직. Andrew 가 ssqrt 없고 실수 오차가 없어 더 선호됨.

2. Convex Hull Trick (CHT)

y = m*x + b 직선 중 특정 x 에서 최댓값. Convex hull (lower envelope) 과 동형.

3. 동적 Convex Hull

점이 추가/삭제될 때 hull 유지. O(log N) 갱신. (Overmars / Van Leeuwen 트리)

4. 3D Convex Hull

QuickHull O(N log N). 결과는 삼각형 메시 (face).

5. Rotating Calipers, 최근접 점 쌍, 최대 면적 삼각형

hull 위에서 O(N) 으로 각종 최적화.

함정

1. Collinear 처리

ccw <= 0 조건으로 collinear 점을 pop 하면 hull 변 가장자리 위의 점이 제외됨. 모든 collinear 점을 포함하려면 ccw < 0.

2. x 정렬만으로는 부족

x 가 같으면 y 정렬 필수. 안 하면 vertical line 에서 잘못된 hull.

3. Integer overflow

좌표 ±10^9 에서 (b.x - a.x) * (c.y - a.y) 는 ±4*10^18 까지 가능 -> C++ long long (64-bit). __int128 이 필요할 수 있음.

4. 점이 2개 이하

N ≤ 2 면 hull = 점들 그대로.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 4181	Convex Hull	21.1%	kokoa-lab
BOJ 3679	단순 다각형	26.2%	kokoa-lab
BOJ 17058	Convex Hull 연습	39.1%	kokoa-lab
BOJ 6850	Cows	42.5%	kokoa-lab
BOJ 2254	감옥 건설	33.1%	kokoa-lab

참고

[[Geometry|2D 기하 기본]]
[[CCW|CCW (시계/반시계 판정)]]
[[Rotating Calipers|회전 캘리퍼스]]
[[Convex Hull Trick|CHT (Convex Hull Trick)]]

오일러 지표 (Euler Characteristic)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

오일러 지표 (Euler Characteristic) χ 는 다면체(polyhedron) 또는 CW 복합체의 위상적 불변량으로, χ = V - E + F 로 정의. V는 꼭짓점(vertex), E는 변(edge), F는 면(face)의 개수. 볼록 다면체에서는 항상 χ = 2 (오일러의 다면체 정리).

문제 상황과 동기

임의의 다면체가 주어졌을 때 V - E + F 를 계산하면 그 다면체가 어떤 위상적 성질을 가지는지 알 수 있음.

Naive 접근: 단순히 V, E, F 를 세어 빼기.
핵심 통찰: χ 는 위상 불변량. 구면 위의 그래프는 χ=2, 원환면(torus)은 χ=0. 위상수학에서 genus g 와 χ = 2 - 2g.
PS 위치: 평면 그래프 판별 (χ=2), 3D 기하 문제에서 다면체 종류 분류.

시각화

{}

핵심 아이디어

볼록 다면체 (convex polyhedron):  V - E + F = 2
   정육면체: V=8, E=12, F=6 -> 8-12+6 = 2
   정사면체: V=4, E=6, F=4 -> 4-6+4 = 2

평면 그래프 (planar graph):     V - E + F = 1 + C (C = connected components)

원환면 (torus):                 V - E + F = 0

일반화:                         χ = V - E + F = 2 - 2g  (g = genus)

Invariant: 모든 convex polyhedron 은 구면과 위상 동형, 따라서 χ=2. 위상 변화 없이 edge 를 추가/제거해도 χ 불변.

알고리즘

euler_characteristic(vertices, edges, faces):
    return V - E + F

genus_from_chi(chi):
    return (2 - chi) / 2  # if chi is even

평면 그래프의 경우 outer face 를 포함한 F 사용.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Euler characteristic from V, E, F #include <bits/stdc++.h> using namespace std; int main() { int V, E, F; cin >> V >> E >> F; int chi = V - E + F; cout << "chi = " << chi << "\\n"; if (chi == 2) cout << "Sphere / convex polyhedron\\n"; else if (chi == 0) cout << "Torus (genus 1)\\n"; else if (chi == -2) cout << "Double torus (genus 2)\\n"; else cout << "Genus g = " << (2 - chi) / 2 << "\\n"; }, }, { language: “python”, label: “Python”, code: `# Euler characteristic from planar graph input

Input: N edges, each with two vertex IDs

Output: V, E, F, chi

n = int(input()) # number of edges vertex_set = set() edges = [] for _ in range(n): u, v = map(int, input().split()) vertex_set.add(u); vertex_set.add(v) edges.append((u, v)) V = len(vertex_set) E = n

For a connected planar graph: F = E - V + 2

F includes the outer face

F = E - V + 2 chi = V - E + F print(f”V={V}, E={E}, F={F}”) print(f”chi = {chi}”) if chi == 2: print(“Planar graph (sphere)”) elif chi == 0: print(“Torus”), }, { language: "java", label: "Java", code: import java.util.*;

public class Main { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int E = Integer.parseInt(br.readLine()); Set vs = new HashSet<>(); for (int i = 0; i < E; i++) { StringTokenizer st = new StringTokenizer(br.readLine()); vs.add(Integer.parseInt(st.nextToken())); vs.add(Integer.parseInt(st.nextToken())); } int V = vs.size(); int F = E - V + 2; // connected planar graph int chi = V - E + F; System.out.println(“V=” + V + ”, E=” + E + ”, F=” + F); System.out.println(“chi = ” + chi); if (chi == 2) System.out.println(“Planar (sphere)”); else if (chi == 0) System.out.println(“Torus”); } }, }, ]} cases={[ { label: "정육면체", input: 12 0 1 1 2 2 3 3 0 4 5 5 6 6 7 7 4 0 4 1 5 2 6 3 7, output: V=8, E=12, F=6 chi = 2 Sphere / convex polyhedron, }, { label: "정사면체 (4개 변)", input: 6 0 1 1 2 2 0 0 3 1 3 2 3, output: V=4, E=6, F=4 chi = 2 Sphere / convex polyhedron`, }, ]} />

복잡도

항목	값
V, E, F 카운트	O(V + E + F)
χ 계산	O(1)
genus 계산	O(1)
공간	O(V)

변형 / 활용

평면 그래프 판별: V - E + F = 1 + C (연결 성분 C). planar embedding 존재 여부 체크.
3D 모델링: manifold mesh 의 위상 검증. χ=2 면 구면 위상.
GIS: 지도에서 지역/경계/꼭짓점 관계 분석.
Poincare 공식: 고차원 일반화 (alternating sum of Betti numbers).

함정

1. F 에 outer face 포함

평면 그래프에서 F 는 outer (unbounded) face 를 포함한 모든 face 개수. 빼먹으면 χ 가 1 작아짐.

2. 연결성

공식 V - E + F = 2 는 connected graph 기준. disconnected 면 V - E + F = 1 + C.

3. Non-planar graph

K_5, K_3,3 같은 non-planar 그래프는 평면에 embedding 불가능해 Euler 공식이 성립하지 않음.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 1707	이분 그래프	-	kokoa-lab
BOJ 2170	선 긋기	-	kokoa-lab

참고

[[Geometry 3D|3D 기하]]
[[Geometry Basic|기하 기본]]
[[Planar Graph|평면 그래프]]

도형 불 연산 (Geometric Boolean Operations)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

도형 불 연산 (Geometric Boolean Operations) 은 두 다각형(또는 임의의 폐곡선)에 대해 합집합(union), 교집합(intersection), 차집합(difference)을 계산하는 기하 알고리즘. 대표적으로 Sutherland-Hodgman (convex clipping) 과 Weiler-Atherton (general polygon clipping) 이 알려져 있음.

문제 상황과 동기

두 다각형 A, B 가 주어졌을 때 A ∪ B, A ∩ B, A - B (또는 B - A) 를 구해야 함.

Naive 접근: 각 변을 무한 직선으로 확장 후 교차점을 찾고 폐곡선을 재구성. O(NM) 이지만 self-intersection / 구멍 처리 까다로움.
핵심 통찰: 한 다각형의 각 변을 clipping edge 로 삼아 반대 다각형을 잘라내면 출력 폴리곤이 자연스럽게 생성. Weiler-Atherton 은 교차점 리스트를 따라가며 출력 링을 구성.
PS 위치: convex polygon clipping 은 Sutherland-Hodgman 으로 O(N+M). 일반 polygon 은 Weiler-Atherton 필요.

시각화

{}

핵심 아이디어

Sutherland-Hodgman: convex clipping window 의 각 edge 에 대해, subject polygon 의 점들을 inside/outside 판정. 출력 리스트를 누적.

for each clip edge (from clip polygon):
    for each edge (S->E) of subject:
        if S inside, E inside  -> output E
        if S inside, E outside -> output intersection
        if S outside, E inside -> output intersection, then E
        if S outside, E outside -> output nothing

Weiler-Atherton: 교차점을 표시한 후, entering/leaving 에 따라 출력 링크를 순회.

알고리즘

Sutherland-Hodgman(subject, clip):
    output = subject
    for each edge of clip:
        input = output; output = []
        for each edge S->E in input:
            if inside(E, clipEdge):
                if not inside(S, clipEdge):
                    output.push(intersect(S,E, clipEdge))
                output.push(E)
            else if inside(S, clipEdge):
                output.push(intersect(S,E, clipEdge))
    return output

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Sutherland-Hodgman convex polygon clipping #include <bits/stdc++.h> using namespace std; using ld = long double; struct Pt { ld x, y; }; ld cross(Pt a, Pt b) { return a.x*b.y - a.y*b.x; } Pt sub(Pt a, Pt b) { return {a.x-b.x, a.y-b.y}; } Pt add(Pt a, Pt b) { return {a.x+b.x, a.y+b.y}; } Pt mul(Pt a, ld t) { return {a.x*t, a.y*t}; } ld dot(Pt a, Pt b) { return a.x*b.x + a.y*b.y; } bool inside(Pt p, Pt a, Pt b) { return cross(sub(b,a), sub(p,a)) >= 0; // clockwise } Pt intersect(Pt p1, Pt p2, Pt a, Pt b) { Pt v1 = sub(p2,p1), v2 = sub(b,a), v3 = sub(a,p1); ld t = cross(v2,v3) / cross(v1,v2); return add(p1, mul(v1, t)); } vector<Pt> clip(vector<Pt> subj, vector<Pt> clip) { vector<Pt> out = subj; int m = clip.size(); for (int i = 0; i < m; i++) { Pt a = clip[i], b = clip[(i+1)%m]; vector<Pt> in = out; out.clear(); int n = in.size(); for (int j = 0; j < n; j++) { Pt cur = in[j], prv = in[(j+n-1)%n]; bool curIn = inside(cur, a, b); bool prvIn = inside(prv, a, b); if (curIn) { if (!prvIn) out.push_back(intersect(prv, cur, a, b)); out.push_back(cur); } else if (prvIn) { out.push_back(intersect(prv, cur, a, b)); } } } return out; } int main() { int n; cin >> n; vector<Pt> subj(n); for (auto& p : subj) cin >> p.x >> p.y; int m; cin >> m; vector<Pt> clipPoly(m); for (auto& p : clipPoly) cin >> p.x >> p.y; auto res = clip(subj, clipPoly); cout << res.size() << "\\n"; for (auto& p : res) cout << p.x << " " << p.y << "\\n"; }, }, { language: “python”, label: “Python”, code: # Sutherland-Hodgman convex polygon clipping def cross(a, b): return a[0]*b[1] - a[1]*b[0] def sub(a, b): return (a[0]-b[0], a[1]-b[1]) def add(a, b): return (a[0]+b[0], a[1]+b[1]) def mul(a, t): return (a[0]*t, a[1]*t) def inside(p, a, b): return cross(sub(b,a), sub(p,a)) >= 0 def intersect(p1, p2, a, b): v1 = sub(p2,p1); v2 = sub(b,a); v3 = sub(a,p1) t = cross(v2,v3) / cross(v1,v2) return add(p1, mul(v1, t)) def clip(subj, clip_poly): out = subj[:] m = len(clip_poly) for i in range(m): a, b = clip_poly[i], clip_poly[(i+1)%m] inp = out; out = [] n = len(inp) for j in range(n): cur, prv = inp[j], inp[(j+n-1)%n] cur_in, prv_in = inside(cur,a,b), inside(prv,a,b) if cur_in: if not prv_in: out.append(intersect(prv,cur,a,b)) out.append(cur) elif prv_in: out.append(intersect(prv,cur,a,b)) return out n = int(input()) subj = [tuple(map(float, input().split())) for _ in range(n)] m = int(input()) clip_poly = [tuple(map(float, input().split())) for _ in range(m)] res = clip(subj, clip_poly) print(len(res)) for p in res: print(f"{p[0]} {p[1]}"), }, { language: “java”, label: “Java”, code: `import java.util.*;

public class Main { static class Pt { double x,y; Pt(double x,double y){this.x=x;this.y=y;} } static double cross(Pt a, Pt b) { return a.xb.y - a.yb.x; } static Pt sub(Pt a, Pt b) { return new Pt(a.x-b.x, a.y-b.y); } static Pt add(Pt a, Pt b) { return new Pt(a.x+b.x, a.y+b.y); } static Pt mul(Pt a, double t) { return new Pt(a.xt, a.yt); } static boolean inside(Pt p, Pt a, Pt b) { return cross(sub(b,a), sub(p,a)) >= 0; } static Pt intersect(Pt p1, Pt p2, Pt a, Pt b) { Pt v1=sub(p2,p1), v2=sub(b,a), v3=sub(a,p1); double t = cross(v2,v3) / cross(v1,v2); return add(p1, mul(v1, t)); } static List clip(List subj, List clip) { List out = new ArrayList<>(subj); for (int i=0; i<clip.size(); i++) { Pt a=clip.get(i), b=clip.get((i+1)%clip.size()); List in = out; out = new ArrayList<>(); for (int j=0; j<in.size(); j++) { Pt cur=in.get(j), prv=in.get((j+in.size()-1)%in.size()); boolean curIn=inside(cur,a,b), prvIn=inside(prv,a,b); if (curIn) { if (!prvIn) out.add(intersect(prv,cur,a,b)); out.add(cur); } else if (prvIn) out.add(intersect(prv,cur,a,b)); } } return out; } public static void main(String[] args) throws IOException { BufferedReader br=new BufferedReader(new InputStreamReader(System.in)); int n=Integer.parseInt(br.readLine()); List subj=new ArrayList<>(); for (int i=0; i<n; i++) { StringTokenizer st=new StringTokenizer(br.readLine()); subj.add(new Pt(Double.parseDouble(st.nextToken()),Double.parseDouble(st.nextToken()))); } int m=Integer.parseInt(br.readLine()); List clipP=new ArrayList<>(); for (int i=0; i<m; i++) { StringTokenizer st=new StringTokenizer(br.readLine()); clipP.add(new Pt(Double.parseDouble(st.nextToken()),Double.parseDouble(st.nextToken()))); } List res=clip(subj, clipP); System.out.println(res.size()); for (Pt p:res) System.out.println(p.x+” “+p.y); } }, }, ]} cases={[ { label: "사각형-사각형 교집합", input: 4 0 0 10 0 10 10 0 10 4 5 5 15 5 15 15 5 15, output: 4 5 5 10 5 10 10 5 10`, }, ]} />

복잡도

항목	값
Sutherland-Hodgman	O(N * M) (각 clip edge 마다 전체 순회)
Weiler-Atherton	O(N + M + K) (K = 교차점 개수)
공간	O(N + M)

N, M 은 각각 subject, clip polygon 의 꼭짓점 개수.

변형 / 활용

Union (합집합): A, B 의 outside 부분을 취합.
Intersection (교집합): Sutherland-Hodgman 직접 적용.
Difference (차집합): A - B 는 B 의 반대 방향 edge 로 clipping.
CAD/CAM: 솔리드 모델링의 CSG (Constructive Solid Geometry).
GIS: 지도 영역 중첩 분석.

함정

1. 수치 오차

부동소수점 교차점 계산에서 epsilon (1e-9) 처리 필요. inside 판정이 epsilon 범위에서 일관되어야 함.

2. Degenerate case

edge 위에 점이 정확히 놓인 경우 (collinear). inside/boundary 판정을 일관된 규칙으로.

3. Self-intersecting polygon

Sutherland-Hodgman 은 convex window 에만 동작. 일반 polygon 은 Weiler-Atherton 필요.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 5212	지구 온난화	-	kokoa-lab
BOJ 3392	화성 지도	-	kokoa-lab
BOJ 2671	잠수함 식별	-	kokoa-lab

참고

[[Convex Hull|볼록 껍질]]
[[Geometry Basic|기하 기본]]

기하 (Geometry) 기본

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Computational Geometry 는 점, 선, 다각형 등 기하 객체를 컴퓨터로 처리하는 알고리즘 분야. PS 에서는 2D 평면 위의 정수 좌표 가 주로 다루어지며, 핵심 연산은 벡터의 외적 (cross product) 과 내적 (dot product) 이다.

문제 상황과 동기

기하 문제는 naive 하게 거리 / 각도를 실수로 계산하면 오차와 시간 폭발.

Naive: N 개 점의 모든 쌍 거리 비교 O(N^2). N=10^5 면 불가능.
선분 교차: 모든 쌍 O(N^2) 검사 대신 sweep line ([[Sweeping|스위핑]]) O(N log N).
다각형 면적: shoelace 공식으로 O(N).

핵심 통찰: 정수 좌표에서는 외적 하나로 CCW, 선분 교차, 면적, convex hull 을 모두 판정 가능. 실수 비교가 없으면 오차도 없음.

시각화

{}

핵심 아이디어

점과 벡터

2D 점 P = (x, y) 는 원점에서의 벡터 로도 해석.

연산	수식	기하적 의미
외적 (cross)	`a x b = a.xb.y - a.yb.x`	평행사변형 넓이 (부호 있음)
내적 (dot)	`a . b = a.xb.x + a.yb.y`	`
거리	`sqrt(dxdx + dydy)`	피타고라스

CCW (Counter-Clockwise) 판정

ccw(a, b, c) = (b - a) x (c - a)
> 0  -> 반시계 (좌회전)
< 0  -> 시계 (우회전)
= 0  -> 일직선 (collinear)

CCW 하나로 선분 교차, 점의 다각형 포함 여부, convex hull 을 모두 구현 가능.

알고리즘

선분 교차

intersect(a, b, c, d):     // 선분 ab 와 cd
    det = ccw(a, b, c) * ccw(a, b, d)
    det2 = ccw(c, d, a) * ccw(c, d, b)
    if det <= 0 and det2 <= 0: return true
    // 일직선 위에 겹치는 경우: projection range check 필요
    return false

다각형 면적 (Shoelace)

area(polygon):
    sum = 0
    for i = 0..N-1:
        j = (i + 1) % N
        sum += polygon[i].x * polygon[j].y
        sum -= polygon[j].x * polygon[i].y
    return abs(sum) / 2

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // CCW test + 선분 교차 + 다각형 면적 (shoelace) #include <bits/stdc++.h> using namespace std; using ll = long long; struct Point { ll x, y; }; ll ccw(Point a, Point b, Point c) { return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); } double area(vector<Point>& p) { ll sum = 0; for (int i = 0; i < (int)p.size(); i++) { int j = (i + 1) % p.size(); sum += p[i].x * p[j].y - p[j].x * p[i].y; } return abs(sum) / 2.0; } int main() { Point a{0,0}, b{2,0}, c{1,2}; cout << "CCW(0,0, 2,0, 1,2) = " << (ccw(a,b,c) > 0 ? 1 : ccw(a,b,c) < 0 ? -1 : 0) << "\\n"; vector<Point> tri = {{0,0}, {3,0}, {0,4}}; cout << "삼각형 면적: " << area(tri) << "\\n"; }, }, { language: “python”, label: “Python”, code: `# CCW + shoelace 면적 def ccw(ax, ay, bx, by, cx, cy): return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax) a, b, c = (0,0), (2,0), (1,2) print(f”CCW(0,0, 2,0, 1,2) =”, 1 if ccw(*a, *b, *c) > 0 else -1 if ccw(*a, *b, *c) < 0 else 0)

def polygon_area(poly): n = len(poly) s = 0 for i in range(n): s += poly[i][0] * poly[(i+1)%n][1] s -= poly[(i+1)%n][0] * poly[i][1] return abs(s) / 2.0

tri = [(0,0), (3,0), (0,4)] print(f”삼각형 면적: {polygon_area(tri)}“), }, { language: "java", label: "Java", code: import java.util.*; public class Main { static long ccw(long ax, long ay, long bx, long by, long cx, long cy) { return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax); } static double area(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] - p[j][0] * p[i][1]; } return Math.abs(sum) / 2.0; } public static void main(String[] args) { System.out.println(“CCW(0,0, 2,0, 1,2) = ” + Long.signum(ccw(0,0, 2,0, 1,2))); long[][] tri = {{0,0}, {3,0}, {0,4}}; System.out.println(“삼각형 면적: ” + area(tri)); } }, }, ]} cases={[ { label: "기본 예제", input: ``, output: CCW(0,0, 2,0, 1,2) = 1 삼각형 면적: 6`, }, ]} />

복잡도

연산	비용
CCW 판정	O(1) (정수 곱셈 2회)
선분 교차 판정	O(1) (CCW 4회)
다각형 면적	O(N) (shoelace)
Convex Hull (Graham Scan)	O(N log N)
최근접 점 쌍	O(N log N) (분할 정복)

변형 / 활용

1. Convex Hull

점 집합을 감싸는 최소 볼록 다각형. Graham scan (O(N log N)), Andrew monotone chain.

2. Rotating Calipers

Convex Hull 위에서 평행선을 회전시키며 최장 거리 / 최소 폭 계산.

3. Line Sweep ([[Sweeping|스위핑]])

이벤트 정렬 후 active set 유지. 선분 교차 / 직사각형 합집합 면적.

4. Point in Polygon

Ray casting (홀수/짝수 교차) 또는 winding number.

함정

1. 정수 오버플로우

CCW 에서 (b.x - a.x) * (c.y - a.y) 는 좌표가 10^6 범위면 10^12 → long long (64-bit) 필요. Java 는 long, Python 은 무제한.

2. 일직선 (Collinear)

CCW = 0 인 경우, 선분 교차 판정에서 onSegment() 추가 체크 필요. 포함 관계, 겹침을 세분.

3. 부동소수점 비교

면적 / 거리 출력 시 double 이 필요한 순간에는 EPS = 1e-9 로 비교. abs(a - b) < EPS.

4. 시계 방향 입력

다각형 입력이 시계(cw) 또는 반시계(ccw) 일 수 있음. shoelace 는 부호로 방향을 알려줌 (양수 = ccw).

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11758	CCW	50.7%	kokoa-lab
BOJ 2166	다각형의 면적	39.5%	kokoa-lab
BOJ 17386	선분 교차 1	38.2%	kokoa-lab
BOJ 2477	참외밭	44.5%	kokoa-lab

참고

[[Sweeping|스위핑]]
[[Convex Hull|볼록 껍질]]
[[CCW|CCW (시계/반시계 판정)]]
[[Geometry-3D|3D 기하]]

3D 기하 (Geometry) 기본

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

3D 기하 는 3차원 공간 (x, y, z) 위의 점, 직선, 평면, 벡터를 다루는 분야. PS 에서는 정육면체 / 구 / 원뿔 체적, 3D convex hull, 최근접 점 3D 등이 등장. 2D 기하의 cross/dot product 를 3차원으로 확장한 것이 핵심.

문제 상황과 동기

3D 공간에서는 2D 에 비해 고려할 자유도가 1 추가되어 직관을 벗어나는 상황이 많음.

2D: 점 이외에도 직선(1D) 만 있음. 선분 교차 = CCW 4회.
3D: 점 + 직선(1D) + 평면(2D). 두 직선은 꼬인 위치(skew) 가능. 외적 결과가 벡터.
직선과 평면의 교차: 매개변수 방정식 풀이 필요.

핵심 통찰: 3D 외적은 두 벡터에 수직인 벡터(법선) 를 반환. 이 법선으로 평면의 방정식을 세우고, 직선과의 교차점, 점과 평면의 거리를 모두 O(1) 에 계산.

시각화

{}

핵심 아이디어

3D 벡터 연산

연산	수식	의미
외적	`a x b = (aybz - azby, azbx - axbz, axby - aybx)`	`a`, `b` 에 수직인 벡터. `
내적	`a . b = axbx + ayby + az*bz`	스칼라. cos(theta) 비례. = 0 이면 수직
norm	`\|a\| = sqrt(a . a)`	벡터 길이
단위 벡터	`a / \|a\|`	방향만 남김

평면의 방정식

점 P0(x0, y0, z0) 를 지나고 법선 n = (nx, ny, nz) 인 평면:
    nx*(x - x0) + ny*(y - y0) + nz*(z - z0) = 0
    -> nx*x + ny*y + nz*z + d = 0    (d = -nx*x0 - ny*y0 - nz*z0)

직선의 매개변수 방정식

점 P0, 방향 v = (vx, vy, vz):
    P(t) = P0 + t * v    (t 는 실수)

알고리즘

점과 평면의 거리

plane_distance(P, nx, ny, nz, d):
    return |nx*P.x + ny*P.y + nz*P.z + d| / sqrt(nx*nx + ny*ny + nz*nz)

직선과 평면의 교차

line_plane_intersection(P0, v, nx, ny, nz, d):
    denom = v.x*nx + v.y*ny + v.z*nz
    if denom == 0: return "평행 또는 평면 위"
    t = -(nx*P0.x + ny*P0.y + nz*P0.z + d) / denom
    return P0 + t * v

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // 3D 벡터: 외적, 내적, norm, 평면 거리 #include <bits/stdc++.h> using namespace std; struct Vec3 { double x, y, z; }; Vec3 cross(Vec3 a, Vec3 b) { return {a.y*b.z - a.z*b.y, a.z*b.x - a.x*b.z, a.x*b.y - a.y*b.x}; } double dot(Vec3 a, Vec3 b) { return a.x*b.x + a.y*b.y + a.z*b.z; } double norm(Vec3 a) { return sqrt(dot(a, a)); } int main() { Vec3 u{1, 0, 0}, v{0, 1, 0}; Vec3 w = cross(u, v); printf("u x v = (%.0f, %.0f, %.0f)\\n", w.x, w.y, w.z); printf("|u x v| = %.2f\\n", norm(w)); printf("u . v = %.0f\\n", dot(u, v)); // 평면 방정식: z = 0 (법선 (0,0,1), d = 0) auto dist = [](Vec3 p, Vec3 n, double d) { return fabs(dot(p, n) + d) / norm(n); }; Vec3 n{0, 0, 1}, p{1, 2, 3}; printf("점(1,2,3) - 평면 z=0 거리: %.2f\\n", dist(p, n, 0)); }, }, { language: “python”, label: “Python”, code: `# 3D 벡터 연산 (numpy 없이) import math 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 norm(a): return math.sqrt(dot(a, a))

u, v = (1, 0, 0), (0, 1, 0) w = cross(u, v) print(f”u x v = {w}”) print(f”|u x v| = {norm(w):.2f}”) print(f”u . v = {dot(u, v)}“)

평면 z=0 까지 점 (1,2,3) 의 거리

n, d = (0, 0, 1), 0 dist = abs(dot((1,2,3), n) + d) / norm(n) print(f”점-평면 거리: {dist:.2f}“), }, { language: "java", label: "Java", code: import java.util.; public class Main { static class Vec3 { double x, y, z; Vec3(double x, double y, double z) { this.x = x; this.y = y; this.z = z; } } static Vec3 cross(Vec3 a, Vec3 b) { return new Vec3(a.yb.z - a.zb.y, a.zb.x - a.xb.z, a.xb.y - a.yb.x); } static double dot(Vec3 a, Vec3 b) { return a.xb.x + a.yb.y + a.zb.z; } static double norm(Vec3 a) { return Math.sqrt(dot(a, a)); } public static void main(String[] args) { Vec3 u = new Vec3(1,0,0), v = new Vec3(0,1,0); Vec3 w = cross(u, v); System.out.printf(“u x v = (%.0f, %.0f, %.0f)%n”, w.x, w.y, w.z); System.out.printf(“|u x v| = %.2f%n”, norm(w)); System.out.printf(“u . v = %.0f%n”, dot(u, v)); Vec3 n = new Vec3(0,0,1); double d = 0; Vec3 p = new Vec3(1,2,3); double dist = Math.abs(dot(p, n) + d) / norm(n); System.out.printf(“점-평면 거리: %.2f%n”, dist); } }, }, ]} cases={[ { label: "기본 예제", input: ``, output: u x v = (-0, 0, 1) |u x v| = 1.00 u . v = 0 점-평면 거리: 3.00`, }, ]} />

복잡도

연산	비용
3D 외적	O(1) (6회 곱셈 + 3회 뺄셈)
3D 내적	O(1) (3회 곱셈 + 2회 덧셈)
점-평면 거리	O(1)
직선-평면 교차	O(1)
3D Convex Hull	O(N log N) (QuickHull)
최근접 점 (3D)	O(N log^2 N) (KD-tree / 분할 정복)

변형 / 활용

1. 3D Convex Hull

점들을 감싸는 최소 볼록 다면체. QuickHull (O(N log N)) 이 일반적. 결과는 삼각형 메시. 2D convex hull 과 달리 face(면) 의 법선 방향이 중요.

2. 직선과 직선의 최단 거리

꼬인 위치(skew) 에서 두 직선의 최단 거리는 외적으로 계산:

skew_distance(P1, v1, P2, v2) = |(P2 - P1) . (v1 x v2)| / |v1 x v2|

3. 구와 직선의 교차

직선 매개변수 방정식을 구에 대입, 2차 방정식 풀이. 판별식으로 접하는지 / 통과하는지 판정.

4. 회전 변환 (Rotation)

3D 회전은 오일러 각 또는 쿼터니언(quaternion) 으로 표현. 외적이 회전축을 결정.

함정

1. 평행 / 수직 판정

|a x b| 가 0 에 가까우면 두 벡터는 평행 (collinear). dot(a, b) 가 0 에 가까우면 수직. 각각 EPS 비교.

2. 법선 방향 (Right-hand rule)

3D 외적 a x b 는 right-hand rule 을 따름. 왼손 좌표계(예: Unity) 에서는 반대 방향.

3. 정수 좌표의 한계

3D 에서도 정수 좌표가 가능하지만, 외적 결과가 long long 범위를 초과할 수 있음. 부동소수점 사용 또는 __int128 (C++) 필요.

4. 평면의 네 가지 표현

점-법선 / 일반형 / 세 점 / 두 직선. 문제에 따라 적절히 변환 필요.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 11758	CCW	50.7%	kokoa-lab
BOJ 2166	다각형의 면적	39.5%	kokoa-lab
BOJ 17386	선분 교차 1	38.2%	kokoa-lab
BOJ 25308	방사형 그래프	24.0%	kokoa-lab

참고

[[Geometry|2D 기하 기본]]
[[Convex Hull 3D|3D Convex Hull]]
[[CCW|CCW (시계/반시계 판정)]]

4차원 이상 기하 (Hyper Geometry)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

고차원 기하 (Hyper / 4D+ Geometry) 는 4차원 이상의 공간 R^d (d >= 4) 에서 점, 벡터, 초평면, 초구 등을 다루는 분야. PS 에서는 d ≤ 4 인 경우가 대부분이며, 주로 벡터-행렬 연산, 초평면과의 거리, 고차원 Convex Hull (d > 3 은 실질적 불가) 형태로 등장.

문제 상황과 동기

3차원까지는 직관이 통하지만 4차원부터 기하 직관이 완전히 무너짐.

Naive: 점 N 개, 차원 d 에서 모든 쌍 거리 O(N^2) 는 d 와 무관. 하지만 d 가 커지면 곱셈 비용 증가.
차원의 저주 (Curse of Dimensionality): d 가 커질수록 공간이 지수적으로 넓어져, 최근접 이웃 / Convex Hull 의 복잡도가 폭발.
- d=2 에서 Convex Hull O(N log N). d=3 에서 O(N log N) (QuickHull). d>=4 에서는 O(N^{d/2}) (비현실적).
응용: ML 의 고차원 feature 공간, 추천 시스템 (cosine similarity), 선형 계획법 (simplex method).

핵심 통찰: 차원이 높아져도 벡터의 내적(dot) 과 거리(Euclidean norm) 는 정의가 변하지 않는다. 외적은 d=3 전용이므로, d>=4 에서는 일반화된 wedge product 또는 행렬 연산으로 대체한다.

시각화

{}

핵심 아이디어

d차원 벡터 연산

d차원 벡터 a = (a_1, a_2, ..., a_d), b = (b_1, ..., b_d):

연산	수식	의미
내적	`a . b = Σ a_i * b_i`	스칼라. 두 벡터의 정사영. = 0 이면 직교
norm	`\|a\| = sqrt(a . a)`	유클리드 길이
거리	`\|a - b\|`	두 점 사이 유클리드 거리
외적 (일반화)	(d=3) cross / (d>=4) wedge product `a ^ b` (bivector)	평행사변형의 oriented area

초평면 (Hyperplane)

d차원 공간에서 초평면은 d-1차원의 아핀 부분공간.

n . x + b = 0   (n 은 법선 벡터, b 는 bias)

초구 (Hypersphere)

||x - c|| = r    (c 는 중심, r 은 반지름)

tesseract (4D 정육면체)

[0,1]^4 범위. 16개 꼭짓점, 32개 모서리, 24개 면(정사각형), 8개 정육면체 셀.

알고리즘

점과 초평면의 거리

hyperplane_distance(P, n, b):
    return |n . P + b| / ||n||

d차원 Convex Hull

d >= 4 인 경우 QuickHull 의 확장 (Chan’s algorithm) 은 존재하지만 대회에서는 d ≤ 3 까지만 현실적. d=4 에서 O(N^2) 까지도 문제에 따라 사용 가능.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // 4D 벡터 연산: 내적, norm, 점-초평면 거리 #include <bits/stdc++.h> using namespace std; struct Vec4 { double w, x, y, z; }; double dot(Vec4 a, Vec4 b) { return a.w*b.w + a.x*b.x + a.y*b.y + a.z*b.z; } double norm(Vec4 a) { return sqrt(dot(a, a)); } double dist(Vec4 p, Vec4 n, double b) { return fabs(dot(p, n) + b) / norm(n); } int main() { Vec4 p{1, 2, 3, 4}; Vec4 n{0, 0, 0, 1}; // 초평면 w=0 의 법선 double b = 0; cout << "distance to hyperplane w=0: "; cout << dist(p, n, b) << "\\n"; // 4D tesseract 꼭짓점 (0,0,0,0) ~ (1,1,1,1) Vec4 a{0,0,0,0}, c{1,1,1,1}; cout << "tesseract diagonal: " << norm({c.w-a.w, c.x-a.x, c.y-a.y, c.z-a.z}) << "\\n"; }, }, { language: “python”, label: “Python”, code: `# 4D 벡터 연산 (함수형) import math

def dot(a, b): return sum(x*y for x, y in zip(a, b))

def norm(a): return math.sqrt(dot(a, a))

def hyperplane_dist(p, n, b): return abs(dot(p, n) + b) / norm(n)

p = (1, 2, 3, 4) n = (0, 0, 0, 1) # 초평면 w=0 법선 b = 0 print(“distance to hyperplane w=0:”, hyperplane_dist(p, n, b))

tesseract 대각선

a, c = (0,0,0,0), (1,1,1,1) print(“tesseract diagonal:”, norm(tuple(c[i]-a[i] for i in range(4)))), }, { language: "java", label: "Java", code: // 4D 벡터: Java record (Java 16+)

public class Main { record Vec4(double w, double x, double y, double z) { double dot(Vec4 o) { return wo.w + xo.x + yo.y + zo.z; } double norm() { return Math.sqrt(dot(this)); } } static double dist(Vec4 p, Vec4 n, double b) { return Math.abs(p.dot(n) + b) / n.norm(); } public static void main(String[] args) { Vec4 p = new Vec4(1, 2, 3, 4); Vec4 n = new Vec4(0, 0, 0, 1); System.out.printf(“거리: %.2f%n”, dist(p, n, 0)); Vec4 a = new Vec4(0,0,0,0), c = new Vec4(1,1,1,1); Vec4 d = new Vec4(c.w-a.w, c.x-a.x, c.y-a.y, c.z-a.z); System.out.printf(“대각선: %.2f%n”, d.norm()); } }, }, ]} cases={[ { label: "기본 예제", input: ``, output: distance to hyperplane w=0: 4 tesseract diagonal: 2`, }, ]} />

복잡도

항목	값
벡터 내적 (d차원)	O(d)
점-초평면 거리	O(d)
Convex Hull (d=2)	O(N log N)
Convex Hull (d=3)	O(N log N)
Convex Hull (d>=4)	O(N^{d/2}) - 대회 수준 비현실적
최근접 이웃 (Naive)	O(N^2 * d)

변형 / 활용

1. 고차원에서의 거리

d 가 클수록 모든 점 쌍 간 거리가 비슷해지는 현상 (차원의 저주). 최근접 / 최원접 구분이 어려워짐.

2. Cosine Similarity

cos(a, b) = (a . b) / (||a|| * ||b||)

추천 시스템, 정보 검색에서 고차원 벡터의 방향 유사도 측정.

3. 선형 변환과 행렬

고차원 기하는 행렬 곱으로 표현. 회전, 반사, 스케일링 모두 d x d 행렬.

4. 4D -> 3D 투영 (Perspective)

P_3d = (P.x / P.w, P.y / P.w, P.z / P.w)

tesseract 의 3D 그림자, 게임 엔진의 4D 렌더링.

함정

1. 외적 부재

d >= 4 에서 cross product 는 정의되지 않음. d choose 2 개의 wedge component 로 bivector 표현.

2. Curse of Dimensionality

d=20 만 되어도 단위 구의 부피는 거의 0 에 가까움. 무작위 두 점 사이 거리가 모두 거의 일정.

3. 정수 연산 확장

CCW 의 d차원 일반화는 행렬식 계산 필요 (O(d!)). d 가 크면 float 으로만 가능.

4. BOJ 에서의 희소성

순수 4D+ 기하 문제는 BOJ 에 거의 없음. d ≤ 3 까지만 출제.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 17058	Reservoir	39.1%	kokoa-lab
BOJ 16115	팬이에요	25.8%	kokoa-lab
BOJ 10903	Wall construction	61.4%	kokoa-lab

참고

[[Geometry|2D 기하 기본]]
[[Geometry-3D|3D 기하]]
[[Convex Hull|볼록 껍질]]

그린 정리 (Green's Theorem)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

그린 정리 (Green’s Theorem) 는 평면 위의 폐곡선 C 에 대한 선적분(line integral) 과 그 내부 영역 D 에 대한 이중 적분(double integral) 을 연결: ∮_C (L dx + M dy) = ∬_D (∂M/∂x - ∂L/∂y) dA. 곡선 C 는 반시계 방향(counterclockwise)으로 양의 방향.

문제 상황과 동기

폐곡선으로 둘러싸인 영역의 넓이를 선적분만으로 계산.

Naive 접근: 영역을 작은 사각형으로 분할해 Riemann 합. mesh size 에 의존.
핵심 통찰: Green 정리의 특수한 경우: ∮_C x dy = area(D). 즉, 경계선을 따라 x dy 만 적분하면 면적.
PS 위치: [[Shoelace|신발끈 공식]] 이 Green 정리의 이산 버전. 다각형의 면적 O(N). 좌표 기하 문제에서 면적을 직접 계산해야 할 때.

시각화

{}

핵심 아이디어

Green 정리 (일반):
  ∮_C (L dx + M dy) = ∬_D (∂M/∂x - ∂L/∂y) dA

면적 공식 (L = -y/2, M = x/2):
  Area(D) = ∮_C (x dy - y dx) / 2 = ∮_C x dy

다각형 면적 (Shoelace, 이산 버전):
  Area = (1/2) * | Σ (x_i * y_{i+1} - x_{i+1} * y_i) |

증명 스케치: ∂M/∂x - ∂L/∂y 가 1 이 되도록 L, M 을 잡으면 우변은 area.

알고리즘

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

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Green 정리 기반 shoelace 공식으로 다각형 면적 #include <bits/stdc++.h> using namespace std; using ll = long long; struct Pt { ll x, y; }; int main() { int n; cin >> n; vector<Pt> p(n); for (auto& v : p) cin >> v.x >> v.y; ll area2 = 0; for (int i = 0; i < n; i++) { int j = (i + 1) % n; area2 += p[i].x * p[j].y; area2 -= p[j].x * p[i].y; } area2 = abs(area2); cout << "Area: " << area2 / 2; if (area2 % 2) cout << ".5"; cout << "\\n"; }, }, { language: “python”, label: “Python”, code: # Green 정리로 다각형 면적 (shoelace) def polygon_area(p): area2 = 0 n = len(p) for i in range(n): j = (i + 1) % n area2 += p[i][0] * p[j][1] - p[j][0] * p[i][1] area2 = abs(area2) area = area2 // 2 return area, area2 % 2 n = int(input()) p = [tuple(map(int, input().split())) for _ in range(n)] area, half = polygon_area(p) print(f"Area: {area}" + (".5" if half else "")), }, { language: “java”, label: “Java”, code: `import java.util.*;

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()); long[] x = new long[n], y = new long[n]; for (int i = 0; i < n; i++) { StringTokenizer st = new StringTokenizer(br.readLine()); x[i] = Long.parseLong(st.nextToken()); y[i] = Long.parseLong(st.nextToken()); } long a2 = 0; for (int i = 0; i < n; i++) { int j = (i + 1) % n; a2 += x[i] * y[j] - x[j] * y[i]; } a2 = Math.abs(a2); System.out.print(“Area: ” + a2 / 2); if (a2 % 2 == 1) System.out.print(“.5”); System.out.println(); } }, }, ]} cases={[ { label: "직사각형 (0,0)-(4,0)-(4,3)-(0,3)", input: 4 0 0 4 0 4 3 0 3, output: Area: 12, }, { label: "삼각형 (0,0)-(6,0)-(0,8)", input: 3 0 0 6 0 0 8, output: Area: 24, }, { label: "오각형", input: 5 0 0 5 0 6 3 2 5 -1 2, output: Area: 24`, }, ]} />

복잡도

항목	값
시간	O(N)
공간	O(1) (incremental)
선적분 변환	O(1) per edge

변형 / 활용

Shoelace (신발끈 공식): Green 정리의 이산 버전. 정수 좌표 다각형의 면적.
Stokes 정리: 3차원 일반화. Green 은 Stokes 의 2D 특수 케이스.
발산 정리 (Divergence Theorem): ∮ F·n ds = ∬ div F dA (flux form).
응용: 유체 역학에서 circulation, CAD 에서 면적 계산, GIS.

함정

1. 방향

시계 방향(clockwise) 입력이면 면적이 음수. 반드시 abs() 처리.

2. 정수 좌표 .5 문제

면적이 2 로 나누어떨어지지 않으면 .5 단위. 코드에서 area2 (2배 값) 를 유지해야 정밀도 손실 없음.

3. 자기 교차 다각형

자기 교차하는 폴리곤은 Green 정리의 단순 폐곡선 조건을 만족하지 않음. signed area 개념으로 확장 가능.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2166	다각형의 면적	-	kokoa-lab
BOJ 1485	정사각형	-	kokoa-lab
BOJ 1358	하키	-	kokoa-lab
BOJ 1004	어린 왕자	-	kokoa-lab

참고

[[Shoelace|신발끈 공식]]
[[Pick|Pick 정리]]
[[Geometry Basic|기하 기본]]

Half-Plane Intersection

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

반평면 교집합 (Half-Plane Intersection) 은 N 개의 직선으로 정의된 반평면 ax + by + c <= 0 (또는 >= 0) 을 모두 만족하는 점들의 집합, 즉 볼록다각형 (convex polygon) 혹은 무한 영역 / 공집합을 구하는 기하 알고리즘.

문제 상황과 동기

각 반평면을 naive 하게 교집합하면 O(N^2). 즉, convex polygon 의 clipping 을 N 번 반복해야 한다. N=10^5 면 불가능.

핵심 통찰: 반평면을 각도(기울기) 순으로 정렬하고 deque 로 관리하면 convex hull 과 동일한 각도 정렬 + Amortized O(N) 테크닉 으로 O(N log N) 에 해결된다. [[Convex Hull]] 의 Graham scan 과 거의 같은 구조.

활용: 볼록다각형 내 최대 내접원, Minkowski 덧셈, 일부 LP (Linear Programming) 의 특수 케이스.

시각화

{}

핵심 아이디어

각 반평면을 directed line p -> q 로 표현. valid side 는 항상 line 의 왼쪽 (CCW > 0). 각도 atan2(dy, dx) 순으로 정렬 후 deque 로 관리.

for each L in sorted order:
    while deque[-2] x deque[-1] NOT in L -> pop back
    while deque[0] x deque[1] NOT in L -> pop front
    push back L
마지막에 front/back 정리

각 반평면은 최대 한 번 push/pop. O(N).

알고리즘

halfplane_intersection(L):
    sort L by angle = atan2(dy, dx) (같은 angle: tight 한 것만 keep)
    deque = empty
    for each line in L:
        while |deque| >= 2 and cross(line, inter(deque[-2], deque[-1])) < 0:
            pop back
        while |deque| >= 2 and cross(line, inter(deque[0], deque[1])) < 0:
            pop front
        push back
    while |deque| >= 3 and cross(deque[0], inter(deque[-2], deque[-1])) < 0:
        pop back
    return [inter(deque[i], deque[(i+1)%|deque|]) for i]

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Half-plane intersection, O(N log N) #include <bits/stdc++.h> using namespace std; using ld = long double; const ld EPS = 1e-9; struct Pt { ld x, y; }; struct Line { Pt p, q; }; // valid: left side ld cross(Pt a, Pt b) { return a.x*b.y - a.y*b.x; } ld cross(Pt a, Pt b, Pt c) { return (b.x-a.x)*(c.y-a.y) - (b.y-a.y)*(c.x-a.x); } Pt inter(Line a, Line b) { Pt va = {a.q.x-a.p.x, a.q.y-a.p.y}; Pt vb = {b.q.x-b.p.x, b.q.y-b.p.y}; Pt vc = {b.p.x-a.p.x, b.p.y-a.p.y}; ld t = cross(vc, vb) / cross(va, vb); return {a.p.x + t*va.x, a.p.y + t*va.y}; } ld angle(Line l) { return atan2(l.q.y-l.p.y, l.q.x-l.p.x); } vector<Pt> halfplane(vector<Line> L) { sort(L.begin(), L.end(), [](Line a, Line b) { return angle(a) < angle(b); }); deque<Line> dq; for (auto& l : L) { while (dq.size() >= 2 && cross(l.p, l.q, inter(dq[dq.size()-2], dq.back())) < EPS) dq.pop_back(); while (dq.size() >= 2 && cross(l.p, l.q, inter(dq[0], dq[1])) < EPS) dq.pop_front(); dq.push_back(l); } while (dq.size() >= 3 && cross(dq[0].p, dq[0].q, inter(dq[dq.size()-2], dq.back())) < EPS) dq.pop_back(); vector<Pt> res; for (int i = 0; i < (int)dq.size(); i++) res.push_back(inter(dq[i], dq[(i+1)%dq.size()])); return res; } int main() { vector<Line> L = {{{0,0},{1,0}}, {{0,1},{0,0}}, {{6,0},{0,6}}, {{4,6},{-2,0}}}; auto poly = halfplane(L); cout << fixed << setprecision(0); for (auto& p : poly) cout << "(" << p.x << ", " << p.y << ")\\n"; }, }, { language: “python”, label: “Python”, code: `# Half-plane intersection, O(N log N) import math

class Pt: def init(self, x, y): self.x, self.y = x, y

def cross(a, b, c): return (b.x-a.x)(c.y-a.y) - (b.y-a.y)(c.x-a.x)

def inter(a, b): v1 = Pt(a[1].x-a[0].x, a[1].y-a[0].y) v2 = Pt(b[1].x-b[0].x, b[1].y-b[0].y) v3 = Pt(b[0].x-a[0].x, b[0].y-a[0].y) denom = v1.xv2.y - v1.yv2.x if abs(denom) < 1e-12: return None t = (v3.xv2.y - v3.yv2.x) / denom return Pt(a[0].x + tv1.x, a[0].y + tv1.y)

lines = [ (Pt(0,0), Pt(1,0)), (Pt(0,1), Pt(0,0)), (Pt(6,0), Pt(0,6)), (Pt(4,6), Pt(-2,0)) ] lines.sort(key=lambda l: math.atan2(l[1].y-l[0].y, l[1].x-l[0].x)) dq = [] for l in lines: while len(dq) >= 2 and cross(l[0], l[1], inter(dq[-2], dq[-1])) < 0: dq.pop() while len(dq) >= 2 and cross(l[0], l[1], inter(dq[0], dq[1])) < 0: dq.pop(0) dq.append(l)

while len(dq) >= 3 and cross(dq[0][0], dq[0][1], inter(dq[-2], dq[-1])) < 0: dq.pop()

res = [inter(dq[i], dq[(i+1)%len(dq)]) for i in range(len(dq))] for p in res: print(f”({p.x:.0f}, {p.y:.0f})“), }, { language: "java", label: "Java", code: // Half-plane intersection (basic, no deque in snippet)

public class Main { static double cross(Point2D o, Point2D a, Point2D b) { return (a.getX()-o.getX())(b.getY()-o.getY()) - (a.getY()-o.getY())(b.getX()-o.getX()); }

static Point2D inter(Point2D p1, Point2D q1, Point2D p2, Point2D q2) {
    double vx1 = q1.getX()-p1.getX(), vy1 = q1.getY()-p1.getY();
    double vx2 = q2.getX()-p2.getX(), vy2 = q2.getY()-p2.getY();
    double vx3 = p2.getX()-p1.getX(), vy3 = p2.getY()-p1.getY();
    double denom = vx1*vy2 - vy1*vx2;
    double t = (vx3*vy2 - vy3*vx2) / denom;
    return new Point2D.Double(p1.getX()+t*vx1, p1.getY()+t*vy1);
}

static double angle(Point2D p, Point2D q) {
    return Math.atan2(q.getY()-p.getY(), q.getX()-p.getX());
}

public static void main(String[] args) {
    Point2D.Double[][] lines = {
        {new Point2D.Double(0,0), new Point2D.Double(1,0)},
        {new Point2D.Double(0,1), new Point2D.Double(0,0)},
        {new Point2D.Double(6,0), new Point2D.Double(0,6)},
        {new Point2D.Double(4,6), new Point2D.Double(-2,0)}
    };
    Arrays.sort(lines, (a,b) -> Double.compare(
        angle(a[0],a[1]), angle(b[0],b[1])));
    // Deque simulation omitted for brevity
    for (int i = 0; i < 4; i++) {
        Point2D p = inter(lines[i][0], lines[i][1],
            lines[(i+1)%4][0], lines[(i+1)%4][1]);
        System.out.printf("(%.0f, %.0f)%n", p.getX(), p.getY());
    }
}

}, }, ]} cases={[ { label: "4 반평면 교집합", input: ``, output: (0, 0) (6, 0) (2, 4) (0, 2)`, }, ]} />

복잡도

항목	값
시간 (정렬)	O(N log N)
시간 (Deque)	O(N) (각 line 최대 1회 push/pop)
전체	O(N log N)
공간	O(N)

변형 / 활용

1. 볼록다각형 내 최대 내접원

Convex polygon 의 각 변을 안쪽으로 평행 이동 (offset) 하여 새로운 반평면들 생성. 그 교집합에 가장 큰 원이 들어갈 수 있는 중심점.

2. Minkowski Sum

두 볼록다각형 A, B 의 Minkowski sum A + B = {a + b | a in A, b in B}. 각 변의 방향별로 half-plane 으로 표현 가능.

3. LP (Linear Programming) 의 2D 특수 케이스

2변수 LP 는 half-plane intersection 으로 변환 가능. 후에 simplex 또는 [[Parametric Search]] 로 최적화.

함정

1. EPS 좌우 판정

cross(l.p, l.q, inter(...)) < EPS 로 반평면에 속하지 않음을 판정. EPS 를 너무 작게 잡으면 floating error 로 무한루프.

2. 무한 영역 / 공집합

결과가 유계 폴리곤이 아닐 수 있음. 빈 deque 나 2개 미만의 점이면 unbounded 또는 empty.

3. 평행 반평면

같은 각도의 반평면은 cross 값이 더 큰 (더 제약적인) 것만 유지.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 16872	Count the Half-Planes	(수집 안 됨)	kokoa-lab
BOJ 12795	Half-Plane	(수집 안 됨)	kokoa-lab
BOJ 20420	1차원 Half-Plane	(수집 안 됨)	kokoa-lab

참고

[[Convex Hull]] (비슷한 Deque 구조)
[[Sweeping|스위핑]]
[[Line Intersection|선분 교차 판정]]

선분 교차 (Line Segment Intersection)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

선분 교차 판정 (Line Segment Intersection) 은 2D 평면 위 두 선분 AB 와 CD 가 서로 교차하는지 O(1) 에 판정하는 기하 연산. CCW (Counter-Clockwise) 벡터 외적만으로 이루어짐.

문제 상황과 동기

두 선분의 교차 여부는 기하 문제의 가장 기본적인 빌딩 블록.

naive: 모든 선분 쌍 O(N^2) 검사. N=10^3 이상에서 터짐.
O(1) CCW 판정: [[CCW]] 4 회로 교차 여부를 바로 알 수 있음.

핵심 통찰: 각 선분의 양 끝점이 상대 선분의 양 옆에 있는지 확인. 즉, CCW(A,B,C) 와 CCW(A,B,D) 의 부호가 다른지, 동시에 CCW(C,D,A) 와 CCW(C,D,B) 의 부호가 다른지.

활용: [[Convex Hull]], 선분 그룹 (DSU), [[Sweeping]] 의 기초 연산.

시각화

{}

핵심 아이디어

세 점의 CCW 값을 구하는 cross product:

ccw(a, b, c) = (b.x - a.x)(c.y - a.y) - (b.y - a.y)(c.x - a.x)

> 0 : 반시계 (좌회전)
< 0 : 시계 (우회전)
= 0 : 일직선 (collinear)

두 선분 AB, CD 가 교차하는 조건:

ccw(a,b,c) * ccw(a,b,d) <= 0  AND
ccw(c,d,a) * ccw(c,d,b) <= 0

즉, A-B 기준으로 C 와 D 가 서로 다른 쪽에 있고 (또는 하나가 선 위), C-D 기준으로 A 와 B 가 서로 다른 쪽에 있음.

Collinear (네 점이 모두 일직선) 인 경우는 projection range check 로 겹침 판정.

알고리즘

intersect(a, b, c, d):
    ab = ccw(a,b,c) * ccw(a,b,d)
    cd = ccw(c,d,a) * ccw(c,d,b)

    if ab == 0 and cd == 0:
        // 모두 일직선: x/y projection 이 겹치는지 확인
        if a.x > b.x: swap(a,b)
        if c.x > d.x: swap(c,d)
        if max(a.x,c.x) > min(b.x,d.x): return false
        if a.y > b.y: swap(a,b)
        if c.y > d.y: swap(c,d)
        return max(a.y,c.y) <= min(b.y,d.y)

    return ab <= 0 and cd <= 0

구현

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

struct Point { ll x, y; };

ll ccw(Point a, Point b, Point c) { ll ret = (b.x-a.x)(c.y-a.y) - (b.y-a.y)(c.x-a.x); if (ret > 0) return 1; if (ret < 0) return -1; return 0; }

bool intersect(Point a, Point b, Point c, Point d) { ll ab = ccw(a,b,c) * ccw(a,b,d); ll cd = ccw(c,d,a) * ccw(c,d,b); if (ab == 0 && cd == 0) { if (a.x > b.x) swap(a,b); if (c.x > d.x) swap(c,d); if (max(a.x,c.x) > min(b.x,d.x)) return false; if (a.y > b.y) swap(a,b); if (c.y > d.y) swap(c,d); return max(a.y,c.y) <= min(b.y,d.y); } return ab <= 0 && cd <= 0; }

int main() { Point a{1,1}, b{7,3}, c{2,4}, d{6,1}; cout << (intersect(a,b,c,d) ? “YES” : “NO”) << “\n”; Point e{0,0}, f{3,3}, g{1,1}, h{2,2}; cout << (intersect(e,f,g,h) ? “YES” : “NO”) << “\n”; }, }, { language: "python", label: "Python", code: # CCW-based line segment intersection def ccw(ax, ay, bx, by, cx, cy): ret = (bx-ax)(cy-ay) - (by-ay)(cx-ax) if ret > 0: return 1 if ret < 0: return -1 return 0

def intersect(ax, ay, bx, by, cx, cy, dx, dy): ab = ccw(ax,ay,bx,by,cx,cy) * ccw(ax,ay,bx,by,dx,dy) cd = ccw(cx,cy,dx,dy,ax,ay) * ccw(cx,cy,dx,dy,bx,by) if ab == 0 and cd == 0: if (ax, ay) > (bx, by): ax, bx = bx, ax; ay, by = by, ay if (cx, cy) > (dx, dy): cx, dx = dx, cx; cy, dy = dy, cy return max(ax, cx) <= min(bx, dx) and max(ay, cy) <= min(by, dy) return ab <= 0 and cd <= 0

print(“YES” if intersect(1,1, 7,3, 2,4, 6,1) else “NO”) print(“YES” if intersect(0,0, 3,3, 1,1, 2,2) else “NO”), }, { language: "java", label: "Java", code: import java.util.; public class Main { static int ccw(long ax, long ay, long bx, long by, long cx, long cy) { long ret = (bx-ax)(cy-ay) - (by-ay)*(cx-ax); if (ret > 0) return 1; if (ret < 0) return -1; return 0; }

static boolean intersect(
    long ax, long ay, long bx, long by,
    long cx, long cy, long dx, long dy
) {
    int ab = ccw(ax,ay,bx,by,cx,cy) * ccw(ax,ay,bx,by,dx,dy);
    int cd = ccw(cx,cy,dx,dy,ax,ay) * ccw(cx,cy,dx,dy,bx,by);
    if (ab == 0 && cd == 0) {
        if (ax > bx || (ax == bx && ay > by)) {
            long t; t=ax; ax=bx; bx=t; t=ay; ay=by; by=t;
        }
        if (cx > dx || (cx == dx && cy > dy)) {
            long t; t=cx; cx=dx; dx=t; t=cy; cy=dy; dy=t;
        }
        return (Math.max(ax,cx) <= Math.min(bx,dx) &&
                Math.max(ay,cy) <= Math.min(by,dy));
    }
    return ab <= 0 && cd <= 0;
}

public static void main(String[] args) {
    System.out.println(intersect(1,1,7,3,2,4,6,1) ? "YES" : "NO");
    System.out.println(intersect(0,0,3,3,1,1,2,2) ? "YES" : "NO");
}

}, }, ]} cases={[ { label: "일반 + Collinear", input: ``, output: YES YES`, }, ]} />

복잡도

항목	값
시간	O(1) (CCW 4 회 + 비교)
공간	O(1)

변형 / 활용

1. 선분 그룹 (Union-Find)

N 개 선분의 교차 관계를 DSU 로 묶으면 연결된 컴포넌트로 그룹화 가능. BOJ 2162.

2. 직선과의 교차

무한 직선과 선분의 교차: ccw(A,B,C) == 0 조건을 제거하고 projection 만 체크.

3. 교차점 좌표 구하기

두 직선의 교점을 parameter form 으로 직접 계산. collinear 가 아닐 때만.

t = cross(C-A, D-C) / cross(B-A, D-C)
P = A + t * (B - A)

4. 선분 교차 개수 (Sweep)

N 개 선분의 모든 교차점을 찾는 [[Sweeping]] 알고리즘. O((N+K) log N). Bentley-Ottmann.

함정

1. 정수 오버플로우

CCW 에서 (b.x-a.x) * (c.y-a.y) 는 10^6 * 10^6 = 10^12 로 int (32-bit) 범위 초과. long long 필요.

2. Collinear 겹침 처리

네 점이 일직선 위에 있을 때 ccw 만으로는 겹침 여부를 알 수 없음. Projection range check 필수.

3. 끝점 접촉

한 선분의 끝점이 다른 선분 위에 있는 경우 (< 0 조건) 교차로 인정. ccw() * ccw() < 0 대신 <= 0 사용.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 17386	선분 교차 1	38.2%	kokoa-lab
BOJ 17387	선분 교차 2	27.5%	kokoa-lab
BOJ 20149	선분 교차 3	18.3%	kokoa-lab
BOJ 2162	선분 그룹	28.5%	kokoa-lab

참고

[[CCW]] (시계/반시계 판정)
[[Convex Hull]] (CCW 의 확장)
[[Sweeping]] (N 개 선분 교차)

최소 외접원 (Minimum Enclosing Circle)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

최소 외접원 (Minimum Enclosing Circle, MEC) 은 평면 위 N 개의 점을 모두 포함하는 가장 작은 반지름의 원을 찾는 문제. 대표 알고리즘은 Emo Welzl (1991) 의 randomized incremental algorithm, 기댓값 O(N).

문제 상황과 동기

모든 점을 하나의 원으로 커버하면서 반지름을 최소화.

Naive 접근: 점 2개 또는 3개로 결정되는 모든 원을 시도하며 O(N^4).
핵심 통찰: MEC 는 항상 2개 또는 3개의 support point 에 의해 결정. 점을 무작위 순서로 추가하며 원 밖의 점만 경계로 편입.
PS 위치: N=10^5 점의 최소 커버 반지름. [[Convex Hull|볼록 껍질]] 위의 점만 고려해도 됨.

시각화

{}

핵심 아이디어

MEC 의 성질:
1. MEC 는 점 2개가 직경을 결정 (지름) 하거나, 3개 점이 원주 위에 있음.
2. MEC 내부에 있는 점은 제거해도 원이 변하지 않음.
3. 새로운 점 p 가 현재 원 밖에 있으면, p 는 새 원의 경계 위에 있어야 함.

Welzl 의 재귀:
  welzl(P, R):  // P: 남은 점, R: 경계 점
    if P == {} or |R| == 3: return trivial_circle(R)
    p = random(P)
    C = welzl(P - {p}, R)
    if p in C: return C
    return welzl(P - {p}, R ∪ {p})

알고리즘

welzl(P, R):
    if P is empty or |R| == 3:
        return circle_from(R)   // R 크기에 따라 0/1/2/3 점 처리
    p = random element from P
    C = welzl(P \ {p}, R)
    if p inside C:
        return C
    R.push(p)
    C = welzl(P \ {p}, R)
    R.pop()
    return C

circle_from(R):
    if |R| == 0: return zero-radius at origin
    if |R| == 1: return zero-radius at R[0]
    if |R| == 2: return circle with R[0],R[1] as diameter
    if |R| == 3: return circumcircle of R[0],R[1],R[2]

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Welzl's algorithm, expected O(N) #include <bits/stdc++.h> using namespace std; struct Pt { double x, y; }; struct Cir { Pt c; double r; }; double dist(const Pt& a, const Pt& b) { return hypot(a.x-b.x, a.y-b.y); } bool inside(const Pt& p, const Cir& cir) { return dist(p, cir.c) <= cir.r + 1e-9; } Cir c2(const Pt& a, const Pt& b) { return {{(a.x+b.x)/2, (a.y+b.y)/2}, dist(a,b)/2}; } Cir c3(const Pt& a, const Pt& b, const Pt& c) { double d = 2*(a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y)); if (abs(d) < 1e-12) return c2(a, b); double ux = ((a.x*a.x+a.y*a.y)*(b.y-c.y) + (b.x*b.x+b.y*b.y)*(c.y-a.y) + (c.x*c.x+c.y*c.y)*(a.y-b.y)) / d; double uy = ((a.x*a.x+a.y*a.y)*(c.x-b.x) + (b.x*b.x+b.y*b.y)*(a.x-c.x) + (c.x*c.x+c.y*c.y)*(b.x-a.x)) / d; return {{ux, uy}, dist({ux,uy}, a)}; } Cir welzl(vector<Pt>& P, vector<Pt>& R, int n) { if (n == 0 || R.size() == 3) { if (R.empty()) return {{0,0}, 0}; if (R.size() == 1) return {R[0], 0}; if (R.size() == 2) return c2(R[0], R[1]); return c3(R[0], R[1], R[2]); } int idx = rand() % n; swap(P[idx], P[n-1]); Pt p = P[n-1]; Cir C = welzl(P, R, n-1); if (inside(p, C)) return C; R.push_back(p); C = welzl(P, R, n-1); R.pop_back(); return C; } int main() { int N; cin >> N; vector<Pt> P(N); for (auto& p : P) cin >> p.x >> p.y; Cir ans = welzl(P, *new vector<Pt>(), N); cout << fixed << setprecision(10); cout << ans.c.x << " " << ans.c.y << " " << ans.r << "\\n"; }, }, { language: “python”, label: “Python”, code: import math, random, sys def dist(a, b): return math.hypot(a[0]-b[0], a[1]-b[1]) def inside(p, cx, cy, r): return dist(p, (cx, cy)) <= r + 1e-9 def c2(a, b): return ((a[0]+b[0])/2, (a[1]+b[1])/2, dist(a,b)/2) def c3(a, b, c): d = 2*(a[0]*(b[1]-c[1]) + b[0]*(c[1]-a[1]) + c[0]*(a[1]-b[1])) if abs(d) < 1e-12: return c2(a, b) ux = ((a[0]**2+a[1]**2)*(b[1]-c[1]) + (b[0]**2+b[1]**2)*(c[1]-a[1]) + (c[0]**2+c[1]**2)*(a[1]-b[1])) / d uy = ((a[0]**2+a[1]**2)*(c[0]-b[0]) + (b[0]**2+b[1]**2)*(a[0]-c[0]) + (c[0]**2+c[1]**2)*(b[0]-a[0])) / d return (ux, uy, dist((ux,uy), a)) def welzl(P, R): if not P or len(R) == 3: if len(R) == 0: return (0.0, 0.0, 0.0) if len(R) == 1: return (R[0][0], R[0][1], 0.0) if len(R) == 2: return c2(R[0], R[1]) return c3(R[0], R[1], R[2]) idx = random.randrange(len(P)) P[idx], P[-1] = P[-1], P[idx] p = P.pop() cx, cy, r = welzl(P, R) if inside(p, cx, cy, r): P.append(p) return (cx, cy, r) R.append(p) cx, cy, r = welzl(P, R) P.append(p) R.pop() return (cx, cy, r) N = int(sys.stdin.readline()) pts = [tuple(map(float, sys.stdin.readline().split())) for _ in range(N)] cx, cy, r = welzl(pts, []) print(f"{cx:.10f} {cy:.10f} {r:.10f}"), }, { language: “java”, label: “Java”, code: `import java.util.*;

public class Main { static class Pt { double x, y; Pt(double x, double y) { this.x=x; this.y=y; } } static class Cir { Pt c; double r; Cir(Pt c, double r) { this.c=c; this.r=r; } } static double d(Pt a, Pt b) { return Math.hypot(a.x-b.x, a.y-b.y); } static boolean in(Pt p, Cir cir) { return d(p, cir.c) <= cir.r+1e-9; } static Cir c2(Pt a, Pt b) { return new Cir(new Pt((a.x+b.x)/2,(a.y+b.y)/2), d(a,b)/2); } static Cir c3(Pt a, Pt b, Pt c) { double dd = 2*(a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y)); if (Math.abs(dd)<1e-12) return c2(a,b); double ux = ((a.xa.x+a.ya.y)(b.y-c.y)+(b.xb.x+b.yb.y)(c.y-a.y)+(c.xc.x+c.yc.y)(a.y-b.y))/dd; double uy = ((a.xa.x+a.ya.y)(c.x-b.x)+(b.xb.x+b.yb.y)(a.x-c.x)+(c.xc.x+c.yc.y)(b.x-a.x))/dd; return new Cir(new Pt(ux,uy), d(new Pt(ux,uy), a)); } static Cir welzl(Pt[] P, List R, int n, Random rnd) { if (n==0||R.size()==3) { if (R.isEmpty()) return new Cir(new Pt(0,0),0); if (R.size()==1) return new Cir(R.get(0),0); if (R.size()==2) return c2(R.get(0),R.get(1)); return c3(R.get(0),R.get(1),R.get(2)); } int idx = rnd.nextInt(n); Pt tmp = P[idx]; P[idx]=P[n-1]; P[n-1]=tmp; Pt p = P[n-1]; Cir C = welzl(P, R, n-1, rnd); if (in(p, C)) return C; R.add(p); C = welzl(P, R, n-1, rnd); R.remove(R.size()-1); return C; } public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(br.readLine()); Pt[] P = new Pt[N]; for (int i=0; i<N; i++) { StringTokenizer st = new StringTokenizer(br.readLine()); P[i] = new Pt(Double.parseDouble(st.nextToken()), Double.parseDouble(st.nextToken())); } Cir ans = welzl(P, new ArrayList<>(), N, new Random()); System.out.printf(“%.10f %.10f %.10f%n”, ans.c.x, ans.c.y, ans.r); } }, }, ]} cases={[ { label: "삼각형", input: 3 0 0 1 0 0 1, output: 0.5000000000 0.5000000000 0.7071067812, }, { label: "정사각형", input: 4 0 0 2 0 2 2 0 2, output: 1.0000000000 1.0000000000 1.4142135624`, }, ]} />

복잡도

항목	값
시간 (기댓값)	O(N)
시간 (최악)	O(N^2) (매우 드묾)
공간	O(N) (재귀 스택)

변형 / 활용

Minimum enclosing ball: 고차원 공간으로 일반화. Welzl 은 임의 차원에 동작.
Convex hull 최적화: MEC 는 항상 [[Convex Hull|볼록 껍질]] 위의 점에 의해 결정. 껍질만 추려낸 후 Welzl 적용 가능.
응용: 클러스터링 반경 최소화, GPS 오차 보정, 충돌 감지.

함정

1. 3 점 공선 (collinear)

세 점이 일직선이면 외접원이 정의되지 않음. circle_from_3 에서 분모 d = 0 이면 circle_from_2 로 fallback.

2. 실수 오차

eps = 1e-9 로 inside 판정. 특히 공선 판정에서 오차 보정이 중요.

3. 재귀 깊이 / 복사

Welzl 의 naive 복사 구현은 O(N^2). 인덱스 기반 swap 으로 제자리 처리하여 O(N) 유지.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 13708	모든 점을 포함하는 원	-	kokoa-lab
BOJ 2626	헬기착륙장	-	kokoa-lab
BOJ 11664	선분과 점	-	kokoa-lab

참고

[[Geometry Basic|기하 기본]]
[[Convex Hull|볼록 껍질]]
[[Randomized Algorithm|무작위 알고리즘]]

Pick 정리 (Pick's Theorem)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

Pick 정리는 꼭짓점이 격자점 (integer lattice) 위에 있는 단순 다각형의 넓이 A 를 내부 격자점 개수 I 와 경계 격자점 개수 B 로 표현: A = I + B/2 - 1. 1899년 오스트리아 수학자 Georg Pick 이 발견.

문제 상황과 동기

격자점 다각형의 넓이를 구할 때, 내부 점과 경계 점의 개수만 세면 넓이를 알 수 있음.

Naive 접근: 다각형을 삼각형 분할 후 면적 합산. 분할 자체가 복잡하고 일반화 어려움.
핵심 통찰: 격자점의 개수만으로 단순한 공식 A = I + B/2 - 1. [[Shoelace|신발끈 공식]] 으로 면적을 구한 후 역으로 I 를 계산하기도 함.
PS 위치: 좌표 범위가 작고 격자점이 명시적인 문제. 내부 점 개수만 묻는 문제에 직접 활용.

시각화

{}

핵심 아이디어

A = I + B/2 - 1

A: 다각형 넓이
I: 내부 격자점 개수 (경계 제외)
B: 경계 위 격자점 개수

경계 격자점 계산 (각 변):
  dx = |x2 - x1|, dy = |y2 - y1|
  기여 = gcd(dx, dy)   # (0,0) 포함, (x2,y2) 미포함 합계

면적을 알 때 내부 점:
  I = A - B/2 + 1

알고리즘

boundary_points(vertices):
    B = 0
    for i = 0..N-1:
        j = (i+1) % N
        dx = |vertices[i].x - vertices[j].x|
        dy = |vertices[i].y - vertices[j].y|
        B += gcd(dx, dy)
    return B

area_from_pick(I, B):
    return I + B/2 - 1

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Pick 정리: 격자점 다각형의 넓이 = I + B/2 - 1 #include <bits/stdc++.h> using namespace std; using ll = long long; struct Pt { ll x, y; }; ll gcd(ll a, ll b) { return b ? gcd(b, a%b) : a; } ll shoelace2(const vector<Pt>& p) { ll a2 = 0; for (int i = 0; i < (int)p.size(); i++) { int j = (i+1) % p.size(); a2 += p[i].x * p[j].y - p[j].x * p[i].y; } return abs(a2); // 2*A } ll boundary(const vector<Pt>& p) { ll B = 0; for (int i = 0; i < (int)p.size(); i++) { int j = (i+1) % p.size(); B += gcd(abs(p[i].x-p[j].x), abs(p[i].y-p[j].y)); } return B; } int main() { int N; cin >> N; vector<Pt> p(N); for (auto& pt : p) cin >> pt.x >> pt.y; ll A2 = shoelace2(p); ll B = boundary(p); ll I = (A2 - B + 2) / 2; cout << "Area: " << A2/2; if (A2 % 2) cout << ".5"; cout << "\\nBoundary: " << B << "\\nInterior: " << I << "\\n"; }, }, { language: “python”, label: “Python”, code: from math import gcd def shoelace2(p): a2 = 0 for i in range(len(p)): j = (i+1) % len(p) a2 += p[i][0]*p[j][1] - p[j][0]*p[i][1] return abs(a2) def boundary(p): B = 0 for i in range(len(p)): j = (i+1) % len(p) B += gcd(abs(p[i][0]-p[j][0]), abs(p[i][1]-p[j][1])) return B N = int(input()) p = [tuple(map(int, input().split())) for _ in range(N)] A2 = shoelace2(p) B = boundary(p) I = (A2 - B + 2) // 2 area = A2 // 2 print(f"Area: {area}" + (".5" if A2 % 2 else "")) print(f"Boundary: {B}\\nInterior: {I}"), }, { language: “java”, label: “Java”, code: `import java.util.*;

public class Main { static long gcd(long a, long b) { return b==0 ? a : gcd(b, a%b); } public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int N = Integer.parseInt(br.readLine()); long[] x = new long[N], y = new long[N]; for (int i=0; i

복잡도

항목	값
Shoelace 면적	O(N)
B 계산 (gcd)	O(N log M)
전체	O(N log M)

변형 / 활용

역 Pick: 면적 A 와 B 를 알 때 I = A - B/2 + 1.
Ehrhart theory: 고차원 격자점 다각형 일반화.
응용: GIS 영역 분석, 화면 픽셀 커버리지.

함정

1. .5 단위 넓이

B 가 홀수면 A 는 .5 단위. 정수형만 사용할 때 shoelace 의 2 배 값 (A2) 을 유지해야 손실 없음.

2. 단순 다각형 조건

자기 교차 (self-intersecting) 또는 구멍이 있는 다각형에서는 성립하지 않음.

3. GCD 경계 계산

dx=0 또는 dy=0 인 수평/수직 변은 gcd(0, k) = k. 변의 양 끝점 중 한쪽만 세도록 처리.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2166	다각형의 면적	-	kokoa-lab
BOJ 1485	정사각형	-	kokoa-lab
BOJ 1358	하키	-	kokoa-lab
BOJ 1004	어린 왕자	-	kokoa-lab

참고

[[Geometry Basic|기하 기본]]
[[Shoelace|신발끈 공식]]

평면 그래프 (Planar Graph)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

평면 그래프 (Planar Graph) 는 간선끼리 교차하지 않고 평면에 그릴 수 있는 그래프. 연결된 평면 그래프는 항상 Euler 공식 V - E + F = 2 를 만족한다, 여기서 V = 꼭짓점, E = 간선, F = 면(face). 평면 그래프의 대표적인 비존재 정리로 Kuratowski 정리: 그래프가 평면 iff K_5 또는 K_{3,3} 을 세부 그래프로 포함하지 않는다.

문제 상황과 동기

회로 기판(PCB) 배선, 지도 색칠(4색 정리), VLSI 설계 등에서 간선 교차를 허용할 수 없는 상황. 컴퓨터 비전의 planar SLAM, 그래프 마이닝의 genus 계산까지 확장됨. Naive planar embedding 은 NP-hard 이지만, 평면성 검사는 O(V+E) 에 가능 (Hopcroft-Tarjan).

핵심 통찰: 면(faces)까지 포함한 combinatorial count가 V, E 만으로 결정된다 는 Euler 공식이 평면 그래프 이론의 기둥.

시각화

{}

핵심 아이디어

Euler's formula (connected planar graph):
  V - E + F = 2

Necessary condition (V >= 3):
  E <= 3V - 6

Kuratowski's theorem:
  G is planar  <=>  G has no subgraph homeomorphic to K_5 or K_{3,3}

평면 그래프의 면에는 바깥 면(outer face) 도 포함된다. Triangulation (최대 평면 그래프) 은 E = 3V - 6 을 만족.

Euler 지표: V - E + F = 2(C - G) 로 일반화 (C = 연결 성분 수, G = genus)
K_5: 5개의 꼭짓점이 모두 연결 (K_5 = 10 간선). 3V-6 = 9 이므로 평면 불가.
K_{3,3}: 3+3 완전 이분 그래프 (9 간선). E = 9 > 3V-6 = 12(v=6), 필연 조건은 통과하지만 non-planar (Kuratowski).

알고리즘

planarity_test(V, E, adj):
  if V < 3: return true
  if E > 3V - 6: return false          # necessary condition
  # Hopcroft-Tarjan O(V+E) planarity test
  # DFS-free numbering + lowlink 로 embedding 시도
  # 세부 Kuratowski subgraph 탐지
  return planarity_embedding(V, adj)   # 성공시 true

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Planar graph necessary condition + Euler formula verification #include <bits/stdc++.h> using namespace std; int main() { int v, e; cin >> v >> e; vector<vector<int>> adj(v); for (int i = 0; i < e; i++) { int a, b; cin >> a >> b; adj[a].push_back(b); adj[b].push_back(a); } // Necessary condition: E <= 3V - 6 (for V >= 3) if (v >= 3 && e > 3 * v - 6) { cout << "NOT PLANAR (E > 3V-6: " << e << " > " << 3*v-6 << ")\\n"; return 0; } // Euler test: given face count F int f; cin >> f; if (v - e + f == 2) { cout << "Euler formula holds: V-E+F = " << v << "-" << e << "+" << f << " = 2\\n"; cout << "PLANAR (consistent with planar embedding)\\n"; } else { cout << "Euler formula fails: V-E+F = " << v-e+f << " != 2\\n"; } return 0; }, }, { language: “python”, label: “Python”, code: `def main(): v, e = map(int, input().split()) adj = [[] for _ in range(v)] for _ in range(e): a, b = map(int, input().split()) adj[a].append(b); adj[b].append(a) if v >= 3 and e > 3 * v - 6: print(“NOT PLANAR (E > 3V-6)”) return f = int(input()) if v - e + f == 2: print(f”Euler holds: {v}-{e}+{f}=2”) print(“PLANAR”) else: print(f”Euler fails: {v}-{e}+{f} != 2”)

if name == “main”: main(), }, { language: "java", label: "Java", code: import java.util.*;

public class Main { public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringTokenizer st = new StringTokenizer(br.readLine()); int v = Integer.parseInt(st.nextToken()); int e = Integer.parseInt(st.nextToken()); ArrayList[] adj = new ArrayList[v]; for (int i = 0; i < v; i++) adj[i] = new ArrayList<>(); for (int i = 0; i < e; i++) { st = new StringTokenizer(br.readLine()); int a = Integer.parseInt(st.nextToken()); int b = Integer.parseInt(st.nextToken()); adj[a].add(b); adj[b].add(a); } if (v >= 3 && e > 3 * v - 6) { System.out.println(“NOT PLANAR (E > 3V-6)”); return; } int f = Integer.parseInt(br.readLine()); if (v - e + f == 2) System.out.println(“Euler holds: ” + v + ”-” + e + ”+” + f + “=2\nPLANAR”); else System.out.println(“Euler fails: ” + (v - e + f) + ” != 2”); } }, }, ]} cases={[ { label: "K_4 (planar)", input: 4 6 0 1 0 2 0 3 1 2 1 3 2 3 4, output: Euler holds: 4-6+4=2 PLANAR, }, { label: "K_5 (non-planar)", input: 5 10 0 1 0 2 0 3 0 4 1 2 1 3 1 4 2 3 2 4 3 4 7, output: NOT PLANAR (E > 3V-6: 10 > 9)`, }, ]} />

복잡도

항목	값
필연 조건 검사	O(V+E)
Planarity test (Hopcroft-Tarjan)	O(V+E)
Euler formula 검증	O(1) (V, E, F 입력)
Kuratowski subgraph 검출	O(V+E)
공간	O(V+E)

변형 / 활용

변형	설명
Maximum planar graph (triangulation)	`E = 3V - 6`, 모든 면이 삼각형
Outerplanar graph	모든 꼭짓점이 바깥 면에 속함. `E <= 2V - 3`
Genus (종수)	평면 대신 g 개 손잡이를 가진 곡면. Euler: `V - E + F = 2 - 2g`
Dual graph	면을 꼭짓점으로, 인접 면을 간선으로
4-color theorem	평면 그래프는 4색으로 vertex-coloring 가능

응용: PCB / VLSI routing (간선 교차 금지), 지도 제작 (4색 정리), 네트워크 다이어그램, Feynman diagram.

함정

1. 필요 조건 vs 충분 조건

E <= 3V - 6 은 필요 조건일 뿐 충분하지 않음. K_{3,3} 은 V=6, E=9 <= 12 이지만 planar 가 아님.

2. 면의 정의

바깥 면(outer face) 도 면의 개수에 포함. Disconnected graph 는 V - E + F = 1 + C (C=연결성분).

3. K_4 는 planar, K_5 는 non-planar

K_4 (V=4, E=6, F=4) 는 Euler 를 만족하고 평면에 교차 없이 그릴 수 있음. K_5 (V=5, E=10) 는 간선이 하나 비껴서 교차가 불가피.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 1709	평면그래프	-	kokoa-lab
BOJ 2613	번호표 교환	-	kokoa-lab
BOJ 1997	사분면	-	kokoa-lab

참고

[[Convex Hull|볼록 껍질]]
[[Point in Convex Polygon|볼록 다각형 점 판정]]

볼록 다각형 내부 점 판정 (Point in Convex Polygon)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

볼록 다각형 내부 점 판정 은 볼록 다각형(convex polygon) 과 하나의 점이 주어졌을 때, 점이 다각형의 내부/경계/외부 중 어디에 있는지 O(log N) 에 판별하는 알고리즘. N 은 꼭짓점 개수. 다각형이 반드시 볼록 (내각 180도 미만) 이어야 하며, 꼭짓점이 반시계(CCW) 또는 시계(CW) 순서로 주어져야 한다.

문제 상황과 동기

Q 개의 점이 볼록 N 각형 내부에 있는지 묻는 문제.

naive: 모든 변에 대해 CCW 검사를 일일이 수행. O(N Q). N=10^5, Q=10^5 면 불가능.
binary search on angle: O(N) 전처리 + O(log N) 쿼리. 총 O(N + Q log N).

핵심 통찰: 볼록 다각형의 꼭짓점은 한 점(p_0) 을 기준으로 각도순으로 정렬되어 있다. 임의의 점 q 에 대해, q 가 속하는 “쐐기” (p_0, p_i, p_{i+1}) 를 이분 탐색으로 찾고, 그 삼각형 내부에 q 가 있는지 CCW 한 번으로 확인.

시각화

{}

핵심 아이디어

invariant: 볼록 다각형의 꼭짓점 p_0 에서 다른 꼭짓점으로의 방향 벡터는 각도 순서 로 정렬되어 있다.

1. p_1 ... p_{N-1} 이 p_0 를 기준으로 반시계 방향 정렬
2. 쿼리 점 q 에 대해, p_0 에서 q 로의 벡터가 어느 구간
   (p_0, p_i) 와 (p_0, p_{i+1}) 사이에 있는지 이분 탐색
3. q 가 삼각형 (p_0, p_i, p_{i+1}) 내부에 있는지 CCW 로 확인

방향 판정	결과
CCW(p_0, p_i, q) > 0	q 가 왼쪽: i 를 오른쪽으로
CCW(p_0, p_i, q) ≤ 0	q 가 오른쪽: i 를 왼쪽으로
CCW(p_i, p_{i+1}, q) ≥ 0	q 가 내부 또는 경계
그 외	외부

알고리즘

INPUT: convex polygon P[0..N-1] (CCW order), query point q
OUTPUT: IN / OUT / ON

// 1. q 가 P[0] 과 같은 점인지 확인
if P[0] == q: return ON

// 2. q 가 P[0]->P[1] 과 P[0]->P[N-1] 사이에 있는지 확인
if CCW(P[0], P[1], q) < 0 or CCW(P[0], P[N-1], q) > 0:
    return OUT

// 3. 이분 탐색: q 가 속하는 wedge 찾기
lo = 1, hi = N - 1
while hi - lo > 1:
    mid = (lo + hi) / 2
    if CCW(P[0], P[mid], q) >= 0: lo = mid
    else: hi = mid

// 4. lo 와 lo+1 로 이루어진 삼각형 내부 확인
if CCW(P[lo], P[lo+1], q) >= 0:
    if q 가 P[lo] 또는 P[lo+1] 경계 위: return ON
    return IN
return OUT

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // 볼록 다각형 내부 점 판정 O(log N) #include <bits/stdc++.h> using namespace std; using ll = long long; struct Point { ll x, y; }; int ccw(Point a, Point b, Point c) { ll ret = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); if (ret > 0) return 1; if (ret < 0) return -1; return 0; } string pointInConvexPolygon(vector<Point>& P, Point q) { int n = P.size(); if (ccw(P[0], P[1], q) < 0 || ccw(P[0], P[n-1], q) > 0) return "OUT"; if (ccw(P[0], P[1], q) == 0) { if (q.x >= min(P[0].x, P[1].x) && q.x <= max(P[0].x, P[1].x) && q.y >= min(P[0].y, P[1].y) && q.y <= max(P[0].y, P[1].y)) return "ON"; return "OUT"; } int lo = 1, hi = n - 1; while (hi - lo > 1) { int mid = (lo + hi) / 2; if (ccw(P[0], P[mid], q) >= 0) lo = mid; else hi = mid; } int c = ccw(P[lo], P[lo+1], q); if (c > 0) return "IN"; if (c < 0) return "OUT"; return "ON"; } int main() { int n, q; cin >> n >> q; vector<Point> P(n); for (auto& p : P) cin >> p.x >> p.y; while (q--) { Point qp; cin >> qp.x >> qp.y; cout << pointInConvexPolygon(P, qp) << "\\n"; } }, }, { language: “python”, label: “Python”, code: `# 볼록 다각형 내부 점 판정 (binary search on angle) import sys input = sys.stdin.readline

def ccw(ax, ay, bx, by, cx, cy): return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax)

def inside(P, qx, qy): n = len(P) if ccw(P[0][0], P[0][1], P[1][0], P[1][1], qx, qy) < 0: return “OUT” if ccw(P[0][0], P[0][1], P[-1][0], P[-1][1], qx, qy) > 0: return “OUT” lo, hi = 1, n - 1 while hi - lo > 1: mid = (lo + hi) // 2 if ccw(P[0][0], P[0][1], P[mid][0], P[mid][1], qx, qy) >= 0: lo = mid else: hi = mid c = ccw(P[lo][0], P[lo][1], P[lo+1][0], P[lo+1][1], qx, qy) if c > 0: return “IN” if c < 0: return “OUT” return “ON”

n, q = map(int, input().split()) P = [tuple(map(int, input().split())) for _ in range(n)] for _ in range(q): x, y = map(int, input().split()) print(inside(P, x, y)), }, { language: "java", label: "Java", code: // 볼록 다각형 내부 점 판정 O(log N)

public class Main { static long ccw(long ax, long ay, long bx, long by, long cx, long cy) { return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax); } static String inside(long[][] P, long qx, long qy) { int n = P.length; if (ccw(P[0][0], P[0][1], P[1][0], P[1][1], qx, qy) < 0 || ccw(P[0][0], P[0][1], P[n-1][0], P[n-1][1], qx, qy) > 0) return “OUT”; int lo = 1, hi = n - 1; while (hi - lo > 1) { int mid = (lo + hi) / 2; if (ccw(P[0][0], P[0][1], P[mid][0], P[mid][1], qx, qy) >= 0) lo = mid; else hi = mid; } long c = ccw(P[lo][0], P[lo][1], P[lo+1][0], P[lo+1][1], qx, qy); if (c > 0) return “IN”; if (c < 0) return “OUT”; return “ON”; } public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringTokenizer st = new StringTokenizer(br.readLine()); int n = Integer.parseInt(st.nextToken()); int q = Integer.parseInt(st.nextToken()); long[][] P = new long[n][2]; for (int i = 0; i < n; i++) { st = new StringTokenizer(br.readLine()); P[i][0] = Long.parseLong(st.nextToken()); P[i][1] = Long.parseLong(st.nextToken()); } StringBuilder sb = new StringBuilder(); for (int i = 0; i < q; i++) { st = new StringTokenizer(br.readLine()); long qx = Long.parseLong(st.nextToken()); long qy = Long.parseLong(st.nextToken()); sb.append(inside(P, qx, qy)).append(‘\n’); } System.out.print(sb); } }, }, ]} cases={[ { label: "기본 예제", input: 5 3 0 0 6 0 5 4 2 5 -1 3 3 2 0 5 2 2, output: IN OUT ON`, }, ]} />

복잡도

항목	값
전처리	O(N)
쿼리 (점 1개)	O(log N)
전체 (Q 쿼리)	O(N + Q log N)
공간	O(N)

변형 / 활용

[[Convex Hull|컨벡스 헐]] 점들을 CCW 정렬 후 hull 바깥 점을 빠르게 필터.
다각형 내부 점 수: 쿼리당 O(log N), N=Q=10^5 에서 실용적.
Boundary-on: CCW=0 인 변 위에 있으면 projection 범위로 확인.
Rotating calipers 와 결합해 convex hull 회전 과정에서 포함 여부 확인.

함정

CCW 방향: 다각형이 시계 방향이면 부호 반전 또는 reverse 후 처리.
오버플로우: 좌표 10^6 에서 CCW 는 10^12 → C++/Java long long/long 필수.
경계 판정: 점이 꼭짓점이나 변 위면 ON. 이분 탐색 전 p_0 일치 여부 먼저 확인.
Collinear: 모든 점이 일직선이면 볼록 다각형이 아님. degenerate case 로 따로 처리.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2254	감옥 건설	33.149%	kokoa-lab
BOJ 2049	가장 먼 두 점	37.784%	kokoa-lab
BOJ 2699	격자점 컨벡스헐	57.516%	kokoa-lab

참고

[[CCW|CCW (시계/반시계 판정)]]
[[Convex Hull|볼록 껍질]]
[[Angle Sorting|각도 정렬]]
[[Geometry|기하 기본]]
AtCoder ABC 296 G - Polygon and Points

(오목 포함) 다각형 내부 점 판정 (Point in Polygon)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

다각형 내부 점 판정 (Point in Polygon, PIP) 은 단순 다각형 (볼록 또는 오목) 과 하나의 점이 주어졌을 때, 점이 내부/경계/외부 중 어디에 있는지 판별하는 문제. Ray casting (ray crossing) 알고리즘이 가장 일반적으로 사용되며, O(N) 시간에 동작한다. N 은 꼭짓점 개수.

문제 상황과 동기

단순 다각형 (볼록/오목 구분 없음) 과 하나의 점. 오목 다각형에서는 CCW 만으로 일관된 판정이 불가능.

Naive: 각 변마다 점과의 위치 관계를 확인하는 CCW 검사는 볼록일 때만 O(N). 오목에선 실패.
Ray casting: 점에서 임의의 방향으로 반직선을 그려 다각형 변과의 교차 횟수로 판정. O(N).

핵심 통찰: 다각형의 변은 내부와 외부를 가르는 경계선. 반직선이 변과 교차할 때마다 내부/외부 패리티가 바뀐다. 최종 교차 횟수가 홀수면 내부, 짝수면 외부.

시각화

{}

핵심 아이디어

even-odd rule (홀짝 법칙):
  점 p 에서 오른쪽으로 수평 반직선을 긋는다.
  이 반직선과 다각형의 변이 교차하는 횟수를 센다.
  교차 횟수 % 2 == 1 → IN
  교차 횟수 % 2 == 0 → OUT

조건	판정
교차 횟수 = 홀수	내부 (IN)
교차 횟수 = 짝수 (0 포함)	외부 (OUT)
점이 변 위에 있음	경계 (ON)

반직선 방향은 어디든 상관없으나, 오른쪽 수평 이 구현이 가장 간단.

알고리즘

INPUT: polygon P[0..N-1] (CCW or CW), query point q
OUTPUT: IN / ON / OUT

count = 0
for i = 0..N-1:
    j = (i + 1) % N
    if q is on segment(P[i], P[j]): return ON

    // P[i].y < q.y <= P[j].y (upward crossing)
    // 또는 P[j].y < q.y <= P[i].y (downward crossing)
    if (P[i].y <= q.y < P[j].y) or (P[j].y <= q.y < P[i].y):
        // 반직선과 변의 교차 x 좌표 계산
        x_intersect = P[i].x + (q.y - P[i].y)
                        * (P[j].x - P[i].x) / (P[j].y - P[i].y)
        if q.x < x_intersect: count++

return count % 2 == 1 ? IN : OUT

주의: 한쪽 끝점만 inclusive 로 처리하여 꼭짓점 중복 교차 방지.

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Ray casting O(N) 점의 다각형 포함 여부 #include <bits/stdc++.h> using namespace std; using ll = long long; struct Point { ll x, y; }; int ccw(Point a, Point b, Point c) { ll ret = (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); if (ret > 0) return 1; if (ret < 0) return -1; return 0; } bool onSegment(Point a, Point b, Point q) { if (ccw(a, b, q) != 0) return false; return min(a.x, b.x) <= q.x && q.x <= max(a.x, b.x) && min(a.y, b.y) <= q.y && q.y <= max(a.y, b.y); } string pip(vector<Point>& P, Point q) { int n = P.size(), cnt = 0; for (int i = 0; i < n; i++) { int j = (i + 1) % n; if (onSegment(P[i], P[j], q)) return "ON"; if ((P[i].y <= q.y && q.y < P[j].y) || (P[j].y <= q.y && q.y < P[i].y)) { double x_intersect = P[i].x + (double)(q.y - P[i].y) * (P[j].x - P[i].x) / (P[j].y - P[i].y); if (q.x < x_intersect) cnt++; } } return cnt % 2 ? "IN" : "OUT"; } int main() { int n, q; cin >> n >> q; vector<Point> P(n); for (auto& p : P) cin >> p.x >> p.y; while (q--) { Point qp; cin >> qp.x >> qp.y; cout << pip(P, qp) << "\\n"; } }, }, { language: “python”, label: “Python”, code: `# Ray casting O(N) point in polygon import sys input = sys.stdin.readline

def ccw(ax, ay, bx, by, cx, cy): return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax)

def on_seg(x1, y1, x2, y2, qx, qy): if ccw(x1, y1, x2, y2, qx, qy) != 0: return False return min(x1, x2) <= qx <= max(x1, x2) and min(y1, y2) <= qy <= max(y1, y2)

def pip(P, qx, qy): n, cnt = len(P), 0 for i in range(n): x1, y1 = P[i] x2, y2 = P[(i + 1) % n] if on_seg(x1, y1, x2, y2, qx, qy): return “ON” if (y1 <= qy < y2) or (y2 <= qy < y1): x_int = x1 + (qy - y1) * (x2 - x1) / (y2 - y1) if qx < x_int: cnt += 1 return “IN” if cnt % 2 else “OUT”

n, q = map(int, input().split()) P = [tuple(map(int, input().split())) for _ in range(n)] for _ in range(q): x, y = map(int, input().split()) print(pip(P, x, y)), }, { language: "java", label: "Java", code: // Ray casting O(N) point in polygon

public class Main { static long ccw(long ax, long ay, long bx, long by, long cx, long cy) { return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax); } static boolean onSeg(long x1, long y1, long x2, long y2, long qx, long qy) { if (ccw(x1, y1, x2, y2, qx, qy) != 0) return false; return Math.min(x1, x2) <= qx && qx <= Math.max(x1, x2) && Math.min(y1, y2) <= qy && qy <= Math.max(y1, y2); } static String pip(long[][] P, long qx, long qy) { int n = P.length, cnt = 0; for (int i = 0; i < n; i++) { long x1 = P[i][0], y1 = P[i][1]; long x2 = P[(i+1)%n][0], y2 = P[(i+1)%n][1]; if (onSeg(x1, y1, x2, y2, qx, qy)) return “ON”; if ((y1 <= qy && qy < y2) || (y2 <= qy && qy < y1)) { double xInt = x1 + (double)(qy - y1) * (x2 - x1) / (y2 - y1); if (qx < xInt) cnt++; } } return cnt % 2 == 1 ? “IN” : “OUT”; } public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); StringTokenizer st = new StringTokenizer(br.readLine()); int n = Integer.parseInt(st.nextToken()); int q = Integer.parseInt(st.nextToken()); long[][] P = new long[n][2]; for (int i = 0; i < n; i++) { st = new StringTokenizer(br.readLine()); P[i][0] = Long.parseLong(st.nextToken()); P[i][1] = Long.parseLong(st.nextToken()); } StringBuilder sb = new StringBuilder(); for (int i = 0; i < q; i++) { st = new StringTokenizer(br.readLine()); long qx = Long.parseLong(st.nextToken()); long qy = Long.parseLong(st.nextToken()); sb.append(pip(P, qx, qy)).append(‘\n’); } System.out.print(sb); } }, }, ]} cases={[ { label: "기본 예제", input: 6 4 0 0 4 0 4 2 2 2 2 4 0 4 1 1 5 1 2 2 0 0, output: IN OUT ON ON`, }, ]} />

복잡도

항목	값
점 1개 판정	O(N)
Q 개 점	O(N Q)
공간	O(N)

변형 / 활용

볼록 다각형: O(log N) 이분 탐색 ([[Point in Convex Polygon|볼록 다각형 내부 점 판정]]).
Winding number: crossing number 와 달리 방향 고려, self-intersecting 다각형에서도 올바름. CCW 부호를 누적해 wn != 0 이면 내부.
Grid point location: 쿼리가 많으면 plane sweep 으로 O(N log N) 전처리 후 O(log N) 쿼리.
GIS / 그래픽스: 구역 판별, hit testing, 영역 필터링.

함정

꼭짓점 중복 교차: 반직선이 꼭짓점 통과 시 두 번 세는 문제. upward/downward edge 끝점을 한쪽만 inclusive.
수평 변: 반직선과 평행하면 무시. y 비교 부등호로 자연히 걸러짐.
부동소수점 오차: 교차점 x 계산에 double. 정수 좌표면 유리수 유지 또는 CCW 만으로 onSegment 검사.
경계 점: 점이 변 위일 때 ON. onSegment 함수로 먼저 검사.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 1688	지민이의 테러	23.417%	kokoa-lab
BOJ 2254	감옥 건설	33.149%	kokoa-lab
BOJ 3679	단순 다각형	26.233%	kokoa-lab

참고

[[Convex Hull|볼록 껍질]]
[[Point in Convex Polygon|볼록 다각형 내부 점 판정]]
[[CCW|CCW (시계/반시계 판정)]]
[[Angle Sorting|각도 정렬]]

다각형 넓이 (Polygon Area)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

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

문제 상황과 동기

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

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

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

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

시각화

{}

핵심 아이디어

다각형의 꼭짓점을 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 이면 시계 방향.

알고리즘

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)

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

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

4. 정수 좌표 + long long

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

함정

1. 오버플로우

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

2. 다각형 방향

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

3. 마지막 변

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

4. 정수 나눗셈

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

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]] (기하 기본)

피타고라스 정리 (Pythagorean Theorem)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

피타고라스 정리는 직각삼각형에서 빗변 c 의 제곱이 두 직각변 a, b 의 제곱의 합과 같다는 정리: c^2 = a^2 + b^2. 기원전 6세기 그리스 수학자 피타고라스가 증명. 피타고라스 수 (Pythagorean triple) 는 이 등식을 만족하는 세 자연수 (a, b, c) 쌍으로 (3, 4, 5) 가 가장 잘 알려짐.

문제 상황과 동기

2D 평면에서 두 점 사이의 거리, 직각 판별, 원의 방정식 등 기하의 거의 모든 곳에서 피타고라스 정리가 쓰임.

Naive 접근: 세 변이 주어졌을 때 a^2 + b^2 = c^2 를 확인하려면 세 변을 정렬한 후 O(1).
핵심 통찰: c 가 항상 가장 크므로 정렬 후 한 번의 검사로 직각 판별 가능.
PS 위치: 두 점 거리의 제곱을 그대로 비교해 실수 연산 회피. 좌표 기하 문제의 가장 기초.

시각화

{}

핵심 아이디어

c^2 = a^2 + b^2

직각삼각형:
- a, b: 직각변 (legs)
- c: 빗변 (hypotenuse), 항상 가장 긴 변

Euclid 공식 (primitive triple 생성):
a = m^2 - n^2
b = 2mn
c = m^2 + n^2
조건: m > n, gcd(m,n)=1, m-n 은 홀수

알고리즘

is_right_triangle(a, b, c):
    sides = [a, b, c] 정렬
    return sides[0]^2 + sides[1]^2 == sides[2]^2

generate_triples(limit):
    for m = 2..sqrt(limit):
        for n = 1..m-1:
            if (m-n) is even: continue
            if gcd(m, n) != 1: continue
            a = m^2 - n^2, b = 2mn, c = m^2 + n^2
            if c > limit: continue
            for k = 1; k*c <= limit; k++:
                output (k*a, k*b, k*c)

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // 피타고라스 수 생성 + 직각 판별 #include <bits/stdc++.h> using namespace std; int main() { int limit; cin >> limit; vector<tuple<int,int,int>> triples; for (int m = 2; m*m <= limit; m++) { for (int n = 1; n < m; n++) { if ((m-n) % 2 == 0) continue; if (gcd(m, n) != 1) continue; int a = m*m - n*n, b = 2*m*n, c = m*m + n*n; if (c > limit) continue; for (int k = 1; k*c <= limit; k++) triples.push_back({k*a, k*b, k*c}); } } cout << "Found " << triples.size() << " triples:\\n"; for (auto& [a,b,c] : triples) cout << a << " " << b << " " << c << "\\n"; int x, y, z; cin >> x >> y >> z; vector<int> v = {x, y, z}; sort(v.begin(), v.end()); bool right = v[0]*v[0] + v[1]*v[1] == v[2]*v[2]; cout << (right ? "RIGHT" : "NOT RIGHT") << "\\n"; }, }, { language: “python”, label: “Python”, code: from math import gcd def generate_triples(limit): triples = [] for m in range(2, int(limit**0.5)+1): for n in range(1, m): if (m-n) % 2 == 0: continue if gcd(m, n) != 1: continue a, b, c = m*m - n*n, 2*m*n, m*m + n*n if c > limit: continue k = 1 while k*c <= limit: triples.append((k*a, k*b, k*c)) k += 1 return triples limit = int(input()) triples = generate_triples(limit) print(f"Found {len(triples)} triples") for t in triples: print(*t) x, y, z = sorted(map(int, input().split())) print("RIGHT" if x*x + y*y == z*z else "NOT RIGHT"), }, { language: “java”, label: “Java”, code: `import java.util.*;

public class Main { static int gcd(int a, int b) { return b==0 ? a : gcd(b, a%b); } public static void main(String[] args) throws IOException { BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); int limit = Integer.parseInt(br.readLine()); List out = new ArrayList<>(); int cnt = 0; for (int m = 2; mm <= limit; m++) { for (int n = 1; n < m; n++) { if ((m-n)%2==0) continue; if (gcd(m,n)!=1) continue; int a = mm-nn, b = 2mn, c = mm+nn; if (c > limit) continue; for (int k = 1; kc <= limit; k++) { out.add((ka)+” ”+(kb)+” ”+(k*c)); cnt++; } } } System.out.println(“Found ” + cnt + ” triples”); out.forEach(System.out::println); StringTokenizer st = new StringTokenizer(br.readLine()); int[] v = {Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken()), Integer.parseInt(st.nextToken())}; Arrays.sort(v); boolean right = v[0]*v[0]+v[1]*v[1]==v[2]*v[2]; System.out.println(right ? “RIGHT” : “NOT RIGHT”); } }, }, ]} cases={[ { label: "기본", input: 50 3 4 5, output: Found 5 triples 3 4 5 5 12 13 8 15 17 7 24 25 20 21 29 RIGHT`, }, ]} />

복잡도

항목	값
직각 판별 (3 변)	O(1)
Triple 생성 (limit L)	O(L log L)
Triple 생성 공간	O(L)

변형 / 활용

응용	설명
유클리드 거리	sqrt((x1-x2)^2 + (y1-y2)^2)
제곱 거리 비교	sqrt 없이 제곱 상태로 비교 (실수 오차 회피)
내적과 직각	두 벡터의 내적이 0 이면 직각. 좌표 기하에서 활용

함정

1. 빗변 식별 실수

가장 큰 변을 빗변으로 지정해야 함. 정렬 없이 a^2 + b^2 == c^2 만 검사하면 c 가 빗변이 아닐 때 오답.

2. 오버플로우

N=10^5 에서 좌표 제곱은 10^10 -> 32-bit int 초과. 반드시 long long 사용.

3. 실수 sqrt 비교

sqrt(a^2 + b^2) == c 는 부동소수점 오차 유발. 반드시 정수 제곱으로 비교.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 4153	직각삼각형	-	kokoa-lab
BOJ 3000	직각삼각형	-	kokoa-lab
BOJ 1711	직각삼각형	-	kokoa-lab
BOJ 1485	정사각형	-	kokoa-lab

참고

[[Geometry Basic|기하 기본]]
[[Distance|거리 (유클리드)]]

회전 캘리퍼스 (Rotating Calipers)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

회전 캘리퍼스 (Rotating Calipers) 는 볼록 다각형 위에서 서로 마주보는 두 평행선 (겹지름, antipodal pair) 을 회전시키며 다각형의 최장 거리, 최소 폭, 최대 삼각형 면적 등을 O(N) 에 구하는 기법.

미하일 슐로스만 (M. Shamos) 의 박사 논문 (1978) 에서 처음 제안.

문제 상황과 동기

N 개 점 중 가장 먼 두 점 (farthest pair) 을 구한다.

Naive: 모든 쌍 거리 계산 O(N^2). N=10^5 면 10^10, 불가능.
Convex Hull + Rotating Calipers:
1. Convex hull 구축 O(N log N)
2. Hull 위에서 rotating calipers O(N)
3. 총 O(N log N)

핵심 통찰: 가장 먼 두 점은 항상 볼록 껍질 위에 있다. 캘리퍼스를 360도 회전시키면서 antipodal pair 의 거리를 갱신하면 O(N).

시각화

{}

핵심 아이디어

Antipodal pair (겹지름)

볼록 다각형의 두 꼭짓점에 평행한 두 접선 을 그을 수 있을 때, 그 쌍을 antipodal (마주보는) pair 라고 함.

한 360도 회전 동안 antipodal pair 의 개수 = O(N)
각 pair 의 거리 = max distance candidate

캘리퍼스 회전 (Two-pointer)

1. hull 구축 (반시계 방향)
2. hull[0] 에 대해 가장 먼 hull[j] 찾기 (j = 1)
3. for i = 0..N-1:
       while distance(hull[i], hull[j+1]) > distance(hull[i], hull[j]):
           j = (j + 1) % N
       ans = max(ans, dist(hull[i], hull[j]))
   // i 가 한 바퀴 도는 동안 j 도 많아야 2N 번 움직임 -> O(N)

알고리즘

rotating_calipers(hull):
    N = |hull|
    j = 1
    ans = 0
    for i = 0..N-1:
        while True:
            nxt = (j + 1) % N
            if area(hull[i], hull[i+1], hull[nxt]) <= area(hull[i], hull[i+1], hull[j]):
                break
            j = nxt
        ans = max(ans, dist2(hull[i], hull[j]))
    return sqrt(ans)

// area(a, b, c) = |ccw(a, b, c)| (삼각형 넓이 2배)
// hull[i] - hull[i+1] 변에 대해 가장 먼 점 hull[j]

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Rotating Calipers: farthest pair on convex hull #include <bits/stdc++.h> using namespace std; using ll = long long; struct Point { ll x, y; }; ll ccw(Point a, Point b, Point c) { return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); } ll dist2(Point a, Point b) { ll dx = a.x - b.x, dy = a.y - b.y; return dx*dx + dy*dy; } double rotating_calipers(vector<Point>& hull) { int n = hull.size(); if (n == 2) return sqrt(dist2(hull[0], hull[1])); int j = 1; ll ans2 = 0; for (int i = 0; i < n; i++) { int ni = (i + 1) % n; while (true) { int nj = (j + 1) % n; if (abs(ccw(hull[i], hull[ni], hull[nj])) <= abs(ccw(hull[i], hull[ni], hull[j]))) break; j = nj; } ans2 = max(ans2, dist2(hull[i], hull[j])); ans2 = max(ans2, dist2(hull[ni], hull[j])); } return sqrt(ans2); } int main() { vector<Point> hull = {{0,0},{2,0},{3,1},{1,3},{-1,2}}; cout.precision(6); cout << fixed << "Max distance: " << rotating_calipers(hull) << "\\n"; }, }, { language: “python”, label: “Python”, code: `# Rotating Calipers: farthest pair on convex hull import math def ccw(ax, ay, bx, by, cx, cy): return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax)

def dist2(a, b): return (a[0]-b[0])**2 + (a[1]-b[1])**2

def rotating_calipers(hull): n = len(hull) if n == 2: return math.sqrt(dist2(hull[0], hull[1])) j = 1 ans2 = 0 for i in range(n): ni = (i + 1) % n while True: nj = (j + 1) % n if abs(ccw(*hull[i], *hull[ni], *hull[nj])) <=
abs(ccw(*hull[i], *hull[ni], *hull[j])): break j = nj ans2 = max(ans2, dist2(hull[i], hull[j])) ans2 = max(ans2, dist2(hull[ni], hull[j])) return math.sqrt(ans2)

hull = [(0,0), (2,0), (3,1), (1,3), (-1,2)] print(f”Max distance: {rotating_calipers(hull):.6f}“), }, { language: "java", label: "Java", code: // Rotating Calipers: farthest pair on convex hull

public class Main { static class Point { long x, y; Point(long x, long y) { this.x = x; this.y = y; } } static long ccw(Point a, Point b, Point c) { return (b.x - a.x) * (c.y - a.y) - (b.y - a.y) * (c.x - a.x); } static long dist2(Point a, Point b) { long dx = a.x - b.x, dy = a.y - b.y; return dxdx + dydy; } static double rotatingCalipers(List hull) { int n = hull.size(); if (n == 2) return Math.sqrt(dist2(hull.get(0), hull.get(1))); int j = 1; long ans2 = 0; for (int i = 0; i < n; i++) { int ni = (i + 1) % n; while (true) { int nj = (j + 1) % n; if (Math.abs(ccw(hull.get(i), hull.get(ni), hull.get(nj))) <= Math.abs(ccw(hull.get(i), hull.get(ni), hull.get(j)))) break; j = nj; } ans2 = Math.max(ans2, dist2(hull.get(i), hull.get(j))); ans2 = Math.max(ans2, dist2(hull.get(ni), hull.get(j))); } return Math.sqrt(ans2); } public static void main(String[] args) { List hull = Arrays.asList( new Point(0,0), new Point(2,0), new Point(3,1), new Point(1,3), new Point(-1,2)); System.out.printf(“Max distance: %.6f%n”, rotatingCalipers(hull)); } }, }, ]} cases={[ { label: "기본 예제", input: ``, output: Max distance: 4.472136`, }, ]} />

복잡도

항목	값
시간 (Convex Hull 포함)	O(N log N) (정렬)
시간 (Hull 위 calipers)	O(N) (two-pointer)
공간	O(N)

j 포인터는 전체 루프에서 최대 2N 번만 전진 -> amortized O(N).

변형 / 활용

1. 최장 거리 (Farthest pair)

가장 먼 두 점. hull + rotating calipers.

2. 최소 폭 (Minimum width)

평행한 두 직선 사이에 hull 을 끼울 때 최소 거리.

3. 최대 면적 삼각형 (Largest triangle in convex polygon)

Antipodal pair 개념 확장: hull[i], hull[j], hull[k] 세 점. O(N^2) (또는 O(N) with rotating calipers 3 개).

4. 최대 내접 사각형

회전 캘리퍼스로 hull 에 내접하는 최대 면적 사각형.

5. Minimum bounding box (최소 면적 외접 직사각형)

hull 의 각 변을 기준으로 캘리퍼스로 나머지 세 변의 위치 O(N) 결정.

함정

1. 정수 vs 실수

거리 제곱을 정수로 유지하다가 최종 sqrt 만 실수. 부동소수점 오차 최소화.

2. Hull 이 점 2개

N=2 면 거리만 출력. calipers 불필요.

3. j 가 i 를 추월

i 와 j 가 동기화되지 않게 주의. while 조건으로 j 가 i 를 넘어가는 것 방지.

4. CCW 부호 일관성

hull 이 반시계(ccw)로 주어져야 area 부호가 일정. Building hull 시 ccw convention 통일.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 9240	로버트 후드	37.2%	kokoa-lab
BOJ 10254	고속도로	23.2%	kokoa-lab
BOJ 1310	달리기 코스	54.1%	kokoa-lab
BOJ 2626	헬기착륙장	23.9%	kokoa-lab
BOJ 10903	Wall construction	61.4%	kokoa-lab

참고

[[Convex Hull|볼록 껍질]]
[[Geometry|2D 기하 기본]]
[[CCW|CCW (시계/반시계 판정)]]

선인장 그래프 (Cactus Graph)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

선인장 그래프 (Cactus Graph) 는 모든 간선이 최대 한 개의 단순 사이클에만 포함되는 무방향 연결 그래프. 트리 (tree) 의 일반화로, 사이클은 허용하되 “사이클끼리 간선을 공유하지 않음”.

형태: 여러 사이클이 점 (정점) 으로만 연결된 구조. 간선 수 E ≤ V + (사이클 수 - 1), 트리면 E = V - 1.

문제 상황과 동기

일반 그래프는 사이클이 복잡하게 엉켜 DP / 최단 경로 / 매칭이 NP-hard. 트리는 선형 시간 가능하지만 사이클 없음. 선인장은 사이클이 있으면서도 트리와 비슷한 구조적 성질을 보존.

naive: 일반 그래프 알고리즘 O(V^2) 또는 O(V E). 핵심 통찰: 각 사이클을 “super-node” 로 축약하면 트리 → DFS / DP 가능. 사이클 내부는 별도 처리.

PS 에서: “도로망에 사이클 하나”, “회로 네트워크 (공유 안 함)”, BOJ 지름 / 최단 경로 변형.

시각화

{}

핵심 아이디어

invariant

간선 e 는 최대 하나의 사이클 C 에만 속함. 두 사이클이 간선을 공유하지 않음 → 간선 분할 (edge partition) 이 깔끔.

DFS 기반 분해

DFS tree 를 만든다.
back edge (u, v) 가 나오면 u → v 경로 + (u, v) 가 사이클 C.
C 의 간선들을 “이미 사이클에 포함됨” 마킹. 다른 back edge 가 C 의 간선을 다시 쓰면 선인장 아님.

시간 O(V + E), 공간 O(V).

DP on cactus

각 사이클을 “구간” 으로 보고 사이클 내 DP.
사이클을 하나의 노드로 축약한 트리에서 tree DP.
둘 합치기: 사이클 DP → 트리 DP.

예: 선인장 지름 = max(트리 지름, 각 사이클 내 최대 거리).

알고리즘

is_cactus(G):
    visited = [false] * V
    edge_used = set()
    for root in V:
        if not visited[root]:
            if not dfs_cactus(root, -1, visited, edge_used):
                return false
    return true

dfs_cactus(u, parent, visited, edge_used):
    visited[u] = true
    for v in adj[u]:
        if v == parent: continue
        edge = (min(u,v), max(u,v))
        if visited[v]:
            # back edge
            if edge in edge_used:
                return false   # 이미 다른 사이클에 속함
            path = trace_path(u, v)
            for e in path:
                if e in edge_used:
                    return false
                edge_used.add(e)
        else:
            if not dfs_cactus(v, u, visited, edge_used):
                return false
    return true

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// 선인장 그래프 검증: DFS + back edge 중복 체크 #include <bits/stdc++.h> using namespace std;

vector<vector> adj; vector parent, depth; set<pair<int,int>> cycleEdges; bool isCactus;

void dfs(int u, int p, int d) { parent[u] = p; depth[u] = d; for (int v : adj[u]) { if (v == p) continue; auto edge = minmax(u, v); if (depth[v] == -1) { dfs(v, u, d + 1); } else if (depth[v] < depth[u]) { // back edge u -> v // trace cycle for (int x = u; x != v; x = parent[x]) { auto e = minmax(x, parent[x]); if (cycleEdges.count(e)) { isCactus = false; return; } cycleEdges.insert(e); } if (cycleEdges.count(edge)) { isCactus = false; return; } cycleEdges.insert(edge); } } }

int main() { int n, m; cin >> n >> m; adj.resize(n); parent.resize(n, -1); depth.resize(n, -1); isCactus = true; for (int i = 0; i < m; i++) { int u, v; cin >> u >> v; adj[u].push_back(v); adj[v].push_back(u); } for (int i = 0; i < n; i++) if (depth[i] == -1) dfs(i, -1, 0); cout << (isCactus ? “cactus” : “not cactus”) << “\n”; }, }, { language: "python", label: "Python", code: # 선인장 그래프 판별 import sys sys.setrecursionlimit(10**6) input = sys.stdin.readline

def is_cactus(n, edges): adj = [[] for _ in range(n)] for u, v in edges: adj[u].append(v) adj[v].append(u) parent = [-1] * n depth = [-1] * n cycle_edges = set() result = [True]

def dfs(u, p, d):
    parent[u], depth[u] = p, d
    for v in adj[u]:
        if v == p:
            continue
        edge = (min(u, v), max(u, v))
        if depth[v] == -1:
            dfs(v, u, d + 1)
        elif depth[v] < depth[u]:
            # back edge
            x = u
            while x != v:
                e = (min(x, parent[x]), max(x, parent[x]))
                if e in cycle_edges:
                    result[0] = False
                    return
                cycle_edges.add(e)
                x = parent[x]
            if edge in cycle_edges:
                result[0] = False
                return
            cycle_edges.add(edge)

for i in range(n):
    if depth[i] == -1:
        dfs(i, -1, 0)
return result[0]

n, m = map(int, input().split()) edges = [tuple(map(int, input().split())) for _ in range(m)] print(“cactus” if is_cactus(n, edges) else “not cactus”), }, ]} cases={[ { label: "선인장", input: 5 6 0 1 1 2 2 0 2 3 3 4 4 2, output: cactus, }, { label: "비선인장 (간선 공유)", input: 4 5 0 1 1 2 2 0 0 2 2 3, output: not cactus`, }, ]} />

복잡도

항목	값
선인장 판별	O(V + E) DFS
선인장 DP	O(V + E) (사이클 + 트리 DP)
지름	O(V + E)
최단 경로	O((V + E) log V) (Dijkstra)
공간	O(V + E)

변형 / 활용

1. 선인장 지름

각 사이클 내 최대 거리 + 트리 지름. 사이클을 “무게 중심” 으로 축약.

2. 선인장 최단 경로

Dijkstra / BFS. 사이클 구조가 트리와 비슷해 일반 그래프보다 빠름.

3. 선인장 DP

부분합 DP, 매칭, 독립 집합 모두 O(V + E). 일반 그래프는 NP.

4. 방향 선인장

각 간선이 최대 한 사이클. functional graph 의 변형.

함정

1. 간선 공유 놓침

두 사이클이 정점을 공유해도 OK. 간선을 공유하면 NO.

  O---O
  |\ /|
  | X |  ← 간선 (중앙 교차) 공유 → 선인장 아님
  |/ \|
  O---O

2. back edge 중복 처리

같은 back edge 를 두 번 방문하면 잘못된 판단. set 으로 관리.

3. 비연결 그래프

선인장 정의는 “연결 그래프”. 비연결이면 각 컴포넌트 따로 판별.

4. DP 순서

사이클 내부 DP → 트리 DP 순서. 역순이면 값 꼬임.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 10891	Cactus? Not Cactus?	-	kokoa-lab
BOJ 13926	gahui and sousenkyo 2	-	kokoa-lab
BOJ 17409	트리의 외심	-	kokoa-lab
BOJ 2406	전략적 배치	-	kokoa-lab

참고

[[Tree|트리]]
[[DFS|깊이 우선 탐색]]
[[Cycle Detection|사이클 탐지]]
[[Graph DP|그래프 동적 계획법]]

서큘레이션 (Circulation)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

서큘레이션 (Circulation) 은 방향 그래프 G = (V, E) 에서 모든 간선에 하한 l(u,v) 과 상한 c(u,v) 이 주어질 때, 모든 정점에서 유량 보존 (in-flow = out-flow) 을 만족하는 유량 f: E -> R 을 찾는 문제.

l(u,v) ≤ f(u,v) ≤ c(u,v) (용량 제약)
모든 v in V: sum_{(u,v) in E} f(u,v) = sum_{(v,w) in E} f(v,w) (유량 보존)

최대 유량의 일반화: 하한이 0 이면 일반 max-flow 와 동일. source/sink 대신 모든 정점이 보존되어야 함.

문제 상황과 동기

실제 흐름 문제는 “이 파이프에 최소 X 만큼은 흘러야 한다” 는 하한 조건이 자주 붙음.

naive: 하한을 무시하고 max-flow 를 돌린 뒤 보정 -> 불가능한 경우가 많음.
표준 변환: 하한을 먼저 보낸 뒤, 각 정점의 surplus/deficit 을 super-source/sink 로 연결 -> 일반 max-flow 로 환원.

핵심 통찰: 하한을 만족시키는 최소 유량을 가상의 source/sink 로 조정하면 일반 max-flow 문제가 됨.

PS 응용: 파이프 최소 유량, 작업 최소 배정량, 교통망 최소 통행량, 화학 공정 흐름.

시각화

{}

핵심 아이디어

Max-flow 로의 환원

모든 간선 (u,v) 에 하한 l(u,v) 만큼 미리 흘려보낸다.
각 정점 v 의 순 유입량 b(v) = sum l(u,v) - sum l(v,w) 를 계산.
b(v) > 0 이면 (공급 과잉) super-source S -> v 로 용량 b(v) 의 간선 추가.
b(v) < 0 이면 (공급 부족) v -> super-sink T 로 용량 -b(v) 의 간선 추가.
원래 간선의 잔여 용량 = c(u,v) - l(u,v).
S -> T max-flow 실행.
S 에서 나가는 모든 간선이 포화 (flow = sum_{b(v)>0} b(v)) -> feasible circulation 존재.

정당성

b(v) 의 총합은 항상 0 (모든 l(u,v) 가 b(u) 에서 -1 배, b(v) 에서 +1 배로 정확히 한 번씩 더해지므로). S -> T flow 가 모든 surplus 를 sink 로 전달하면, 남은 간선으로 하한 이상의 유량이 보존 조건을 만족하며 흐를 수 있음.

알고리즘

feasible_circulation(G, l, c):
    G' = copy of G, remove all edges
    add super-source S, super-sink T
    for each (u,v) in E:
        add edge u->v with cap c[u][v] - l[u][v]
        b[u] -= l[u][v]
        b[v] += l[u][v]
    for each node v:
        if b[v] > 0: add edge S->v with cap b[v]
        if b[v] < 0: add edge v->T with cap -b[v]
    flow = max_flow(G', S, T)
    if flow == sum(b[v] for b[v] > 0): return "YES"
    else: return "NO"

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Circulation with lower bounds, reduction to Dinic max flow #include <bits/stdc++.h> using namespace std; using ll = long long;

struct Edge { int to, rev; ll cap; };

class Dinic { public: vector<vector> g; vector level, it; Dinic(int n) : g(n), level(n), it(n) {} void add_edge(int u, int v, ll cap) { g[u].push_back({v, (int)g[v].size(), cap}); g[v].push_back({u, (int)g[u].size() - 1, 0}); } bool bfs(int s, int t) { fill(level.begin(), level.end(), -1); queue q; q.push(s); level[s] = 0; while (!q.empty()) { int u = q.front(); q.pop(); for (auto& e : g[u]) if (e.cap > 0 && level[e.to] < 0) { level[e.to] = level[u] + 1; q.push(e.to); } } return level[t] >= 0; } ll dfs(int u, int t, ll f) { if (u == t) return f; for (int &i = it[u]; i < (int)g[u].size(); i++) { Edge& e = g[u][i]; if (e.cap > 0 && level[u] < level[e.to]) { ll ret = dfs(e.to, t, min(f, e.cap)); if (ret > 0) { e.cap -= ret; g[e.to][e.rev].cap += ret; return ret; } } } return 0; } ll max_flow(int s, int t) { ll flow = 0, INF = 1e18; while (bfs(s, t)) { fill(it.begin(), it.end(), 0); while (ll f = dfs(s, t, INF)) flow += f; } return flow; } };

int main() { int n, m; cin >> n >> m; Dinic dinic(n + 2); int S = n, T = n + 1; vector b(n, 0); for (int i = 0; i < m; i++) { int u, v; ll l, c; cin >> u >> v >> l >> c; u—; v—; dinic.add_edge(u, v, c - l); b[u] -= l; b[v] += l; } ll sum_pos = 0; for (int i = 0; i < n; i++) { if (b[i] > 0) { dinic.add_edge(S, i, b[i]); sum_pos += b[i]; } else if (b[i] < 0) dinic.add_edge(i, T, -b[i]); } ll flow = dinic.max_flow(S, T); cout << (flow == sum_pos ? “YES\n” : “NO\n”); }, }, { language: "python", label: "Python", code: # Circulation with lower bounds, using Dinic max flow import sys sys.setrecursionlimit(10**6) input = sys.stdin.readline

class Dinic: def init(self, n): self.n = n self.g = [[] for _ in range(n)] def add_edge(self, u, v, cap): self.g[u].append([v, cap, len(self.g[v])]) self.g[v].append([u, 0, len(self.g[u]) - 1]) def bfs(self, s, t): self.level = [-1] * self.n q = [s]; self.level[s] = 0 for u in q: for v, cap, rev in self.g[u]: if cap > 0 and self.level[v] < 0: self.level[v] = self.level[u] + 1 q.append(v) return self.level[t] >= 0 def dfs(self, u, t, f): if u == t: return f for i in range(self.it[u], len(self.g[u])): self.it[u] = i v, cap, rev = self.g[u][i] if cap > 0 and self.level[u] < self.level[v]: ret = self.dfs(v, t, min(f, cap)) if ret > 0: self.g[u][i][1] -= ret self.g[v][rev][1] += ret return ret return 0 def max_flow(self, s, t): flow = 0; INF = 10**18 while self.bfs(s, t): self.it = [0] * self.n while True: f = self.dfs(s, t, INF) if not f: break flow += f return flow

n, m = map(int, input().split()) dinic = Dinic(n + 2) S, T = n, n + 1 b = [0] * n for _ in range(m): u, v, l, c = map(int, input().split()) u -= 1; v -= 1 dinic.add_edge(u, v, c - l) b[u] -= l; b[v] += l sum_pos = 0 for i in range(n): if b[i] > 0: dinic.add_edge(S, i, b[i]); sum_pos += b[i] elif b[i] < 0: dinic.add_edge(i, T, -b[i]) flow = dinic.max_flow(S, T) print(“YES” if flow == sum_pos else “NO”), }, ]} cases={[ { label: "순환 그래프", input: 4 4 1 2 2 5 2 3 1 4 3 4 1 5 4 1 2 6, output: YES, }, { label: "불가능", input: 3 2 1 2 3 5 2 3 0 2, output: NO`, }, ]} />

복잡도

항목	값
변환	O(E)
Max-flow (Dinic)	O(V^2 E) 일반 그래프
Max-flow (Push-Relabel)	O(V^3)
공간	O(V+E)

변형 / 활용

Minimum cost circulation: 각 간선에 비용이 있을 때, 하한을 만족하는 최소 비용 circulation. Successive Shortest Augmenting Path 등으로 해결.
Feasibility with demands: source/sink 가 있는 flow 에 하한 추가 -> demand node 개념.
Upper/lower bound flow decomposition: circulation = cycle basis 의 합.
Dual of max flow: min-cut 과 circulation 정리로 연결.
냉난방 공조, 화학 물질 흐름 등 연속 시스템 모델링.

함정

1. 정수 overflow

b(v) 의 합이 int 범위를 넘을 수 있음. long long 사용.

2. 하한이 상한보다 큰 경우

l > c 인 간선이 입력되면 바로 infeasible. 전처리 필요.

3. 그래프가 연결되지 않은 경우

각 컴포넌트의 b(v) 합이 0 이어야 함. 컴포넌트 별로 독립적으로 검증.

4. MAX FLOW 값 == sum_pos 만 체크

flow > sum_pos 는 불가능 (S 의 나가는 간선 총합 = sum_pos). flow = sum_pos 면 모든 surplus 가 T 로 전달됨.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2316	도시 왕복하기 2	-	kokoa-lab
BOJ 12918	정리정돈	-	kokoa-lab
BOJ 1031	스타 대결	-	kokoa-lab

참고

[[Maximum Flow|최대 유량]] (max-flow, Dinic, Edmonds-Karp)
[[Minimum Cost Flow|최소 비용 유량]]
[[Bipartite Matching|이분 매칭]] (서큘레이션의 특수 case)

차수열 (Degree Sequence)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

차수열 (Degree Sequence) 은 그래프의 각 정점 차수를 내림차순으로 나열한 수열 d[1] >= d[2] >= … >= d[N]. 이 수열을 만족하는 단순 그래프(loop / multigraph 없음)가 존재하면 graphic sequence 라고 한다.

문제 상황과 동기

“이 차수열을 가진 단순 그래프가 실제로 존재하는가?” 를 판별해야 할 때:

naive: 모든 가능한 그래프를 생성해 차수열 비교. 지수적 불가능.
Havel-Hakimi / Erdos-Gallai: O(N^2) 에 necessary and sufficient 조건 판별.

핵심 통찰: 가장 큰 차수 정점을 그 다음 큰 정점들에 연결하고 제거하는 과정을 반복하면, 차수열의 실현 가능성이 결정된다.

시각화

{}

핵심 아이디어

Havel-Hakimi 정리 (구성적)

내림차순 차수열 d[1..N] 이 graphic 할 필요충분조건:

d[1] <= N-1 이고
d[1] 을 제거한 후, d[1] 개의 다음 정점들의 차수를 1씩 감소시킨 새 수열이 graphic 함.

Erdos-Gallai 정리 (필요충분)

내림차순 d[1..N] 이 graphic 할 필요충분조건:

모든 d[i] ≤ N-1
sum(d) 가 짝수
모든 1 ≤ k ≤ N 에 대해:

sum_{i=1..k} d[i] <= k(k-1) + sum_{i=k+1..N} min(d[i], k)

알고리즘

is_graphic(d):
    d 를 내림차순 정렬
    if any d[i] < 0: return false
    if sum(d) % 2 == 1: return false
    if all d[i] == 0: return true
    x = d[0]  # 가장 큰 차수
    d[0] = 0
    for i = 1..x:
        d[i] -= 1
        if d[i] < 0: return false
    return is_graphic(d)  # 재귀

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: // Havel-Hakimi 로 graphic sequence 판별 #include <bits/stdc++.h> using namespace std; bool havel_hakimi(vector<int> d) { while (true) { sort(d.rbegin(), d.rend()); // 내림차순 while (!d.empty() && d.back() == 0) // 0 제거 d.pop_back(); if (d.empty()) return true; // 모두 0 int x = d.front(); // 최대 차수 d.erase(d.begin()); if (x > (int)d.size()) return false; // 정점 부족 for (int i = 0; i < x; i++) { d[i]--; if (d[i] < 0) return false; } } } int main() { ios::sync_with_stdio(false); cin.tie(nullptr); int n; cin >> n; vector<int> d(n); for (auto& v : d) cin >> v; cout << (havel_hakimi(d) ? 1 : -1) << "\\n"; return 0; }, }, { language: “python”, label: “Python”, code: `# Havel-Hakimi algorithm from heapq import nlargest

def is_graphic(d): d = sorted(d, reverse=True) while d and d[-1] == 0: d.pop() if not d: return True x = d[0] d = d[1:] if x > len(d): return False for i in range(x): d[i] -= 1 if d[i] < 0: return False return is_graphic(d)

n = int(input()) d = list(map(int, input().split())) print(1 if is_graphic(d) else -1), }, { language: "java", label: "Java", code: // Havel-Hakimi in Java

public class Main { static boolean hh(ArrayList d) { while (true) { Collections.sort(d, Collections.reverseOrder()); while (!d.isEmpty() && d.get(d.size()-1) == 0) d.remove(d.size()-1); if (d.isEmpty()) return true; int x = d.remove(0); if (x > d.size()) return false; for (int i = 0; i < x; i++) { d.set(i, d.get(i) - 1); if (d.get(i) < 0) return false; } } } public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); ArrayList d = new ArrayList<>(); for (int i = 0; i < n; i++) d.add(sc.nextInt()); System.out.println(hh(d) ? 1 : -1); } }, }, ]} cases={[ { label: "Graphic 가능", input: 5 3 3 2 2 2, output: 1, }, { label: "Graphic 불가능", input: 4 3 3 3 1, output: -1`, }, ]} />

복잡도

항목	값
Havel-Hakimi 시간	O(N^2) (매 단계 정렬)
Erdos-Gallai 시간	O(N^2) (k 마다 합)
최적화 Erdos-Gallai	O(N log N) (prefix sum + binary search)
공간	O(N)

변형 / 활용

정리	접근	특징
Havel-Hakimi	구성적 (constructive)	실제 그래프 복원 가능
Erdos-Gallai	판별적 (decision)	부등식만 확인
Gale-Ryser	이분 그래프용	bipartite degree sequence

함정

1. 정렬 유지

각 단계마다 내림차순 정렬을 유지해야 함. 차수를 감소시킨 후 정렬하지 않으면 결과가 달라짐.

2. 차수 합 홀짝

차수 합이 홀수면 무조건 불가능 (handshaking lemma).

3. N=1 일 때

N=1 이면 차수열 [0] 만 유효. d[1] > 0 이면 불가능 (loop 필요).

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2084	차수열	46.8%	kokoa-lab
BOJ 13560	축구 게임	26.8%	kokoa-lab
BOJ 31217	Y	59.0%	kokoa-lab
BOJ 3386	테니스 클럽	25.6%	kokoa-lab

참고

[[Graph Traversal|그래프 탐색]]
[[MST|최소 스패닝 트리]]
[[Bipartite Graph|이분 그래프]] (Gale-Ryser)

네트워크 유량 (Network Flow)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

네트워크 유량 (Network Flow) 은 방향 그래프 G = (V, E) 에서 각 간선 (u, v) 의 용량 (capacity) c(u, v) 가 주어질 때, 소스 s 에서 싱크 t 로 흐를 수 있는 최대 유량 (max flow) 을 구하는 문제.

제약:

용량 제약 (capacity constraint): 각 간선의 유량 f(u, v) ≤ c(u, v).
유량 보존 (flow conservation): s, t 제외 모든 정점에서 들어오는 유량 = 나가는 유량.

가장 유명한 알고리즘: Ford-Fulkerson (개념), Edmonds-Karp (O(VE^2)), Dinic (O(V^2 E)).

문제 상황과 동기

“파이프 네트워크에서 최대로 보낼 수 있는 물의 양”, “교통망 최대 수송량”, “이분 매칭 (bipartite matching)”, “최소 컷 (min-cut)” 모두 유량으로 모델링.

naive: 모든 경로 나열 O(2^E). 핵심 통찰: 증가 경로 (augmenting path) 를 반복. 남은 용량 (residual capacity) 가 있는 s → t 경로를 찾아 유량을 밀어 넣으면, 최종적으로 최대 유량 수렴. max-flow min-cut theorem: 최대 유량 = 최소 컷.

PS: “매칭 개수”, “분리 집합”, “비용 + 유량 (MCMF)”, BOJ 이분 매칭 대부분.

시각화

{}

핵심 아이디어

residual graph

원 그래프 G 와 현재 유량 f 에서, 잔여 그래프 (residual graph) G_f:

간선 (u, v) 가 c(u, v) - f(u, v) > 0 이면 (u, v) 간선 추가 (forward edge).
f(u, v) > 0 이면 (v, u) 간선 추가, 용량 = f(u, v) (backward edge).

증가 경로: G_f 에서 s → t 경로. 경로 용량 = min(residual capacity).

Ford-Fulkerson 반복

f = 0
while exists augmenting path p in G_f:
    push flow along p
    update f and G_f
return f

증가 경로를 어떻게 찾느냐에 따라 복잡도 다름.

Edmonds-Karp (BFS)

증가 경로를 BFS 로. 가장 짧은 경로 우선 → O(VE) 번 반복, 각 BFS O(E) → O(VE^2).

Dinic (level graph + blocking flow)

level graph: BFS 로 s 에서 거리 d[v] 계산.
blocking flow: d[u] + 1 = d[v] 인 간선만 DFS. 한 번에 여러 경로 동시 처리.
반복: level graph 재구성 → blocking flow. 총 O(V) 번 → O(V^2 E).

알고리즘

Edmonds-Karp(G, s, t):
    for each edge (u, v):
        f[u][v] = 0
    while true:
        path, bottleneck = BFS_augment(G_f, s, t)
        if path is null: break
        for (u, v) in path:
            f[u][v] += bottleneck
            f[v][u] -= bottleneck
    return sum of f[s][v] for all v

BFS_augment(G_f, s, t):
    parent = [-1] * V
    queue = [s]
    while queue not empty:
        u = queue.pop(0)
        for v in adj[u]:
            if parent[v] == -1 and residual[u][v] > 0:
                parent[v] = u
                queue.append(v)
                if v == t:
                    path = trace(parent, s, t)
                    bottle = min(residual[u][v] for (u,v) in path)
                    return path, bottle
    return null, 0

구현

<CodeWithOutput variants={[ { language: “cpp”, label: “C++”, code: `// Edmonds-Karp: O(VE^2) #include <bits/stdc++.h> using namespace std;

const int INF = 1e9; int n, cap[105][105], flow[105][105];

int bfs(int s, int t, vector& parent) { fill(parent.begin(), parent.end(), -1); parent[s] = s; queue<pair<int,int>> q; q.push({s, INF}); while (!q.empty()) { auto [u, f] = q.front(); q.pop(); if (u == t) return f; for (int v = 0; v < n; v++) { int res = cap[u][v] - flow[u][v]; if (parent[v] == -1 && res > 0) { parent[v] = u; int nf = min(f, res); q.push({v, nf}); } } } return 0; }

int maxFlow(int s, int t) { int total = 0; vector parent(n); while (int pushed = bfs(s, t, parent)) { total += pushed; int v = t; while (v != s) { int u = parent[v]; flow[u][v] += pushed; flow[v][u] -= pushed; v = u; } } return total; }

int main() { int m, s, t; cin >> n >> m >> s >> t; for (int i = 0; i < m; i++) { int u, v, c; cin >> u >> v >> c; cap[u][v] += c; } cout << maxFlow(s, t) << “\n”; }, }, { language: "python", label: "Python", code: # Edmonds-Karp max flow from collections import deque import sys input = sys.stdin.readline

def bfs(s, t, parent, cap, flow, n): parent[:] = [-1] * n parent[s] = s q = deque([(s, float(‘inf’))]) while q: u, f = q.popleft() if u == t: return f for v in range(n): res = cap[u][v] - flow[u][v] if parent[v] == -1 and res > 0: parent[v] = u nf = min(f, res) q.append((v, nf)) return 0

def max_flow(n, s, t, cap): flow = [[0]*n for _ in range(n)] parent = [-1] * n total = 0 while True: pushed = bfs(s, t, parent, cap, flow, n) if pushed == 0: break total += pushed v = t while v != s: u = parent[v] flow[u][v] += pushed flow[v][u] -= pushed v = u return total

n, m, s, t = map(int, input().split()) cap = [[0]*n for _ in range(n)] for _ in range(m): u, v, c = map(int, input().split()) cap[u][v] += c print(max_flow(n, s, t, cap)), }, { language: "java", label: "Java", code: // Edmonds-Karp in Java

public class Main { static int n, cap[][], flow[][]; static final int INF = (int)1e9;

static int bfs(int s, int t, int[] parent) {
    Arrays.fill(parent, -1);
    parent[s] = s;
    Queue<int[]> q = new LinkedList<>();
    q.add(new int[]{s, INF});
    while (!q.isEmpty()) {
        int[] cur = q.poll();
        int u = cur[0], f = cur[1];
        if (u == t) return f;
        for (int v = 0; v < n; v++) {
            int res = cap[u][v] - flow[u][v];
            if (parent[v] == -1 && res > 0) {
                parent[v] = u;
                int nf = Math.min(f, res);
                q.add(new int[]{v, nf});
            }
        }
    }
    return 0;
}

static int maxFlow(int s, int t) {
    int total = 0;
    int[] parent = new int[n];
    while (true) {
        int pushed = bfs(s, t, parent);
        if (pushed == 0) break;
        total += pushed;
        for (int v = t; v != s; v = parent[v]) {
            int u = parent[v];
            flow[u][v] += pushed;
            flow[v][u] -= pushed;
        }
    }
    return total;
}

public static void main(String[] args) throws IOException {
    BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    StringTokenizer st = new StringTokenizer(br.readLine());
    n = Integer.parseInt(st.nextToken());
    int m = Integer.parseInt(st.nextToken());
    int s = Integer.parseInt(st.nextToken());
    int t = Integer.parseInt(st.nextToken());
    cap = new int[n][n]; flow = new int[n][n];
    for (int i = 0; i < m; i++) {
        st = new StringTokenizer(br.readLine());
        int u = Integer.parseInt(st.nextToken());
        int v = Integer.parseInt(st.nextToken());
        int c = Integer.parseInt(st.nextToken());
        cap[u][v] += c;
    }
    System.out.println(maxFlow(s, t));
}

}, }, ]} cases={[ { label: "기본", input: 6 7 0 5 0 1 3 0 2 2 1 3 3 2 3 2 2 4 2 3 5 4 4 5 3, output: 5`, }, ]} />

복잡도

알고리즘	시간	공간
Ford-Fulkerson	O(E · max_flow), 정수 용량시 pseudo-polynomial	O(V^2)
Edmonds-Karp	O(V E^2)	O(V^2)
Dinic	O(V^2 E), 이분 그래프면 O(E √V)	O(V^2)
Push-Relabel	O(V^3), 실제 빠름	O(V^2)

변형 / 활용

1. 이분 매칭 (bipartite matching)

왼쪽 그룹 L, 오른쪽 R. s → L (용량 1), R → t (용량 1), L-R 간선 (용량 1). max flow = 최대 매칭.

2. 최소 컷 (min-cut)

max-flow min-cut theorem: 최대 유량 = 최소 컷. BFS 로 s 에서 도달 가능 정점 집합 S, 나머지 T. cut = 간선 (u, v) where u ∈ S, v ∈ T.

3. 비용 유량 (MCMF, Min-Cost Max-Flow)

각 간선에 비용. 최대 유량 중 최소 비용 경로. SPFA / Dijkstra + 유량.

4. 다중 소스/싱크

여러 소스 s_i, 싱크 t_j. super-source S → s_i (INF), t_j → super-sink T (INF).

함정

1. 양방향 간선

무방향 간선 (u, v) 는 (u, v), (v, u) 두 방향 각각 cap 추가.

2. 역방향 간선 초기화

flow[v][u] = -flow[u][v]. 초기 0.

3. 정수 용량 가정

Ford-Fulkerson 은 무리수 용량이면 무한 루프 가능. Edmonds-Karp / Dinic 은 OK.

4. overflow

용량 합이 int 범위 넘으면 long long.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 6086	최대 유량	-	kokoa-lab
BOJ 2188	축사 배정 (이분 매칭)	-	kokoa-lab
BOJ 11375	열혈강호	-	kokoa-lab
BOJ 17412	도시 왕복하기 1	-	kokoa-lab

참고

[[BFS|너비 우선 탐색]]
[[Bipartite Matching|이분 매칭]]
[[Min-Cut|최소 컷]]
[[MCMF|최소 비용 최대 유량]]

함수 그래프 (Functional Graph)

koa (김신건) — Thu, 25 Jun 2026 00:00:00 GMT

정의

함수 그래프 (Functional Graph) 는 정점 집합 V 와 함수 f: V → V 로 정의되는 방향 그래프. 각 정점 v 에서 정확히 하나의 간선 v → f(v) 가 나간다. 형태는 여러 사이클 (cycle) + 각 사이클로 들어가는 트리 (tree) 구조.

문제 상황과 동기

PS 에서 “다음 칸으로 이동”, “연결된 정점으로 한 단계” 문제는 out-degree 가 정확히 1 인 그래프. BFS/DFS 로 naive 하게 x 번 진행하면 O(x · N), 구간이 10^9 이상이면 터진다. 핵심 통찰: 경로는 반드시 “tree part → cycle entry → cycle 회전”, 세 구간으로 분해. Floyd’s cycle finding (토끼와 거북) 으로 사이클 길이 + 시작점 O(N) 에 찾고, 나머지는 prefix jump 또는 modular 계산.

자주 등장: BOJ 상태 전이 시뮬레이션, “N 번 이동 후 위치”, “언제 사이클 만나는가”, 해시 충돌 분석, 수열 반복 규칙.

시각화

{}

핵심 아이디어

invariant

정점 v 에서 출발하면 경로는 tree tail → cycle 두 단계.

v → f(v) → f²(v) → ... → entry → [cycle 시작] → entry (다시)

사이클 진입까지 거리 λ (lambda), 사이클 길이 μ (mu).

f^k(v) = {
    tree 안,           k < λ
    cycle 회전,        k ≥ λ,  (k - λ) mod μ 위치
}

Floyd’s cycle finding

토끼 (2배 속도), 거북 (1배 속도):

phase 1: 토끼가 사이클 한 바퀴 돌 동안 거북을 따라잡으면 사이클 존재 확정.
phase 2: 토끼를 시작점으로, 둘 다 1 step 씩 움직여 만나면 그 점이 entry.
phase 3: entry 에서 한 바퀴 돌면 μ.

시간: O(λ + μ), 공간 O(1). 비순환 그래프면 null 이나 범위 밖 도달.

binary lifting (optional)

k 가 큰 경우 f^k(v) 를 O(log k) 에 구하려면:

dp[v][i] = f^(2^i)(v)

전처리 O(N log N), 쿼리 O(log k).

알고리즘

Floyd_cycle(f, start):
    tortoise = start
    hare = start
    # phase 1: 사이클 감지
    loop
        tortoise = f(tortoise)
        hare = f(f(hare))
        if hare == tortoise: break
        if hare null or f(hare) null: return (λ=∞, μ=0)  # 비순환
    # phase 2: entry 찾기
    tortoise = start
    while tortoise ≠ hare:
        tortoise = f(tortoise)
        hare = f(hare)
    entry = tortoise
    # phase 3: μ 측정
    μ = 1
    hare = f(entry)
    while hare ≠ entry:
        hare = f(hare)
        μ++
    # λ 측정
    λ = 0
    p = start
    while p ≠ entry:
        p = f(p)
        λ++
    return (λ, μ, entry)

구현

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

struct Cycle { int lambda, mu, entry; };

Cycle floyd(const vector& f, int start) { auto step = [&](int x) { return (x >= (int)f.size() || x < 0) ? -1 : f[x]; }; int t = start, h = start; // phase 1 do { t = step(t); h = step(step(h)); if (h < 0 || t < 0) return {-1, 0, -1}; } while (t != h); // phase 2 int entry = start; while (entry != h) { entry = step(entry); h = step(h); } // phase 3 int mu = 1; for (int x = step(entry); x != entry; x = step(x)) mu++; int lambda = 0; for (int x = start; x != entry; x = step(x)) lambda++; return {lambda, mu, entry}; }

int main() { int n, s; cin >> n >> s; vector f(n); for (auto& v : f) cin >> v; auto [lam, mu, ent] = floyd(f, s); cout << “lambda=” << lam << ” mu=” << mu << ” entry=” << ent << “\n”; }, }, { language: "python", label: "Python", code: # Functional graph cycle detection import sys input = sys.stdin.readline

def floyd(f, start): def step(x): return f[x] if 0 <= x < len(f) else None t, h = start, start # phase 1 while True: t = step(t) h = step(step(h)) if step(h) is not None else None if h is None or t is None: return None, 0, None if t == h: break # phase 2 entry = start while entry != h: entry, h = step(entry), step(h) # phase 3 mu = 1 x = step(entry) while x != entry: x = step(x) mu += 1 # lambda lam = 0 x = start while x != entry: x = step(x) lam += 1 return lam, mu, entry

n, s = map(int, input().split()) f = list(map(int, input().split())) lam, mu, ent = floyd(f, s) print(f”lambda={lam} mu={mu} entry={ent}“), }, ]} cases={[ { label: "기본 사이클", input: 6 0 1 2 3 4 2 5, output: lambda=2 mu=3 entry=2`, }, ]} />

복잡도

항목	값
사이클 탐지	O(λ + μ) 시간, O(1) 공간
f^k(v) 단일	O(k) naive, O(log k) binary lifting
전처리 (lifting)	O(N log N) 시간, O(N log N) 공간
쿼리 (lifting)	O(log k)

변형 / 활용

1. 상태 전이 시뮬레이션

“N 번 이동 후 위치” 문제. k < λ 면 순회, k ≥ λ 면 (k - λ) mod μ.

2. 연결 요소 분석

각 정점에서 Floyd 돌려 entry 찾으면, 같은 entry 를 공유하는 정점끼리 한 “weakly connected component”.

3. 사이클 없는 경우

hare 가 null 이면 무한히 뻗어나가거나 단절. 예: 해시 체인.

4. 다중 출발

여러 시작점이 같은 사이클로 모이는가? entry 기준 그룹.

함정

1. out-degree ≠ 1

일반 그래프라면 functional graph 가 아님. 이 기법 안 먹힘.

2. 범위 체크

f[v] 가 배열 밖이면 비순환. step 함수 null 처리.

3. λ 계산 빠뜨림

phase 1~3 은 μ, entry 만 줌. λ 는 start → entry 거리 따로.

4. k 매우 큰 경우

k > 10^9 면 naive loop 불가. binary lifting 또는 mod μ 쓰기.

BOJ 연습 문제

번호	제목	정답률	링크
BOJ 2331	반복수열	-	kokoa-lab
BOJ 9466	텀 프로젝트	-	kokoa-lab
BOJ 15591	MooTube (Silver)	-	kokoa-lab
BOJ 16958	텔레포트	-	kokoa-lab

참고

[[DFS|깊이 우선 탐색]]
[[Cycle Detection|사이클 탐지]]
[[Binary Lifting|이진 점프]]

김신건의 로그 - 위키

[DB] Transaction Isolation Levels: 완벽 가이드

정의

이 문서의 흐름

격리 수준 매트릭스 (전체 지도)

Level 1: READ UNCOMMITTED

이 수준의 정의

발생하는 문제: Dirty Read

해결법 / 대안

Level 2: READ COMMITTED

이 수준의 정의

발생하는 문제: Non-Repeatable Read

해결법 / 대안

Level 3: REPEATABLE READ

이 수준의 정의

발생하는 문제: Phantom Read (ANSI 정의상)

해결법 / 대안

Level 4: SERIALIZABLE

이 수준의 정의

SERIALIZABLE 을 쓸 때 알아야 할 것

성능 트레이드오프

ANSI 표준을 벗어난 이상 현상들

Lost Update (읽고 → 계산 → 쓰기 경쟁)

Write Skew (Snapshot Isolation 의 치명적 함정)

PostgreSQL SSI (Serializable Snapshot Isolation)

MVCC 기반 스냅샷 격리의 원리

실무 가이드

언제 어느 수준을?

격리 수준 명시 방법

프레임워크 예시

실제 DB 엔진 매핑

흔한 함정

Anti-Pattern: Lock 으로 모든 것 해결 시도

관련 위키

[DRF] Filtering: django-filter, SearchFilter, OrderingFilter

정의

3가지 내장 Backend

설치 + 설정

1. DjangoFilterBackend

간단한 필드 매칭

상세 FilterSet

Lookup expressions

2. SearchFilter

Prefix 조정

3. OrderingFilter

다중 Backend 조합

Custom Filter Backend

PostgreSQL Full-Text Search

OpenAPI 문서화

다른 프레임워크

흔한 함정

관련 위키

[DRF] Schemas + OpenAPI: 자동 문서화

정의

왜 API 문서화가 필요한가

도구 선택

drf-spectacular 설치 (5분 완성)

Swagger UI vs Redoc

자동 추출 되는 것

@extend_schema 로 커스터마이즈

Enum 필드 문서화

Nested Serializer 문서화

SerializerMethodField 타입 힌트

인증 문서화

여러 개 응답 (union)

요청 예시

Serializer 재사용 (같은 이름 충돌 방지)

Schema 파일 export

Client SDK 자동 생성

다른 프레임워크 문서화 대응

실무 팁

1. 태그로 그룹핑

2. CORS 문제

3. 문서 접근 권한 제한

4. 버전별 문서 분리

흔한 함정

관련 위키

[DRF] Testing: APIClient, APITestCase, force_authenticate

정의

테스트 도구 계층

`@extend_schema` 로 커스터마이즈

`force_authenticate` (권장)