2-g0rnn

[g0rnn]

🔗 문제 링크

[트리] LCA2 : https://www.acmicpc.net/problem/11438

✔️ 소요된 시간

3h 이상..

원래는 LCA를 풀려고 했으나 약간 막히는 부분에서 조금 서칭해보다가 시간복잡도가 O(log n)인 알고리즘이 있다고 해서... 거기에 혹해버리는 바람에 시간이 무진장 오래걸렸습니다..

근데 알고보니 그 문제는 🌟플레 4🌟 였고, 그것도 모르는 저는 그냥 주구장창 알고리즘을 생각하고 연구했던거죠...

원래 cpp로 하려다가 이번에 java로 바꿔보려고 하는데 생각보다 많은 것들이 달라서 거기서도 시간을 좀 빼앗겼습니다....하....

다음부터는 시간을 좀 덜 쓰도록 문제의 난이도를 조절해보겠습니다.

✨ 수도 코드

⏲️ 시간복잡도 O(n)

먼저 기존 LCA에 대한 수도 코드를 적어보겠습니다.

// 수도 코드라서 문법은 틀릴 수 있습니다
func getLowestCommenAncestor {
    //x와 y의 높이를 같게 만듦
    while( depth(x) < depth(y) ) y = y->parent;
    while( depth(x) > depth(y) ) x = x->parent;

    //서로 동시에 올라가면서 LCA를 찾음
    while( x->parent != null && y->parent != null ){
         if (x==y) return x;
         x = x->parent;
         y = y->parent;
    }

    //root까지 올라갔으니 root를 반환
    return root;
}

트리를 구성했다고 치고 LCA만을 구하는 코드입니다. 조금더 설명을 덧붙이겠습니다.

1. 먼저 두 노드의 높이(depth)를 맞춰줍니다. 두개를 동시에 올라가면서 lca를 찾으려고 하는데 높이가 다르면 서로 같아질 수 없기 때문이죠.
2. 그리고 그냥 parent를 찾아서 올라가면 됩니다. parent라는 배열에 각 노드의 부모노드를 저장하면 수월히 찾아갈 수 있습니다.

위의 방법으로 코드를 짜면 O(n)이라는 시간복잡도가 나옵니다. 트리의 구조를 생각했을 때에 높이만을 따지면 되니까 O(log n)이라고 생각하기 쉽지만, 최악의 경우 일직선 형태의 트리구조에서는 높이가 곧 노드의 개수이기 때문에 O(n)이라는 시간복잡도를 가지게 됩니다.

그럼 대체 어떻게 풀어야 할까요? 정답은 "Sparse-Table을 사용한다."입니다. 이는 N번째 앞에 있는 원소를 찾기 위해 사용되는 테이블입니다. 이 테이블을 구성하였다면 기존 LCA 수도코드를 활용하여 Lowest Common Ancestor를 찾으면 됩니다. 기존에는 자신의 직계부모를 찾아가면서 높이(depth)를 맞추고 lca를 찾았는데 이제는 sparse table을 사용하여 더 빠르게 찾을 수 있게 됩니다.

이제 본격적인 수도 코드 설명에 들어가겠습니다.

⏲️ 시간복잡도 O(log n)

0. 입력을 받는다. - 인접 리스트로 트리를 저장
   0-1. 각 노드의 부모 노드를 저장할 2차원 배열 parent를 -1로 채운다.
   0-2. 각 노드의 깊이를 저장하는 depth 배열도 -1로 채운다. - 참고로 root노드의 높이는 0이다.
1. parent 배열을 구성한다
   1-1. adj 배열을 순회하면서 자식 노드를 차례로 방문하며 depth를 기록한다. (이미 방문한 노드는 제외 - depth가 -1이 아님)
   1-2. parent배열에 순회 중인 노드의 직계부모를 저장한다.
   1-3. 이 함수를 반복하여 parent와 depth를 채운다.
