jsj0412 님의 블로그

월파떴냐

jsj0412 — Mon, 9 Mar 2026 13:05:27 +0900

후후

플랜디 #1

jsj0412 — Sat, 20 Sep 2025 00:31:09 +0900

플랜디 현황

(P1) BOJ 15983: 순간이동 발판

현재 시간이 $t$일 때 좌표 $c$에서 발판을 갈아타려면 기다려야 하는 시간을 계산해야 한다.

지금 밟고 있는 발판이 방문하는 좌표의 개수를 $m_1$, 갈아탈 발판이 방문하는 좌표의 개수를 $m_2$라고 하자. 또한, 좌표 $x$는 지금 밟고 있는 발판에서 $a_1$번째로 등장하고, 갈아탈 발판에서는 $a_2$번째로 등장한다고 하자.

이를 모듈러 식으로 나타낼 수 있다. 기다려야 하는 시간을 $x$라고 하면,

$t+x \equiv a_1 \pmod m_1$

$t+x \equiv a_2 \pmod m_2$

와 같은 모듈로 연립방정식으로 나타낼 수 있다.

이러한 형태의 식은 중국인의 나머지 정리로 풀 수 있다. 이 식을 푼 다음, 다익스트라를 돌려서 최단 거리를 찾으면 된다.

구체적으로 말하면, 먼저 각 발판에서 $i$번째 좌표와 $i+1$번째 좌표를 모두 길이가 1인 간선으로 이은 다음, 같은 좌표끼리는 위 식에서 구한 $x$를 사용해 길이가 $x$인 간선으로 이으면 된다.

구현이 상당히 복잡하다. 각 좌표마다 등장하는 발판 번호와, 좌표가 해당 발판에서 몇 번째로 등장하는지를 저장해야 하고, 어떤 발판과 대응되는 다른 발판을 같이 저장해야 하고, ...

아무튼 복잡하다.

(P3) BOJ 20968: Telephone

또 다익스트라 문제가 나왔다.

나이브하게, 각 소마다 자신이 메시지를 보낼 수 있는 모든 소를 간선으로 연결하고 다익스트라를 돌리는 것을 생각할 수 있다. 하지만 이러면 간선이 $O(N^2)$개가 된다.

$K$가 작으므로 이를 이용한 풀이를 생각해 보자.

사실 각 소는, 각 품종(breed)마다 자신과 앞뒤로 가장 가까운 소에게만 메시지를 보내도 된다.

$S_{ij}=1$이고, $i$번째 소에서 품종이 $b$인 $j$번째 소에게 메시지를 보냈다고 가정하자.

이때, 품종이 똑같이 $b$이면서 $i$번째 소와 $j$번째 소 사이에 $k$번째 소가 있다면, $k$번째 소에게 먼저 메시지를 보내고, $k$번째 소가 $j$번째 소에게 메시지를 보내면, 같은 시간 안에 메시지를 보낼 수 있기 때문에, 앞뒤로 가장 가까운 소에게만 메시지를 보내도 된다.

다만 문제에서 $S_{ii}=0$일 수도 있다는 말이 걸린다. 근데 잘 생각해 보면, 이 조건은 그냥 무시해도 상관 없다. 왜일까?

임의의 소 $A$가 자신과 품종이 같은 소 $B$에게 메시지를 보내려고 한다고 생각해 보자. $A$가 1번 소가 아니라면, $A$에게 메시지를 보낸 소 $C$가 있을 것이다. 메시지를 $C \rightarrow A \rightarrow B$로 보내는 대신, $C \rightarrow B$로 메시지를 보내면 된다.

즉, $A$가 메시지를 받았다면, $B$ 역시 메시지를 받을 수 있다. 또한, $S_{ii}=1$로 간주해도 최단 거리는 변함없다는 것을 증명할 수 있는데, 귀찮아서 적진 않겠다. $C$가 $A$와 $B$ 사이에 있는 경우와 아닌 경우로 나눠서 잘 해보면 된다.

따라서 $S_{ii}=1$이라고 가정해도 문제가 없다. 단, 딱 한 가지 예외가 있는데, 1번 소에서는 같은 품종으로 메시지를 보낼 수 없다. 이는 위의 증명 과정에서 $A$가 1번 소가 아니라고 가정했기 때문이다.

