์ฐฉ์ ์ ํ ์๋(31409๋ฒ)
Silver 3
#๊ทธ๋ํ ์ด๋ก #์ ๋ ํน #ํด ๊ตฌ์ฑํ๊ธฐ #ํจ์ํ ๊ทธ๋ํ
๋ฌธ์ ๋ด์ฉ
๋ฌธ์ ์ ๊ทผ
์ ํ๊ธฐ๊ฐ ์ฃผ์ด์ก์ ๋, ์ฐฉ์ ์ ํ์ ํด์ ๋ชจ๋ ์ ํ๊ธฐ๋ฅผ ๋จนํต์ผ๋ก ๋ง๋๋ ์ต์์ ๊ฒฝ์ฐ๋ฅผ ๊ตฌํด์ผ ํ๋ ๋ฌธ์ ์ด๋ค.
๋ฌธ์ ๋ณธ๋ฌธ์ ์์๋ฅผ ๋ค๋ฉด, A => B, B => C, C => A ์์ผ๋ก ์ ํ๋ฅผ ์ฐ๊ฒฐํ๊ณ ์๋ค.
3๊ฐ์ ์ ํ๊ธฐ๊ฐ ๋ฌดํ ์ฌ์ดํด์ ๋๊ณ ์๋ค๋ ๊ฒ์ ์ ์ ์๋ค.
์ ํ๊ธฐ ์ฌ๋ฌ ๊ฐ๋ฅผ ๋ฌดํ ์ฌ์ดํด์ ๋๋ฆฌ๋ ๋ฐฉ๋ฒ์ ๋ค์ํ๋ค.
๋ฌธ์ ์ ์ ๋ ฅ ์์ ๋ง ๋ด๋ ์ ์ ์๋ค.
์ ๋ ฅ ์์ 2๋ ๋ค์๊ณผ ๊ฐ์ด ์ ๋ ฅ์ ๋ฐ๋๋ค.
5
2 1 5 3 4
์ ์ ๋ ฅ๊ฐ์ ๊ทธ๋ํ๋ก ๋ํ๋ด๋ฉด ์๋์ ๊ฐ๋ค.
๊ทธ๋ํ์ ์ ํ๊ฐ ์๋ก ์ด์ด์ ธ์ ๋ฌดํํ ์ฌ์ดํด์ ํ์ฑํ๋ค. ์ด ๊ฒฝ์ฐ์๋ ์ด๋ฏธ ๋จนํต ์ํ์ด๋ฏ๋ก, ๋ฐ๊ฟ์ฃผ์ง ์์๋ ๋๋ค.
๊ฐ ์ ํ๊ธฐ์ ์ฐ๊ฒฐ๋ ์ ํ๊ธฐ๋ฅผ ํ์ธํ๊ธฐ ์ํด์๋ Map์ ์ด์ฉํด ์ด๋ค ์ ํ์ ์ฐ๊ฒฐ๋์ด ์๋์ง ํ์ธํ ํ์๊ฐ ์๋ค.
// graph ๊ตฌ์กฐ: key = ์ ํ๊ธฐ ๋ฒํธ, value = ๊ฑธ๋ ค ์๋ ์ ํ๊ธฐ ๋ฒํธ
private val graph = mutableMapOf<Int, Int>()
์ ๋ ฅ ์์ 3์ ์ ํ๊ธฐ ๋ฒํธ, ์ฐ๊ฒฐ๋ ์ ํ๊ธฐ๋ฅผ map์ผ๋ก ํ์ธํด ๋ณด๋ฉด์ ํ์ ํด ๋ณด์.
4
4 4 4 4
์ ๋ ฅ ์์ ๋ ๋ค์๊ณผ ๊ฐ๊ณ , ์ ํ๊ธฐ์ ๋ฒํธ๋ ์ ๋ ฅ ์์๋๋ก ์ฃผ์ด์ง๊ณ , ์ฐ๊ฒฐ๋ ์ ํ๊ธฐ๋ ์ ๋ ฅ๋ ๊ฐ์ ๋ปํ๋ค.
์ด๋ฅผ ์ด์ฉํด Map์ ๊ตฌ์ฑํด ๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
{1 : 4,
2 : 4,
3 : 4,
4 : 4}
์ ๋ ฅ ์์ผ๋ก ์ ํ๊ธฐ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๊ณ , ์ ๋ ฅ๋ ๊ฐ์ด ์ ํ๊ธฐ ๋ฒํธ์ด๋ค.
์ด ์์ ์ ์ ๋ต์ ๊ทธ๋ํ์ Map์ผ๋ก ๋ํ๋ด๋ณด์.
// ์
๋ ฅ ์์ 3
{1 : 4,
2 : 4,
3 : 4,
4 : 3}
// ์
๋ ฅ ์์ 2
{1 : 2,
2 : 1,
3 : 5,
4 : 3,
5 : 4}
์์ ๊ฒฝ์ฐ์๋ ๋ฌดํํ ์ฌ์ดํด์ด ์์ฑ๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
์ Map์ ๋ณด๊ณ ํ๋์ ์ฌ์ค์ ์ ์ ์๋ค.
๋ฌดํ ์ฌ์ดํด์ด ์ ์ฉ๋๊ธฐ ์ํด์๋ ์ ํ๊ธฐ ๋ฒํธ์ ์ฐ๊ฒฐ๋ ์ ํ๊ธฐ๊ฐ ๊ฐ์ผ๋ฉด ์ ๋๋ค.
์ฆ, ์ฐฉ์ ์ ํ์ด ๊ฑธ๋ ค ์์ง ์์ ์ ํ๊ธฐ๊ฐ ์์ด์ผ ๋ฌดํ ์ฌ์ดํด์ด ํ์ฑ๋๋ค.
์ด ์ฌ์ค์ ์ด์ฉํด ๊ฐ์ ์ ๋ ฅ๋ฐ์ ๋ ์ ํ๊ธฐ ๋ฒํธ์ ๊ฑธ๋ ค ์๋ ์ ํ๊ธฐ๊ฐ ๊ฐ์์ง ํ์ธํด ์ฃผ๋ ์์ ์ด ํ์ํ๋ค.
์ด๋ฅผ Kotlin ์ฝ๋๋ก๋ ๋ค์๊ณผ ๊ฐ์ด ๋ํ๋ผ ์ ์๋ค.
<์กฐ๊ฑด 1>
i == calling[i]
i๊ฐ ์ ํ๊ธฐ ๋ฒํธ์ด๊ณ , calling์ด ํ์ฌ ์ฐ๊ฒฐ๋์ด ์๋ ์ ํ๊ธฐ๋ฅผ ๋ปํ ๋, ์ ํ๊ธฐ ๋ฒํธ์ ํ์ฌ ์ฐ๊ฒฐ๋ ์ ํ๊ธฐ๊ฐ ๊ฐ์ผ๋ฉด ์ฐฉ์ ์ ํ์ด ๊ฑธ๋ ค ์๋ ์ํ๊ฐ ์๋๊ธฐ ๋๋ฌธ์ ์ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด ํด๋น ์ ํ๊ธฐ์ ๋ค๋ฅธ ์ ํ๋ฅผ ์ฐ๊ฒฐํด ์ฃผ๋ฉด ๋๋ค.
๋ฌธ์ ํด๊ฒฐ ์ฝ๋
import java.io.BufferedReader
import java.io.InputStreamReader
fun main() = with(BufferedReader(InputStreamReader(System.`in`))) {
val cellPhoneCnt = readLine().toInt()
val calling = mutableListOf(0)
val phone = readLine().split(" ").map { it.toInt() }
var changeCnt = 0
calling.addAll(phone)
for (i in 1 .. cellPhoneCnt) {
if (i == calling[i]) {
val toChange = if (i == cellPhoneCnt) 1 else cellPhoneCnt
calling[i] = toChange
changeCnt++
}
}
println(changeCnt)
println(calling.filter { it != 0 }.joinToString(" "))
}
๋ฌธ์ ํ์ด
๋ฌธ์ ์ ๊ทผ์์๋ Map์ ์์๋ก ๋ค์์ง๋ง ํด๊ฒฐ ์ฝ๋์์๋ List์ index๋ฅผ ํ์ฌ ์ ํ๊ธฐ ๋ฒํธ๋ก ๊ฐ์ ํ๊ณ , index์ ๊ฐ์ ๊ฑธ๋ ค ์๋ ์ ํ๊ธฐ๋ก ๊ฐ์ ํ๊ณ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
calling list์ ์ ํ๊ธฐ ๋ฒํธ๊ฐ 0์ธ ๊ฒฝ์ฐ๋ ์์ผ๋ฏ๋ก 0์ ๋ฉ์ ์ฃผ๊ณ , 1๋ฒ์งธ index๋ถํฐ ์ ๋ ฅ๋ ๊ฐ์ ์ ๋ถ ๋ฃ์ด ์ค๋ค.
์์ ์ธ๊ธํ <์กฐ๊ฑด 1>์ ๋ง์กฑํ ๊ฒฝ์ฐ, ๊ธฐ์กด ์ฐ๊ฒฐ๋ ์ ํ๋ฅผ ๋ค๋ฅธ ์ ํ๋ก ๋ฐ๊ฟ ์ฃผ์ด์ผ ํ๋ค.
์ด๋ค ๊ฐ์ผ๋ก ๋ฐ๊พธ๋ ์๊ด์๊ธฐ ๋๋ฌธ์, ๋ง์ง๋ง ์ ํ๊ธฐ ๋ฒํธ์ธ ๊ฒฝ์ฐ์๋ 1, ๊ทธ๋ ์ง ์์ ๋๋ ๋ง์ง๋ง ์ ํ๋ก ์ ํ๋ฅผ ๊ฑธ ์ ์๋๋ก ํด์ฃผ์๋ค.
์ถ๋ ฅํ ๋๋ calling์ 0๋ฒ์งธ ๊ฐ์ ์ถ๋ ฅํ์ง ์๋๋ก ์ ๊ฑธ๋ฌ์ ์ถ๋ ฅํ๋ค.
๋ฌธ์ ํด๊ฒฐ ๊ณผ์
์ธ๋ฐ์์ด ์ฌ๊ท๋ก ๋ฌธ์ ๋ฅผ ํ์ด ๋ณด๋ ค๋ค๊ฐ ์ด๋ง์ ๋ณด๊ณ ์์ ๋ฌธ์ ํด๊ฒฐ๋ฒ์ ์ฐพ์์ ํด๊ฒฐํ ๋ฌธ์ ์ด๋ค.
์ฒ์์๋ ๊ฐ ์ ํ์ ๊ฑธ๋ ค ์๋ ๊ฐ์ผ๋ก ๊ณ์ ์ฌ๊ท๋ก ๋ค์ด๊ฐ๋ฉด์ ๋ค์ด๊ฐ ๊ฐ์ด ์ฐฉ์ ์ ํ์ด ์๋ ์ ํ์ธ ๊ฒฝ์ฐ์๋ง ๊ฐ์ ๋ณ๊ฒฝํด ์ฃผ์๋ค. ๊ทธ๋ ๊ฒ ํ๋๊น 94%์ฏค์์ ํ๋ ธ๋ค๊ณ ๋์ค๋๋ผ.
๊ทธ๋์ ๋ฌธ์ ํด์ค์์ ํํธ๋ฅผ ์ป์ด์ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด ์ฃผ์๋ค.
'๐ฏ | ๋ฐฑ์ค > ๐ | Silver' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin, S2] ๋ฐฑ์ค 30804๋ฒ ๊ณผ์ผ ํํ๋ฃจ (0) | 2024.08.05 |
---|---|
[Kotlin, S2] ๋ฐฑ์ค 21736๋ฒ ํ๋ด๊ธฐ๋ ์น๊ตฌ๊ฐ ํ์ํด (0) | 2024.08.04 |
[Kotlin, S2] ๋ฐฑ์ค 18111๋ฒ ๋ง์ธํฌ๋ํํธ (0) | 2024.08.03 |
[Kotlin, S4] ๋ฐฑ์ค 25184๋ฒ ๋๊ฐ์์ด ๊ตฌํ๊ธฐ (0) | 2024.08.01 |
[Kotlin, S5] ๋ฐฑ์ค 30923๋ฒ ํฌ๋๊ณผ 3D ํ๋ฆฐํฐ (0) | 2024.08.01 |