2. parent에서 2단계 위의 부모, 3단계 부모, ... n단계 부모를 채운다 - 이후 추가 설명
3. 높이를 같게 한다.
   3-1. 누가 더 높은 위치에 있는지 모르니까 v를 더 높은 것으로 설정
   3-2. 높이 차이를 0으로 만듦. depthDiff가 13일 때, u를 1 만큼 위로 (diff를 2로 나누고) -> 4 만큼 위로 (diff를 2로 나누고) -> 8 만큼 위로 올리면 13만큼 올라가서 높이가 같아짐
4. 두 노드를 동시에 올려 LCA를 찾는다.

코드를 읽다보면 parent[i][j + 1] = parent[parent[i][j]][j]; 이 부분에서 헷갈릴 수 있는데 이는 이미지를 통해서 설명하겠습니다.

14보다 4(2^2) 단계 위에 있는 노드를 찾기 위해선 14의 2(2^1)단계 위에 있는 노드(p1)를 찾고 p1의 2(2^1)단계 위의 노드를 찾으면 되기 때문입니다.
만약 16단계 위에 있는 노드를 찾고 싶다면 8단계 위의 노드를 찾고 그 노드에서 8단계 올라가면 됩니다.

sparse table(희소 테이블)은 이 블로그를 통해 개념을 익혀가시면 좋습니다.
제가 참고한 블로그는 https://m.blog.naver.com/kks227/220820773477 이고, pr을 위해 찾아보던 중 https://tussle.tistory.com/875 이 블로그도 좋아보여 추가합니다!!

📚 새롭게 알게된 내용

희소 테이블에 대해 알게 되었습니다. 생각보다 좀 어려운 내용이라 골치 아팠지만 재밌었습니다.
자바로... 알고리즘 문제를 풀면 뭔가 불편한 느낌이 듭니다. 그래도 자바에 조금 더 익숙해질 때까지 자바로 코드를 작성하겠습니다. (차피 여러분도 하셔야해요 ^^)

[kangrae-jo]

spare table를 사용하는 방식으로는 힘들 것 같아서, 제 방식대로 한 번 풀어보고 공유합니다.

 처음에는 정석대로 노드를 구현하고 insertNode를 하는 방식이 먼저 떠올랐습니다.
그런데 'LCA를 구하는데 그렇게 많은 노력이 필요한가?' 라는 생각도 거의 동시에 들었습니다.

 그래서 저는 map에 parent-child의 관계를 기록하려고 했습니다.
이 방법 역시 LCA를 구하기에는 적절하지 않은 방식이라는 생각이 들었습니다.
(한 1시간 고민한 것 같네요...)

 map방식으로 tree를 구현해봤을 때의 문제는
부모 노드에 대한 정보가 사용하기 쉽게 저장되지 않는다는 것입니다.
그래서 부모 노드 정보를 담은 배열을 사용해서 LCA를 구하기로 했습니다.

 부모 노드정보를 아래와 같이 저장하고

vector<int> parent(N + 1, 0);
        for (int i = 0; i < N - 1; i++) {
            cin >> A >> B;
            parent[B] = A;
        }

 LCA를 구하고자 하는 두 노드를 x, y라고 했을 때 과정은 다음과 같습니다.

1. x노드를 root까지 이동 시키며, 방문 표시
2. y노드를 visit 표시가 된 곳까지 이동시키기

 어렵지 않게 이해할 수 있을 것 입니다.

int getLCA(vector<int>& parent, int x, int y, int N) {
    vector<bool> visit(N + 1, false);

    while (x != 0) {
        visit[x] = true;
        x = parent[x];
    }
    while (visit[y] != true) {
        y = parent[y];
    }

    return y;
}

[kangrae-jo]

 LCA문제를 보니 반가웠습니다.