모든 품종 $i$에 대해, 각 소에서 앞으로 가장 가까운 품종 $i$의 소와 뒤로 가장 가까운 품종 $i$의 소를 미리 누적 합으로 구해놓고, 다익스트라를 돌리면 된다.

(P2) BOJ 21652: 우물 유적 발굴하기

예제 및 직접 만든 테케 몇 개를 손으로 풀어보다 보면, 항상 답이 0 또는 1이라는 추측을 할 수 있다. 이 추측은 실제로도 참이다.

먼저, 차수가 홀수인 정점이 하나라도 있으면 답은 반드시 1 이상이 됨을 어렵지 않게 알 수 있다.

다음과 같은 과정을 반복한다고 생각해 보자.

- 자신과 연결된 간선이 하나 이상이면서 정점 번호가 최소인 정점 $x$를 고른다.

- $x$에서 DFS를 실행한다. 이때 사용하는 간선은 리스트 $v$에 push_back하고, 간선을 없앤다.

- DFS가 종료되는 정점을 $y$라고 하자. $y$의 차수가 짝수라면, 들어왔으면 항상 나갈 수 있으므로 DFS가 종료되지 않는다. 따라서 $y$의 차수는 홀수이다.

- 리스트 $v$에는 $x$에서 $y$로 향하는 경로상의 간선이 모두 포함되어 있다. $x$의 In degree - Out degree가 양수라면, 모든 간선의 방향을 $x$에서 $y$로 향하는 방향으로 정한다. 양수가 아니라면, 모든 간선의 방향을 $y$에서 $x$로 향하는 방향으로 정한다.

위 과정은 항상 최소 위험도를 도출한다. 왜인지는 차수가 홀수인 정점이 있는지와 없는지로 나눠서 증명해 보자.

1) 차수가 홀수인 정점이 존재한다.

위 과정은 매번 반복될 때마다 $x$와 $y$만 In degree - Out degree가 바뀌고, 나머지는 바뀌지 않는다.

$y$에서 DFS가 종료되었다는 뜻은, $y$는 더 이상 In degree - Out degree가 바뀔 수 없으며, 차수는 홀수라는 것이다. 따라서, $y$의 In degree - Out degree를 -1로 만들던 1로 만들던 정답은 같으므로, 간선의 방향은 $y$에는 영향을 주지 않는다.

따라서 $x$에 이득이 되는 방향으로 간선 방향을 설정한다. In degree - Out degree가 양수면 -1, 아니면 +1 시키는 과정을 계속 반복하므로, $x$의 In degree - Out degree 역시 0 또는 1이 된다.

위 과정을 계속 반복하다 보면, 언젠가는 $x$에 연결된 간선이 없게 되고, 또 반복 과정에서 $y$가 된 몇몇 정점도 연결된 간선이 없게 된다. 다른 정점은 In degree - Out degree가 모두 0으로 유지되고 있으므로, 귀납적으로 위 과정은 항상 정답이 1인 간선 방향을 얻게 된다.

2) 차수가 홀수인 정점이 존재하지 않는다.

$x$에서 DFS를 시작했다면, $x$에서 DFS를 종료해야 한다. (다른 정점은 모두 차수가 짝수이므로, 들어왔으면 항상 나갈 수 있다.) $y$에서 $x$로 향하도록 방향을 정하면, In degree - Out degree가 변하는 정점이 없게 된다. 그러므로, 위 과정을 반복해도 In degree - Out degree가 항상 0이 된다.

간선의 방향을 정한 다음, 문제에서 요구하는 출력 형식으로 변환해야 하는데, 이게 조금 귀찮다.

(P1) BOJ 18648: Three-Step Tunnels

이동을 3번 이내로 해야 한다는 조건은 버킷질을 의심하게 한다.

뭔가 버킷으로 적당히 나눈 다음, 각 버킷의 끝점을 모두 서로 잇고, 버킷에 속한 모든 원소를 버킷의 끝점으로 잇는 풀이를 생각해 볼 수 있다. 이러면 $a$에서 $b$로 이동할 때, $a$ $\rightarrow$ ($a$가 속한 버킷의 오른쪽 끝점) $\rightarrow$ ($b$가 속한 버킷의 왼쪽 끝점) $\rightarrow$ $b$로 3번의 이동 내에 도달 가능하다.

