Gyojun Youn's PS Blog

2026 ICPC Asia Seoul Regional Preliminary Solution Sketches

2026-11-02T20:10:00+09:00

Disclaimer: This is an unofficial analysis of some possible ways to solve the problems of the 2026 ICPC Asia Seoul Regional Preliminary. They are not intended to give complete solutions, but rather to outline some approaches that can be used to solve the problems. If you find an error, please send me an email about it.

K. Square

My solution: 145 bytes.

Let $(a,b)$ be the vector of one side of the square. The other side can be $(-b,a)$ , so its area is $a^2+b^2$ .

Hence, the answer is YES if and only if $n$ is a sum of two squares. This can be checked in $O(\sqrt n)$ .

G. Korean Characters

My solution: 404 bytes.

Scan the string from right to left. If the last letter is a vowel, the last Korean character must have length $2$ ; otherwise, it must have length $3$ .

Check whether the corresponding letters form a valid consonant-vowel(-consonant) pattern, remove them, and repeat. If this is ever impossible, print -ERROR-.

This runs in $O(n)$ .

H. Marathon

My solution: 322 bytes.

Binary search the answer $x$ .

For a section to have section risk at most $x$ , building $i$ requires $\max(0,d_i-x)$ security personnel. Thus, for a fixed $x$ , we only need to check whether some length- $l$ subarray has

\sum \max(0,d_i-x) \le k.

Check this with a sliding window in $O(n)$ , for a total of $O(n\log \max d_i)$ .

A. Citation Index

My solution: 393 bytes.

Cap every citation count at $n$ . Maintain the current h-index $h$ , the number of papers with at least $h$ citations, and the frequency of every capped citation count.

Since citation counts only increase, the h-index never decreases, and one update can increase it by at most one. After each update, $h+1$ is feasible exactly when there are at least $h+1$ papers with more than $h$ citations.

This gives $O(n+q)$ time.

B. Coloring

My solution: 450 bytes.

Let $x_{\min}$ , $x_{\max}$ , $y_{\min}$ , $y_{\max}$ be the extrema among all endpoints. Up to swapping the two colors, an optimal pair of squares can be pushed to one of the two pairs of opposite corners of this bounding box without increasing their side lengths.

Fix the lower-left and upper-right corners. For each segment, try the two assignments of its endpoints to the two squares; each assignment gives the maximum of four distances to the corresponding sides of the bounding box. Take the better assignment independently for every segment, then take the maximum over all segments.

Reflect the $y$ -coordinates and repeat to handle the other diagonal pair of corners. The smaller of the two answers is optimal.

C. Convex Hull

My solution: 549 bytes.

Compute all-pairs shortest-path distances with Floyd--Warshall.

Maintain the current hull and a queue of vertices newly added to it. For a newly added vertex $b$ , for every vertex $a$ already in the hull and every vertex $v$ outside it, add $v$ if

d(a,v)+d(v,b)=d(a,b).

Whenever a new vertex is added, process it in the same way. This computes the closure in $O(n^3)$ time.

J. Secret Agent

My solution: 490 bytes.

Since no interval contains another and all endpoints are distinct, sorting the agents by starting point also sorts them by ending point.

For agent $i$ , let $D_i(t)$ be the maximum capability sum of a valid relay ending at $i$ such that the penultimate agent, if it exists, ends no later than $s_i+t$ .

Suppose $j$ is immediately before $i$ in the relay. They must overlap, so

s_j<s_i<e_j<e_i.

Every earlier agent must not overlap $i$ , so the best previous state is

D_j(s_i-s_j-1).

This transition contributes to state $e_j-s_i$ of $D_i$ . Take prefix maxima over $t$ and add $w_i$ .

This gives an $O(n^2)$ dynamic program.

D. Cross Roller

My solution: 1,227 bytes.

Any row or column containing a zero can never be selected by an operation.

Consider the operations in reverse. The last operation must correspond to a non-banned row and a non-banned column that are both monochromatic with the same nonzero color. Remove such a row and column and keep them as fixed anchors.

Afterwards, any remaining monochromatic row can be removed using the fixed column, and any remaining monochromatic column can be removed using the fixed row. Maintain color frequencies while removing rows and columns, and reverse the recorded operations at the end.

If a nonzero cell remains, the target pattern is impossible. The algorithm runs in $O(n^2)$ time.

F. Interactive String Matching

My solution: 448 bytes.

Simulate KMP, using queries whenever a text character has to be compared with a pattern character.

The only additional difficulty is constructing the prefix function of $T$ , since direct comparisons between two characters of $T$ are unavailable. Whenever $T_i$ has to be compared with $T_j$ , use a position of $S$ that has already been proved equal to $T_j$ , and query that position against $T_i$ .

Construct the prefix function lazily only as far as needed by the current KMP state. The usual KMP amortization shows that the total number of queries is at most $2(|S|+|T|)$ .

I. Pumpkin Friends

My solution: 908 bytes.

Process the deletions in reverse, so that pumpkins are added one by one. Each addition merges the alive segments on its left and right, and the increase in the joy score is exactly the number of valid intervals containing the newly added pumpkin.

Let $P$ be the prefix-sum array. Since all joy values are positive, for each endpoint we can precompute the range of opposite endpoints whose interval sum lies in $[L,R]$ .

When two segments are merged, iterate over the smaller side and count compatible endpoints on the larger side using these precomputed ranges. By the small-to-large argument, each position is scanned only $O(\log n)$ times.

Thus all answers can be computed in $O(n\log n)$ time.

E. Eating Candies

My solution: 444 bytes.

Associate an integer value with every substring. Let $x$ be the maximum value reachable by a Bay move and $y$ the minimum value reachable by a Rei move, using $-\infty$ and $+\infty$ if the corresponding player has no move.

The value of the current substring is

\begin{cases} y-1 & y\le 0,\\ x+1 & x\ge 0,\\ 0 & x<0<y. \end{cases}

These values can be computed by interval DP, since every move deletes either the leftmost or the rightmost candy.

The value of the whole game is the sum of the values of all skewers. If the sum is positive, Bay wins; if it is negative, Rei wins; if it is zero, the player who moves first loses.

The total running time is $O\left(\sum |S_i|^2\right)$ .

2025 ICPC Asia Seoul Regional Finals Solution Sketches

2025-11-22T18:00:00+09:00

Disclaimer: This is an unofficial analysis of some possible ways to solve the problems of the 2025 ICPC Asia Seoul Regional Finals. They are not intended to give complete solutions, but rather to outline some approaches that can be used to solve the problems. If you find an error, please send me an email about it.

Live Solutions Presentation: https://www.youtube.com/live/5L4TCvByfCQ?t=1534s

M. Triple Fairness

My solution: 41 bytes.

Print $1$ to $n$ , three times.

L. Segments

My solution: 289 bytes.

The answer is determined solely by the maximum of the left endpoints and the minimum of the right endpoints of the given line segments.

When computing the answer, remember to apply $\max(0, \cdot)$ .

C. Bay

My solution: 752 bytes.

Treat the grid cells as vertices to form a rooted forest; then, via DFS, one can identify all edges that constitute the solution. Be sure to choose the vertices connected to the exterior of the grid as roots.

Alternatively, the problem can be solved by supporting "sum of cross products along a path" queries efficiently on the given tree $T$ . However, when applying Pick's theorem, the number of interior lattice points may not be zero.

I. Magic Door

My solution: 1,153 bytes.

Implement the rules exactly as specified. Within the gem-type encoding scheme defined in the problem, it helps to translate into a representation you are comfortable with—for example, distinguishing bombs by whether they are active or not. Treat a match-3 group as the union of matches whose length is exactly $3$ , and observe that repeatedly triggering activated bombs in the same row/column does not change the total time complexity, which simplifies implementation.

You must handle the problem's "simultaneously" requirement without missed or overwritten states. Using a "to-be-removed" bit flag (e.g., $16$ ) is effective.

Be careful not to early-terminate. For instance, you must continue processing even when there are activated bombs but no match-3 groups.

G. Extraterrestrial Creatures

My solution: 449 bytes.

Let $f(t)$ denote the number of button presses required to make all creature numbers at least $t$ . Use binary search to find $t$ such that $f(t) \le X < f(t + 1)$ .

After raising all creature numbers to at least $t$ , apply one additional press to exactly $\left( X - f(t) \right)$ creatures whose values are exactly $t$ , chosen in increasing order of their IDs.

E. Clean Arrangements

My solution: 415 bytes.

For each vertex $v$ , let $D_v$ be the minimum of "(cost of a clean arrangement of the subtree $T_v$ ) + (total length in which the edge joining $v$ to its parent overlaps the interval of $T_v$ )".

Sort the child subtrees of $v$ in decreasing order of size and place them alternately to the left and right around $v$ ; this minimizes $D_v$ .

For the root, a slightly different expression is used for the objective, but the same placement strategy is optimal. The overall time complexity is $O(n)$ .

K. Quadrants

My solution: 1,189 bytes.

Fix a point and draw two perpendicular lines through it. Rotate these lines while maintaining the counts of points in each of the four quadrants. For convenience, call the lines the $x$ - and $y$ -axes. When another point lies on the $+x$ ray, let the quadrant counts be $c_{*, *}$ . Then the current state uniquely determines the $\left[ c_{+,+}, c_{+,+} + c_{-,+} \right)$ -quadrants in the region $y > 0$ and the $\left[ c_{+,-}, c_{+,-} + c_{-,-} \right)$ -quadrants in the region $y < 0$ .

D. Bookshelf

My solution: 451 bytes.

The initial positions are irrelevant. Let the width of book $i$ be $A_i$ , and define $w := L - \sum_i A_i$ . Any book can be swapped with a book of width $\le w$ , while the relative order of two books with width $> w$ is invariant.

Anchor the favorite book, and place all books with width $> w$ to its left and right. The remaining books with width $\le w$ can always be fitted into the leftover gaps.

It therefore suffices to test feasibility over all possible relative orderings between the favorite book and the other books with width $> w$ .

F. CPEquivalence

My solution: 2,894 bytes.

Two arrays are CP-equivalent if and only if the max Cartesian trees constructed from them are isomorphic.

Let $T$ be the Cartesian tree of $x$ . For a subarray $y[s \cdots e]$ , define $D_{[s, e], c, T_v}$ as the minimum possible value at the node of $y$ ’s Cartesian tree corresponding to $v$ , over all ways to transform $y[s \cdots e]$ with at most $c$ edits so that its Cartesian tree becomes isomorphic to the subtree $T_v$ . A straightforward recursive recurrence follows, but its time complexity has degree $6$ . By leveraging the monotonicity of $D_{*}$ and applying a two-pointer technique with suitable precomputation, the degree can be reduced.

J. Mex Culpa

My solution: 2,539 bytes.

Define $I_i := \left[ a_i , a_i + b_i \right]$ . The inequality in the problem is equivalent to $I_i \cap I_j \ne \emptyset$ .

First, identify all indices $i$ with $f_i = 0$ . By repeatedly querying, for a given interval $J$ , the smallest index $i$ such that $I_i \subseteq J$ , we can recover all entries with $f_{*} = 0$ .

After removing these, proceed analogously to find $f_{*} = 1, 2, \cdots$ in order.

A. Adventurer Dabi

My solution: 6,154 bytes.

This is a heavy-implementation problem. Implement the following in order:

Move to an arbitrary cell adjacent to a wall.
Discover all walls using the right-hand rule.
Identify all teleport cells.
Recover the full teleport pairs connectivity.
From the key cell, travel to the treasure chest cell via a shortest path.

The following observation suffices: suppose Dabi is either at a known cell $\alpha$ or, via teleportation, at an unknown cell $\beta$ . To distinguish the two, starting from $\alpha$ , move—using only known cells—to a cell adjacent to a wall, then apply the right-hand rule. If no contradiction arises, it was $\alpha$ ; if a contradiction occurs, it was $\beta$ . Since all moves are invertible, upon detecting a contradiction you can revert to a known state.

H. Fair Problemset

My solution: 743 bytes.

Let $\lambda_n$ denote the number of Fair Problemset sequences of length $3n$ . Writing $n = 3q + r$ and setting $\alpha := q + \delta_{r, 1}$ and $\beta := q + \delta_{r, 2}$ , we have

\lambda_n = (\alpha!)^3 (\beta!)^6 C_n

where $C_n$ is the number of tuples $\left( \sigma_0, \sigma_1, \cdots, \sigma_{n - 1} \right) \in \Sigma_{3}^{n}$ satisfying

\alpha \delta_{i, j} + \beta \left( 1 - \delta_{i, j} \right) = \left\lvert \left\{ k : \sigma_k (i) = j \right\} \right\rvert

Inspecting the six elements of $\Sigma_3$ yields

C_n = \sum_{i = 0}^{q} {\binom{n}{\alpha - i ; i ; i ; i ; \beta - i ; \beta - i}}^{3}

Define $B_q := \sum_{i = 0}^{q} {\binom{q}{i}}^{3}$ . For $r = 0$ , one obtains $\lambda_n = n! (q!)^{6} B_q$ . For $r = 1, 2$ , $\lambda_n$ can be expressed similarly in terms of $B_q$ and $B_{q + 1}$ .

B. Badge Relay

My solution: 3,538 bytes.

First, for $n \ge 3$ people with times $t_1 \le t_2 \le \cdots \le t_n$ , the answer is

(n - k - 2) t_1 + (2k + 1) t_2 + \sum_{i = 3}^{n - 2k} t_i + \sum_{i = 0}^{k - 1} t_{n - 2i}

where $m := \max\left\{ j : t_j \le 2 t_2 - t_1 \right\}$ and $k := \left\lfloor (n - m) / 2 \right\rfloor$ . A greedy strategy is optimal—this can be strongly supported by local testing, and proved rigorously in several ways. For an elegant approach, see: M. Jianu, M. Jianu, and S. A. Popescu, "A Combinatorial Solution for Bridge and Torch Problem," SN Operations Research Forum, 1(3), Article 21, Aug. 2020, doi: 10.1007/s43069-020-00022-3.

The final summation term is the trickiest to compute efficiently. After applying standard Mo's ordering to the query index intervals, maintain in a segment tree quantities such as "the sum of values that are the $1$ st, $3$ rd, $5$ th, $\cdots$ largest." The overall time complexity is $O \left( q \sqrt{n} \log n \right)$ .

2025 ICPC Asia Seoul Regional Preliminary Solution Sketches

2025-10-11T17:00:00+09:00

Disclaimer: This is an unofficial analysis of some possible ways to solve the problems of the 2025 ICPC Asia Seoul Regional Preliminary. They are not intended to give complete solutions, but rather to outline some approaches that can be used to solve the problems. If you find an error, please send me an email about it.

F. Inverse Look-and-Say

My solution: 239 bytes.

Read the input as a string $S$ . If $\lvert S \rvert$ is odd, $S[1] = 0$ , $S[2i] = 0$ , or $S[2i + 1] = S[2i + 3]$ , then print $-1$ .

Otherwise, for each $0 \le i < \lvert S \rvert / 2$ , print $S[2i+1]$ $S[2i]$ times.

A. Best Partition

My solution: 346 bytes.

Let $D_c$ denote the answer for the first $c$ elements. Compute DP in $O\left( n^2 \right)$ .

Note that it can be solved in $O(n)$ .

H. Mountain

My solution: 354 bytes.

Sort the points $(x, y)$ by $10^7 \times (x - y) - y$ , then take a longest strictly increasing sequence of $x + y$ .

I. Quadratic Equation

My solution: 114 bytes.

Let $\alpha$ and $\beta$ be the roots of the equation $x^2 + px + kp = 0$ .

Since $(\alpha + k)(\beta + k) = k^2 > 0$ and $p = 2k - (\alpha + k) - (\beta + k)$ , we have $N_p = 2 \times \left\lvert \left\{ n \in \mathbb{Z} \cap \left[ 1, \lvert k \rvert \right] : n \mid k^2 \right\} \right\rvert$ , and $\sum p = 2k \times N_p$ .

C. Docking Day

My solution: 865 bytes.

Send all the points to $+\infty$ in $3$ moves; then $\le 5$ more moves always suffice to place them at their target positions.

Hence, we need $8 - 3 = 5$ extra coordinates beyond the $6$ critical ones. Insert up to $5$ auxiliaries into the $7$ gaps determined by $0$ , the $6$ critical coordinates, and $+\infty$ ; then run BFS over $(6 + 5 \times 7)^3 = 41^3$ states.

J. Rescue Squad

My solution: 1,053 bytes.

Reindex the vertices in nondecreasing degree, and orient each edge from the smaller to the larger index. With this orientation, each vertex has $O\left( \sqrt{m} \right)$ outgoing edges.

Handle all three $C_4$ configurations in $O\left( nm \right)$ total time.

B. Bridge

My solution: 1,440 bytes.

Sweep the path left-to-right, maintaining a stack of downward segments that can host the bridge's left endpoint.

For each chosen pair of host segments, minimize the maximum of three linear functions; only their pairwise intersection points are relevant, but I suggest using ternary search due to floating-point error.

E. Image Analysis

My solution: 2,016 bytes.

Since all $x$ and $y$ are distinct, when the frame moves by Manhattan distance $d$ , the in-frame set changes by $O(d)$ single-point updates.

Apply standard Mo's ordering over frames, and answer the queries with square-root decomposed bucket sums.

D. Fox Buki

My solution: 1,602 bytes.

Construct a bipartite graph: add an edge $(i^-, j^+)$ for each card of type $j$ owned by fan $i$ . The graph is $n$ -regular, so it decomposes into $n$ perfect matchings.

In matching $k$ , if $(i^-, j^+)$ is chosen, define fan $i$ 's $k$ -th card to be of type $j$ . Then swapping fan $a$ 's $b$ -th card with fan $b$ 's $a$ -th card achieves the goal, with each card used at most once.

G. Magical Sort

My solution: 1,664 bytes.

Build a directed graph $G$ : if $u$ 's group- $c$ receiver is $v$ , add an edge $v \rightarrow u$ with label $c$ . For every vertex, all outgoing edges share the same label.

Put $v \in \left[ S_v \right]$ if every infinite walk from $v$ yields the same edge-label string $S_v$ . The answer is $\prod_S \left\lvert [S] \right\rvert !$ .