처음에는 제가 원래 알던대로 직접 노드를 구현하고, 포인터로 링크를 구현하는 방식으로 설명해주셔서 이해가 빨랐습니다.
저는 이 알고리즘의 단점은 다음과 같다고 생각했습니다.

1. 노드를 구현하는 것에대한 시간 문제
2. 포인터를 많이 사용하기에 실수가 잦을 수 있는 등의 난이도 문제

 시간복잡도가 단점이라고는 생각하지 못했었습니다. 덕분에 새로운 방식을 알게되었네요.
희소 테이블 처음 들어봤습니다. 사실 희소(spare)라는 말은 예전에 들어봤는데 뜻을 정확히 몰랐습니다.
이번에 균호님께서 희소 테이블을 소개해주시고 관련된 블로그를 추천해주셔서 잘 배워갈 수 있겠네요. 감사합니다.

 희소 테이블을 사용하는 것에 대한 설명도 좋았습니다.
parent[i][j + 1] = parent[parent[i][j]][j]; 부분도 첨부된 이미지를 보고 한 번에 이해할 수 있었습니다.

[wnsmir]

꽤 긴시간에 걸쳐 브루트포스로 풀어봤습니다.
그러나 백준사이트에선 시간초과로 실패 처리되었습니다...

class Node:
    def __init__(self, value):
        self.value = value
        self.children = []
    
    def add_child(self, child_node):
        self.children.append(child_node)

N = int(input())
edges = [tuple(map(int, input().split())) for _ in range(N - 1)]

nodes = {}

# 트리 생성 (부모-자식 관계 설정)
for parent, child in edges:
    if parent not in nodes:
        nodes[parent] = Node(parent)
    if child not in nodes:
        nodes[child] = Node(child)
    
    # 부모-자식 관계 설정
    nodes[parent].add_child(nodes[child])
    nodes[child].add_child(nodes[parent])

# 부모와 깊이 정보를 저장한 후 LCA를 찾는 방식
def find_parent_bruteforce(nodes, child1, child2):
    parent_map = {}
    
    # 트리의 루트에서부터 DFS로 부모 정보를 저장
    def build_parent_map(node, parent=None):
        if parent is not None:
            parent_map[node.value] = parent
        for child in node.children:
            if child.value != parent:  # 이미 방문한 부모는 다시 방문하지 않음
                build_parent_map(child, node.value)
    
    # 부모 정보와 깊이를 기록 (루트는 1이라고 가정)
    root = nodes[1]
    build_parent_map(root)

    # 각 노드의 부모를 거슬러 올라가서 공통 조상을 찾음
    def find_ancestors(node_value):
        ancestors = []
        while node_value is not None:
            ancestors.append(node_value)
            node_value = parent_map.get(node_value, None)
        return ancestors

    # 두 자식의 공통 조상을 찾는 과정
    ancestors1 = find_ancestors(child1)
    ancestors2 = find_ancestors(child2)

    # 가장 가까운 공통 조상 찾기
    for ancestor in ancestors1:
        if ancestor in ancestors2:
            return ancestor

# 쿼리 입력
M = int(input())

# 각 쌍에 대해 공통 조상을 출력
for _ in range(M):
    node_a, node_b = map(int, input().split())
    print(find_parent_bruteforce(nodes, node_a, node_b))

시험 끝나고 LCA알고리즘으로 다시 풀어보겠습니다 ㅎ,,
알고보니 플레티넘문제였군요🥲

[kokeunho]

알고리즘 수업 수강 못했어도 혼자 공부해둘걸 하고 후회가 많이 되네요..
LCA도 잘 몰랐었는데
균호님의 친절한 설명 덕분에 LCA2에 대해 이해할 수 있었습니다.
sparse-table과 거듭제곱 단위 점프가 LCA와 LCA2의 주요 차이점인 것 같네요
아직 구현은 못할 것 같아요..
추후에 LCA 알고리즘 문제부터 차근차근 풀어보겠습니다.
수고하셨습니다!