21-dohyeondol1

[dohyeondol1]

🔗 문제 링크

석고 모형 만들기

✔️ 소요된 시간

2h

✨ 수도 코드

수도 코드

함수 DFS(u):
    만약 visited[u]가 true이면 return
    visited[u]를 true로 설정
    u와 연결된 모든 v에 대해:
        DFS(v) 재귀 호출

함수 main():
    입력: height, width
    반복 (i = 0 to height-1):
        반복 (j = 0 to width-1):
            현재 셀 문자 ch 입력
            base = (i * width + j) * 8  // 이 셀의 상태 시작 인덱스

            // 문자의 XOR 마스크 설정
            mask = 0
            만약 ch == 'H'이면 mask = 1
            만약 ch == 'I'이면 mask = 2
            만약 ch == 'O'이면 mask = 4

            // 각 상태 k(0~7)에 대해 XOR 연결 추가
            반복 (k = 0 to 7):
                graph[base + k]에 base + (k XOR mask) 추가

    // 좌우 인접 셀 연결
    반복 (i = 0 to height-1):
        반복 (j = 0 to width-2):  // j+1이 범위 내에 있어야 함
            u = (i * width + j) * 8
            v = (i * width + (j+1)) * 8

            graph[u+1] <-> graph[v]         // 상태 1 ↔ 상태 0
            graph[u+3] <-> graph[v+2]       // 상태 3 ↔ 상태 2
            graph[u+5] <-> graph[v+4]       // 상태 5 ↔ 상태 4
            graph[u+7] <-> graph[v+6]       // 상태 7 ↔ 상태 6

    // 상하 인접 셀 연결
    반복 (i = 0 to height-2):
        반복 (j = 0 to width-1):
            u = (i * width + j) * 8
            v = ((i+1) * width + j) * 8

            graph[u+2] <-> graph[v]         // 상태 2 ↔ 상태 0
            graph[u+3] <-> graph[v+1]       // 상태 3 ↔ 상태 1
            graph[u+6] <-> graph[v+4]       // 상태 6 ↔ 상태 4
            graph[u+7] <-> graph[v+5]       // 상태 7 ↔ 상태 5

    연결 요소 개수 cnt = 0
    반복 (i = 0 to height * width * 8 - 1):
        만약 visited[i]가 false이면:
            DFS(i)
            cnt += 1

    출력: cnt

R x C 크기의 틀에 원기둥들을 배치하고, 그 틀에 석고를 부은 후 굳히고 나서 원기둥을 제거했을 때, 분리된 석고 조각의 개수를 구하고자 할때, 원기둥을 모두 제거하고 난 뒤 만들어지는 분리된 석고 조각의 개수를 구하는 문제입니다.

우선 단위 정육면체를 변의 길이가 1/2인 작은 정육면체 8개로 쪼갭시다.
두 이웃한 작은 정육면체 안의 석고 조각이 서로 연결되어 있다면, 둘 사이에 간선을 이어서 그래프를 만들 것입니다.

그림과 같이 단위 정육면체 내에서 회전축과 평행하게 4개의 간선을 잇습니다.
위 그림에서 나올 수 있는 조각 개수는 간선의 개수로 볼 수 있는 것이죠.

문제의 H, I, O를 단위 정육면체로 표현하면 다음과 같습니다.

이를 연결 컴포넌트로 시각화하면 다음과 같습니다.

그리고 단위 정육면체끼리 맞닿은 면 사이에 4개의 간선을 잇습니다.

이와 같이 그래프를 구성하면 DFS나 BFS를 사용해 그래프를 탐색하여 연결 컴포넌트의 개수를 세어주면 됩니다.

---

저는 단위 정육면체를 다음과 같이 분할하였습니다.

for(int i = 0; i < height; ++i) {
        for(int j = 0; j < width; ++j) {
            int base = (i * width + j) * 8;
            char ch;
            cin >> ch;

            int mask = 0;
            if(ch == 'H') mask = 1;
            else if(ch == 'I') mask = 2;
            else if(ch == 'O') mask = 4;

            for(int k = 0; k < 8; ++k)
                graph[base + k].push_back(base + (k ^ mask));
        }
    }