Form $G' \subset G$ by keeping exactly one outgoing edge per vertex. Then each $v$ has a unique infinite walk; let its string be $S'_v$ . These strings can be compared in $O(1)$ after $O( n \log n )$ precomputation.

Now, in $G$ , the information from $S'_*$ suffices to determine which vertices belong to which equivalence classes.

It is really challenging to generate valid inputs. If you know a way to validate inputs in $\mathcal{o}\left( n^2 \right)$ , please let me know.

이승진 교수님의 선형 대수학 후기

2023-01-05T02:44:08+09:00

선형 대수학 1을 들었어야 했는데, 단선대를 수강해버렸다. 심지어, 같이 듣기로 한 친구는 수강신청에 실패해버려서 이 과목을 들을 이유가 하나도 없었다.

교수님의 수업은 깔끔하고 담백하다. 교과서를 통해 큰 그림을 미리 그려가지 않으면, 수업만 듣고서는 무슨 이야기를 하시는지 하나도 이해하지 못할 수 있다.

사실, 나는 김명수 교수님의 선형 및 비선형 계산모델 수업을 들어서, 어려움이 전혀 없었다.

수업 시간마다 에거 교수님의 숙제를 풀었고, 모든 과제와 시험에서 만점을 받았다.

시험 문제는 교과서 연습 문제에서 가져오시는 듯 하다. 내가 푼 문제들을 가벼운 첨언을 얹어 적어본다.

Midterm Exam

Problem 1.

Solve as two triangular systems, without multiplying $LU$ to find $A$ :

LUx = \begin{bmatrix} 1 & 0 & 0 \\ 1 & 1 & 0 \\ 1 & 0 & 1 \end{bmatrix} \begin{bmatrix} 2 & 4 & 4 \\ 0 & 1 & 2 \\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} u \\ v \\ w \end{bmatrix} = \begin{bmatrix} 2 \\ 0 \\ 2 \end{bmatrix}

Sol)

$L (Ux) = b$ 로 두어 $Ux$ 의 값을 구하고, $Ux = c$ 를 풀자.

$L$ 이 lower triangular 하므로, $c$ 의 첫 번째 항부터 차례대로 알아낼 수 있다.

Lc = \begin{bmatrix} 1 & 0 & 0 \\ 1 & 1 & 0 \\ 1 & 0 & 1 \end{bmatrix} \begin{bmatrix} * \\ * \\ * \end{bmatrix} = \begin{bmatrix} 2 \\ 0 \\ 2 \end{bmatrix} = b \quad \Longrightarrow \quad c = \begin{bmatrix} 2 \\ -2 \\ 0 \end{bmatrix}

비슷하게, $U$ 가 upper triangular 하므로, $x$ 의 마지막 항부터 차례대로 알아낼 수 있다.

Ux = \begin{bmatrix} 2 & 4 & 4 \\ 0 & 1 & 2 \\ 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} u \\ v \\ w \end{bmatrix} = \begin{bmatrix} 2 \\ -2 \\ 0 \end{bmatrix} = c \quad \Longrightarrow \quad x = \begin{bmatrix} 5 \\ -2 \\ 0 \end{bmatrix}

마지막으로, $LUx = b$ 가 되는지 검산을 하자. 나는 검산을 통해 산수 실수를 찾을 수 있었다. 아침 시험 첫 문제로 이런 문제는 틀리기 쉽다.

여담으로, 답이 틀리면 부분점수가 없었다.

Problem 2.

Find the inverse of

A = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 1/4 & 1 & 0 & 0 \\ 1/3 & 1/3 & 1 & 0 \\ 1/2 & 1/2 & 1/2 & 1 \end{bmatrix}

Sol)

$A$ 가 lower triangular하기 때문에, $A = L_1 L_2 \cdots L_k$ 꼴로 나타내면, $A^{-1} = L_k^{-1} \cdots L_1^{-1}$ 로 쉽게 계산할 수 있을 것 같다.

A = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 1/4 & 1 & 0 & 0 \\ 1/3 & 0 & 1 & 0 \\ 1/2 & 0 & 0 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 1/3 & 1 & 0 \\ 0 & 1/2 & 0 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 1/2 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & 0 & 1 \end{bmatrix}

A^{-1} = \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & 0 & 1 & 0 \\ 0 & 0 & -1/2 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ 0 & 1 & 0 & 0 \\ 0 & -1/3 & 1 & 0 \\ 0 & -1/2 & 0 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 & 0 \\ -1/4 & 1 & 0 & 0 \\ -1/3 & 0 & 1 & 0 \\ -1/2 & 0 & 0 & 1 \end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 & 0 \\ -1/4 & 1 & 0 & 0 \\ -1/4 & -1/3 & 1 & 0 \\ -1/4 & -1/3 & -1/2 & 1 \end{bmatrix}

1번처럼, $A^{-1} A = I$ 인지 검산을 하자. 분수가 섞여있어서 계산이 정말 하기 싫게 생겼지만, 해보면 정말 단순하고 짧은 산수뿐이다.

Problem 3.

Let

A = \begin{bmatrix} 1 & 2 & 0 & 1 \\ 0 & 1 & 1 & 0 \\ 1 & 4 & 2 & 1 \end{bmatrix} , \quad b = \begin{bmatrix} 1 \\ 2 \\ 5 \end{bmatrix} \text{.}

(1) Find the $LU$ decomposition of $A$ , i.e., a lower triangular matrix $L$ that has only $1$ 's on its main diagonal, and an echelon form $U$ such that $A = LU$ .

(2) Write the complete solutions $x = x_p + x_n$ to $Ax = b$ .

(3) Find a basis for the column space $C(A)$ .

(4) Either find a left-inverse of $A$ , or prove that there is no left-inverse of $A$ .

Sol)

(1)

충분히 훈련되어 있어야 한다.

A = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 2 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 1 & 0 & 1 \end{bmatrix} \begin{bmatrix} 1 & 2 & 0 & 1 \\ 0 & 1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{bmatrix} \quad \Longrightarrow \quad L = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 0 & 2 & 1 \end{bmatrix} \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 1 & 0 & 1 \end{bmatrix} = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ 1 & 2 & 1 \end{bmatrix} , \quad U = \begin{bmatrix} 1 & 2 & 0 & 1 \\ 0 & 1 & 1 & 0 \\ 0 & 0 & 0 & 0 \end{bmatrix}

(2)

$L$ 이 invertible하므로, $Ax = b$ 는 $Ux = L^{-1}b =: c$ 와 동치다.

c := L^{-1} b = \begin{bmatrix} 1 & 0 & 0 \\ 0 & 1 & 0 \\ -1 & -2 & 1 \end{bmatrix} \begin{bmatrix} 1 \\ 2 \\ 5 \end{bmatrix} = \begin{bmatrix} 1 \\ 2 \\ 0 \end{bmatrix}

$U$ 의 zero row에 대응하는 $c$ 의 항이 $0$ 이다. 따라서, $c \in C(U)$ 이고, $Ux = c$ 는 해를 가진다.

먼저, 임의의 해 $x_p$ 를 구하자. pivot을 가지는 $U$ 의 columns으로 backward substitution을 하면 된다.

\begin{bmatrix} 1 & 2 \\ 0 & 1 \end{bmatrix} \begin{bmatrix} -3 \\ 2 \end{bmatrix} = \begin{bmatrix} 1 \\ 2 \end{bmatrix} \quad \Longrightarrow \quad U \begin{bmatrix} -3 \\ 2 \\ 0 \\ 0 \end{bmatrix} = \begin{bmatrix} 1 \\ 2 \\ 0 \end{bmatrix} = c \quad \Longrightarrow \quad x_p := \begin{bmatrix} -3 \\ 2 \\ 0 \\ 0 \end{bmatrix}

$x_n \in N(U)$ 이다. $U$ 의 non-pivot column을 pivot columns의 선형 결합으로 표현하면 된다.

U \begin{bmatrix} 2 \\ -1 \\ 1 \\ 0 \end{bmatrix} = U \begin{bmatrix} -1 \\ 0 \\ 0 \\ 1 \end{bmatrix} = \mathbf{0} \quad \Longrightarrow \quad x_n = c_1 \begin{bmatrix} 2 \\ -1 \\ 1 \\ 0 \end{bmatrix} + c_2 \begin{bmatrix} -1 \\ 0 \\ 0 \\ 1 \end{bmatrix}

(3) - 쉬운 풀이

$U$ 의 pivot이 있는 columns에 대응하는 $A$ 의 columns은 $C(A)$ 의 basis를 이룬다.

C(A) = \text{Span} \left\{ \begin{bmatrix} 1 \\ 0 \\ 1 \end{bmatrix} , \begin{bmatrix} 2 \\ 1 \\ 4 \end{bmatrix} \right\}

(3) - 좋아하는 풀이

**(2)**의 풀이를 다시 보자. $b \in C(A)$ 라는 것은 $c = L^{-1}b$ 의 마지막 항이 $0$ 임과 동치다.

b \in C(A) \quad \Longleftrightarrow \quad \begin{bmatrix} -1 & -2 & 1 \end{bmatrix} b = \mathbf{0} \quad \Longleftrightarrow \quad b \in N\left( \begin{bmatrix} -1 & -2 & 1 \end{bmatrix} \right)

이제, 행렬의 nullspace의 basis를 구하면 된다.

C(A) = \text{Span} \left\{ \begin{bmatrix} -2 \\ 1 \\ 0 \end{bmatrix} , \begin{bmatrix} 1 \\ 0 \\ 1 \end{bmatrix} \right\}

(4)

$A$ 의 왼쪽에 행렬을 곱한다는 것은, $A$ 의 rows로 선형 결합을 해서 새로운 rows를 만든다는 것이다. 따라서, $A$ 가 left-invertible 하려면, $\text{rank}(A) = 4$ 라야 한다.

하지만, $\text{rank}(A) \le 3$ 이다. 실제로, $\text{rank}(A) = \text{rank}(U) = 2$ 다. 따라서, $A$ 는 left-inverse를 가지지 않는다.

Problem 4.

Construct a matrix with the required property, or explain why you can't.

(1) Dimension of nullspace = 1 + dimension of left nullspace.

(2) Row space = column space, nullspace ≠ left nullspace.

Sol)

(1)

$A$ 가 $m \times n$ 행렬이라면, $C(A)$ 와 $C\left( A^\mathsf{T} \right)$ 의 차원은 $r$ 로 같고, $\dim N(A) = n-r$ , $\dim N\left( A^\mathsf{T} \right) = m-r$ 이다.

즉, $n = m+1$ 인 모든 행렬이 찾고자 하는 답이 된다. 가장 쉬운 예시는 이러하다.

\begin{bmatrix} 0 & 0 \end{bmatrix}

(2)

조금 당황했다. 시험 전까지 수업 때 배우지는 않았지만, 반드시 알아두어야 할 식이 하나 있다.

C(A)^\bot = N\left( A^\mathsf{T} \right)

증명은 $\subseteq$ 과 $\supseteq$ 로 나누어 하며, 그 서술은 기계가 한다. 나는 Gram-Schmidt로 $C(A)$ 의 Orthonormal basis를 잡고, $\mathbb{R}^m$ 의 orthonormal basis로 확장해서, 추가한 basis vectors가 $N\left( A^\mathsf{T} \right)$ 을 span한다는 아주 바보같은 서술을 했다. 여러분은 이 증명에 익숙해지도록 하자.

저 중요한 성질을 알면, 찾고자 하는 행렬은 존재하지 않음을 쉽게 알 수 있다.

N(A) = C\left( A^\mathsf{T} \right)^\bot = C(A)^\bot = N\left( A^\mathsf{T} \right)

이 문제에서 점수가 꽤 갈렸던 거 같다.

Problem 5.

For a positive integer $n > 2$ and two nonzero vectors $u, v \in \mathbb{R}^n$ , consider a matrix $A = u u^\mathsf{T} + v v^\mathsf{T}$ . What is the possible value of the rank of $A$ ?

Sol)

Rank에 대한 철학을 갖고 아래의 식을 보자.

A = u u^\mathsf{T} + v v^\mathsf{T} = \begin{bmatrix} u & v \end{bmatrix} \begin{bmatrix} u^\mathsf{T} \\ v^\mathsf{T} \end{bmatrix}

행렬 $A$ 를 $n \times 2$ 행렬과 $2 \times n$ 행렬의 곱으로 나타낼 수 있으므로, $\text{rank}(A) \le 2$ 다.

그리고, $A$ 의 rank는 $0$ , $1$ , $2$ 모두 가능하다. 각각, $u = v = \mathbb{0}$ , $u = \mathbb{0}$ & $v \ne \mathbb{0}$ , $u^\mathsf{T} v \ne 0$ 이면 된다.

Final Exam

Problem 1.

If $V$ is the subspace spanned by $(1, 1, 0, 1)$ and $(0, 0, 1, 0)$ , find

(1) the projection matrix $P$ onto $V$ .

(2) the vector in $V$ closest to the vector $b = (0, 1, 0, -1)$ in $V^\bot$ .

(3) an orthonormal basis of $V^\bot$ containing $b$ .

Sol)

(1)

$V$ 를 span하는 vectors가 orthogonal 하므로, 각 vector의 projection matrix $v v^\mathsf{T} / v^\mathsf{T} v$ 을 더하면 충분하다.

P = \frac{1}{3} \begin{bmatrix} 1 \\ 1 \\ 0 \\ 1 \end{bmatrix} \begin{bmatrix} 1 & 1 & 0 & 1 \end{bmatrix} + \begin{bmatrix} 0 \\ 0 \\ 1 \\ 0 \end{bmatrix} \begin{bmatrix} 0 & 0 & 1 & 0 \end{bmatrix} = \begin{bmatrix} 1/3 & 1/3 & 0 & 1/3 \\ 1/3 & 1/3 & 0 & 1/3 \\ 0 & 0 & 1 & 0 \\ 1/3 & 1/3 & 0 & 1/3 \end{bmatrix}

여담으로, 나는 상수 $1/3$ 을 놓쳐서 틀릴 뻔했다. Vector normalization을 먼저 하는 것도 좋은 습관일 것이다.

(2)

$b \in V^\bot$ 이므로, 더 볼 것 없이 답은 $\mathbf{0}$ 이다. $Pb = \mathbf{0}$ 인지 확인해도 좋다.

(3)

$(1, 1, 0, 1)$ , $(0, 0, 1, 0)$ , $(0, 1, 0, -1)$ 과 수직한 vector를 하나만 찾으면 된다.

N\left( \begin{bmatrix} 1 & 1 & 0 & 1 \\ 0 & 1 & 0 & -1 \\ 0 & 0 & 1 & 0 \end{bmatrix} \right) \ni \begin{bmatrix} -2 \\ 1 \\ 0 \\ 1 \end{bmatrix}

사실, $\lVert b \rVert \ne 1$ 라서, $b$ 를 포함하는 orthonormal basis는 없다. 센스있게 답을 적자.

\left\{ \frac{1}{\sqrt{2}} b , \ \frac{1}{\sqrt{6}} \begin{bmatrix} -2 \\ 1 \\ 0 \\ 1 \end{bmatrix} \right\}

Problem 2.

Let $A = \left( a_ {i j} \right)_ {1 \le i, j \le n}$ be the matrix defined by

a_{i j} = \begin{cases} 1 & \text{if } i - j = 0 \text{ or } 1, \\ -1 & \text{if } i - j = -1, \\ 0 & \text{otherwise.} \end{cases}

Let $F_n$ be the determinant of $A$ .

(1) Compute $F_{10}$ .

(2) When $n = 10$ , compute the last pivot of the matrix $A$ .

Sol)

(1)

직접 해보면, $F_1 = 1$ , $F_2 = 2$ .

$n \ge 3$ 이면, 첫 열과 두 번째 열을 잡고 Laplace expansion을 하면, $F_ n = F_ {n-1} + F_ {n-2}$ 의 점화식을 얻는다. 교과서 연습 문제니깐 꼭 해볼 것.

고로, $F_{10} = 89$ .

(2)

Submatrix의 determinant가 pivots의 곱과 같다는 성질을 사용하자. $A_ {10 \times 10}$ 의 $9 \times 9$ submatrix는 $A_ {9 \times 9}$ 와 같다.

따라서, $n = 10$ 일 때 $A$ 의 마지막 pivot의 값은 $F_ {10} / F_ 9 = 89 / 55$ .

여담으로, 이 문제를 못 푼 학생이 꽤 있었다.

Problem 3.

(1) For a real number $s$ , let $\displaystyle A = \begin{bmatrix} 5 & s \\\\ s & 5 \end{bmatrix}$ . Find a diagonal matrix $D$ and an orthogonal matrix $P$ such that $P^\mathsf{T} A P = D$ .

(2) For which $s$ is $A$ positive definite?

(3) Find a matrix $B$ such that $B^2 = A$ when $s = 4$ .

Sol)

(1)

평범한 대각화다. 충분히 훈련되어야 한다.

D = \begin{bmatrix} 5+s & 0 \\ 0 & 5-s \end{bmatrix} , \ P = \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} \quad \Longrightarrow \quad AP = PD

$P$ 에 상수 $1 / \sqrt{2}$ 를 붙여야 함에 유의할 것.

(2)

고윳값 $5 \pm s$ 가 모두 양수라야 한다. 고로, $-5 < s < 5$ .

(3)

행렬의 다양한 decomposition을 알아야 하고, 또한 각 decomposition이 어떻게 활용되는지 익혀두어야 한다.

B := P \sqrt{D} P^\mathsf{T} \quad \Longrightarrow \quad B^2 = P \sqrt{D} P^\mathsf{T} P \sqrt{D} P^\mathsf{T} = P D P^\mathsf{T} = A

B = P \sqrt{D} P^\mathsf{T} = \left( \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} \right) \begin{bmatrix} \sqrt{5+s} & 0 \\ 0 & \sqrt{5-s} \end{bmatrix} \left( \frac{1}{\sqrt{2}} \begin{bmatrix} 1 & 1 \\ 1 & -1 \end{bmatrix} \right) = \begin{bmatrix} 2 & 1 \\ 1 & 2 \end{bmatrix}