문제는 같은 버킷의 원소끼리 이동할 때이다. 단순히 같은 버킷 내의 모든 원소 쌍을 서로 잇는 것을 생각해볼 수 있다.

이 방법을 사용하면, 버킷 크기를 $N^{1/3}$으로 잡는 것이 최적인데, 이러면 다리를 $8N$개 정도 사용한다.

위 방법은, 같은 버킷의 원소끼리 이동할 때 단 1번의 이동만으로 도달할 수 있다. 사실 우리는 이동을 3번까지 쓸 수 있는데, 1번만에 이동 가능하도록 다리를 사용하는 것은 비효율적이다. 따라서 개선 방법을 생각해보자.

핵심 아이디어는, 이 버킷 내에서 위 풀이를 재귀적으로 적용하는 것이다. 우리가 해결하고 싶은 문제는, 버킷 안에서 3번의 이동으로 모두 연결되도록 하는 것인데, 이는 전체 문제의 축소 버전이므로 그대로 재귀를 돌려 주면 된다. 다만 실제로 구현할 때는, $N=500$이고 루트는 23 정도 되기 때문에, 23짜리 버킷을 다시 루트로 나누지 않고 그냥 크기가 4인 버킷으로 나눠 줬다. 크기가 4인 버킷은 이미 3번의 이동 이내로 도달 가능하기에 더 이상 재귀를 돌려줄 필요가 없다.

버킷 크기는 루트로 잡았는데, 이게 최적인지는 잘 모르겠다. 루트로 잡으면 계산상으로는 $4.75N$ 정도, 실제로는 $N=500$일 때 $2200$ 정도 사용한다.

루트질을 재귀적으로 돌리는 아이디어는 van Emde Boas Tree에서 사용하는 아이디어인데, 이런 아이디어를 사용하는 문제가 있어 놀라웠다. van Emde Boas Tree는 상수가 매우 커서 PS에서는 거의 사용되지 않지만, 아이디어가 재밌으니 궁금하신 분은 한번 알아보시면 좋을 것 같다.

(P4) BOJ 11439: 이항 계수 5

$M$이 소수가 아니므로 모듈러 역원 풀이를 사용할 수 없다.

조합 식을 팩토리얼로 나타내고, 분자와 분모를 소인수분해하면, 이항 계수의 소인수분해를 알 수 있다. 이걸 그냥 그대로 모듈로 상에서 계산해주면 된다.

빠른 소인수분해를 위해, 에라토스테네스의 체를 사용하면 된다.

(P1) BOJ 13928: Arranging Hat

맛도리 DP 문제다.

핵심 아이디어는 다음과 같다.

- 숫자들을 정렬된 상태로 만드는 것은, 첫 번째 자리가 정렬된 상태로 만든 후, 첫 번째 자리가 같은 숫자끼리 정렬되도록 하는 것과 같다.

예를 들어,

011

010

100

010

과 같은 수들이 있다면,

011

100

110

과 같은 답을 생각해볼 수 있다.

이는, 첫 번째 자리만 봤을 때 정렬된 상태(0011)로 만든 뒤, 첫 번째 자리가 같은 숫자끼리 재귀적으로 다시 정렬되도록(011과 011이 정렬되도록 하고, 100과 110이 정렬되도록) 하는 것이다.

따라서 다음과 같은 DP 식을 생각해볼 수 있다.

DP[i][j][k][l]: i번째부터 j번째까지 수의 맨 뒤 k자리를 정렬하는 데 드는 최소 비용 (단, 맨 뒤 k자리 중 가장 앞의 자리는 l 이상의 수만 사용한다.)

점화식은 다음과 같다.

DP[i][j][k][l]: $\min(dp[i][t][k-1][0] + dp[t+1][j][k][l+1] + (i...t$번째 수의 맨 뒤 $k$자리 중 가장 앞의 자리를 모두 $l$로 바꾸는 데 드는 비용$))$

위 점화식의 뜻은, 맨 뒤 $k$자리 중 가장 앞의 자리를 $l$로 바꿀 건데, 몇 개를 $l$로 바꿀 지를 $t$를 통해 반복시켜 가며 구하는 것이다.

