1. ๋ฌธ์
๋ํธ๋ ๋ด๋ ์ ์ด๋ฑํ๊ต๋ฅผ ์ ํํ๋ค. ๊ทธ๋์ ๋ํธ ์ด๋จธ๋๋ ์ํ ์ ํ ํ์ต์ ์ํด ์ฝ๊ฒ ํธ๋ ๋ฌธ์ ๋ฅผ ๋ํธ์๊ฒ ์ฃผ์๋ค.
์ด ๋ฌธ์ ๋ ๋ค์๊ณผ ๊ฐ๋ค. 1์ ํ ๋ฒ, 2๋ฅผ ๋ ๋ฒ, 3์ ์ธ ๋ฒ, ์ด๋ฐ ์์ผ๋ก 1 2 2 3 3 3 4 4 4 4 5 .. ์ด๋ฌํ ์์ด์ ๋ง๋ค๊ณ ์ด๋ ์ผ์ ํ ๊ตฌ๊ฐ์ ์ฃผ๋ฉด ๊ทธ ๊ตฌ๊ฐ์ ํฉ์ ๊ตฌํ๋ ๊ฒ์ด๋ค.
ํ์ง๋ง ๋ํธ๋ ํ์ฌ ๋ ์ด๋ ค์ด ๋ฌธ์ ๋ฅผ ํธ๋๋ผ ๋ฐ์๊ธฐ์ ์ฐ๋ฆฌ๊ฐ ๋ํธ๋ฅผ ๋์์ฃผ์.
2. ์ ๋ ฅ
์ฒซ์งธ ์ค์ ๊ตฌ๊ฐ์ ์์๊ณผ ๋์ ๋ํ๋ด๋ ์ ์ A, B(1 ≤ A ≤ B ≤ 1,000)๊ฐ ์ฃผ์ด์ง๋ค. ์ฆ, ์์ด์์ A๋ฒ์งธ ์ซ์๋ถํฐ B๋ฒ์งธ ์ซ์๊น์ง ํฉ์ ๊ตฌํ๋ฉด ๋๋ค.
3. ํ์ด (์๊ฐ์ ํ๋ฆ)
1. ๊ตฌ๊ฐ์ ํฉ -> 3~7 ๊ตฌ๊ฐ์ ํฉ์ด๋, 7๊น์ง ๋์ ๋ ํฉ - 2๊น์ง ๋์ ๋ ํฉ๊ณผ ๋์ผํ๋ค
2. 3~7๊ตฌ๊ฐ์ ํฉ = 7 ๋์ ํฉ - 2 ๋์ ํฉ
3. ๋์ ํฉ์ด๋ 0๋ถํฐ N๊น์ง ์์ฐจ์ ์ผ๋ก ์ํํ๋ฉด์ ์ ์ฉํ ์ ์๋ค. -> Big O(N), N์ ์ต๋ ๊ฐ์ 1,000์ด๋ฏ๋ก ์์ฉํ๋ค.
4. ์ ์ถ ์์ค
import java.util.*
fun main() = with(System.`in`.bufferedReader()) {
val (s, e) = readLine().split(" ").map{ it.toInt() } // ์
๋ ฅ๋ ๋ ๊ฐ์ ๋ฐ๊ธฐ
var n = 1 // ํ์ฌ ๊ตฌ๊ฐ์ ๊ฐ
var c = 1 // ํ์ฌ ๊ตฌ๊ฐ์ ๊ฐ์ด ๋์จ ํ์
val arr = IntArray(e + 1) // ๊ตฌ๊ฐ์ ๋์ ํฉ์ ๋ด์ ๋ฐฐ์ด
arr[0] = 0 // 1๊ตฌ๊ฐ์ index 1๋ก ์ฌ์ฉํ๋ฏ๋ก 0๊ตฌ๊ฐ์ ํฉ์ 0
// ๊ตฌ๊ฐ 1๋ถํฐ e๊น์ง ์ํ
for (i : Int in 1..e){
arr[i] = arr[i-1] + n // ํ์ฌ ๊ตฌ๊ฐ์ ๋์ ํฉ = ์ด์ ๊ตฌ๊ฐ์ ๋์ ํฉ + ํ์ฌ ๊ตฌ๊ฐ์ ๊ฐ
c++ // ํ์ฌ ๊ตฌ๊ฐ์ ๊ฐ์ด ๋์จ ํ์๋ฅผ ์ถ๊ฐ
if(c > n){ // ํ์ฌ ๊ตฌ๊ฐ์ ๊ฐ์ด ๋์จ ํ์๊ฐ ํ์ฌ ๊ตฌ๊ฐ์ ๊ฐ์ ์ด๊ณผํ๋ค๋ฉด, ๊ฐ์ ์ฌ๋ฆฌ๊ณ ๊ฐฏ์๋ฅผ 1๋ก ์ด๊ธฐํ
n++
c = 1
}
}
println(arr[e] - arr[s-1]) // ์ถ๋ ฅ: ๋ ๋์ ํฉ - ์์ ์ง์ ์์ ๋์ ํฉ
}
'Programming > Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin] ๋ฐฑ์ค 2693 - N๋ฒ์งธ ํฐ ์ (2) | 2024.10.27 |
---|---|
[Kotlin] ๋ฐฑ์ค 2609 - ์ต๋๊ณต์ฝ์์ ์ต์๊ณต๋ฐฐ์(์ ํด๋ฆฌ๋ ํธ์ ๋ฒ) (0) | 2024.10.20 |
[Kotlin] ๋ฐฑ์ค 2309 - ์ผ๊ณฑ ๋์์ด (1) | 2024.10.20 |
[Kotlin] ๋ฐฑ์ค 10870 - ํผ๋ณด๋์น ์ 5 (0) | 2024.10.20 |
[Kotlin] ๋ฐฐ์ค 3460 - ์ด์ง์ (1) | 2024.10.19 |