$B$ 의 각 원소를 미지수로 두고 방정식을 푼 학생이 있다는데, 감각이 좋은 것 같다. $A$ 가 positive definite 하므로, 저러한 square root $B$ 는 유일하게 존재한다.

Problem 4.

Let $\displaystyle A = \begin{bmatrix} .2 & .4 & .3 \\\\ .4 & .2 & .3 \\\\ .4 & .4 & .4 \end{bmatrix}$ .

(1) Show that $0$ is an eigenvalue of $A$ . Find all eigenvalues of $A$ .

(2) If $u_0 = (0, 10, 0)$ , find the limit of $A^k u_0$ as $k \rightarrow \infty$ .

Sol)

(1)

$A$ 의 첫 두 columns의 선형 결합으로 마지막 column을 만들 수 있다. 즉, $A$ 가 singular 하므로, $0$ 을 고윳값으로 가진다.

$A$ 는 Markov matrix 이므로, $1$ 을 고윳값으로 가진다.

고윳값의 합인 $\text{tr}(A) = .2 + .2 + .4 = 0.8$ 을 통해, 마지막으로 남은 고윳값은 $-0.2$ 임을 알 수 있다.

(2) - 철학이 필요한 풀이

하나의 $1$ 을 제외한 두 고윳값의 절댓값이 모두 $1$ 보다 작으므로, $A^k$ 는 $\lambda = 1$ 의 고유벡터의 방향으로 수렴한다.

이 고유벡터로는 $c (3, 3, 4)$ 가 있는데, Markov matrix 이므로 각 항의 합이 보존된다. $c (3 + 3 + 4) = 0 + 10 + 0 = 10$ 이므로, $c = 1$ .

즉, $A^k u_0$ 는 $(3, 3, 4)$ 로 수렴한다.

(2) - 손이 바쁜 풀이

$A$ 를 대각화하면, $A^k = P D^k P^\mathsf{T}$ 꼴로 표현할 수 있다. $\displaystyle D^k \rightarrow \begin{bmatrix} 1 & 0 & 0 \\\\ 0 & 0 & 0 \\\\ 0 & 0 & 0 \end{bmatrix}$ 가 되므로, 수렴값을 계산하기 어렵지 않을 것이다.

고유벡터를 전부 찾아줘야 하는데 조금 귀찮다. $\lambda = 0$ 과 $\lambda = 1$ 의 고유벡터를 찾고, 둘을 외적하면 $\lambda = -0.2$ 의 고유벡터를 공짜로 얻을 수 있다.

Problem 5.

Suppose that $A^2 = A$ .

(1) Show that an eigenvalue of $A$ must be either $0$ or $1$ .

(2) Show that $A$ is diagonalizable.

Sol)

(1)

Ax = \lambda x, \ x \ne \mathbf{0} \quad \Longrightarrow \quad \lambda x = A x = A^2 x = \lambda A x = \lambda^2 x \quad \Longrightarrow \quad \lambda = \lambda^2 \quad \Longrightarrow \quad \lambda \in \{ 0, 1 \}

(2) - 모범 답안

$A^2 = A$ 이므로, $A$ 의 minimal polynomial은 $x$ , $x-1$ , $x(x-1)$ 중 하나다. 각 factor의 degree가 $1$ 이므로, Primary decomposition theorem에 의해 대각화 가능하다.

문제는, 최소 다항식이랑 PDT를 안 배웠다. 최강의 정리로 오버킬링하는 풀이다.

(2) - 내 풀이

$A$ 의 Jordan normal form $AM = MJ$ 를 생각하자. $A^2 = M J^2 M^{-1}$ 이므로, $J = J^2$ 고, 각 Jordan block에 대해 $J_i = J_i^2$ 라야 한다.

$\lambda \in \{ 0, 1 \}$ 임을 고려하면, Jordan block $J_i$ 의 크기가 $2 \times 2$ 이상이면 모순이 생긴다. 즉, 모든 Jordan block의 크기는 $1 \times 1$ .

이는, $J$ 가 대각 행렬이라는 뜻이고, Jordan normal form이 우리가 찾던 $A$ 의 대각화 식이다.

(2) - 가장 아름다운 풀이

수업 때 배운 모든 지식에 대한 철학이 필요하다.

고윳값 $0$ 과 $1$ 에 대응하는 고유벡터의 벡터 공간을 $V_0$ , $V_1$ 라고 하자.

$A^2 = A$ 이므로, $C(A) \subseteq V_1$ .
$V_0 = N(A)$ .
$C(A) \cap N(A) \subseteq V_1 \cap V_0 = \{ \mathbf{0} \}$ .
Rank-nullity theorem에 의해, $C(A) \bigoplus N(A) = \mathbb{R}^n$ .
정리하면, $V_0 \bigoplus V_1 = \mathbb{R}^n$ . 고로, 대각화 가능하다.

완전하게 푼 학생이 몇 안 된다. 유명한 문제니깐 한 번씩은 꼭 도전해볼 것.

2021 ICPC Seoul Regional 후기

2022-12-26T03:15:56+09:00

F.S.M.

ICPC Seoul Regional 2020에서 예상하지 못한 좋은 성과를 거두고선, 이번 2021년도 대회에는 같은 팀으로 욕심을 내며 출전하였다.

팀원은 나와 민제, 세빈이. 팀명은 FSM. 민제랑 세빈이가 JetPunk라는 십덕 세계지리 오타쿠 퀴즈 사이트에 빠져있었는데, 오세아니아의 국가, "미크로네시아 연방"(Federated States of Micronesia)이 좋았나보다. 사실, 작년 팀명인 "Let Us Win ICPC WF"의 최악의 작명자가 나라서, 나는 발언권이 없었다. 팀명을 "유한 상태 기계"(Finite State Machine)로도 해석할 수 있기에 재밌다고 생각했다.

후기글을 작년에 왜 안 썼느냐 하면... 대회 초반부터 결과 발표 직전까지 분위기가 내내 암울했어서 쓰고 싶지 않았다.

그러면 그걸 왜 이제 와서 쓰나면... 올해 World Finals 2021 자랑글을 쓰고 있는데, 얘를 안 쓰니 뭔가 글의 구성이 이상하다. 하지만, 지금으로부터 2년 전 이야기라 기억나는 게 별로 없었다. 그래서, 뇌리에 박힌 몇 가지 중요 이벤트만 적어본다.

ICPC Seoul 인터넷 예선

자기 반성과 연습을 많이 했기에, 예선은 부담없이 즐겼다. 그냥 셋 다 잘했고 F, G 빼고 전부 풀어서 1등을 했다.

F의 티어는 다이아 4라는데 못 풀어서 아쉽지는 않다. G는 내가 보자마자 풀었어야 했는데 그러지 못해 아쉬웠다.

ICPC Seoul Regional 본선

Before the contest

본선 진출 명단을 보고, 셋 중 둘만 제정신이면 무난하게 World Finals 진출권을 따낼 거라고 생각했다. KAIST 신입생 팀들의 실력이 가늠이 되지 않아, 우승 자신감이 100%에서 80% 정도로 떨어졌다. 난 이렇게 생각했는데 세빈이랑 민제는 어땠는지 모르겠다.

대회 초반

본선 대회가 시작했다. 주최측이 올려준 합본 pdf를 프린터가 읽어들이지 못했다. 우왕좌왕하다가 결국 각 문제별로 pdf를 다운로드 받아서 하나씩 인쇄했다. 작년의 그 악몽이 떠올라서 살짝 싸했다.

초반 한 시간 내내 서울대 The Elders 팀과 KAIST의 BabyPenguin 팀에게 질질 끌려다녔다. 솔브 수 차이까지 생겨서 다들 멘탈 빈약 상태였다.

60 ~ 150 min.

세빈이가 초반부터 F를 잡고 두 번 틀리더니 G.G.를 치고 멘탈이 깨졌다. 나는 G를 뚫은 다음 세빈이의 F를 뺏어서 풀기 시작했다.

남들은 찍어맞추는 E를 엄밀하게 증명하느라 심신 미약 상태가 된 민제는 K의 역겨운 구현을 마치고 시간 초과 판정을 받았다. 나는 "F, 개쉬운 DP 기초 문제인데 왜 못 풂?"을 시전하고 세빈이랑 똑같이 틀렸다. 이때가 대회 시간의 절반이 지나간 때였다.

중간 점검.

이때 상황을 정리하자면, 나랑 세빈이는 F, 민제는 K에 한 시간 가까이 발이 묶여있었다. 그런데 상위권 팀들은 모두 F, K를 풀었다. 걍 자살 마려웠다.

150 ~ 180 min.

F를 한 번 더 틀린 나는 "주최측 데이터가 틀렸다"를 시전하고 문제를 민제에게 유기했다. 그러고 나는 H, I, J를, 세빈이는 A를 잡았다.

지금 돌이켜보면 나는 절대 해서는 안되는 최악의 판단을 내렸다. 반드시 풀어야 하는 F, K를 둘 다 민제가 맡게 되었고, 민제가 받았을 압박감은 상당했을 것이다. 심지어, 페널티로는 가망이 없어서, 두 문제 뒤쳐지고 있는 상황에서 솔브 수로 이겨야 했기 때문에, 더이상 민제에게 남은 코인은 없었다.

압박을 이겨내고 민제는 20여분만에 F를 풀어주었다. 이때 칼바람보다도 싸늘했던 분위기가 수그러들었다.

대회 끝나고 나랑 세빈이가 F를 틀린 이유를 며칠동안 분석해봤다. 부분문제의 해가 원래 문제의 해와 연관이 있어서 답은 DP로 구할 수 있는 건 맞았다. 그런데, 부분문제의 해를 구성하는 "방법"은 원래 문제의 것과 연관이 없었다. 나랑 세빈이는 여기에 낚여서, 그 "방법"도 DP로 구하려다가 틀렸다. 민제는 여기까지 생각 안하고 모든 "방법"에 대한 답을 계산해서 함정을 피할 수 있었다. 생각이 깊어지면 틀린다. 이런 억까는 처음 당해본다.

191 min.

J를 잘 생각해보니, 내가 나는코더다 송년대회에 출제하려다가 제한의 상한을 증명하지 못해 안 냈던 문제랑 완전하게 똑같았다. 출제진은 상한을 증명했겠거니 생각하고 내 풀이를 그대로 짜서 맞았다.

여기서 우리와 상위권 팀들의 솔브 수가 같아졌다. 대회 중 처음으로 웃을 수 있었다.

191 ~ 240 min.

민제가 시간 초과로 고생하길래 Fenwick tree를 쓰라고 적당히 훈수를 두었다. 결국 민제가 K를 풀었다.

세빈이는 A의 거대한 구현량에 정신이 나가 미쳐있었다.

H랑 I가 남았는데, H는 case-work를 꽤 많이 해야 해서 출제진의 양심이 없는 거 같았다. 결국 개노답 기하 I를 잡았다.

민제는 뭐했는지 모르겠다.

240 ~ 300 min.

세빈이가 종료 17분 전에 결국 A를 해치웠다.

내 I 코드는 요리보고 조리봐도 정해인데 WA 판정을 받았다.

민제는 뭐했는지 모르겠다.

After the contest

프리즈된 스코어보드를 보면서 다른 팀을 열심히 분석했다.

대회 종료 10분 전 즈음에 서울대 The Elders 팀이 A를 제출하고, 더이상의 제출이 없었다. 일반적으로 대회 종료 직전에 WA 판정을 받으면 코드 여기저기를 고쳐가면서 마구 제출하기 때문에, 우리는 The Elders가 당연히 한 번에 A를 맞았으리라 생각했다.

KAIST의 BabyPenguin 팀도 종료 30분 전에 I를 세 번 제출했고, 그 이후로는 더 제출하지 않았다. I는 뭔가 잘하면 풀릴법한 기하 문제라서, 당연히 풀었을 거라고 생각했다.

두 시나리오 모두, 우리가 솔브 수는 같지만 페널티로 지는 ~~Bad Ending~~이다. 특히, 첫 번째 시나리오가 일어나면 서울대 2등이 되어버려서 World Finals 진출에 실패한다. 하지만, A의 풀이는 아주 직관적이고, 강팀인 The Elders가 A를 못 풀었을 리가 없기 때문에, 셋 다 소파에 엎드려서 암울하게 울고 있었다.

Unfreeze the scoreboard

대회가 끝나고 한 시간 반동안 스코어보드 공개가 이루어지지 않았다. 너무 괴로워서 배고파도 저녁이 먹고 싶지 않았다.

그런데, 이 모든 짓거리가 전부 비틱질이었다.

The Elders는 A를 못 풀었고, BabyPenguin은 H, I 둘 다 풀지 못했다. 뜬금없이 KAIST의 DO Solve 팀이 J를 해결하면서 우리와 솔브 수가 같아졌는데, 우리보다 페널티를 많이 쌓아둔 고마운 친구들이라서, 정말 다이나믹하게 우리가 우승할 수 있었다. 무슨 90년대 소년만화 최종화처럼 스토리가 흘러갔다.

이 상황이 생각할 수록 참 재미있다. 만약 내가 J를 송년대회에 출제했다면, BabyPenguin은 J를 해결하면서 우승했을 것이다. The Elders는 A에서 아주아주 사소한 코딩 실수를 했고, 대회 종료 직후에 찾아서 고쳤다고 한다. (라이벌 팀이지만 이 부분은 너무 공감되기에 진심으로 안타까웠다.) 내가 구상한 문제는 유출된 적이 없는데 이게 J로 똑같이 등장한 이 우연도 참 믿기지가 않는다.

결과만 놓고 보자면, 초반에 아주 부진했던 우리는 솔브 수로 역전하며 당당하게 우승했다. 그 비하인드에 수많은 억까와 행운이 있었지만, 뭐, 알빠노.

세 줄 요약

우리는 Seoul Regional 대회를 두 번 연속으로 우승한 유일한 팀이 되었다.

덕분에, 우리는 서로가 서로를 2023년까지 입대하지 못하게 견제하는 사이가 되었다.

그리고 그렇게, World Finals 2021은 우리에게 잊혀져갔다.

실무에서 빠르게 LCS를 계산하는 실용적인 Hunt-Szymanski 알고리즘에 관하여

2022-03-20T14:55:28+09:00

개요

두 문자열의 가장 긴 공통 부분문자열을 찾는 Longest Common Subsequence (LCS) 문제는 정보과학에서 기초가 되는 잘 알려진 문제이다. 이렇게 기초적임에도 불구하고, LCS 문제는 생물정보학이나 전산언어학, 그리고 실생활에서 자주 사용하는 검색 엔진 등 다양한 학문과 분야에서 활용되는 아주 중요한 문제이다.

길이가 각각 $L_1, \cdots, L_N$ 인 문자열 $N$ 개의 LCS는 다이나믹 프로그래밍 기법을 이용하여 $\displaystyle \mathcal{O} \left( N \prod _{k=1}^{N} L _k \right)$ 의 시간 복잡도로 해결할 수 있음이 잘 알려져 있다.

본 글은 길이 $N$ , $M$ $(N \gg M)$ 의 두 문자열의 LCS를 평균 $\displaystyle \mathcal{O} \left( N \lg N \right)$ 에 해결하는 효율적인 알고리즘을 소개하고 그 응용 방안에 대하여 알아본다.

본문에서는 다음의 내용을 부가적인 설명 없이 서술한다. 각 항목에 대하여, 자세하게 서술한 좋은 글을 링크해두었다.

문제 제기

가장 긴 공통 부분문자열 문제

어떤 문자열 $S$ 의 부분문자열 (Subsequence)의 정의는 다음과 같다.

문자열 $S = s _1 s _2 \cdots s _N$ 의 부분문자열 $s _{i _1} s _{i _2} \cdots s _{i _K}$ 은 정수열 $\left\{ i _k \right\} _{k = 1}^{k = K}$ 로 생성되는 문자열이다. 여기서 수열 $\left\{ i _k \right\} _{k = 1}^{k = K}$ 는 다음 조건을 만족해야 한다.

$0 \le K \le N$

$\displaystyle 1 \le i _1 < i _2 < \cdots < i _K \le N$

즉, 부분문자열은 원 문자열에서 순서를 유지한 채 몇 개의 문자를 제거하여 얻어질 수 있는 문자열을 뜻한다.

가장 긴 공통 부분문자열 (LCS) 문제란, $K$ 개의 문자열이 주어질 때, 모든 문자열의 공통 부분문자열 중에서 최장인 것을 찾는 문제이다. 이러한 문제는 특히 생물정보학에서 자주 사용되며, 단백질의 아미노산 서열이나, DNA, RNA의 염기 서열의 LCS를 계산하여 얼마나 그 구조가 유사한지를 분석하는 데에 응용될 수 있다.

1978년에 David Maier는 문자열의 개수 $K$ 를 변수로 두면, LCS 문제는 NP-Hard가 됨을 증명하였다. 본 글에서는 $\displaystyle K = \mathcal{O} \left( 1 \right)$ , 특히 $K = 2$ 로 가정한다.

고전적인 DP 알고리즘

LCS 문제는 동적 계획법 (Dynamic Programming)을 이용하여 쉽게 해결할 수 있다.

먼저, 두 문자열 $X$ , $Y$ 에 대하여, $\text{LCS} (X, Y)$ 를 " $X$ 와 $Y$ 의 최장 공통 부분문자열의 집합"으로 정의하자.

Lemma 1. 공통 접미사는 LCS에 포함된다.

임의의 문자열 $X$ , $Y$ , $S$ 에 대하여, 다음이 성립한다.
$\text{LCS} \left( X + S, Y + S \right) = \text{LCS} \left( X, Y \right) + S := \left\{ C + S : C \in \text{LCS} \left( X, Y \right) \right\}$

이는 $\left\lvert S \right\rvert = 1$ 일 때에만 증명해도 충분하다. $X + S$ 와 $Y + S$ 의 마지막 문자는 서로에게 대응시키는 것이 LCS를 구함에 있어 손해가 되지 않기 때문에 항상 최적임을 알 수 있다.

Lemma 2. 양자택일.