모든 $t$에 대해 반복해주면 된다. Base case는 $k=0$ 또는 $l=9$이다.

결과적으로 모든 수를 정렬하는 데 드는 비용은 DP[1][N][M][0]이다.

역추적을 해줘야 하는데, 이건 그냥 잘 하면 된다.

BOJ 34096 - 자동 광고 배치 시스템

jsj0412 — Sun, 7 Sep 2025 20:11:45 +0900

문제

대회 때 팀원한테 살짝 문제 설명만 듣고, 잡진 않았는데 생각보다 할 만한 문제이다. 그냥 대회때 A를 잡지 말고 이 문제를 잡을 걸 그랬다.

문제 요약:

수 $N$개가 주어진다. 당신은 다음 행동을 반복해야 한다.

남은 수가 2개 이상이라면, 맨 앞의 수 3개 중 2개를 골라 삭제한다. 이 연산의 비용은 max(삭제하는 두 수)이다.
남은 수가 1개라면, 그 수를 삭제한다. 이 연산의 비용은 삭제하는 수와 같다.

모든 수를 삭제하는 데 드는 최소 비용을 구하라.

풀이:

그리디로 접근하는 순간 망한다.

다음과 같은 2차원 DP를 생각해 보자.

$DP[i][j] = $$i$번째까지 봤을 때, $j$만 남기고 다른 수를 모두 삭제하는 데 드는 경우의 수

이때, $i$번째까지 봤을 때 수가 하나만 남으려면, $i-3$이 짝수여야 한다. 따라서 $i-3$이 짝수일 때만 위 DP식이 정의된다고 하자.

DP 전이 방식은 다음과 같다.

모든 $k$에 대해,

$DP[i][k] = DP[i-2][k] + \max(A[i-1], A[i])$ (1)

