๐ ๋ฌธ์
๐ง ์์ด๋์ด
N ์ด 50๋ง๊ฐ๋ฏ๋ก $$ O(N^2) $$ ์ผ๋ก ํ์๋ค๊ฐ ๋ฌด์กฐ๊ฑด ์๊ฐ์ด๊ณผ๋ค.
50๋ง * 50๋ง => 2,500์ต ํ ๋ก ๊ฑฐ์ง 10์ด๊ฐ ์์๋๋ค.
O(N) ์ ๊ฐ๊น์ด ํ์ด๋ฅผ ์๊ฐํดํ๋ค. == ๋์ด๋ฅผ ์์์๋ถํฐ ์ค๋ฅธ์ชฝ์ผ๋ก ์ํํ๋ฉฐ ํ ๋ฒ์ ๋ต์ ๊ตฌํ ์ ์์ด์ผํ๋ค.
๊ฐ์ฅ ๋จผ์ ์ ํธ๋ฅผ ๋ฐ์ ํ์๋ ๋์ด๊ฐ ๋ด ์ผ์ชฝ์ ์๋ ๊ฒ์ค ์ต์ ์ ๊ฒ์ด๋ฏ๋ก ์๋ก์ด ํ์์์ ์ ํธ๋ฅผ ๋ณด๋ผ ๋๋ง๋ค ๋ค์์ ๊ฒ์ฌํ๋ค.
- ์๋ก ๋์จ ํ์๊ฐ ํ์ฌ stack top ๋ณด๋ค ๋ฎ๊ฑฐ๋ ๊ฐ์ผ๋ฉด
- stack top ํ์์ ๋ฒํธ๋ฅผ ์ ๋ต์ผ๋ก ์ ๋ ฅํ๊ณ
- ์๋ก ๋์จ ํ์๊ฐ ํ์ฌ stack top ๋ณด๋ค ํฌ๋ฉด
- ์๋ก ๋์จ ํ์ ๋์ด๋ณด๋ค ๋ฎ์ ๋ชจ๋ ์ ๋ค์ popํด์ ์ง์๋ฒ๋ฆฌ๊ณ
- ์๋ก๋์จ ํ์ ๋์ด์ ๊ฐ๊ฑฐ๋ ํฐ ์ ์ ํ์ ๋ฒํธ๋ฅผ ์ ๋ต์ผ๋ก ์ ๋ ฅํ๋ค.
์ ๋ถ๊ธฐ์ ์๊ด ์์ด ์๋ก ๋์จ ํ์์ ๋์ด๊ฐ ์ด๋ป๊ฑด ์๋ก ๋ง์ฃผํ ํ์๋ฅผ ์คํ์ ๋ฃ์ด์ผํ๋ค.
(๋ค๋ค์ ์คํ์ ๋ ๋ฎ์ ํ์๊ฐ ๋ํ๋ ์ ์๋ค.)
ํ์ ๋ฒํธ๋ฅผ ํตํด์ผํ๋ฏ๋ก Stack์ ๋จ์ ํ์ ๋์ด (Int) ๊ฐ์ด ์๋๋ผ (ํ์ ๋ฒํธ, ๋์ด) ๊ฐ์ keep ํ๋ค.
ํ์์ ๋์ด๋ฅผ ๋ฐฐ์ด์ ์ ์ฅํ๋ค๋ฉด ํ์ ๋ฒํธ == index + 1 ์ด๋ค.
๐ Kotlin Code
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
data class Tower(val number: Int, val height: Int) {}
fun main() {
val bufferedReader = BufferedReader(InputStreamReader(System.`in`))
val N = bufferedReader.readLine().toInt()
val towerHeights = bufferedReader.readLine().split(" ").map(String::toInt)
val stringBuilder = StringBuilder()
val stack = Stack<Tower>()
towerHeights.forEachIndexed { index, height ->
// ๋น์ด์ ธ ์๋ ์ํ๋ผ๋ฉด
if (stack.isEmpty()) stringBuilder.append("0 ")
// ์ต๊ทผ์ ์ธ์์ง ํ์๊ฐ ๋ฐ๋ก ์ ํธ๋ฅผ ๋ฐ์ ์ ์์ผ๋ฉด
// ํ์๋ฅผ ์ธ์ฐ๊ณ ์ ํธ ์ฒ๋ฆฌ.
else if (stack.peek().height >= height) stringBuilder.append("${stack.peek().number} ")
else {
// ํ์ฌ ๋ํ๋ ํ์์ ์ ํธ๋ฅผ ๋ฐ์ ํ์๊ฐ ๋ํ๋ผ๊น์ง ์ด์ ํ์๋ฅผ ์ญ์ ์ํด
while(stack.isNotEmpty() && stack.peek().height < height) stack.pop()
// ์ด๋ค ํ์๋ ๊ฐ๊ฑฐ๋ ๋์ ๋์ด๋ฅผ ๊ฐ์ง์ง ๋ชปํด ์ ํธ๋ฅผ ๋ฐ์ง ๋ชปํ์ผ๋ฉด 0
if (stack.isEmpty()) stringBuilder.append("0 ")
// ์ ํธ๋ฅผ ๋ฐ์ ํ์์ ๋ฒํธ๋ฅผ ์ถ๊ฐ
else stringBuilder.append("${stack.peek().number} ")
}
stack.push(Tower(index + 1, height))
}
print(stringBuilder.toString())
}
โ๏ธ ๋ฆฌํํ ๋ง
๋งค loop ๋ง๋ค ์คํ์ด ๋น์ด์๋์ง ๋น์ด์์ง ์์์ง ์ฒดํฌํ๋ ๊ฒ ๋๋ฌธ์ ์ฝ๋๊ฐ ์กฐ๊ธ ๋๋ฌ์ ๋ค.
์์ ์ ๋ ๋์ ์ ์๋ ์ต๋ ๋์ด์ 0๋ฒ ํ์๊ฐ ์กด์ฌํ๋ค๊ณ ๊ฐ์ ํ๋ฉด ๋ ๊น๋ํ๊ฒ ์ฝ๋๋ฅผ ์งค ์์๋ค.
(์ด๋ค ํ์๋ ๋ฐ๋์ 0๋ฒ ์ด์์ ๋ต์ผ๋ก ๊ฐ์ง ๊ฒ์ด๋ฏ๋ก)
์๋ก ์ธ์ธ ํ์์ ๋์ด์ ๋ฌด๊ดํ๊ฒ ๋ฌด์กฐ๊ฑด ํ์๋ ์ธ์ธ ๊ฒ์ด๊ณ ๋งค loop ๋ง๋ค ์ ํธ๋ฅผ ๋ฐ์ ํ์๋ง stringBuilder ์ ์ถ๊ฐํด์ฃผ๋ฉด ๋๋ค.
๐ Kotlin Code (๊ฐ์ ๋ ํ์ด)
import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*
data class Tower(val number: Int, val height: Int) {
}
fun main() {
val bufferedReader = BufferedReader(InputStreamReader(System.`in`))
val N = bufferedReader.readLine().toInt()
val stringBuilder = StringBuilder()
val stack = Stack<Tower>()
// ์ ํธ๋ฅผ ์๋ฌด ํ์๋ ๋ชป๋ฐ์ผ๋ฉด 0์ ๋ฐํํ ๊ฒ์ด๋ฏ๋ก
// ์์ ๋์ด๋ฅผ ๋ฌดํ๋๋ก ๊ฐ๋ 0 ๋ฒ ํ์๊ฐ ์กด์ฌํ๋ ๊ฒ์ผ๋ก ๋์น
// -> stack ์ด null ์ธ์ง ์๋์ง ๊ฒ์ฌํ ํ์๊ฐ ์์ด์ง. -> ์ฝ๋๊ฐ ๊ฐ๊ฒฐํด์ง.
stack.push(Tower(0, Int.MAX_VALUE))
val towers = bufferedReader.readLine().split(" ").map(String::toInt)
towers.forEachIndexed { index, currentHeight ->
// ํ์ฌ ์ธ์์ง ํ์์ ๋ํด ์ ํธ๋ฅผ ๋ชป๋ฐ๋ ํ์๋ ์กด์ฌํ ํ์๊ฐ ์์.
while (stack.peek().height < currentHeight) stack.pop()
// ์ ํธ ๋ฐ์ ํ์๊ฐ ์์ผ๋ฉด 0, ์์ผ๋ฉด ๋ฐ์ ํ์ ๋ฒํธ
stringBuilder.append("${stack.peek().number} ")
// ์์์ ์ ํธ๋ฐ์ ํ์๊ฐ ์๋ ์๋ ํ์ฌ ํ์๋ ์ธ์์ผํจ. ํ์ ๋ฒํธ๋ 1๋ถํฐ ์์ํ๋ฏ๋ก ํ์ฌ index + 1
stack.push(Tower(index + 1, currentHeight))
}
print(stringBuilder.toString())
}
'Algorithm > Algorithm (๋ฌธ์ ํ์ด)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 18808 ์คํฐ์ปค ๋ถ์ด๊ธฐ (0) | 2022.10.06 |
---|---|
[๋ฐฑ์ค] 15683 ๊ฐ์ (0) | 2022.10.03 |
[๋ฐฑ์ค] 2217 ๋กํ (0) | 2022.09.28 |
[๋ฐฑ์ค] 11779 ์ต์๋น์ฉ ๊ตฌํ๊ธฐ 2 (0) | 2022.09.23 |
[LeetCode] Same Tree (0) | 2022.09.05 |