임의의 문자열 $X$ , $Y$ 와 서로 다른 두 알파벳 $\alpha, \beta \in \Sigma$ 에 대하여, 다음이 성립한다.
$\text{LCS} \left( X + \alpha, Y + \beta \right) = \max \left[ \text{LCS} \left( X + \alpha, Y \right), \text{LCS} \left( X, Y + \beta \right) \right]$
여기서, $\max \left[ U, V \right]$ 는 $U \cup V$ 에서 길이가 가장 긴 문자열만 모아놓은 문자열 집합을 의미한다.

$\alpha \ne \beta$ 이므로, 두 알파벳은 서로에게 대응될 수 없다. 즉, 둘 중 하나는 공통 부분문자열에 포함되지 못하므로, 각각의 경우에 대하여 LCS를 계산한 후 합쳐줄 수 있다. $\alpha = \beta$ 인 경우는 **Lemma 1.**에 해당함에 유의하라.

우리는 이 두 Lemma를 적용하여 LCS의 길이를 계산할 수 있다.

두 문자열 $X = x _1 x _2 \cdots x _N$ , $Y = y _1 y _2 \cdots y _M$ 에 대하여, $D _{i, j}$ 를 $X[1 \cdots i]$ 와 $Y[1 \cdots j]$ 의 LCS 길이로 정의하자. 그러면 다음과 같은 재귀적 관계식을 세울 수 있다.

$x _i = y _j$ 라면, $D _{i, j} = D _{i-1, j-1} + 1$

그렇지 않다면, $D _{i, j} = \max \left\{ D _{i, j-1}, D _{i-1, j} \right\}$

전자는 Lemma 1., 후자는 **Lemma 2.**에 대응됨에 유의하라.

따라서, 두 문자열의 LCS의 길이는 $D _{N, M}$ 과 같고, 이 값은 $\displaystyle \mathcal{O} \left( NM \right)$ 의 시간 복잡도로 계산할 수 있다. $\text{LCS}(X, Y)$ 중 하나의 원소를 알아내는 작업은 $D _{N, M}$ 의 값이 어디로부터 왔는지를 역추적하여 계산할 수 있다.

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

// input: two strings X[0 ... N-1], Y[0 ... M-1]
// output: length of LCS(X, Y)
int lcs(char *X, int N, char *Y, int M) {
    int D[N+1][M+1] = {}; // D_{i, j}
    
    for(int i = 1; i <= N; i++)
        for(int j = 1; j <= M; j++)
            D[i][j] = X[i] == Y[j]
                    ? D[i-1][j-1] + 1 // Lemma 1.
                    : max(D[i][j-1], D[i-1][j]); // Lemma 2.
    
    return D[N][M];
}

Hunt-Szymanski Algorithm

더 빠른 알고리즘의 필요성 제기

해싱이나 문자의 값을 사용하지 않고, 두 문자열의 LCS를 알아내기 위해서는 $\mathcal{O} \left( NM \right)$ 번의 문자쌍 비교가 반드시 필요함이 D S. Hirschberg와 J D. Ullman에 의하여 1974년에 증명되었다. 즉, 상기한 고전적 DP 알고리즘은 LCS를 계산하는 최적의 알고리즘이다.

그러나 현실에서, 그리고 많은 정보과학 관련 학문 분야에서 LCS 문제는 자주 사용되기에, 아주 긴 문자열의 LCS를 빠르게 계산하는 알고리즘의 필요성이 점차 대두되었다.

1970년대에 개발된 Hunt-Szymanski 알고리즘은 간단한 아이디어로 두 문자열의 LCS를 $\displaystyle \mathcal{O} \left( N \lg N \right)$ 의 실험적 시간 복잡도로 계산한다. 본 글은 이 알고리즘의 아이디어와 구현 방법을 소개하고자 한다.

핵심적 관찰

먼저, 고전적 DP 알고리즘의 작동 방식을 생각하자.

두 문자열 aeaca와 acea에서 같은 알파벳을 가지는 모든 위치쌍을 'X'표로 나타내면 아래와 같다.

그림 1: 두 문자열의 공통 알파벳에 대응되는 모든 위치를 표시한 표

두 문자열 $X$ , $Y$ 에 대하여, $x _i = y _j$ 인 모든 위치쌍 $(i, j)$ 을 'X'표로 나타내었다.

고전적 DP 알고리즘은 $D _{i, j}$ 의 값을 구할 때 일반적으로 $D _{i, j-1}$ 과 $D _{i-1, j}$ 의 최댓값을 채택하나, 'X'표에 해당하는 위치에서만 $D _{i-1, j-1} + 1$ 의 값을 택하는 알고리즘이다.

그러나, 실생활에서, 알파벳의 총 개수가 충분히 크다면, 이러한 'X'표의 개수가 $\displaystyle \mathcal{O} \left( NM \right)$ 보다는 유의미하게 작으리라 기대할 수 있다. Hunt-Syzmanski 알고리즘은 이러한 아이디어에서 출발한다.

Lemma 3. $D _{, }$ 의 행의 단조성

고전적 DP 알고리즘에서 한 행 $D _{i, *}$ 의 값은 항상 다음과 같은 형식을 가진다.
$0\ 0\ 1\ 1\ 1\ 2\ 3\ 3\ 3\ 3\ 3\ 4\ 4\ 5\ 5\ 5\ \cdots$
즉, 첫 번째 값은 항상 0이고, 이웃한 두 수의 차이는 최대 1이며, 값을 차례대로 읽으면 단조증가한다.

단, 편의상 $D _{0, * } = D _{ *, 0} = 0$ 라고 가정한다.

행 번호 $i$ 에 대하여 귀납법을 적용하여 증명할 수 있다. $D _{0, *}$ 은 그 값이 모두 0이므로 자명하다. $D _{i, j}$ 의 값은 (1) 그 이전 값 $D _{i, j-1}$ 거나, (2) 그 위의 값 $D _{i-1, j}$ 거나, (3) 대각 위의 값 $D _{i-1, j-1}$ 에서 1을 더한 값이다. 인접한 수의 차이는 0 아니면 1이므로, $D _{i, *}$ 또한 단조증가하면서 차이가 최대 1인 수열임을 알 수 있다.

이제, 각 행에 대하여 연속한 값을 가지는 구간의 특징을 관찰하자. 같은 값을 가지는 Segment에서 첫 수를 Head, 나머지 수들을 Tail이라고 부르자. 어떤 행의 $D _{i, *}$ 값이 $0\ 0\ 0\ 0\ 0\ 1\ 1\ 1\ 1\ 2\ 3\ 3\ 3\ 3\ 4\ 4\ 4\ 4$ 일 때, 각 Segment의 Tail을 직사각형 블록으로 묶어서 표현하면 아래와 같다.

그림 2: 한 행에서 모든 Tail을 직사각형으로 나타낸 그림

총 네 개의 Tail을 직사각형으로 묶어 나타내었다. Head의 값이 차례대로 0, 1, 2, 3, 4 임에 유의하라.

그림 2와 같이 $D _{i, *}$ 값을 Segment 표기법으로 나타낸 후, 그 바로 아래의 행에서 'X'표 배치에 따른 $D _{i+1, *}$ 값 변화를 관찰하자. 만약, 그림 3의 상단과 같이 'X'표가 배치되었다면, $D _{i+1, *}$ 의 값은 하단과 같이 결정된다.

그림 3: 'X'표 배치와 그 아래 행의 값

그림 2의 $D _{i, *}$ 과 'X'표 배치가 상단과 같이 주어지면, $D _{i+1, *}$ 의 값은 하단과 같이 결정된다.

여기서 우리는 다음의 사실을 관찰할 수 있다.

Theorem.

Head 아래에 있는 'X'표는 무시해도 $D _{i+1, *}$ 값에 변화를 주지 않는다.

같은 Tail에 여러 개의 'X'표가 있다면, 가장 앞에 있는 'X'표만 남겨도 그 결과는 동일하다.

각 Tail의 가장 앞에 있는 'X'표는 $D _{i+1, *}$ 의 값을 1 증가시킨다.

알고리즘의 구현

$D _{*, 0} = 0$ 이고 값이 증가한다면 증감량이 무조건 1이므로, 각 행에서 $D _{i, *}$ 값이 증가하는 시점만 기록해도 모든 정보를 나타내기에 충분하다.

조금 더 자세하게는, $D _{i, j} - D _{i, j-1} = 1$ 인 $j$ 만 모아놓은 집합 $S _i$ 는 $D _{i, *}$ 의 모든 값을 잘 표현한다. 뿐만 아니라, $D _{i, *}$ 는 $\Theta \left( M \right)$ 의 공간 복잡도가 필요한 반면, $\left\lvert S _i \right\rvert$ 는 $M$ 보다 충분히 작을 것이라 기대할 수 있다. 실제로 이 집합의 크기가 어느 정도인 지는 추후에 분석한다.

예를 들어, 그림 3에서 $D _{i, *}$ 과 $D _{i+1, *}$ 의 값으로부터 집합 $S _i$ , $S _{i+1}$ 을 계산하면 아래와 같다.

$S _i = \left\{ 5, 9, 10, 14 \right\}$ $S _{i+1} = \left\{ 2, 9, 10, 12, 16 \right\}$

그러면, $S _i$ 와 'X'표 배치로부터 집합 $S _{i+1}$ 는 어떻게 얻을 수 있을까. 먼저, 다음과 같이 함수 $\text{succ}(S, x)$ 를 정의하자.

$\text{succ} \left( S, x \right) := \min \left\{ y \in S : y \ge x \right\}$

이 함수는 C++의 std::lower_bound에 대응된다.

$i+1$ 번째 행에 위치한 'X'표의 좌표를 모두 모아놓은 집합을 $R _i$ 라고 하자. 즉, $R _i := \left\{ j : x _{i+1} = y _j \right\}$ 이다. 이때, $S _{i+1}$ 는 다음과 같이 계산할 수 있다.

$S _{i+1} \longleftarrow S _i$ : 집합 $S _i$ 를 $S _{i+1}$ 에 복사한다.

각 $j \in R _i$ 를 감소하는 순서대로 다음을 반복한다.

$S _{i+1}$ 에서 $\text{succ} \left( S _{i+1}, j \right)$ 를 제거한다.

$S _{i+1}$ 에 $j$ 를 추가한다.

이러한 알고리즘의 정당성은 **Theorem.**에서 직관적으로 얻어진다.

이를 코드로 구현하면 다음과 같다. 고전적 DP 알고리즘과 비교하여도, 코드가 상당히 짧고 간결함을 알 수 있다.

// input: two strings X[0 ... N-1], Y[0 ... M-1]
// output: length of LCS(X, Y)
int lcs(char *X, int N, char *Y, int M) {
    vector<int> idx[256]; // # of alphabets = 256
    
    // Counting sort + Reverse
    // We use them to compute R_i fast
    for(int i = M; i--;) idx[Y[i]].emplace_back(i);
    
    // Init S_0
    int S[N+1] = {-1}, l = 1;
    
    // Compute S_1, ..., S_N
    for(int i = 0; i < N; i++) {
        for(int j : idx[A[i]]) {
            if(S[l-1] < j) S[l++] = j; // No succ. exists
            else S[int(lower_bound(S, S+l, j) - S)] = j;
                // Find succ. and replace
        }
    }
    
    return l-1;
}

결론

LCS 문제는 정보과학에서 기초적인 문제이지만, 생물정보학과 전산언어학, 검색 엔진, diff 프로그램 등, 학문적으로도 실용적으로도 다양한 분야에 접목되고 활용된다.

두 개의 문자열의 LCS를 구하는 문제는 해싱 등의 기법을 활용하지 않고서는 $\displaystyle \mathcal{O} \left( NM \right)$ 보다 빠르게 해결할 수 없음이 알려져 있다. 우리는 같은 알파벳을 나타내는 위치쌍의 총 개수 $\displaystyle R := \sum _i \left\lvert R _i \right\rvert$ 가 실험적으로는 $\displaystyle \mathcal{O} \left( NM \right)$ 보다는 유의미하게 작다는 사실을 활용한 Hunt-Szymanski 알고리즘에 대하여 알아보았다.

이 알고리즘은 고전적 DP 알고리즘에서 인접한 두 행의 $D _{i, *}$ , $D _{i+1, *}$ 값의 특징을 관찰하고, 이 DP 배열을 적은 개수의 수로 이루어진 집합으로 표현함으로써, 평균 시간 복잡도를 낮추었다. $N \gg M$ 을 가정하면, 시간 복잡도는 $\displaystyle \mathcal{O} \left( R \lg N + M \lg M \right)$ 가 되며, $R = \Theta \left( NM \right)$ 인 최악의 경우에도 고전적 DP 알고리즘보다 $\displaystyle \mathcal{O}\left( \lg N \right)$ 배밖에 느리지 않다. 또한, 실험적으로는 $\displaystyle R = \mathcal{O} \left( N \right)$ 을 기대할 수 있다.

Hunt-Szymanski 알고리즘의 핵심적인 관찰들은 추후 Bit-String LCS 알고리즘에 응용되었다. 이 알고리즘은 $\displaystyle \mathcal{O} \left( \frac{ NM }{ \omega } \right)$ 의 시간 복잡도와 $\displaystyle \mathcal{O} \left( \frac{ \left\lvert \Sigma \right\rvert M }{ \omega } \right)$ 의 공간 복잡도로 LCS를 계산한다.

Stern-Brocot Tree를 활용한 수론적 함수의 합 계산

2022-02-18T18:27:10+09:00

개요

정수론에서 주로 다루는 중요한 수론적 함수로는 약수 함수 $\sigma_k (n)$ , 오일러 피 함수 $\phi (n)$ , 뫼비우스 함수 $\mu (n)$ 등이 있다. 이러한 함수의 학문적 중요도는 이루 말할 수 없으며, 컴퓨터과학와 PS 분야에도 종종 등장할 정도로 다양하게 활용된다.

본 글은 수론적 함수의 대표인 약수 함수 $\sigma (n)$ 의 구간 합을 효율적으로 계산하는 알고리즘을 서술한다. 함수의 합을 기하적으로 해석한 후, 이를 Stern-Brocot Tree 자료구조로 계산한다. 이후, 이 알고리즘의 시간 복잡도가 $\tilde{O} \left( N^{1/3} \right)$ 로 아주 효율적임을 보인다.

문제 제기

약수 함수의 합 문제

양의 정수 $n$ 에 대하여, $n$ 의 모든 양의 약수의 $k$ 제곱의 합을 생각하자. 이것이 약수 함수 $\sigma_k (n)$ 의 정의이다.

$\sigma_k (n) := \sum_{ d | n } d^k$

이 글에서는 $k = 1$ 인 시그마 함수 $\sigma (n) := \sigma_1 (n)$ 에 대하여 주로 다룬다. 이 값은 $n$ 의 약수의 합을 나타낸다.

이제, 정수 $N$ 이 주어졌을 때, 1부터 $N$ 까지 시그마 함숫값의 합 $\displaystyle \sum_{k=1}^{N} \sigma(k)$ 을 구하는 문제를 생각하자.

정수론적 접근

$\sigma(1) + \cdots + \sigma(N)$ 의 값은 다음 조건을 만족하는 양의 정수 쌍 $(n, d)$ 의 개수와 같다.

$d$ 는 $n$ 의 약수

$1 \le d \le n \le N$

이는 시그마 함수의 정의를 생각할 때, $\sigma(k)$ 의 값은 $n = k$ 인 $(n, d)$ 의 개수와 같으므로 자명하다.

이제, $d$ 의 값을 고정한 후, 위의 조건을 만족하는 $n$ 의 개수를 세자. $n$ 은 $N$ 이하인 $d$ 의 배수라야 하므로, 총 $\displaystyle \left\lfloor \frac{ N }{ d } \right\rfloor$ 개만큼 존재한다.

\sum _{k=1}^{N} \sigma(k) = \sum _{d=1}^{N} \left\lfloor \frac{ N }{ d } \right\rfloor

이는 다르게 해석하면, $y = \frac{N}{x}$ 그래프 아래에 있는 양의 정수 쌍 $(x, y)$ 의 개수를 세는 것과 같다. 곡선 $xy = N$ 은 직선 $x = y$ 에 대하여 대칭이며, 이 둘의 교점은 $\left( \sqrt{N}, \sqrt{N} \right)$ 이므로, 최종적으로 아래의 식을 얻을 수 있다.

\sum _{d=1}^{N} \left\lfloor \frac{ N }{ d } \right\rfloor = 2 \sum _{x=1}^{ \left\lfloor \sqrt{N} \right\rfloor } \left\lfloor \frac{ N }{ x } \right\rfloor - { \left\lfloor \sqrt{N} \right\rfloor }^2

우리는 시그마 함수 $\sigma(n)$ 의 값을 어떻게 계산하는지 알지 않아도, 시그마 함수의 합을 $O \left( \sqrt{N} \right)$ 만에 쉽게 계산할 수 있게 되었다.

그러나 $N$ 이 $10^{18}$ -scale로 아주 큰 수라면, 우리는 이보다도 더욱 효율적인 방법을 찾아야 한다.

Stern-Brocot Tree

효율적인 알고리즘을 구상하기 전에, 페리 수열과 Stern-Brocot Tree 자료구조에 대하여 먼저 알아보자.

Farey Sequence

Stern-Brocot Tree에 대하여 논하기 전에, 먼저 페리 수열의 정의를 소개한다. $n$ 번째 페리 수열 $F_n$ 는 다음을 만족하는 모든 기약분수 $\displaystyle \frac{a}{b}$ 를 오름차순으로 나열한 수열이다.

$0 \le b \le a \le n$

$\gcd (a, b) = 1$

예를 들어, 몇몇의 $n$ 에 대하여 페리 수열 $F_n$ 을 나열하면 아래와 같다.

$F _1 = \left\{ \frac{0}{1}, \frac{1}{1} \right\}$ $F _2 = \left\{ \frac{0}{1}, \frac{1}{2}, \frac{1}{1} \right\}$ $F _5 = \left\{ \frac{0}{1}, \frac{1}{5}, \frac{1}{4}, \frac{1}{3}, \frac{2}{5}, \frac{1}{2}, \frac{3}{5}, \frac{2}{3}, \frac{3}{4}, \frac{4}{5}, \frac{1}{1} \right\}$