각 셀에 대해 틀의 형태를 입력받고, 이를 비트연산을 통해 연결될 노드를 인접리스트에 push하는 방식으로 구현하였습니다.
만약 앞서 봤던 그림처럼 I 두개가 연결된 경우라면, 다음과 같은 비트연산 결과를 얻을 수 있습니다.

0 → 0 ^ 2 = 2 (2진수 0000 과 0010의 XOR은 0010이다.)
1 → 1 ^ 2 = 3
2 → 2 ^ 2 = 0
3 → 3 ^ 2 = 1
4 → 4 ^ 2 = 6
5 → 5 ^ 2 = 7
6 → 6 ^ 2 = 4
7 → 7 ^ 2 = 5

여기까지가 셀 내부에서의 연결 컴포넌트 작업입니다.
이 친구들을 반복문을 돌려 셀단위로 연결시켜주면 그래프를 완성할 수 있고,
이를 DFS로 연결 컴포넌트의 개수를 구해주면 문제를 해결할 수 있습니다.

📚 새롭게 알게된 내용

[froglike6]

와 이 문제 매우 어렵네요. 머릿속으로 코드 짰을 때는 잘 돌아갔는데, 실제로 하니 잘 안되네요 ㅠㅠ...
더 이상 제 머릿속의 인터프리터를 믿을 수 없어서, 결국 거대 언어 모델의 도움을 받았습니다. 다음 기회에 그래프 탐색을 마스터하고 다시 한 번 이 문제에 시도해보도록 하겠습니다. (수학보다 그래프가 확실히 어렵군요 ㅠㅠㅠㅠ)

거대 언어 모델의 도움을 받은 파이썬 코드

import sys
sys.setrecursionlimit(1 << 25)
input = sys.stdin.readline

R, C = map(int, input().split())
grid = [input().rstrip() for _ in range(R)]

N = 8 * R * C
parent = list(range(N))
size   = [1] * N

def find(x):
    while parent[x] != x:
        parent[x] = parent[parent[x]]
        x = parent[x]
    return x

def union(a, b):
    ra, rb = find(a), find(b)
    if ra == rb:
        return
    if size[ra] < size[rb]:
        ra, rb = rb, ra
    parent[rb] = ra
    size[ra] += size[rb]

EDGES_X = [(0, 1), (2, 3), (4, 5), (6, 7)]          # 가로(H) 축
EDGES_Y = [(0, 2), (1, 3), (4, 6), (5, 7)]          # 세로(I) 축
EDGES_Z = [(0, 4), (1, 5), (2, 6), (3, 7)]          # 수직(O) 축

EAST_PAIRS  = [(1, 0), (3, 2), (5, 4), (7, 6)]      # (x, y) → (x+1, y)
SOUTH_PAIRS = [(2, 0), (3, 1), (6, 4), (7, 5)]      # (x, y) → (x, y+1)

def idx(y, x, k):
    return ((y * C + x) * 8) + k

for y in range(R):
    for x in range(C):
        cell = grid[y][x]
        keep = EDGES_X if cell == 'H' else EDGES_Y if cell == 'I' else EDGES_Z
        base = (y * C + x) * 8
        for a, b in keep:
            union(base + a, base + b)

for y in range(R):
    for x in range(C):
        base = (y * C + x) * 8

        if x + 1 < C:
            nb = (y * C + (x + 1)) * 8
            for a, b in EAST_PAIRS:
                union(base + a, nb + b)

        if y + 1 < R:
            nb = ((y + 1) * C + x) * 8
            for a, b in SOUTH_PAIRS:
                union(base + a, nb + b)

answer = sum(1 for i in range(N) if parent[i] == i)
print(answer)

[Fnhid]

저는 인접 행렬을 이용해서 풀어보려 했는데, 메모리 이슈로 던졌습니다. 🫠🫠
웬만한 그래프 문제는 현석님처럼 인접 리스트로 해결하는게 현명한 것 같습니다.
규모가 작고 간선이 많은 그래프에는 인접 행렬을 적용하는 것도 괜찮을 것 같네요!