$DP[i][A[i]] = \min (DP[i-2][k] + \max(k, A[i-1])$ (2)

$DP[i][A[i-1]] = \min(DP[i-2][k] + \max(k, A[i])$ (3)

위 식을 해석해보자.

현재까지 $A[1], ..., A[i-2]$를 잘 처리해서 $k$만 남기고 삭제하는 최소 비용이 곧 $DP[i-2][k]$이다.

그렇게 삭제하고 나면, 맨 앞의 수 3개에는 $k, A[i-1], A[i]$가 오게 된다.

(1)번 식은 $k$를 남기고 나머지 둘을 삭제하는 경우, (2)번 식은 $A[i]$를 남기는 경우, (3)번 식은 $A[i-1]$을 남기는 경우이다.

가능한 $k$의 후보는 $A[1], ..., A[N]$밖에 없으므로, 좌표 압축을 통해 $k$를 인덱싱해주면 $O(N^2 \log N)$ 풀이가 나온다.

이제 이 풀이를 $O(N \log N)$으로 최적화해보자.

편의상 모든 인덱스는 좌표 압축을 적용하기 전 기준으로 설명한다.

(1)번 식은 모든 $k$에 대해 같은 값을 더하는 것이다. 따라서 offset을 관리해주는 것으로 $O(1)$에 전이 가능하다.

(2)번 식을 어떻게 전이할지 생각해 보자.

먼저, $k \leq A[i-1]$인 경우와 $A[i-1] < k$인 경우로 나누자.

$k \leq A[i-1]$인 경우, $\max$ 식을 풀어서 $DP[i][A[i]] = \min(DP[i-2][k] + A[i-1])$으로 계산할 수 있다. 세그먼트 트리의 Range Minimum Query로 계산 가능한 형태이다.

$A[i-1] < k$인 경우, 역시 $\max$ 식을 풀어서 $DP[i][A[i]] = \min(DP[i-2][k] + k)$로 계산할 수 있다. 이는 세그먼트 트리에 약간의 변형을 가해 계산 가능하다. 세그먼트 트리에서 $k$번째 값이 $DP[i-2][k] + k$를 갖도록 하면 된다.

따라서, 두 개의 세그먼트 트리 seg1과 seg2를 관리한다. seg1의 $k$번째 값은 $DP[i][k]$이고, seg2의 $k$번째 값은 $DP[i][k] + k$이다. DP값을 업데이트할 때 사용하는 점 업데이트, 전이에 사용되는 구간 최솟값 쿼리와 offset을 사용한 전체 덧셈 쿼리를 지원하면 충분하다.

DP값을 전이할 때, seg1은 $[1, A[i-1]]$의 범위에 쿼리를 날리고, seg2는 $[A[i-1]+1, k]$에 쿼리를 날리면 된다. 물론 실제로 $[1, A[i-1]]$에 쿼리를 날리는 것이 아니라, 좌표 압축을 적절히 적용해서 대응되는 범위에 쿼리를 날리면 된다.

$N-3$이 짝수라면, 마지막에는 수가 하나 남게 된다. 모든 $k$에 대해 $DP[N][k]+k$의 최솟값이 답이다.

$N-3$이 홀수라면, 마지막에는 수가 두 개 남게 된다. 이 중 $A[N]$은 반드시 남는다. (수가 4개 남았을 때, $A[N]$은 삭제될 수 없는 위치에 있으므로 삭제되지 않는다.) 따라서 모든 $k$에 대해 $DP[N-1][k]+\max(k, A[N])$의 최솟값이 답이다.

총 $O(N\log N)$에 해결 가능하다.

코드:

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
struct Segtree
{
    vector<ll> seg;
    ll N, add;
    Segtree(ll n)
    {
        N = n;
        add = 0;
        seg.resize(4 * n + 100);
        fill(seg.begin(), seg.end(), 1e18);
    }
    ll query(ll l, ll r)
    {
        return query(1, 1, N, l, r) + add;
    }
    ll query(ll n, ll s, ll e, ll l, ll r)
    {
        if (r < s || e < l)
            return 1e18;
        if (l <= s && e <= r)
            return seg[n];
        ll m = (s + e) / 2;
        return min(query(2 * n, s, m, l, r), query(2 * n + 1, m + 1, e, l, r));
    }
    void add_all(ll x)
    {
        add += x;
    }
    void update(ll i, ll x)
    {
        update(1, 1, N, i, x - add);
    }
    void update(ll n, ll s, ll e, ll i, ll x)
    {
        if (i < s || e < i)
            return;
        if (s == e)
        {
            seg[n] = min(seg[n], x);
            return;
        }
        ll m = (s + e) / 2;
        update(2 * n, s, m, i, x), update(2 * n + 1, m + 1, e, i, x);
        seg[n] = min(seg[2 * n], seg[2 * n + 1]);
    }
};
int main()
{
    cin.tie(0)->sync_with_stdio(0);
    ll T;
    cin >> T;

    while (T--)
    {
        ll N;
        cin >> N;
        vector<ll> v(N + 1);
        for (int i = 1; i <= N; i++)
            cin >> v[i];
        if (N == 1)
        {
            cout << v[1] << '\n';
            continue;
        }
        if (N == 2)
        {
            cout << max(v[1], v[2]) << '\n';
            continue;
        }
        vector<ll> c = vector<ll>(v.begin() + 1, v.end());
        sort(c.begin(), c.end());
        c.erase(unique(c.begin(), c.end()), c.end());
        Segtree seg1(N), seg2(N);

        for (int i = 1; i <= 3; i++)
        {
            ll ma = 0;
            for (int j = 1; j <= 3; j++)
            {
                if (i == j)
                    continue;
                ma = max(ma, v[j]);
            }
            ll t = lower_bound(c.begin(), c.end(), v[i]) - c.begin() + 1;
            seg1.update(t, ma);
            seg2.update(t, ma + v[i]);
        }
        // for (int i = 1; i <= N; i++)
        //     cout << seg1.query(i, i) << ' ';
        // cout << endl;
        for (int i = 4; i + 1 <= N; i += 2)
        {
            ll a = v[i], b = v[i + 1];
            ll ta = lower_bound(c.begin(), c.end(), a) - c.begin() + 1;
            ll tb = lower_bound(c.begin(), c.end(), b) - c.begin() + 1;

            ll sa = min(seg1.query(1, tb) + b, seg2.query(tb, N));
            ll sb = min(seg1.query(1, ta) + a, seg2.query(ta, N));

            seg1.add_all(max(a, b));
            seg2.add_all(max(a, b));

            seg1.update(ta, sa);
            seg2.update(ta, sa + a);

            seg1.update(tb, sb);
            seg2.update(tb, sb + b);

            // for (int i = 1; i <= N; i++)
            //     cout << seg1.query(i, i) << ' ';
            // cout << endl;
        }
        ll ans = 1e18;
        if ((N - 3) % 2 == 0)
            for (int i = 1; i <= c.size(); i++)
                ans = min(ans, seg1.query(i, i) + c[i - 1]);
        else
            for (int i = 1; i <= c.size(); i++)
                ans = min(ans, seg1.query(i, i) + max(c[i - 1], v[N]));
        cout << ans << '\n';
    }
}

BOJ 28089 - 응애(HARD)

jsj0412 — Sun, 7 Sep 2025 03:29:50 +0900

문제

처음에는 "이게 풀린다고?" 싶었는데, 몇 번 관찰을 거듭하니 나름 무난했던 문제다.

문제 요약:

$N$명의 사람이 원형으로 앉아 있다. 한 사람이 인사를 하면, 그 양 옆에 있는 두 사람은 1초 뒤에 인사를 해야 한다. 단, 자신의 양 옆에 있는 두 사람이 동시에 인사했다면, 인사하지 않는다. 0초에 인사하는 사람의 목록이 주어질 때, $K$초 뒤 인사하는 사람의 수를 구하라.

$3 \leq N \leq 2\,000\,000; 0 \leq K \leq 10^{18}$

풀이:

1. 인사하는 상태를 1, 인사하지 않는 상태를 0으로 나타냈을 때, 어떤 사람의 1초 뒤 상태는 그 사람의 양옆 상태를 XOR한 값이다.

사실 당연한 말인데, 이걸 숨기려고 지문이 교묘하게 작성되어 있는 것 같다.

2. $x$초가 지났을 때 $i$번 사람의 상태를 $A_x(i)$라고 하자.

$A_1(i) = A_0(i-1)$^$A_0(i+1)$이다. (편의상 인덱스의 모듈러는 생략한다.)

$A_2(i) = A_1(i-1)$^$A_1(i+1) = A_0(i-2)$^$A_0(i+2)$이다.

$A_4(i) = A_2(i-2)$^$A_2(i+2) = A_0(i-4)$^$A_0(i+4)$이다.

같은 방식으로, 모든 2의 거듭제곱 $x$에 대해,

$A_x(i) = A_0(i-x)$^$A_0(i+x)$

임을 알 수 있다.

3. 따라서, $k$의 켜져있는 비트마다 모든 사람의 상태를 업데이트해주면 된다.

시간 제한이 상당히 빡빡해서, 비트셋 사용 + 반복문 안에서 모듈러를 사용하지 않는 최적화를 한 후에야 맞았습니다를 받았다.

빠른 거듭제곱을 쓰긴 했는데, 사실 생각해 보니 거듭제곱 결과가 최대 $2^{60}$밖에 안 돼서 빠른 거듭제곱은 쓸 필요가 없다.

코드:

#include <bits/stdc++.h>
using namespace std;
using ll = long long;
bitset<2'000'200> v;
ll N, M, K;
ll pw(ll n, ll ex)
{
    if (ex == 0)
        return 1;
    ll tmp = pw(n, ex / 2);
    if (ex % 2 == 0)
        return tmp * tmp % N;
    return tmp * tmp % N * n % N;
}
int main()
{
    cin.tie(0)->sync_with_stdio(0);
    cin >> N >> M >> K;
    for (int i = 0; i < M; i++)
    {
        ll a;
        cin >> a;
        v[a] = 1;
    }
    for (int i = 60; i >= 0; i--)
    {
        if (K & (1LL << i))
        {
            K -= (1LL << i);
            bitset<2'000'200> t;
            int g = pw(2, i);
            int l = ((-g) % N + N) % N, r = g % N;

            for (int j = 0; j < N; j++)
            {
                t[j] = v[l] ^ v[r];
                l++, r++;
                if (l >= N)
                    l -= N;
                if (r >= N)
                    r -= N;
            }
            v = t;
        }
    }
    cout << v.count();
}

2025 숭고한 연합 알고리즘 경진대회 후기

jsj0412 — Mon, 1 Sep 2025 15:52:32 +0900

숭고한에 운영 및 출제로 참여했다.

https://www.acmicpc.net/category/1128

기획

사실 숭고한은 매우 일찍부터 기획되었다. 첫 회의가 올해 3월 즈음이었고, 그때부터 문제를 모으기 시작했다.

원래 숭고한은 3~4일간 알고리즘 캠프 + 마지막 날 알고리즘 대회의 형식으로 진행되었으나, 올해는 모종의 이유로 캠프는 진행할 수 없게 되었다. 사실 알고리즘 대회는 자주 열려도 캠프는 흔하지 않기 때문에 꼭 진행하고 싶었는데, 정말 아쉽다.

숭고한 대회 셋의 의도는 다음과 같다.

Div. 1: ICPC 예선을 대비하기 위한 문제들

Div. 2, 3: 알고리즘 대회에 익숙하지 않은 참가자들에게 교육적인 문제들

이 의도에 맞춰서, Div. 1은 3인 팀 대회가 됐고, Div. 2, 3은 개인 대회가 됐다.

Div. 3은 이러한 의도로 브루트포스 셋이 됐고, Div. 2는 어느 정도 교육적인 문제들이 출제되었다.

Div. 1은 ICPC 예선의 난이도커브를 많이 참고했다.

출제

출제에 있어서는 한양대학교의 gggkik가 정말 고생해주었다. 밑의 셋 리스트를 봐도 알겠지만, 정말 많은 문제를 세팅했다. 거의 원맨쇼라고 봐도 될 듯 하다.

숭고한 셋 리스트

나는 숭고한에 어서오세요, 현대모비스 부품 조립, 받아쓰기, 반원, 토너먼트로 총 5문제를 출제했다.

3A. 숭고한에 어서오세요 (BOJ 34236)

매우 쉬운 브론즈 문제이다. 사실 이번 숭고한이 2022년 이후 3년만에 열리는 대회라서, "숭고한은 앞으로 주기적으로 열릴 것이다"를 암시하고 싶었다.

3E2B1F. 현대모비스 부품 조립 (BOJ 34225)

원래는 HCPC에 출제될 실버 그리디 문제였다.

셋 코디네이팅을 담당한 한양대 gggkik가 실버 문제가 없다고 해서 급하게 가져왔다. 난이도가 실버인 만큼 모든 디비전에 출제된 유일한 문제이다.

초기 지문

현대모비스에서 큰 후원을 해주셔서, 요청사항대로 현대모비스 홍보 문제를 하나 작성하기로 했다. 이 문제가 유일하게 모든 디비전에 출제된 문제라, 자연스레 홍보 문제가 되었다.

당연히 Div. 1 참가자분들은 매우 쉽게 풀어주셨지만, Div. 2, 3 참가자분들은 상당히 고전한 문제였던 것 같기도 하다. 어느 정도 교육적이라고 생각한다.

3G2F. 받아쓰기 (BOJ 34234)

이 문제는 상당히 오래 묵혀둔 문제이다. 2025년 학기가 처음 시작할 때 구상한 문제고, 내가 ps를 하면서 두 번째로 구상한 문제이기도 하다. (첫 번째로 구상한 문제는 ALOHA 봄 내전에 출제되었다.)

내가 출제한 문제 중에 두 번째로 마음에 드는 문제이다. 일단 문제가 간결하면서도 티피컬하지 않아서 상당히 만족한다. 실제로 gpt도 Div. 2, 3의 다른 문제는 쉽게 풀어내는 반면, 이 문제는 잘 풀지 못했다.

참가자분들도 상당히 어려워하신 것 같다. 본 대회와 오픈 컨테스트 모두 한 분만 이 문제를 풀어 주셨다.

골드 상위를 의도하고 출제한 문제인데, 검수진 몇몇 분들은 플레티넘으로 기여하기도 했다.

정말 마음에 드는 문제라서, Div. 1만 참가하신 분들이 한번씩 풀어주셨으면 좋겠습니다.

+ 지금 보니 플레5가 찍혀 있다.. 난이도 예측에 실패한 듯 하다.

3H. 반원 (BOJ 34240)

솔직히... 출제한 내가 봐도 그렇게 좋은 문제는 아닌 것 같다. 다만 Div. 3는 알고리즘 배경 지식이 많이 없는 분들이 참가할 거라고 생각해서 수학적인 지식만으로 풀리는 문제가 하나쯤 있었으면 좋겠다고 생각했다. 다만 마지막 문제라서 그렇게 많은 참가자가 이 문제를 풀려는 시도를 하지 않은 것 같다. 한두명 정도는 깡수학으로 이 문제를 풀어줄 걸 기대했는데, 아쉬운 부분이다.

셋 코디네이터인 gggkik가 기하를 잘 모르는데(CCW도 모른다고 한다), 이 문제를 보더니 좋은 문제인 것 같다고 하고 기하 한 문제쯤은 필요하다며 셋에 넣었다. Div. 3 문제로는 나쁘지 않았던 것 같다.

많조분 + 기하는 사람들이 싫어하는 태그를 섞어 놓은거라, 아마 많은 분들이 좋아해주시진 않을 것 같다.

2G1H. 토너먼트 (BOJ 34227)

내가 출제한 문제 중 가장 마음에 드는 문제이다.

내가 의도한 정해는, 수학적으로 증명해 놓으면 구현이 매우 간단해지는 풀이이다. 2k와 2k+1 중 2k를 사용하는 것이 항상 이득임을 귀납법으로 증명 가능하다.

다만 많은 참가자들이 비트마스킹으로 관찰하는 풀이를 내서 아쉽다. 개인적으로 비트마스킹 풀이보다 정해가 훨씬 아름답다고 생각한다.

제일 처음 이 문제를 출제했을 때는 난이도를 대충 매겨서 실버 상위정도 되는 줄 알았는데, 이 문제를 세팅하고 보니까 생각보다 어렵다는걸 깨달았다.

Div. 2에도 출제됐으나, 아쉽게도 풀리지 않았다. Div. 1에서는 거의 대부분 참가자들이 풀어주셨다.

이외에 내가 출제하지 않은 문제 중에, 다음 문제들은 흥미롭고 좋다고 생각한다.

2C. 네모난 순열 찾기 2 (간단한 애드 혹 문제이다.)

2E1E. 멀지만 가까운 사이 (정해는 골드 중위정도 되는 dfs 문제이나, 본 대회에서 small to large 풀이를 짠 참가자가 매우 많았다.)

1J. 극대 찾기 (개인적으로 셋에서 가장 좋은 문제라고 생각한다. 풀이를 듣고 감탄했다.)

기타

사실 출제 및 세팅보다는 기타 잡다한 일을 많이 맡아서 했던 것 같다.

특히, 에디토리얼 및 문제지 작성을 담당했다. 슬픈 건, 정말 힘들게 문제지를 디자인하고 지문을 옮겨 놨는데, 하필 프린터 이슈가 터졌다. 그날 대회 건물이 12시까지 정전됐고, 14시가 대회 시작이라 2시간 안에 대략 1000장 가량을 인쇄해야 했다. 근데 빌린 프린터가 너무 느려서, 일단 팀 대회인 Div. 1부터 문제지를 인쇄하기로 했다.

근데 알 수 없는 이유로 프린터의 latex 글씨가 깨져서 보였다. png로도 인쇄해보려고 하고 여러 시도를 했지만, 프린터가 좀 구형이라 잘 안 되는것 같았다. 결국 어쩔 수 없이 깨진 문제지를 나눠주고, BOJ 지문을 우선시해달라는 공지를 했다.

실제로 어떤 참가자분은 J번의 쿼리 제한이 27번이 아니라 7번이라고 보였다고 해서, 미안한 마음이 들기도 했다.

solved.ac 배경도 내가 제작했다. 이번 대회를 하면서 디자인을 할 일이 몇 번 있었던 것 같은데, 굉장히 재미있었다. 새로운 적성을 찾은 느낌이다. 아마 다음에도 대회를 운영할 일이 생기면 디자인까지 하지 않을까 싶다.

숭고한을 운영하면서 정말 힘든 일이 많았고, 화나는 일도 몇 번 (사실 많음) 있었지만.. 끝나고 보니 정말 재미있는 경험이었다. 고생해주신 분들이 정말 많은데, 너무 감사드립니다.

내년에도 숭고한 열어주시면 감사하겠습니다.

끝