여기서, 페리 수열 $F_n$ 에서 인접한 두 유리수를 "차수 $n$ 에서 페리 이웃하다"라고 한다. 페리 이웃에 관한 중요한 정리를 하나 소개한다.

차수에 상관없이, 페리 이웃한 두 유리수 $\displaystyle \frac{a}{b} > \frac{c}{d}$ 는 $ad - bc = 1$ 을 만족한다.

이 정리는 아래에 서술할 Stern-Brocot Tree에 관한 정리의 기반이 된다.

Stern-Brocot Tree

페리 수열 $F_n$ 을 확장하여, 각 유리수의 역수까지 등장하는 수열을 생각하자. 편의상, $\displaystyle \frac{1}{0} = + \infty$ 로 생각하면, 이 수열은 $\displaystyle \frac{0}{1} = 0$ 이상 $\displaystyle \frac{1}{0} = + \infty$ 이하인 기약분수를 잘 나열할 것이다.

실제로, $0$ 이상의 모든 유리수는 충분히 큰 $n$ 에 대하여 확장된 페리 수열 $F' _n$ 에 정확하게 한 번 등장함을 증명할 수 있다. 이제, 깊이 $n$ 에 해당하는 층에 확장된 페리 수열 $F' _n$ 을 적어, 아래 그림과 같은 이진 트리를 생각하자.

그림 1: Stern–Brocot Tree

확장된 페리 수열 $F' _1$ 부터 $F' _4$ 까지 활용하여 깊이 4의 Stern-Brocot Tree를 만들 수 있다.

이 트리는 (1) 완전 이진 검색 트리이며, (2) 모든 양의 유리수가 정확하게 한 번씩 등장한다는 강력한 성질을 가진다. 또한, 트리 그 자체로 유리수와 자연수 간의 일대일 대응을 잘 보여준다.

이러한 완전 이진 검색 트리를 Stern-Brocot Tree라고 부른다.

유리수 이분탐색

알고리즘 분야에서 Stern-Brocot Tree는 유리수를 대상으로 이분탐색을 할 수 있게 되었다는 점에서 그 의미가 깊다.

두 유리수 $\displaystyle \frac{a}{b} < \frac{c}{d}$ 에 대하여, $\displaystyle \frac{a}{b}$ 초과 $\displaystyle \frac{c}{d}$ 미만의 모든 유리수를 담고 있는 Stern-Brocot Subtree의 루트 정점은 $\displaystyle \frac{a+c}{b+d}$ 이다.

이를 그대로 활용하면, 다음과 같은 이분탐색 알고리즘을 생각할 수 있다.

$\displaystyle s := \frac{a}{b} = \frac{0}{1}$ , $\displaystyle e := \frac{c}{d} = \frac{1}{0}$ 으로 설정한다. 이제, 각 스텝마다 $s$ 초과 $e$ 미만인 유리수에 대하여 이분탐색을 수행한다.

중간값 $\displaystyle m := \frac{ a+c }{ b+d }$ 을 잡자.

만약, $m$ 이 찾고자 하는 유리수라면, 탐색을 멈춘다.

아니라면, 찾고자 하는 유리수와 $m$ 에 대한 대소비교를 수행한다.

$(s, e)$ 를 $(s, m)$ 혹은 $(m, e)$ 로 대입한 후, 위의 과정을 반복한다.

이러한 이분탐색 과정을 통하여 최종적으로 기약분수 $\displaystyle \frac{x}{y}$ 를 얻었다면, 탐색 횟수는 Stern-Brocot Tree에서 정점 $\displaystyle \frac{x}{y}$ 의 깊이와 같으므로 $O(x+y)$ 이다.

과정 2.는 Stern-Brocot Tree의 정점에서 한 쪽 방향으로 내려가는 것을 나타낸다. 여기서, 연속으로 몇 번까지 같은 방향으로 내려가는지를 알아낼 수 있다면 탐색 횟수를 줄일 수 있다. 예를 들어, 중간값 $m$ 보다 작은 쪽으로 탐색을 이어나가야 한다면, $e$ 값을 $\displaystyle \frac{ ta + c }{ tb + d }$ 꼴로 제한할 수 있다. 이것이 가능한 최대 정수 $t$ 를 이분탐색으로 찾으면, 전체 탐색 횟수를 $O(x+y)$ 에서 $O \left( x + \lg y \right)$ 로 크게 개선할 수 있다.

기하적 접근

다시 원래의 문제로 돌아오자. 우리는 아래의 그림과 같이 $\displaystyle y = \frac{N}{x}$ 곡선 아래의 회색 영역에 존재하는 양의 정수 쌍 $(x, y)$ 의 수를 세어야 한다.

그림 2: $xy = 20$ 그래프와 회색 영역

$N = 20$ 이라면 위 회색 영역 내부의 정수 점의 개수를 세어야 한다.

이 그래프에서 기울기가 $-1$ 인 접선을 긋자. 아래의 그림에 접점 $G$ , $x$ 축과 $y$ 축과의 교점 $P _x$ , $P _y$ 을 나타내었다.

그림 3: $xy = 20$ 그래프와 기울기 $-1$ 의 접선

접점 $G$ 와 중요한 교점 두 개 $P _x$ , $P _y$ 를 나타내었다. 접선 아래 영역의 정수 점의 개수는 쉽게 셀 수 있다.

여기서 아이디어는 이러하다. 곡선 아래의 정수 점의 개수를 세는 것은 어렵지만, 직선 아래의 정수 점의 수는 사칙연산을 이용하여 아주 쉽게 셀 수 있다.

우리는 남은 영역에 대하여 적당한 기울기의 접선을 그어 점의 개수를 세는 작업을 재귀적으로 반복하고자 한다. 정수 점의 개수는 유한하므로, 접선의 기울기를 잘 설정하였다면, 이러한 작업은 유한 시간 안에 종료할 것이다.

편의를 위하여, 그림 4와 같은 영역 내부의 정수 점의 개수를 $\displaystyle f \left( x _0, y _0, \frac{a}{b}, \frac{c}{d} \right)$ 로 나타내자. 이에 대한 엄밀한 정의는 다음과 같다.

음이 아닌 정수 $x _0$ , $y _0$ 과 페리 이웃한 두 기약분수 $\displaystyle \frac{a}{b}$ , $\displaystyle \frac{c}{d}$ 에 대하여,

점 $P \left( x _0, y _0 \right)$ 을 잡고

점 $P$ 로부터 각각 기울기 $\displaystyle - \frac{a}{b}$ , $\displaystyle - \frac{c}{d}$ 의 접선을 그어 교점 $Q$ , $R$ 를 잡았을 때

직선과 곡선으로 닫힌 삼각 영역 $PQR$ 내부의 정수 점의 개수를 $\displaystyle f \left( x _0, y _0, \frac{a}{b}, \frac{c}{d} \right)$ 로 정의한다.

인자가 상기한 조건을 만족하지 않으면, 편의상 $\displaystyle f \left( x _0, y _0, \frac{a}{b}, \frac{c}{d} \right) = 0$ 으로 정의한다.

그림 4: 점 $P$ , $Q$ , $R$ 과 회색 삼각 영역

$\displaystyle f \left( x _0, y _0, \frac{a}{b}, \frac{c}{d} \right)$ 의 정의에서 사용되는 세 점을 나타내었다.

우리는 결국 $\displaystyle f \left( x _0, y _0, \frac{a}{b}, \frac{c}{d} \right)$ 가 0이 될 때까지 재귀적으로 탐색을 이어나가야 한다. 따라서, 이 함숫값을 계산할 수 있어야 한다. 이를 어떻게 계산할 수 있을까?

그림 4의 두 접선을 각각 새로운 축으로 잡고, 점 $P$ 를 원점으로 생각한 새로운 좌표계 $u-v$ 를 생각하자. $u$ 축이 직선 $PR$ , $v$ 축이 직선 $PQ$ 이다. 이 경우 회색 영역은 다음과 같이 변환된다.

그림 5: 변환된 새로운 영역

드디어 우리는 재귀적으로 정수 점의 개수를 셀 수 있게 되었다!

시간 복잡도

재귀적으로 변하는 접선의 기울기는 Stern-Brocot Tree에서 경로를 따라 아래로 내려가는 것과 같으므로, 시간 복잡도를 아래와 같이 쓸 수 있다.

O \left( \sum _{ ad - bc = 1 } I \left[ \sqrt{ \frac{N}{ c/d } } - \sqrt{ \frac{N}{ a/b } } \ge b + d \right] \right)

= O \left( \sum _{ ad - bc = 1 } I \left[ \frac{ \sqrt{bc + 1} - \sqrt{bc} }{ \sqrt{ac} } \ge \frac{ b + d }{ \sqrt{N} } \right] \right)

= O \left( \sum _{ ad - bc = 1} I \left[ \frac{1}{ \sqrt{ab} c } \ge \frac{b+d}{\sqrt{N}} \right] \right) = O \left( \sum _{ad - bc = 1} I \left[ ab c^2 \left( b + d \right)^2 \ge N \right] \right)

마지막 줄에서는 $\displaystyle \sqrt{x+1} - \sqrt{x} = O \left( \frac{1}{ \sqrt{x} } \right)$ 가 사용되었다.

이제, $t = bc$ 치환을 적용하면,

O \left( \sum _{t} \sum _{ b | t} \sum _{ a | (t+1) } I \left[ \frac{t^4}{ab} + t^3 + ab t^2 \ge N \right] \right)

= O \left( \sum _{t = 1}^{N^{1/3}} \sigma(t) \sigma(t+1) \right) = O \left( \sum _{t=1}^{N^{1/3}} \sigma^2 (t) \right)

엄밀한 증명이나 식 전개는 생략하였다.

이제, 다음의 잘 알려진 정리를 적용하자.

$\sum _{k=1}^{N} \sigma^2 (k) = \Theta \left( N \lg^3 N \right)$

즉, 서술한 알고리즘의 시간 복잡도는 $\displaystyle O \left( N^{ \frac{1}{3} } \lg^3 N \right) = \tilde{O}\left( N^{ \frac{1}{3} } \right)$ 임을 알 수 있다.

결론

수론적 함수는 정수론 뿐만 아니라 컴퓨터과학, 알고리즘, PS 분야에도 사용될 정도로 중요하며 그 폭이 아주 넓다.

우리는 대표적인 수론적 함수 $\sigma (n)$ 의 구간 합 $\displaystyle \sum _{k=1}^{N} \sigma(k)$ 을 효율적으로 계산하는 알고리즘에 대하여 알아보았다.

일반적인 식 전개로는 $\displaystyle O \left( \sqrt{N} \right)$ 까지 시간 복잡도를 줄일 수 있었다. 그러나, $N$ 이 아주 큰 수라면 이 방법도 아직은 느리다.

우리는 $\displaystyle y = \frac{N}{x}$ 그래프와 구하고자 하는 값과의 관계를 알아내고, 그래프의 볼록성이라는 기하적 특성과 Stern-Brocot Tree 자료구조를 활용하여, 재귀적으로 값을 계산하는 새로운 알고리즘을 조사하였다.

또한, 이 알고리즘의 시간 복잡도가 $\displaystyle \tilde{O} \left( N^{1/3} \right)$ 로 아주 효율적임을 밝혔다.

이러한 알고리즘의 아이디어는 다양한 볼록 함수에 대하여 접목시킬 수 있으며, 그 응용성이 높다. 다음 글에는 $\sigma (n)$ 외에 다른 수론적 함수의 구간 합을 효율적으로 계산하는 방법에 대하여 알아본다.

영 타블로의 조합론적 의미와 알고리즘적 응용 (1)

2021-09-19T22:43:07+09:00

개요

영 타블로(Young tableaux)는 20세기 초반, 알프레드 영(Alfred Young)이 제안한 객체로, 조합론에서 군(Group)을 표현할 때 유용하게 사용할 수 있는 특수한 형태의 행렬이다.

본 글은 다소 어려운 개념인 영 타블로를 쉽게 서술하고, 조합론적인 의미를 설명하며, 이를 활용하여 얻을 수 있는 효율적인 알고리즘과 새로운 문제 해결 관점 등을 소개하고자 한다.

본문은 특별한 배경지식을 가지지 않아도 읽고 이해할 수 있도록 작성되었다.

용어의 정의

영 다이어그램

영 타블로에 대하여 이야기하기 전에, 먼저 영 다이어그램(Young diagram)을 정의하자.

$\lambda = \left( \lambda _1, \lambda _2, \cdots, \lambda _k \right)$ 가 다음 조건을 모두 만족할 때, $\lambda$ 를 $N$ 의 자연수 분할이라고 하며, $\lambda \vdash N$ 이라고 표기하자.

$\lambda _1, \lambda _2, \cdots, \lambda _k$ 는 모두 양의 정수

$\lambda _1 \ge \lambda _2 \ge \cdots \ge \lambda _k > 0$

$\displaystyle \sum _{i = 1}^{k} \lambda _i = N$

양의 정수 $N$ 의 자연수 분할 $\lambda$ 가 주어지면, 우리는 " $\lambda$ 의 형태를 가지는 영 다이어그램"을 다음과 같이 정의할 수 있다.

$\lambda = \left( \lambda _1, \lambda _2, \cdots, \lambda _k \right)$ 의 형태를 가지는 영 다이어그램은

$k$ 개의 행으로 이루어진 표이며,

$i$ 번째 행의 길이는 $\lambda _i$ 이다 $(1 \le i \le k)$ .

영 다이어그램은 페러스 다이어그램(Ferrers diagram)이라고 부르기도 한다. 예를 들어, $(4, 2, 2, 1)$ 의 형태를 가지는 영 다이어그램은 아래의 그림과 같다.

그림 1: $(4, 2, 2, 1)$ 형태의 영 다이어그램

영 타블로

영 다이어그램의 각 칸에 양의 정수를 적자. 수를 어떻게 적냐에 따라서 표준 영 타블로(Standard Young tableaux) 혹은 준표준 영 타블로(Semistandard Young tableaux)를 정의할 수 있다.

$1$ 부터 $N$ 까지 서로 다른 양의 정수를 각 칸에 적고

각 행에 대하여, 왼쪽에서 오른쪽으로 갈 수록 수가 증가하고

각 열에 대하여, 위에서 아래로 갈 수록 수가 증가하면

이를 표준 영 타블로라고 부른다.

각 행에 대하여, 왼쪽에서 오른쪽으로 갈 수록 수가 감소하지 않고

각 열에 대하여, 위에서 아래로 갈 수록 수가 증가하면

이를 준표준 영 타블로라고 부른다.

그림 1에서 그림 2와 같이 수를 채웠다면, 이는 $(4, 2, 2, 1)$ 형태의 표준 영 타블로가 된다. 영 타블로에서 각 수가 등장하는 횟수를 기록한 벡터를 "영 타블로의 가중치"라고 부른다. 모든 표준 영 타블로의 가중치는 $(1, 1, \cdots, 1)$ 임이 자명하다. 표준 영 타블로에서 1번 조건은 필요에 따라 무시할 수 있다.

그림 2: $(4, 2, 2, 1)$ 형태의 표준 영 타블로

$(4, 2, 2, 1)$ 형태의 영 다이어그램에서 $1$ 부터 $9$ 까지 수를 조건에 맞게 칸에 채워 넣었음을 확인할 수 있다.

치우친 영 타블로

