ํธ๋ฆฌ ์ํ(1991๋ฒ)
Silver 1
#ํธ๋ฆฌ #์ฌ๊ท
https://www.acmicpc.net/problem/1991
๋ฌธ์ ๋ด์ฉ
๋ฌธ์ ์ ๊ทผ
์ ๋ ฅ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ํธ๋ฆฌ๋ฅผ ๋ง๋ค์ด์ ์ ์, ์ค์, ํ์ ์ํ๋ฅผ ํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค.
ํธ๋ฆฌ ๋ฌธ์ ๊ฐ ์์ํ ์ฌ๋๋ค์ ํธ๋ฆฌ๋ฅผ ์ด๋ป๊ฒ ๊ตฌ์ฑํด์ผ ํ๋์ง๋ถํฐ ๋๊ฐํ ๊ฒ์ด๋ค. ๋ด๊ฐ ๊ทธ๋ฌ๋ค.
ํธ๋ฆฌ ๊ตฌ์ฑ์ ๋ฌธ์ ๋ณธ๋ฌธ์ ๋์ ์๋ ๊ฒ ๊ทธ๋๋ก ๊ตฌ์ฑํด ๋ณผ ์๊ฐ์ด๋ค.
๋จผ์ ํ ๋ ธ๋์ ์ ๋ณด๋ฅผ ํ์ํ Node ๋ฐ์ดํฐ๋ฅผ ๊ตฌ์ฑํด ์ค ๊ฒ์ด๋ค. node์๋ value์ left, right ๋ฐ์ดํฐ๊ฐ ์กด์ฌํ๋๋ก ๊ตฌํํ๋ค.
private data class Node(
val value: String,
var left: Node?,
var right: Node?,
)
left์ right๋ ํ์ Node๋ก ๊ตฌ์ฑ๋์ด ์๋ค. nullable ํ๊ฒ ๊ตฌํํ ์ด์ ๋ ๋ฃจํธ ๋ ธ๋(ํธ๋ฆฌ์ ๋)์๋ ์์ ๋ ธ๋์ธ left, right๊ฐ ์กด์ฌํ์ง ์๊ธฐ ๋๋ฌธ์ด๋ค.
์์ ๊ฐ์ด data class๋ฅผ ๊ตฌํํด ์ฃผ๋ฉด ๋ฌธ์ ๋ณธ๋ฌธ์ ํธ๋ฆฌ์ ๋ ธ๋ ํ๋ํ๋๊ฐ Node๊ฐ ๋๋๋ก ๊ตฌ์ฑํด ์ค ์ ์๊ณ , ํธ๋ฆฌ ๋ณ์์ ํ์ ๋ Node ํ๋๋ก ์ ์ํ ์ ์๋ค. List๋ Map์ ์ธ ํ์๊ฐ ์๋ค.
ํ์ง๋ง ๊ทธ๋งํผ Node๋ฅผ ๊ตฌ์ฑํ๋ ๊ฒ ์ฌ์ด ๊ฒ ์๋๋ค.
๋ฌธ์ ์์ ๋ฃจํธ ๋ ธ๋๋ A๋ก ๊ณ ์ ๋์ด ์๋ค๊ณ ํ๊ธฐ ๋๋ฌธ์, tree๋ฅผ ์์ฑํด ์ค๋ค.
private val tree = Node("A", null, null)
์ด์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ์ผ๋ฉด์ right์ left๋ฅผ ์ฑ์์ฃผ๋ฉด ๋๋ค.
์ฑ์ฐ๋ ๊ฒฝ์ฐ๋ ๊ฐ ๋ ธ๋๊ฐ tree์ value์ ์ผ์นํ ๋๋ง ์ฑ์ ์ค์ผ ํ๋ค. ๋ง์นจํ๊ฐ ์ ๋ ฅ๋๋ ๊ฒฝ์ฐ๋ ์ ์ฒดํฌํด์ผ ํ๋ค.
์ด์ ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ ๋ฐ ํ์ํ ์กฐ๊ฑด๋ค์ ์์๋ณด์.
์กฐ๊ฑด๋ค์ ์ ๋ ฅ ์์ 1์ ๊ธฐ๋ฐ์ผ๋ก ์ค๋ช ํ๋ค.
7
A B C
B D .
C E F
E . .
F . G
D . .
G . .
<์กฐ๊ฑด 1>
์์์ ์ธ๊ธํ ๊ฒ์ฒ๋ผ ๋ค์ด์ค๋ ๊ฐ์ ๋ ธ๋ ๊ฐ์ด Node์ value์ ์ผ์นํด์ผ ํ๋ค.
private fun insertNode(tree: Node?, value: String, left: String, right: String) {
if (tree?.value == value) ...
...
}
์์ ๊ฐ์ด ์ค์ ํ๋ฉด ๋ง์ฝ value๊ฐ A๊ฐ ๋ค์ด์์ ๋, ํ์ฌ tree์ value์ธ A์ ์ผ์นํ๊ธฐ ๋๋ฌธ์ A์ ๊ฐ์ด ์ ๋ ฅ๋ B, C๋ฅผ ๊ฐ๊ฐ left, right์ ์ ์ฅํ๋ฉด ๋๋ค.
๋ง์ฝ ์ผ์นํ์ง ์์ ๊ฒฝ์ฐ์๋ ์ด๋ป๊ฒ ํด์ผ ํ ๊น?
<์กฐ๊ฑด 2>
ํ์ฌ tree์๋ value์๋ ๋ฃจํธ A๊ฐ ์๊ณ , ํ์ Node๋ค B, C๊ฐ ์๋ค. ์ด์ B์ ์์์ ์ฒดํฌํด์ผ ํ๋ค. ํ์ฌ tree?.value๋ A๋ก ์ค์ ๋์ด ์์ด์ ์กฐ๊ฑด์ด ๋ง์ง ์๋๋ค.
์กฐ๊ฑด 1์ด ์ผ์นํ์ง ์์ผ๋ฉด ์กฐ๊ฑด 1์ ์ ์ํ ์กฐ๊ฑด์์ tree?.value๋ฅผ ์์ ํด ์ค์ผ ํ๋ค. ๊ทธ๋๋ค ๋ค๋ฅธ ๊ฐ๋ค๋ ์์ Node๋ฅผ ์ค์ ํ ์ ์์ ํ ๋.
์กฐ๊ฑด์ ์์ ํ๊ธฐ ์ํ ์กฐ๊ฑด์ ํ์ฌ Node์ left ๋๋ right๊ฐ null์ด ์๋์ด์ผ ํ๋ค. ์ด๋ฅผ ์ฝ๋๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
if (tree?.left != null) insertNode(tree.left, value, left, right)
if (tree?.right != null) insertNode(tree.right, value, left, right)
ํ์ฌ A ํ์์ B, C Node๊ฐ ์กด์ฌํ๊ธฐ์ ์กฐ๊ฑด์ด ์ฑ๋ฆฝ๋๋ค. ๊ทธ๋ฌ๋ฏ๋ก tree์ ํด๋นํ๋ ๋ถ๋ถ์ ํ์ฌ tree.left๋ก ๊ต์ฒดํ๊ณ ์ฌ๊ท ํธ์ถ์ ํ๋ค. right๋ ๋ง์ฐฌ๊ฐ์ง.
๊ทธ๋ ๊ฒ ์ฌ๊ท ํธ์ถ์ ํ๋ฉด ๋ค์ ์กฐ๊ฑด 1๋ถํฐ ๋ค์ ๋ณด๊ฒ ๋๋๋ฐ ํ์ธํ ๋ ธ๋๋ฅผ A์ ํ์ ๋ ธ๋๋ก ์ฎ๊ฒจ๊ฐ๋ ๊ฒ์ด๋ค.
์ด๋ฅผ ๋ฐ๋ณตํ๊ฒ ๋๋ฉด ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ํธ๋ฆฌ๋ก ๊ตฌ์ฑํ ์ ์๊ฒ ๋๋ค.
์ฌ๊ท ํจ์๋ฅผ ํตํด ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ์ผ๋ฉด ๋๋จธ์ง๋ ์ฝ๋ค.
ํธ๋ฆฌ๋ฅผ ๋ค์ ์ฌ๊ท ํธ์ถ์ ํ๋ฉด์ ์ํํด ์ฃผ๋ฉด ๋๋ค.
์ ์ ์ํ๋ฅผ ์๋ก ๊ตฌํํด ๋ณด๊ฒ ๋ค.
์ ์ ์ํ ์์๊ฐ ๋ฃจํธ -> ์ผ์ชฝ -> ์ค๋ฅธ์ชฝ ์ด๊ธฐ ๋๋ฌธ์ ์ฌ๊ท ํจ์๋ฅผ ์๋์ ๊ฐ์ด ๊ตฌ์ฑํด ์ค๋ค.
private fun frontTraversal(node: Node?) {
if (node == null) return
// ์ ์ ์ํ: ๋ฃจํธ -> ์ผ์ชฝ -> ์ค๋ฅธ์ชฝ.
print(node.value)
frontTraversal(node.left)
frontTraversal(node.right)
}
๋จผ์ ๋ฃจํธ๋ฅผ ์ถ๋ ฅํด์ผ ํ๊ธฐ ๋๋ฌธ์ ์ถ๋ ฅ์ ๋จผ์ ์งํํ๊ณ , ์ผ์ชฝ์ผ๋ก ๊ทธ๋ค์์ ์ค๋ฅธ์ชฝ์ผ๋ก ํ์์ ์งํํ๋ค.
๋จผ์ ์ผ์ชฝ ๋ฐฉํฅ์ผ๋ก ๊ฐ๋๋ฐ, ๋ฃจํธ ๋ ธ๋๊น์ง ๋๊น์ง ์งํํ๊ณ null์ด ๋ค์ด์ค๋ฉด ํจ์๊ฐ ๋๋๊ฒ ๋๋ค.
๊ฐ๋จํ๊ฒ ํ์ ๊ณผ์ ์ ์ค๋ช ํ๊ฒ ๋ค.
1. ์ฐ์ A๋ถํฐ ์์ํด B, D์์ผ๋ก ํ์์ ์งํํ๋ค.
2. D์ ๋๋ฌํ๊ฒ ๋๋ฉด ๋ค์ Node๋ null์ด๊ธฐ ๋๋ฌธ์ ์ฌ๊ท๊ฐ ๋๋๊ณ ๋จ์ tree.right ์ฌ๊ท๊ฐ ํธ์ถ๋๋ค.
3. C๋ฅผ ์ถ๋ ฅํ๊ณ ๋ค์ tree.left ์ฌ๊ท๋ก ๋ค์ด๊ฐ์ E๋ฅผ ์ถ๋ ฅํ๊ณ return ๋๋ค(๋ค์ Node๊ฐ null).
4. ๋ค์ C์ tree.right ์ฌ๊ท๋ฅผ ์งํํด F, G๋ก ์งํ๋๋ค(left๋ null์ด๋ผ ๋์ด๊ฐ).
๊ทธ๋์ ์ถ๋ ฅ์ด ABDCEFG๊ฐ ๋๋ค.
์ค์, ํ์ ์ํ๋ ์ ์ ์ํ ํจ์์ฒ๋ผ ์ฌ๊ท๋ก ์งํํ๋ฉด ๋๋ค.
๋ฌธ์ ํด๊ฒฐ ์ฝ๋
import java.io.BufferedReader
import java.io.InputStreamReader
private val tree = Node("A", null, null)
private data class Node(
val value: String,
var left: Node?,
var right: Node?,
)
fun main() = with(BufferedReader(InputStreamReader(System.`in`))) {
val case = readLine().toInt()
for (i in 0 until case) {
val (number, left, right) = readLine().split(" ")
insertNode(tree, number, left, right)
}
frontTraversal(tree)
println()
middleTraversal(tree)
println()
endTraversal(tree)
}
private fun insertNode(tree: Node?, value: String, left: String, right: String) {
if (tree?.value == value) {
tree.left = if (left == ".") null else Node(left, null, null)
tree.right = if (right == ".") null else Node(right, null, null)
} else {
if (tree?.left != null) insertNode(tree.left, value, left, right)
if (tree?.right != null) insertNode(tree.right, value, left, right)
}
}
private fun frontTraversal(node: Node?) {
if (node == null) return
// ์ ์ ์ํ: ๋ฃจํธ -> ์ผ์ชฝ -> ์ค๋ฅธ์ชฝ.
print(node.value)
frontTraversal(node.left)
frontTraversal(node.right)
}
private fun middleTraversal(node: Node?) {
if (node == null) return
// ์ค์ ์ํ: ์ผ์ชฝ ์์ -> ๋ฃจํธ -> ์ค๋ฅธ์ชฝ ์์.
middleTraversal(node.left)
print(node.value)
middleTraversal(node.right)
}
private fun endTraversal(node: Node?) {
if (node == null) return
// ํ์ ์ํ: ์ผ์ชฝ -> ์ค๋ฅธ์ชฝ -> ๋ฃจํธ.
endTraversal(node.left)
endTraversal(node.right)
print(node.value)
}
๋ฌธ์ ํ์ด
Node data class๋ฅผ ์์ฑํด ์ฃผ๊ณ ์กฐ๊ฑด 1, ์กฐ๊ฑด 2๋ฅผ ๋ฐํ์ผ๋ก tree ๋ณ์์ ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํด ์ค๋ค.
๊ทธ๋ฆฌ๊ณ ์ ์ ์ํ, ์ค์ ์ํ, ํ์ ์ํ์ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค.
๋ฌธ์ ํด๊ฒฐ ๊ณผ์
ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฒ๋ ํ๋ค๋ค.
์ฒ์ ํ๋ ์ฌ๋๋ค์ ๋ง์ด ํค๋งฌ ์ ์๋ค. ๋ด๊ฐ ๊ทธ๋ฌ๋ค.
๋๋ ํธ๋ฆฌ ๊ตฌ์ฑ๋ถํฐ ๋งํ์ ์ ๋ต์ ์ฐธ๊ณ ํ ์๋ฐ์ ์์๋ค.
ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ ๊ฒ์ ์ ๋ฐ ํ์์ ๋ฐ๋ฅธ๋ค๋ ๊ฒ์ ์๊ณ ์์ด์ผ๊ฒ ๋ค.
์ฐธ๊ณ ํ ๋ธ๋ก๊ทธ ๋งํฌ๋ ๊ฑธ์ด ๋๊ฒ ๋ค.
https://stdio-han.tistory.com/138
'๐ฏ | ๋ฐฑ์ค > ๐ | Silver' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin] ๋ฐฑ์ค 16506๋ฒ CPU (0) | 2024.08.23 |
---|---|
[Kotlin, S5] ๋ฐฑ์ค 11068๋ฒ ํ๋ฌธ์ธ ์ (0) | 2024.08.23 |
[Kotlin, S3] ๋ฐฑ์ค 1904๋ฒ 01ํ์ผ (0) | 2024.08.20 |
[Kotlin, S3] ๋ฐฑ์ค 1002๋ฒ ํฐ๋ (0) | 2024.08.20 |
[Kotlin, S3] ๋ฐฑ์ค 1004๋ฒ ์ด๋ฆฐ ์์ (0) | 2024.08.19 |