57-tgyuuAn

[tgyuuAn]

🔗 문제 링크

트리의 순회

✔️ 소요된 시간

2시간

✨ 수도 코드

인오더, 프리오더, 포스트오더 (Inorder, Preorder, Postorder)

이 문제 쪼꼼은 어렵다.

문제를 풀기 전에, 위에 링크에서 도대체 문제를 어떻게 풀 수 있을 까 곰곰히 20분동안 쳐다보기만 했다.

갑자기 무언가 번뜩 떠올랐다.

아래와 같은 트리에 후위 순회로 탐색한다고 해보자. (Left -> Right -> Root)

(1) -> (4) -> (6) -> (5) -> (3) -> (12) -> (16) -> (15) -> (7)

그러면 마지막으로 탐색되는 항은 항상 트리의 루트가 된다.

그리고 그 루트 값 (7) 이 전위 순회 에서 어디에 위치하는 지 찾아보니,

(1) -> (3) -> (4) -> (5) -> (6) -> (7) -> (12) -> (15) -> (16)

정확히 왼쪽 트리, 오른쪽 트리를 가르고 있다는 것을 알게 되었다.

호올리... 이 규칙을 찾자마자 무언가 머리 속에서 스쳐 지나갔다.

무엇인지 찾으셨나요 ...?

그것은 바로, 아래와 같이 오른쪽, 왼쪽 트리를 나눈 뒤

전위 순회, 후위 순회를 분할하면 또 똑같은 문제가 나온다는 것...!

즉 이 문제는 분할 정복 이었따!!!!!!!!

이 것을 파악한 뒤, 처음에는 오른쪽 트리, 왼쪽 트리를 나누는 것을 그냥 리스트를 잘라서 복사 하려고 했다.

import sys

def input(): return sys.stdin.readline().rstrip()

N = int(input())
in_order = list(input().split())
post_order = list(input().split())

def divide_and_conquer(in_order, post_order):
    pre_order_root = post_order.pop()
    root_idx = in_order.index(pre_order_root)

    left_in_order_tree = in_order[:root_idx]
    right_in_order_tree = in_order[root_idx+1:] if root_idx != len(in_order) else []

    pre_order = [pre_order_root]
    temp = []
    if len(right_in_order_tree) >= 1:
        temp = divide_and_conquer(right_in_order_tree, post_order)
    
    if len(left_in_order_tree) >= 1:
        pre_order.extend(divide_and_conquer(left_in_order_tree, post_order))
    
    pre_order.extend(temp)
    return pre_order

print(" ".join(divide_and_conquer(in_order, post_order)))

하지만 이렇게 하니까 메모리 초과가 나버렸고,

결국 리스트를 아예 건들지 않고, 인덱스로만 트리를 자르도록 로직을 바꿨다.

이 과정에서 시간을 너무 많이 써버렸다.

쨋든 계속 슛해보면서 디버깅하고 어떻게든 풀었다...............

📚 새롭게 알게된 내용

[SeongHoonC]

전위, 후위, 중위 순회도 오랜만에 봐서 개념 잡느라 여려웠네요..
문제 푸는 아이디어가 생각이 안나서 코드를 따라치면서 이해해보았습니다..!

lateinit var br: BufferedReader
lateinit var inOrder: List<Int>
lateinit var postOrder: List<Int>
lateinit var positions: Array<Int>

fun main() {
    br = BufferedReader(InputStreamReader(System.`in`))
    val n = br.readLine().toInt()
    inOrder = br.readLine().split(" ").map { it.toInt() }
    postOrder = br.readLine().split(" ").map { it.toInt() }
    positions = Array(n + 1) { 0 }

    // 각 노드가 몇번째 인덱스에 있는지 저장
    inOrder.forEachIndexed { index, value ->
        positions[value] = index
    }
    divideAndConquer(0, n - 1, 0, n - 1)
}

private fun divideAndConquer(inStart: Int, inEnd: Int, postStart: Int, postEnd: Int) {
    if (inStart > inEnd || postStart > postEnd) return

    // post 의 마지막은 parent 이다.
    val inOrderParent = postOrder[postEnd]
    // pre-order 는 P-L-R 순
    print("$inOrderParent ")

    // 인오더에서 Parent 가 어디있는지 찾기
    val parentIndex = positions[inOrderParent]

    // 왼쪽
    divideAndConquer(inStart, parentIndex - 1, postStart, postStart + (parentIndex - inStart) - 1)

    // 오른쪽
    divideAndConquer(parentIndex + 1, inEnd, postStart + (parentIndex - inStart), postEnd - 1)
}

[alstjr7437]

호올리.... 어떻게 후위 순회는 루트가 제일 뒤로 가고 그 부분을 이용해서 루트 찾고
전위를 이용해서 왼쪽 오른쪽 나누고 분할정복을 하는 방식을 찾은 당신... 신입니까??..🧠🧠

[alstjr7437]

새로운 리스트를 만들어서 해야하나 했는데 이렇게 그냥 바로 print를 해서 중위 순회 출력도 가능하군요 ㄷㄷㄷㄷ

[alstjr7437]

혹시 그냥 궁금한점인데

input = sys.stdin.readline

위 코드와 태규님의 함수화와 다른점이 따로 있을까요??

[tgyuuAn]

업쑤다!!!!!!!!!!!!!!!!!!!!!!!!!!!!

[H0ngJu]

옛날 과제에 postorder가 주어지면, preorder를 출력하는 문제를 푼 적이 있어서
그 코드를 좀 응용해서 제출했더니 계속 메모리 초과가 났슴다..

그래서 태규님 PR이랑 다른 레퍼런스를 참조했어요

hmmmmm.. 트리 문제는 안익숙해서 그런가 어렵네효 🌳 🌳🌳🌳🌳🌳🌳

수고하셨슴다~!

def findPreorder(start, end, postStart, postEnd):
    if postStart > postEnd:
        return

    root = postorder[postEnd]
    print(root, end=" ")
    rIdx = inorderIndex[root]

    leftLength = rIdx - start

    findPreorder(start, rIdx - 1, postStart, postStart + leftLength - 1)
    findPreorder(rIdx + 1, end, postStart + leftLength, postEnd - 1)