이제, 두 개의 자연수 분할 $\lambda = \left( \lambda _1, \lambda _2, \cdots, \lambda _k \right)$ 과 $\mu = \left( \mu _1, \mu _2, \cdots, \mu _{k'} \right)$ 을 생각하자. 모든 $i$ 에 대하여, $\mu _i \le \lambda _i$ 가 성립하면, " $\lambda / \mu$ 형태의 치우친 영 타블로"를 정의할 수 있다.

$\lambda / \mu$ 형태의 치우친 영 타블로는

$i$ 번째 행이 $\lambda _i$ 개의 칸으로 이루어져 있으며

$i$ 번째 행 앞에 $\mu _i$ 개의 빈 칸이 있는

영 타블로를 의미한다.

예를 들어, $(9, 7, 5, 1) / (5, 3, 2)$ 형태의 치우친 표준 영 타블로는 아래와 같다.

그림 3: $(9, 7, 5, 1) / (5, 3, 2)$ 형태의 치우친 표준 영 타블로

오른쪽 그림은 왼쪽 그림의 빈 칸을 명시적으로 표현한 것이다.

이제, 영 타블로를 조합론적으로 어떻게 활용할 수 있는지 알아보자.

영 타블로의 조합론적 해석

영 타블로는 순열 그 자체와, LIS와 같이 순열이 가지는 복잡한 특성 등을 시각적으로 이해할 수 있도록 도와준다. 대표적으로, Robinson–Schensted–Knuth correspondence는 표준 영 타블로와 순열을 대응하는 효과적인 방법을 제시한다.

RSK 대응 알고리즘에 대하여 알아보기 전에, 표준 영 타블로에 대한 몇 가지 중요한 연산을 정의하자.

행 삽입 연산

먼저, 행 삽입 연산 $S \leftarrow x$ 를 정의하자.

표준 영 타블로 $S$ 와 양의 정수 $x$ 에 대하여, 행 삽입 연산 $S \leftarrow x$ 는 다음과 같이 정의된다.

현재 확인하고 있는 행에 대하여, 그 행에서 $x$ 보다 큰 수 중에서 가장 작은 수를 $y$ 라고 하자. 처음에는 첫 번째 행부터 확인한다.

만일, 그러한 $y$ 가 존재하지 않는다면, 그 행의 마지막에 $x$ 를 추가하고, 삽입 연산 작업을 종료한다.

만약 그러한 $y$ 가 존재한다면, 수 $y$ 를 $x$ 로 바꾼다.

$x$ 의 값을 $y$ 로 설정한 후, 아래 행으로 넘어가서 과정 1.부터 다시 수행한다.

그림 4는 표준 영 타블로 $(2, 5, 9)(6, 7)(8)$ 에 수 $3$ 을 행 삽입하는 과정을 보여준다.

그림 4: $(2, 5, 9)(6, 7)(8) \leftarrow 3$ 연산 과정

중간 과정에서 괄호 안에 있는 빨간 수는 현재의 $x$ 값을 의미한다.

열 삽입 연산

유사하게, 열 삽입 연산 $x \rightarrow S$ 또한 정의할 수 있다.

표준 영 타블로 $S$ 와 양의 정수 $x$ 에 대하여, 열 삽입 연산 $x \rightarrow S$ 는 다음과 같이 정의된다.

현재 확인하고 있는 열에 대하여, 그 열에서 $x$ 보다 큰 수 중에서 가장 작은 수를 $y$ 라고 하자. 처음에는 첫 번째 열부터 확인한다.

만일, 그러한 $y$ 가 존재하지 않는다면, 그 열의 마지막에 $x$ 를 추가하고, 삽입 연산 작업을 종료한다.

만약 그러한 $y$ 가 존재한다면, 수 $y$ 를 $x$ 로 바꾼다.

$x$ 의 값을 $y$ 로 설정한 후, 오른쪽 열로 넘어가서 과정 1.부터 다시 수행한다.

그림 5는 표준 영 타블로 $(2, 5, 9)(6, 7)(8)$ 에 수 $3$ 을 열 삽입하는 과정을 보여준다.

그림 5: $3 \rightarrow (2, 5, 9)(6, 7)(8)$ 연산 과정

과연, 행 삽입 연산 혹은 열 삽입 연산 후에도 표준 영 타블로의 조건을 모두 만족할까? 아래의 정리는 우리의 궁금증에 대하여 긍정적인 답을 내놓는다.

삽입 연산의 정당성 정리

두 삽입 연산 $S \leftarrow x$ 와 $x \rightarrow S$ 의 결과는 모두 표준 영 타블로이다.

행 삽입 연산 $S \leftarrow x$ 에 대해서만 살펴보자. 열 삽입 연산 $x \rightarrow S$ 는 행과 열의 역할을 바꾸어 동일하게 증명하면 된다.

과정을 반복함에 따라, $y$ 가 위치한 칸은 항상 아래로 진행하며, 오른쪽으로는 절대 진행하지 않는다. 따라서, 표준 영 타블로의 조건 2.와 3.을 만족한다.

마지막으로 살펴보아야 하는 점은, 아래의 행이 윗 행보다 길이가 길어지지 않는지 확인하는 것이다. 길이가 같은 인접한 두 행을 잡자. 앞에서 이야기 했듯이, $y$ 가 위치한 칸은 오른쪽으로 진행하지 않으므로, 윗 행에서 치환이 발생하였다면, 아래 행에서 조건을 만족하는 수 $y$ 를 반드시 찾을 수 있다. 즉, 아래 행에서 과정 2.가 진행되지 않으므로, 연산의 결과는 표준 영 타블로이다.

즉, 두 삽입 연산은 잘 정의되어 있음을 알 수 있다.

삭제 연산

마지막으로, 삭제 연산을 정의하자. 표준 영 타블로 $S$ 에서 칸 $(s, t)$ 를 삭제하는 연산은 다음과 같이 정의된다.

표준 영 타블로 $S$ 의 $s$ 번째 행, $t$ 번째 열의 칸 $(s, t)$ 에 적힌 수 $x := S_{s, t}$ 를 삭제하는 연산은 다음과 같다.

만약 현재 확인하고 있는 행이 첫 번째 행이라면, $x$ 를 제거한 후, 삭제 연산 작업을 종료한다. 처음에는 $x$ 가 있는 행부터 확인한다.

현재 확인하고 있는 행의 위쪽 행에 대하여, 그 행에서 $x$ 보다 작은 수 중에서 가장 큰 수를 $y$ 라고 하자.

수 $y$ 를 $x$ 로 바꾼다.

$x$ 의 값을 $y$ 로 설정한 후, 윗 행으로 넘어가서 과정 1.부터 다시 수행한다.

이때, 칸 $(s, t)$ 는 모퉁이에 위치하여야 한다. 즉, 두 칸 $(s+1, t)$ 과 $(s, t+1)$ 가 존재하지 않아야 한다.

위 연산 작업의 과정 2.에서 $y$ 가 유일하게 존재함이 보장된다. 이는 표준 영 타블로의 정의를 이용하여 귀납법으로 증명할 수 있다. 아래의 그림은 표준 영 타블로 $(2, 3, 9)(5, 7)(6)(8)$ 에서 칸 $(4, 1)$ 을 삭제하는 연산 과정을 보여준다.

그림 6: $(2, 3, 9)(5, 7)(6)(8)$ 에서 칸 $(4, 1)$ 삭제 연산 과정

당연하게도, 삭제 연산 후에도 표준 영 타블로의 모든 조건을 만족하는지 확인해야 한다. 예상했겠지만, 아래의 정리에 의하여 이는 옳다.

삭제 연산의 정당성 정리

삭제 연산의 결과는 표준 영 타블로이다.

삭제하는 칸 $(s, t)$ 는 모퉁이에 위치함에 유의하자. 즉, 위에 있는 행이 아래에 있는 행보다 더 짧아지는 경우는 발생하지 않는다.

과정 2.에서 $y$ 의 정의에 따라, 각 행의 수가 증가하는 형태임은 자명하다.

과정 2.에서 $y$ 의 존재성 증명으로부터, 과정을 반복함에 따라, $y$ 가 위치한 칸은 항상 위로 진행하며, 절대로 왼쪽으로는 진행하지 않는다. 따라서, 삭제 연산의 결과를 볼 때, 각 열의 수 또한 증가하는 형태임을 알 수 있다. 즉, 삭제 연산의 결과는 표준 영 타블로이다.

이렇듯, 위에서 제시한 세 개의 연산은 모두 잘 정의되어 있다.

이제, 연산을 자유롭게 사용하기 위하여 필요한, 아주 중요한 정리들을 소개한다.

역연산 정리

삭제 연산과 행 삽입 연산은 서로 역연산 관계이다.

즉, 표준 영 타블로 $S$ 에 행 삽입 연산을 하여 칸 $\left( s _1, t _1 \right), \left( s _2, t _2 \right), \cdots, \left( s _n, t _n \right)$ 을 생성하였다면, 칸 $\left( s _n, t _n \right), \left( s _{n-1}, t _{n-1} \right), \cdots, \left( s _1, t _1 \right)$ 에 대하여 순차적으로 삭제 연산을 적용하면 원래의 $S$ 를 얻을 수 있다.

$n=1$ 일 때만 보이면 충분하다. $n > 1$ 인 경우에는 $n$ 에 대한 귀납법으로 쉽게 증명할 수 있다.

$S \leftarrow x$ 연산을 하여, 칸 $(s, t)$ 가 생성되었다고 가정하자. 행 삽입 연산을 수행할 때, 각 과정에서 사용된 $x$ 값을 $x _1, x _2, \cdots, x _m$ 과 같이 나열하자. 즉, $x _1 = x$ 이며, $S \leftarrow x$ 연산의 결과를 볼 때, 칸 $(s, t)$ 에 적힌 값은 $x _m$ 이다.

여기서 칸 $(s, t)$ 에 대하여 삭제 연산을 수행하자. 귀납법을 적용하여, $i$ 번째 행에 삽입하는 수가 $x _i$ 와 동일하다고 가정하자. 적당한 $k$ 가 존재하여, $S _{i-1, k} < x _{i-1} < x _i < S _{i-1, k+2}$ 로 나타낼 수 있기에, $i-1$ 번째 행에서 삽입하는 수는 $x _{i-1}$ 가 되어야만 한다.

따라서, 삭제 연산의 과정은 정확하게 행 삽입 연산의 과정을 역순으로 나열한 것과 같다.

이제, RSK 대응 알고리즘을 맞이할 준비를 모두 끝냈다.

RSK 대응 알고리즘

길이 $k$ 의 순열 $X = \left( x _1, x _2, \cdots, x _k \right)$ 에 대하여, $P _X$ 와 $Q _X$ 를 다음과 같의 정의하자.

$P _X := \left( \left( \cdots \left( \left( x _1 \leftarrow x _2 \right) \leftarrow x _3 \right) \leftarrow \cdots \right) \leftarrow x _k \right)$

즉, 반복적으로 수 $x _i$ 를 행 삽입한 표준 영 타블로.

$Q _X$ 는 $P _X$ 와 동일한 형태의 영 다이어그램에 다음과 같은 규칙으로 수를 채워넣은 표이다.

$P _X$ 를 생성하는 과정에서, 수 $x _i$ 를 행 삽입할 때, 새롭게 생긴 칸을 $\left( s _i, t _i \right)$ 라고 하자.

$Q _X$ 의 칸 $\left( s _i, t _i \right)$ 의 값은 $i$ 로 정의한다.

행 삽입 연산의 정당성 증명을 통하여, $Q _X$ 가 표준 영 타블로임을 바로 확인할 수 있다.

상당히 복잡하다. 예를 들어, 순열 $X = (1, 5, 3, 2, 6, 7, 4)$ 에 대하여 RSK 대응을 수행한 결과는 아래와 같다.

그림 7: 순열 $X = (1, 5, 3, 2, 6, 7, 4)$ 의 RSK 대응, $P _X$ 와 $Q _X$

$P _X$ 와 $Q _X$ 는 모두 조건 1.까지 만족하는 표준 영 타블로임을 알 수 있다.

세 명의 천재 수학자 Robinson과 Schensted, Knuth에 따르면, 다음과 같은 강력한 조합적 관계가 성립한다고 한다.

RSK 대응 정리

길이 $N$ 의 순열과, 서로 같은 형태의 두 표준 영 타블로는 RSK 대응 알고리즘을 통하여 서로 일대일 대응된다.

동일한 형태의 두 표준 영 타블로 $P$ , $Q$ 가 주어졌을 때, $P _X = P$ 와 $Q _X = Q$ 를 만족하는 순열 $X = \left( x _1, x _2, \cdots, s _N \right)$ 를 찾을 수 있음을 보이면 된다.

$Q$ 에서 수 $i$ 가 적힌 칸을 $\left( s _i, t _i \right)$ 라고 하자. $i$ 를 $N$ 부터 $1$ 까지 차례대로 보면서, $P$ 에서 $\left( s _i, t _i \right)$ 에 대한 삭제 연산을 수행하였을 때 지워지는 수를 $x _i$ 로 정의하면 된다.

이렇게 얻어진 순열 $X$ 에 대하여, $X$ 와 $(P, Q)$ 가 서로 대응됨은 역연산 정리에 의하여 분명하다.

RSK 대응 정리에 따라, 다음 따름정리를 얻는다.

RSK 따름정리

$\lambda$ 형태의 표준 영 타블로의 개수를 $t _\lambda$ 라고 하자. 양의 정수 $N$ 에 대하여 다음이 성립한다.
$\sum _{ \lambda \vdash N } \left( t _\lambda \right)^2 = N!$

우리는 자연수 분할과 표준 영 타블로의 가짓수, 순열에 관한 중요한 항등식을 얻었다.

이를 조합론적으로 어떻게 활용할 수 있는지는 다음 포스트에 이어서 설명한다.

결론

영 타블로와 세 가지 연산의 정의를 살펴보고, 역연산 정리 등 아주 중요한 정리를 제시하였다

조합론적으로 중요한 의미를 지닌 RSK 대응 알고리즘에 대하여 알아보았으며, 이 알고리즘은 순열과 표준 영 타블로 쌍을 일대일 대응시킴을 RSK 대응 정리를 통하여 증명하였다. 이로부터, 영 타블로의 가짓수에 대한 중요한 항등식을 얻을 수 있었다.

다음 포스트에는 RSK 대응 정리를 대칭 행렬과 같은 특수 군에 적용하여 영 타블로의 새로운 성질을 조사하고, 이를 통하여 순열의 LIS 등에 관한 새로운 접근 방법을 소개한다.

트리를 활용한 새로운 효율적인 수열 쿼리 알고리즘

2021-07-18T08:10:04+09:00

개요

그래프란 정점과 간선으로 구성된 자료구조로, 버스 노선 설계와 같은 생활속 문제부터 다양한 학술 분야의 이론까지 폭넓게 도입할 수 있다.

트리란 그래프의 일종으로 사이클이 없으며 연결성을 가진다는 강력한 조건을 가져 알고리즘 설계에 자주 사용된다.

본 글은 수열에서 특정 조건을 만족하는 순서쌍의 개수를 세는 복잡한 쿼리를, 트리를 활용하여 효율적으로 처리하는 새로운 알고리즘을 소개한다.

본문은 아래의 내용을 부가적인 설명 없이 서술한다. 각 항목에 대하여 자세하게 서술한 좋은 글을 링크해두었다.

문제 제기

수열 쿼리 문제

다음과 같은 문제를 생각하자.

길이 $N$ 의 수열 $A = \left\{ A _1, A _2, \cdots, A _N \right\}$ 가 주어진다.

아래와 같이 두 종류의 쿼리가 존재한다:

$1 \le i \le N$ 과 $x$ 가 주어진다. $A _i$ 의 값을 $x$ 로 변경한다.

$1 \le i < j \le N$ 과 $\max \left\{ A _{i+1}, A _{i+2}, \cdots, A _{j-2}, A _{j-1} \right\} < A _i = A _j$ 을 모두 만족하는 순서쌍 $(i, j)$ 의 개수를 센다.

$Q$ 개의 쿼리가 주어진다. 이 쿼리를 순차적으로 처리할 때, 2번 쿼리에 대한 답을 반환하라.

2번 쿼리는 다음과 같이 해석할 수 있다:

$N$ 개의 전봇대가 일렬로 배열되어 있으며, $i$ 번째 전봇대의 높이는 $A _i$ 이다.

다른 전봇대와 교차하지 않도록 두 전봇대 $i$ , $j$ 사이에 전선을 놓을 수 있을 때, 그러한 순서쌍 $(i, j)$ 의 개수를 세어라.

예제

$N = 6$ , $A = \left\{ 2, 1, 1, 2, 3, 2 \right\}$ 라고 하자.

$Q = 5$ 개의 쿼리가 순서대로 ["2번 쿼리", "1번 쿼리, $i = 5$ , $x = 2$ ", "2번 쿼리", "1번 쿼리, $i = 2$ , $x = 3$ ", "2번 쿼리"]라고 하자.

먼저, $(1, 4)$ 과 $(2, 3)$ , 두 개의 순서쌍이 2번 쿼리의 조건을 만족하므로, 첫 번째 쿼리의 답은 $2$ 이다.

두 번째 쿼리에 의하여 $A _5 = 2$ 가 되었고, $A = \left\{ 2, 1, 1, 2, 2, 2 \right\}$ 이다.

이제, $(1, 4)$ , $(2, 3)$ , $(4, 5)$ , $(5, 6)$ 의 순서쌍이 조건을 만족한다. 따라서, 세 번째 쿼리의 답은 $4$ 이다.

네 번째 쿼리는 $A _2$ 의 값을 $3$ 으로 변경한다. $A = \left\{ 2, 3, 1, 2, 2, 2 \right\}$ .

마지막 쿼리의 답은, $(4, 5)$ 과 $(5, 6)$ 만 조건을 만족하므로, $2$ 이다.

그림 1: 예제의 시각화

회색 기둥은 전봇대를, 주황색 선은 전선을 의미한다.

가장 단순한 접근

2번 쿼리를 빠르게 해결하는 가장 단순한 알고리즘을 찾아보자.

먼저, 모든 $\displaystyle \frac{N \times (N-1)}{2}$ 개의 순서쌍 $(i, j)$ 에 대하여 부등식 조건을 만족하는지 선형 시간 $O(j-i+1)$ 에 확인하면, 하나의 쿼리를 $O \left( N^3 \right)$ 에 해결할 수 있다.

세그먼트 트리 등의 자료구조를 이용하여 구간의 최댓값을 $O \left( \lg N \right)$ 에 답할 수 있다면, 시간 복잡도를 $O \left( N^2 \lg N \right)$ 까지 낮출 수 있다.

$i$ 를 고정한 후, $j$ 를 점차 증가하면서 구간 $[i+1, j-1]$ 의 최댓값을 잘 관리해주면, 시간 복잡도를 $O \left( N^2 \right)$ 로 개선할 수 있다.

이제 다음과 같은 중요한 관찰이 필요하다.

각 $j$ 에 대하여, 순서쌍 $(i, j)$ 가 부등식 조건을 만족하는 그러한 $i$ 는 많아야 한 개 존재한다.

그러한 $i$ 가 두 개 이상 존재하면, 제일 작은 $i$ 에 대하여 순서쌍 $(i, j)$ 는 부등식 조건을 만족할 수 없다.

그림 2: 첫 번째 관찰의 모식도

$\left( i_1, j \right)$ 과 $\left( i_2, j \right)$ 는 모두 조건을 만족하는 순서쌍이 될 수 없다.

$i < j$ 이고 $A _i \ge A _j$ 라면, 모든 $i' < i$ 에 대하여 순서쌍 $(i', j)$ 는 부등식 조건을 만족할 수 없다.

구간 $[i' + 1, j - 1]$ 의 최댓값이 이미 $A _i$ 이상이고, 이는 $A _j$ 이상이므로, 이 관찰은 성립한다.

그림 3: 두 번째 관찰의 모식도

$A _i$ 가 이미 $A _j$ 이상이므로, $\left( i', j \right)$ 는 조건을 만족하는 순서쌍이 될 수 없다.

위의 관찰은 우리에게 스택을 활용한 알고리즘을 제시한다.

먼저, $j$ 를 $1$ 부터 $N$ 까지 증가하면서, 어떤 $j' \ge j$ 에 대하여 순서쌍 $(i, j')$ 가 부등식 조건을 만족할 '가능성'이 있는 모든 $i$ 를 스택으로 관리하자.

전봇대 표현을 빌리자면, $j$ 번 전봇대에서 앞쪽을 바라보았을 때 보이는 모든 전봇대의 번호를 스택이 순서대로 가지고 있는다.

이때, $j$ 가 증가함에 따라 스택을 쉽게 관리할 수 있으며, 스택을 통하여 조건을 만족하는 순서쌍 $(i, j)$ 를 쉽게 찾을 수 있다.

이에 대한 자세한 방법은 아래의 코드로 제시한다:

S = [] # Stack consisting of indices
AnswerPairs = [] # Answer Pairs

for i in range(1, N+1):
  while S and A[S[-1]] < A[i]: # until S is not empty and A[S.top()] < A[i]
    S.pop()
  if S and A[S[-1]] == A[i]:
    AnswerPairs.append( (S[-1], i) ) # Found a pair! (S.top(), i)
    S.pop()
  S.append(i)

$1$ 부터 $N$ 까지 $N$ 개의 수는 스택에 오직 한 번 삽입되고, 한 번 삭제된다.

따라서, 2번 쿼리 당 시간 복잡도는 $O \left( N \right)$ 이며, 전체 시간 복잡도는 $O \left( NQ \right)$ 이다.

또한, 부등식 조건을 만족하는 순서쌍은 많아봐야 $N-1$ 개임을 알 수 있다.

이제, 2번 쿼리를 $O \left( N \right)$ 보다 빠르게 처리하는 방법을 알아보자.

문제에 대한 첨언

부등식 조건에서 등호 조건 $A _i = A _j$ 만 있다면, 값이 같은 수의 개수만 관리해주면 되기에 문제가 상당히 쉬워진다.

아래와 같이 C++의 std::map, Python의 dict을 활용하면, 1번 쿼리를 $O \left( \lg (N+Q) \right)$ , 2번 쿼리를 $O(1)$ 에 처리할 수 있다.

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

map<int, int> C;
vector<int> A;

ll Ans;
int N;

void init() {
  for(int i = 1; i <= N; i++) {
    Ans += C[A[i]];
    C[A[i]]++;
  }
}

// O(lg (N+Q))
void query1(int i, int x) {
  // Pop
  C[A[i]]--;
  Ans -= C[A[i]];
  
  // Modify
  A[i] = x;
  
  // Push
  Ans += C[x];
  C[x]++;
}

// O(1)
ll query2() {
  return Ans;
}

부등식 조건은 그 자체로도 상당히 다루기 어렵다. 구간의 양 끝 값이 같아야 한다는 '점 조건'과 구간의 최댓값이 양 끝 값보다 작아야 한다는 '구간 조건'이 같이 있으며, 두 조건을 서로 분리할 수 없기 때문이다.

단 한 번의 1번 쿼리 만으로도 부등식 조건을 만족하는 순서쌍을 $O \left( N \right)$ 개 변화시킨다.

$N = 2K + 1$ , $A = \left\{ K, K-1, \cdots, 2, 1, 0, 1, 2, \cdots, K-1, K \right\}$ 인 경우, $A _{K+1}$ 의 값이 무엇이냐에 따라서 순서쌍의 개수가 $0$ 부터 $K+1$ 까지 변화할 수 있다.

이는 곧, 조건을 만족하는 순서쌍을 효율적으로 관리하기 어려울 것임을 암시한다.

그림 4: 답이 급격하게 변하는 경우

$A_{K+1}$ 의 값에 따라서 답이 $0$ 부터 $K+1$ 까지 가능하다.

문제 해결

연속한 2번 쿼리는 항상 같은 답을 가진다.

따라서, 이제부터는 쿼리를 $(i, x)$ 로 표현하자. 이는, 1번 쿼리 $(i, x)$ 와 2번 쿼리를 합쳐 놓은 표현법이다.

즉, 하나의 쿼리는 "값 변경"과 "순서쌍 개수 세기"를 순서대로 수행하여야 한다.

트리 모델링

전봇대 표현을 사용하자.

부등식 조건을 만족하는 모든 순서쌍 $(i, j)$ 에 대하여, $i$ 번 전봇대와 $j$ 번 전봇대 사이에 전선을 선분으로 표현하자.

$A _0 = A _{N+1} = \infty$ 로 한 후, $(0, N+1)$ 또한 조건을 만족한다고 하자. 각 선분을 정점으로 생각하면, 이들이 하나의 트리를 형성하는 것처럼 보인다.

그림 5: 전선의 트리화

보라색 원은 정점을, 보라색 점선은 간선을 의미한다. 전선이 하나의 트리를 형성한다.

이러한 추측은 참이다. 조건을 만족하는 순서쌍은 항상 서로 포함 관계에 있거나, 아니면 교집합을 가지지 않는다. 즉, Laminar set family를 이룬다.

Laminar set family에서 포함 관계를 가장 단순한 형태의 그래프로 표현하면, 여러 개의 트리로 이루어진 Forest가 된다.

여기서는 $(0, N+1)$ 가 하나의 원소이므로, 우리가 원했던 대로, 하나의 트리를 형성한다.

매 쿼리에 의하여 $A _i$ 의 값이 변화하면 트리 또한 바뀔 수 있다. 우리는 알고리즘의 효율성을 위하여 트리를 고정할 필요가 있다.

$Q$ 개의 쿼리에 의하여 한 번이라도 높이( $A _i$ 의 값)가 변화하는 전봇대를 '가변 전봇대'라고 부르자. 그렇지 않은 전봇대는 '불변 전봇대'이다.

$O \left( Q \right)$ 개의 가변 전봇대를 모두 무시한 채로, $O \left( N \right)$ 개의 불변 전봇대에 대해서 위와 같이 트리를 만들자.

여기서 확실한 점은 다음과 같다:

전선으로 연결 가능한 두 불변 전봇대 쌍은 모두 트리의 정점 중 하나이다.
전선으로 연결 가능한 두 가변 전봇대 쌍 혹은 불변-가변 전봇대 쌍은 트리로 알아낼 수 없으며, 매 쿼리마다 새롭게 세어줄 필요가 있다.

이제, 가변 전봇대를 고려할 때, 트리의 어떤 정점만이 실제로 가능한지를 생각해보자.

그림과 같이, 하나의 가변 전봇대는 이와 교차하는 몇 개의 트리 정점을 '비활성화'한다고 생각할 수 있다.

또한, 비활성화되는 그러한 모든 정점은, 자식부터 조상으로 올라가는 하나의 경로로 표현될 수 있다.

따라서, 다음을 효율적으로 처리할 수 있다면, 전선으로 연결 가능한 두 불변 전봇대 쌍의 개수를 셀 수 있다:

초기에, 트리의 모든 정점의 가중치는 $0$ 이다.
자식에서 조상으로 올라가는 경로가 주어질 때, 그 경로 위에 존재하는 모든 정점의 가중치를 $1$ 증가 혹은 감소시킨다. 단, 정점의 가중치가 음수가 되지 않음이 보장된다.
가중치가 정확하게 $0$ 인 정점의 개수를 센다.

정점의 가중치가 항상 $0$ 혹은 양수라는 강력한 조건 덕분에, Heavy-light decomposition을 이용하여 각 작업을 $O\left( \lg^2 N \right)$ 에 처리할 수 있다.

각 체인을 세그먼트 트리로 관리하며, 각 구간에서 가중치의 최솟값과 그러한 값을 가지는 정점의 개수를 관리하면 된다.

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100055;

struct NODE {
  NODE(int mn, int cnt) : mn(mn), cnt(cnt) {}
  
  int mn; // Min value
  int cnt; // # of min values
  
  // Merge two NODEs
  NODE operator + (const NODE &t) const {
    if(mn == t.mn)
      return NODE(mn, cnt + t.cnt);
    return mn < t.mn ? *this : t;
  }
  
  NODE operator + (int delta) const {
    return NODE(mn + delta, cnt);
  }
};

struct SEG {
  NODE node[MAXN*4];
  int delta[MAXN*4];
  
  // Segment i : [s, e] / Add r on [p, q]
  // O(lg^2 N)
  void upd(int i, int s, int e, int p, int q, int r) {
    if(q < s || e < p) return;
    if(p <= s && e <= q) {
      delta[i] += r;
      node[i].mn += r;
      return;
    }
    
    int m = (s+e) / 2;
    upd(i*2, s, m, p, q, r);
    upd(i*2+1, m+1, e, p, q, r);
    
    node[i] = node[i*2] + node[i*2+1] + delta[i];
  }
  
  // # of 0s
  int get() {
    return node[1].mn ? node[1].cnt : 0;
  }
} seg;

int hldrt[MAXN]; // HLD Chain Root
int ord[MAXN]; // DFS Ordering
int prt[MAXN]; // Parent
int dep[MAXN]; // Depth

// Add value x on the path [c, p]
// c : child, p : ancestor
// O(lg^2 N)
void pathUpdate(int c, int p, int x) {
  while(hldrt[c] != hldrt[p]) { // at most O(lg N) times
    // Update the whole chain
    seg.upd(1, 1, N, ord[hldrt[c]], ord[c], x); // O(lg N)
    c = prt[hldrt[c]];
  }
  
  // Now, c and p are on the same chain
  assert(hldrt[c] == hldrt[p]);
  
  // Update a partial path of the chain
  seg.upd(1, 1, N, ord[c], ord[p], x);
}

전선으로 연결할 수 있는 두 가변 전봇대 쌍과 불변-가변 전봇대 쌍은, 위에서 논의한 스택 알고리즘을 조금만 변형하면 $O \left( Q \lg N \right)$ 에 해결할 수 있다.

$A _i$ 의 절대적인 값보다는 값의 상대적인 순서가 중요하기에, 좌표 압축 기법을 적용한다면, $O \left( N \lg N \right)$ 의 전처리로 복잡도를 $O \left( Q \right)$ 까지 낮출 수 있다.

정리하면, 전처리 작업으로

$O \left( N \lg N \right)$ 에 좌표 압축 기법을 적용하고
스택 알고리즘을 이용하여 모든 트리 정점을 $O \left( N \right)$ 에 찾고
Union-find 혹은 Line sweeping, 스택 등 다양한 방법으로 $O(N)$ 에 트리를 실제로 구성한 후
HLD 전처리를 $O(N)$ 에 수행하면

총 시간 복잡도는 $O \left( N \lg N \right)$ 이다.

또한, 각 쿼리에 대하여

높이를 바꾸기 전에, $O \left( \lg^2 N \right)$ 에 그 전봇대와 교차하는 트리 정점의 가중치를 $1$ 감소한 후
높이를 바꾼 전봇대가 트리 정점과 교차하는, 그러한 정점이 이루는 경로의 양 끝 정점을 $O \left( \lg N \right)$ 에 찾고
$O \left( \lg^2 N \right)$ 에 그 경로의 가중치를 $1$ 증가하고
현재 전선으로 연결할 수 있는 두 불변 전봇대 쌍의 개수를 $O \left( \lg^2 N \right)$ 에 알아내며
두 가변 전봇대 쌍과 불변-가변 전봇대 쌍의 개수를 $O \left( Q \right)$ 에 세면

$O \left( \lg^2 N + Q \right)$ 의 시간 복잡도로 처리할 수 있다.

따라서, 전체 시간 복잡도는 $O \left( N \lg N + Q \lg^2 N + Q^2 \right)$ 이다.

기존 스택 알고리즘의 전체 시간 복잡도 $O \left( NQ \right)$ 보다는 빠르다고 말할 수 있다.

하지만, 여기서 약간의 처리만으로 복잡도를 더 낮출 수 있다.

제곱근 분할법

앞에서 논의하길, $O \left( N \lg N + Q \lg^2 N + Q^2 \right)$ 의 복잡도로 $Q$ 개의 쿼리를 처리할 수 있었다.

만약, $Q$ 개의 쿼리를 $D$ 개씩 분할하여, 전체 문제를 $\displaystyle \frac{Q}{D}$ 번에 걸쳐 해결하면 시간 복잡도가 어떻게 될까?

좌표 압축은 오직 한 번만 수행해도 된다는 점에 유의하여, 단순한 사칙연산을 적용하면

O \left( N \lg N + \frac{Q}{D} \times \left( N + D \lg^2 N + D^2 \right) \right) = O \left( N \lg N + \frac{QN}{D} + Q \lg^2 N + QD \right)

가 총 시간 복잡도가 됨을 알 수 있다.

여기서, $D = \sqrt{N}$ 일 때, 위의 복잡도가 최소가 되며, 이는 $O \left( N \lg N + Q \sqrt{N} \right)$ 이다.

정리하면, 쿼리를 $\sqrt{N}$ 개씩 나누어 처리하면, 각 쿼리를 $O \left( \sqrt{N} \right)$ 의 복잡도로 해결할 수 있다!

#include <bits/stdc++.h>
using namespace std;

const int MAXN = 100055;
const int MAXQ = 100055;

int A[MAXN];
int I[MAXQ], X[MAXQ];

int N, Q;

// Solve [s, e] queries
// We now can solve them in O( N + (e-s+1) lg^2 N + (e-s+1)^2 )
void solve(int s, int e);

int main() {
  cin >> N >> Q;
  for(int i = 1; i <= N; i++)
    cin >> A[i];
  for(int i = 0; i < Q; i++)
    cin >> I[i] >> X[i];
  
  
  // Coordinate compression
  // O(N lg N)
  vector<int> XV;
  
  for(int i = 1; i <= N; i++)
    XV.emplace_back(A[i]);
  for(int i = 0; i < Q; i++)
    XV.emplace_back(X[i]);

  sort(XV.begin(), XV.end());
  XV.erase(unique(XV.begin(), XV.end()), XV.end());
  
  for(int i = 1; i <= N; i++)
    A[i] = int(lower_bound(XV.begin(), XV.end(), A[i]) - XV.begin());
  for(int i = 0; i < Q; i++)
    X[i] = int(lower_bound(XV.begin(), XV.end(), X[i]) - XV.begin());
  
 
  // O(Q sqrt(N))
  for(int s = 0, e, d; s < Q; s = e+1) {
    d = min(Q-s+1, (int)(1.5 * sqrt(N))); // Sqrt Decomposition
    e = s+d-1;
    
    solve(s, e); // Solve [s, e] queries
    
    // Update A[i]s
    for(int i = s; i <= e; i++)
      A[I[i]] = X[i];
  }
  
  return 0;
}

결론

트리는 다방면에서 복잡한 현상을 단순화할 때 주로 사용되며, 여러 좋은 성질을 가지고 있기에 알고리즘 분야에서 애용된다.

우리는 두 가지 종류의 쿼리를 요구하는 복잡한 수열 문제를 트리에서의 연산으로 해석한 후 제곱근 분할법을 적용하여 효율적으로 해결하는 방법을 알아내었다.

여기서 다루지는 않았지만, 쿼리 시각에 대한 분할 정복 기법을 적용하면 쿼리당 시간 복잡도를 $O \left( \lg N \lg Q \right)$ 까지 개선할 수 있으며, 이는 추후에 다룰 것이다.

이렇듯 복잡한 문제를 가시화한 후, 잘 알려진 다른 문제로 환원하는 작업은 어려울 수 있으나 우리에게 더 깊은 통찰력을 줄 수 있다.

이번 포스트에서 다룬 문제는 가까운 시일 내에 BOJ에 업로드될 예정이다.

다양한 생성함수와 그 응용 (2)

2021-05-18T00:21:11+09:00

개요

본문은 아래의 포스트와 내용이 이어지며, 다음 포스트의 내용을 부가적인 설명 없이 서술한다.

다양한 생성함수와 그 응용 (1)

이번에는 생성함수를 어떻게 실제 PS 문제에 적용할 수 있는지 살펴본다.

다변수 생성함수

이항계수의 생성함수

이항계수 $\displaystyle \binom{n}{k}$ 의 OGF를 유도하자.

먼저, 이항계수와 같은 값을 가지는 함수 $f(n, k)$ 를 귀납적으로 정의하자. 다음은 이항계수의 일반적인 귀납적 정의이다:

다음을 만족하는 함수 $f : \mathbb{Z}_{\ge 0}^2 \rightarrow \mathbb{R}$ 은 모든 음이 아닌 정수 $n$ , $k$ 에 대하여, $\displaystyle f(n, k) = \binom{n}{k}$ 를 만족한다.

모든 $n \ge 0$ 에 대하여, $f(n, 0) = 1$ .

모든 $n \ge 1$ 에 대하여, $f(0, n) = 0$ .

모든 $n \ge 1$ , $k \ge 1$ 에 대하여, $f(n, k) = f(n-1, k) + f(n-1, k-1)$ .

이변수 함수 $f(n, k)$ 의 OGF $F(x, y)$ 는 다음과 같이 정의하는 것이 자연스러울 것이다:

F(x, y) = \sum _{n = 0}^{\infty} \sum _{k = 0}^{\infty} f(n, k) x^n y^k

위의 식에서 점화식 $f(n, k) = f(n-1, k) + f(n-1, k-1)$ 를 적용하면, 다음과 같은 식을 얻는다:

\sum _{n = 1}^{\infty} \sum _{k = 1}^{\infty} f(n, k) x^n y^k = x \sum _{n = 1}^{\infty} \sum _{k = 1}^{\infty} f(n-1, k) x^{n-1} y^k + xy \sum _{n = 1}^{\infty} f(n-1, k-1) x^{n-1} y^{k-1}

이를 $F(x, y)$ 정의에 대입하자.

\sum _{n = 1}^{\infty} \sum _{k = 1}^{\infty} f(n, k) x^n y^k = F(x, y) - \sum _{n = 1}^{\infty} f(n, 0) x^n - \sum _{k = 1}^{\infty} f(0, k) y^k - f(0, 0) = F(x, y) - \sum _{n = 0}^{\infty} x^n

x \sum _{n = 1}^{\infty} \sum _{k = 1}^{\infty} f(n-1, k) x^{n-1} y^k + xy \sum _{n = 1}^{\infty} f(n-1, k-1) x^{n-1} y^{k-1}

= x \left( F(x, y) - \sum _{n = 0}^{\infty} f(n, 0) x^n \right) + xy F(x, y) = x \left( F(x, y) - \sum _{n = 0}^{\infty} x^n \right) + xy F(x, y)

따라서, $F(x, y)$ 에 관한 중요한 식 하나를 알아낼 수 있다:

F(x, y) - \sum _{n = 0}^{\infty} x^n = x \left( F(x, y) - \sum _{n = 0}^{\infty} x^n \right) + xy F(x, y)

F(x, y) - \frac{1}{1-x} = x \left( F(x, y) - \frac{1}{1-x} \right) + xy F(x, y)

F(x, y) = \frac{ 1 }{ 1 - x - xy }

정리하면, 이항계수 $\displaystyle \binom{n}{k}$ 의 OGF는 $\displaystyle \frac{1}{1-x-xy}$ 이다.

여기서, 식을 약간 조작하면 어렵지 않게 $F(x, y)$ 를 무한 급수 형태로 표현할 수 있다.

F(x, y) = \frac{1}{1-x-xy} = \frac{1}{1 - \left( x (y+1) \right)} = \sum _{n = 0}^{\infty} \left( x (y+1) \right)^n = \sum _{n = 0}^{\infty} x^n (y+1)^n

이로부터 다음과 같은 정리를 증명할 수 있다. 이항 정리를 증명하는 새로운 방법을 찾았다고 말할 수 있다.

이항 정리의 새로운 증명

모든 양의 정수 $n$ 에 대하여, 다음은 일변수 실수 항등식이다.
$(y + 1)^n = \sum _{k = 0}^{n} \binom{n}{k} y^k = \binom{n}{0} y^0 + \binom{n}{1} y^1 + \cdots + \binom{n}{n-1} y^{n-1} + \binom{n}{n} y^n$

$F(x, y)$ 에서 $x^n$ 의 계수를 살펴보자.

$\displaystyle F(x, y) = \sum _{k = 0}^{\infty} (y+1)^k x^k$ 이므로, $x^n$ 의 계수는 $(y+1)^n$ 이다.

또한, 정의에 따르면 $\displaystyle F(x, y) = \sum _{n = 0}^{\infty} \sum _{k = 0}^{\infty} f(n, k) x^n y^k = \sum _{n = 0}^{\infty} \left( \sum _{k = 0}^{\infty} f(n, k) y^k \right) x^n$ 이므로, $x^n$ 의 계수는 $\displaystyle \sum _{k = 0}^{\infty} f(n, k) y^k = \sum _{k = 0}^{\infty} \binom{n}{k} y^k$ 와도 같다.

따라서, 주어진 식은 항상 성립한다.

이제, $F(x, y)$ 를 다음과 같이 변형해보자:

F(x, y) = \frac{1}{1-x-xy} = \frac{1}{(1-x)-xy} = \frac{ \frac{1}{1-x} }{ 1 - \frac{x}{1-x} \cdot y }

= \frac{1}{1-x} \left( 1 + \frac{x}{1-x} \cdot y + \left( \frac{x}{1-x} \right)^2 \cdot y^2 + \cdots \right) = \frac{1}{1-x} \sum _{n = 0}^{\infty} \left( \frac{x}{1-x} \right)^n y^n

여기서, $F(x, y)$ 의 $y^n$ 의 계수가 $\displaystyle \frac{x ^n}{(1-x) ^{n+1}}$ 이라는 사실로부터 다음 정리를 증명할 수 있다.

이항계수의 OGF의 전개식

임의의 $x \in \mathbb{R}$ 와 $k \in \mathbb{Z}_{\ge 0}$ 에 대하여 다음이 성립한다.
$\sum _{n = 0}^{\infty} \binom{n}{k} x^n = \frac{ x^k }{ (1 - x)^{k+1} }$

이 정리는 다음과 같이 해석할 수 있다. $\displaystyle \frac{1}{(1-x)^{k+1}}$ 을 다항식의 형태로 전개하면 $x^{n-k}$ 의 계수가 $\displaystyle \binom{n}{k}$ 와 일치한다는 사실을 함의한다.

따라서, $\displaystyle \frac{1}{(1-x)^k}$ 의 다항 전개의 $x^n$ 의 계수는 $\displaystyle \binom{n+k-1}{k-1}$ 이다. 이는 추후에, 고정된 $k$ 에 대하여 $\displaystyle \binom{n}{k}$ 의 합에 관한 식을 서술해야 할 때 유용하게 사용할 것이다.

카탈랑 수열의 닫힌 형태

이전 포스트에서 카탈랑 수열 $\displaystyle \left\{ c_n \right\} _{n \in \mathbb{Z} _{\ge 0}}$ 의 OGF $C(x)$ 가 다음과 같음을 보였다:

C(x) = \frac{ 1 - \sqrt{ 1 - 4x } }{ 2x }

하지만, $C(x)$ 는 카탈랑 수 $c_n$ 의 닫힌 형태(Closed form expression)를 직접적으로 알려주지는 않는다. 이번에는 카탈랑 수의 닫힌 형태를 유도하고자 한다.

위에서 살펴본 이항계수 $\displaystyle \binom{n}{k}$ 는 복소수 범위까지 확장할 수 있다. 다음 정리는 그러한 확장 방법을 알려준다.

알려진 정의 (일반화된 이항계수)

복소수 $r \in \mathbb{C}$ 와 음이 아닌 정수 $n \in \mathbb{Z} _{\ge 0}$ 에 대하여, (확장)이항계수 $\displaystyle \binom{r}{n}$ 을 다음과 같이 정의한다:
$\binom{r}{n} = \frac{ r (r-1) \cdots (r - (n-1)) }{ n! }$

이제부터 언급하는 이항계수는 모두 일반화된 이항계수를 의미한다. 따라서, $\displaystyle \binom{n}{k}$ 에서 $n$ 가 음이 아닌 정수일 필요성이 사라졌음에 유의하자.

보조정리

임의의 복소수 $r \in \mathbb{C}$ 에 대하여 다음이 성립한다.
$(1+x)^r = \sum _{n = 0}^{\infty} \binom{r}{n} x^n$

엄밀하지는 않지만 가장 직관적인 증명은 이러하다. $(1+x)^r$ 의 다항 전개가 존재한다고 가정할 때, 양변의 $x^n$ 의 계수가 서로 같은지 살펴보자.

먼저, 좌변을 $n$ 번 미분한 식의 상수항은 다음과 같다:

\left. \frac{ \mathrm{d}^n }{ \mathrm{d} x^n } (1+x)^r \right\rvert _{x = 0} = r (r-1) \cdots (r - (n-1)) = n! \binom{r}{n}

우변을 $n$ 번 미분한 식의 상수항은 다음과 같다:

\left. \frac{ \mathrm{d}^n }{ \mathrm{d} x^n } \sum _{n = 0}^{\infty} \binom{r}{n} x^n \right\rvert _{x = 0} = n! \binom{r}{n}

따라서, 주어진 식은 항등식이다.

이제, 보조정리를 이용하면, $\displaystyle \sqrt{1 - 4x}$ 를 다음과 같이 표현할 수 있다:

\sqrt{1-4x} = \left( 1 - 4x \right)^\frac{1}{2} = \sum _{n = 0}^{\infty} \binom{ \frac{1}{2} }{ n } \left( -4x \right)^n

= \sum _{n = 0}^{\infty} \left( \frac{1}{2} \times \frac{-1}{2} \times \frac{-3}{2} \times \cdots \times \frac{-(2n - 3)}{2} \right) \cdot \frac{1}{n!} \times (-4)^n x^n

= 1 + \sum _{n = 1}^{\infty} \frac{ (-1)^{n-1} \left( 1 \times 3 \times \cdots \times (2n-3) \right) }{ 2^n } \cdot \frac{(-4)^n}{n!} x^n

= 1 + \sum _{n = 1}^{\infty} \frac{ -2^n \cdot (2n-2)! }{ 2^{n-1} \cdot (n-1)! } \cdot \frac{1}{n!} x^n

= 1 + \sum _{n = 1}^{\infty} -\frac{2}{n} \cdot \frac{(2n-2)!}{(n-1)!(n-1)!} x^n = 1 + \sum _{n = 1}^{\infty} - \frac{2}{n} \binom{2n-2}{n-1} x^n

즉, $C(x)$ 는 다음과 같이 무한 급수 형태로 나타낼 수 있다:

C(x) = \frac{ 1 - \sqrt{ 1 - 4x } }{ 2x } = \frac{1}{2x} \left( 1 - \left( 1 + \sum _{n = 1}^{\infty} -\frac{2}{n} \binom{2n-2}{n-1} x^n \right) \right) = \sum _{n = 1}^{\infty} \frac{ \binom{2n-2}{n-1} }{n} x^{n-1} = \sum _{n = 0}^{\infty} \frac{1}{n+1} \binom{2n}{n} x^n

정리하면, 아주 긴 여정 끝에 우리는 카탈랑 수의 닫힌 형태가 $\displaystyle c _n = \frac{1}{n+1} \binom{2n}{n}$ 임을 알아내었다. 생성함수로 수열의 새로운 성질을 알아낼 수 있다니, 놀랍지 않은가!

순열과 관련된 생성함수

어떤 순열 $p = \left( p _1, \cdots, p _n \right)$ 가 주어졌다면, 정점 $i$ 에서 $p _i$ 로 가는 간선으로 이루어진 그래프는 여러 개의 Disjoint한 사이클이 된다는 사실은 잘 알려져 있다. 또한, 역으로, Disjoint한 사이클을 하나의 순열 $p$ 로 표현할 수도 있다.

이번에는 사이클의 개수를 세는 문제를 순열로 해석한 후, 생성함수를 적용하여 해결하는 방법에 대하여 알아본다.

$k$ 개의 사이클로 이루어진 길이 $n$ 의 순열의 개수 세기

그러한 순열의 개수를 부호 없는 제1종 스털링 수라고 부른다.

그림 1: $n=4$ , $k=2$ 일 때 가능한 모든 그래프

$n=4$ , $k=2$ 일 때의 부호 없는 제1종 스털링 수는 $11$ 이다.

먼저, 하나의 사이클로 이루어진 길이 $n$ 의 순열의 개수를 $c _n$ 이라고 하자. 어렵지 않게, $c _n = (n-1)!$ 임을 보일 수 있다.

이제, 수열 $\displaystyle \left\{ c _n \right\} _{n \in \mathbb{Z} _{\ge 0}}$ 의 EGF를 $C(x)$ 라고 하자. 정의에 의하여 다음이 성립함에 유의하자:

C(x) = \sum _{n = 0}^{\infty} \frac{ c _n }{ n! } x^n

다시 원래 문제로 돌아오자. $k$ 를 고정하고, $n$ 가 주어졌을 때 그러한 순열의 개수를 $f _n$ 라고 하자. $n < k$ 에 대해서는 필요에 따라 무시해도 좋고, $f _n = 0$ 으로 생각해도 무방하다.

수열 $f$ 의 EGF를 $F(x)$ 라고 하자. 이제 우리는 $\displaystyle F(x) = \frac{1}{k!} C(x)^k$ 임을 보임으로써 문제를 해결할 것이다.

먼저, $n$ 개의 정점으로 이루어진 $k$ 개의 사이클을 생각하자. 각각의 사이클에 $1$ 부터 $k$ 까지 번호를 부여하고, $i$ 번 사이클의 크기를 $a _i$ 라고 하자. 자명하게도, $\displaystyle a _1 + \cdots + a _k = \sum _{i = 1}^{k} a _i = n$ 라야 한다.

$a _i$ 개의 정점으로 하나의 사이클을 만드는 방법은 총 $\displaystyle c _{a _i}$ 가지가 존재한다. 또한, 독립적으로 번호가 부여된 $k$ 개의 사이클을 하나의 순열로 합치는 방법은 총 $\displaystyle \frac{ n! }{ a _1 ! a _2 ! \cdots a _k ! }$ 가지가 있다.

따라서, 다음 식을 얻는다:

f _n = \frac{ n! }{ k! } \sum _{ a _1 + a _2 + \cdots + a _k = n } \frac{ c _{a _1} c _{a _2} \cdots c _{a _k} }{ a _1 ! a _2 ! \cdots a _k ! }

원래 문제에서는 사이클의 순서가 중요하지 않으므로, $k!$ 로 나누어주어야 함에 유의한다.

이전 포스트에서 "7. 분할" 성질에 따르면, $\displaystyle \sum _{ a _1 + a _2 + \cdots + a _k = n } \frac{ c _{a _1} c _{a _2} \cdots c _{a _k} }{ a _1 ! a _2 ! \cdots a _k ! }$ 는 $\displaystyle C(x)^k$ 의 $x^n$ 의 계수와 일치한다.

$F(x)$ 는 EGF이므로, 정리하면 $\displaystyle F(x) = \frac{1}{k!} C(x)^k$ 이다.

만약에 $k$ 와 $N$ 가 주어졌을 때, $n = 1, 2, \cdots, N$ 에서 답을 모두 구해야 한다고 하자. $\displaystyle F(x) = \frac{1}{k!} C(x)^k$ 를 전개하면 문제를 쉽게 해결할 수 있는데

$C(x)$ 의 처음 $O(N)$ 개의 계수를 $O(N)$ 에 계산할 수 있고
$\displaystyle C(x)^k = e^{ k \ln C(x) }$ 임을 이용하면, $\displaystyle C(x)^k$ 의 처음 $O(N)$ 개의 계수를 $O \left( N \lg N \right)$ 에 계산할 수 있으므로

전체 문제를 $O \left( N \lg N \right)$ 이라는 효율적인 시간 복잡도로 해결할 수 있다.

사이클의 길이가 집합 $S$ 의 원소인 길이 $n$ 의 순열의 개수 세기

이전에는 사이클의 개수에 제약이 있었다면, 이번에는 사이클의 길이에 제약이 생겼다.

유사하게 하나의 사이클로 이루어진 길이 $n$ 의 순열의 개수를 $c _n$ 이라고 하자. 다만, $n \not\in S$ 라면, $c _n = 0$ 로 정의하자. 이로부터 우리는 사이클의 길이가 집합 $S$ 의 원소임을 보장할 수 있다.

동일한 논리를 적용하여, $\displaystyle F(x) = \frac{1}{k!} C(x)^k$ 를 얻자. 모든 $k = 1, 2, \cdots, n$ 에 대하여 각각 답을 계산한 뒤 더하면, 이것이 우리가 원하는 답이 된다.

즉, $\displaystyle \sum _{k = 1}^{n} \frac{1}{k!} C(x)^k$ 의 $x^n$ 의 계수를 계산하면 된다. 이 값은 $\displaystyle \sum _{k = 0}^{\infty} \frac{1}{k!} C(x)^k = e^{ C(x) }$ 의 $x^n$ 의 계수와 동일하다.

따라서, 집합 $S$ 와 $n$ 가 주어졌을 때, 문제의 답을 $O \left( \left\lvert S \right\rvert + n \lg n \right)$ 에 효율적으로 알아낼 수 있다.

길이 $n$ 의 순열의 사이클의 개수의 기댓값

길이 $n$ 의 모든 순열이 생성하는 사이클의 개수의 합을 $g _n$ 라고 하자. 이 값을 $n!$ 으로 나누면 우리가 원하는 답이 된다.

수열 $g$ 의 EGF를 $G(x)$ 라고 하자. 편의를 위하여, 다항 전개가 가능한 식 $f(x)$ 에 대하여, $f(x)$ 의 $x^n$ 의 계수를 $\displaystyle \left[ x^n \right] f(x)$ 라고 표기하자. 이전과 동일한 논리를 사용하면, 다음 등식을 얻는다:

\left[ x^n \right] G(x) = \left[ x^n \right] \sum _{k = 1}^{n} k \cdot \frac{ C(x)^k }{ k! } = \left[ x^n \right] \sum _{k = 1}^{\infty} \frac{1}{(k-1)!} C(x)^k

= \left[ x^n \right] C(x) \left( \sum _{k = 0}^{\infty} \frac{ C(x)^k }{ k! } \right) = \left[ x^n \right] C(x) e^{ C(x) }

$c _n = (n-1)!$ 라는 사실로부터, 다음을 알 수 있다:

C(x) = \sum _{k = 1}^{\infty} \frac{ c _k }{ k! } x^k = \sum _{k = 1}^{\infty} \frac{ (k-1)! }{k!} x^k = \sum _{k = 1}^{\infty} \frac{ x^k }{k} = - \ln \left( 1 - x \right)

따라서, $\displaystyle C(x) e^{ C(x) } = - \frac{ \ln (1-x) }{ 1-x }$ 이다.

$\ln (1+x)$ 의 매클로린 급수는 $\displaystyle x - \frac{x^2}{2} + \frac{x^3}{3} - \frac{x^4}{4} + \cdots$ 이므로, $n \ge 1$ 라면 $\displaystyle \left[ x^n \right] \left( - \ln (1-x) \right) = \frac{1}{n}$ 이다.

고로, "8. 구간 합" 성질을 적용하면 다음을 알 수 있다:

\left[ x^n \right] \frac{ - \ln(1-x) }{ 1-x } = 1 + \frac{1}{2} + \cdots + \frac{1}{n} = \sum _{k=1}^{n} \frac{1}{k}

따라서, $\displaystyle \frac{g _n}{n!} = \left[ x^n \right] G(x) = \left[ x^n \right] \frac{ - \ln (1-x) }{ 1-x } = \sum _{k = 1}^{n} \frac{1}{k}$ 이다.

정리하면, 길이 $n$ 의 순열이 생성하는 사이클의 개수의 기댓값은 $n$ 번째 조화수 $\displaystyle 1 + \frac{1}{2} + \cdots + \frac{1}{n}$ 이다.

결론

이항계수의 이변수 생성함수를 유도하고, 이항계수 자체를 복소수 범위까지 확장시켰다. 이 과정에서 이항 정리의 새로운 증명을 알아보았고, $\displaystyle \frac{1}{(1-x)^k}$ 의 다항 전개가 이항계수 $\displaystyle \binom{n+k-1}{k-1}$ 와 밀접한 연관이 있음을 관찰하였다.

이항계수의 생성함수는 카탈랑 수의 닫힌 형태를 유도하는 데에도 큰 도움을 주었다. 보조정리를 이용하여, 카탈랑 수열의 생성함수를 이항계수의 전개 형태로 변형하였고, 이로부터 닫힌 형태를 직접적으로 밝힐 수 있다.

순열과 관련된 조합론 문제는 생성함수 EGF를 이용하면 유용하다는 점을 다양한 예시를 통하여 경험하였다. 일반적인 DP로는 $O \left( n^2 \right)$ 이나 혹은 다항 시간으로 해결하기 어려운 문제를, 생성함수를 이용하면 $O \left( n \lg n \right)$ 의 빠른 시간 복잡도로 해결할 수 있다.

다음 포스트에서는, 일반적인 그래프에 관한 조합론 문제에 어떻게 생성함수를 적용할 수 있는지와, 미분 방정식 테크닉에 관하여 다룰 것이다.