K๋ฒ์งธ ์(1300๋ฒ)
Gold 1
#์ด๋ถ ํ์ #๋งค๊ฐ ๋ณ์ ํ์
https://www.acmicpc.net/problem/1300
๋ฌธ์ ๋ด์ฉ
๋ฌธ์ ์ ๊ทผ
๋ฌธ์ ์์ฒด๋ ์ดํดํ๋ ๋ฐ ์ด๋ ต์ง ์๋ค.
๋ฐฐ์ด์ index๋ 1๋ถํฐ ์์ํ๋ค. ๊ฐ ๋ฐฐ์ด์ ๋ค์ด ์๋ ์๋ค์ ๊ฐ index์ ๊ณฑ์ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก ํ๋ก ๋ํ๋ด ๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
์ ํ์๋ 5 * 5 ํฌ๊ธฐ์ 2์ฐจ์ ๋ฐฐ์ด์ ๋ค์ด๊ฐ ์๋ค์ ๋์ดํด ๋จ๋ค.
๊ฐ index์ ๊ณฑ์ผ๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
๋ชจ๋ ๊ฐ๋ค์ ๊ฐ ์ค์ ํด๋นํ๋ ๋ฐฐ์๋ค๋ก ์ด๋ฃจ์ด์ ธ ์๋ ๊ฒ์ ๋ณผ ์ ์๋ค.
1๋ฒ์งธ ์ค์ 1์ ๋ฐฐ์, 2๋ฒ์งธ ์ค์ 2์ ๋ฐฐ์ ... 5๋ฒ์งธ ์ค์ 5์ ๋ฐฐ์๋ก ์ด๋ฃจ์ด์ ธ ์๋ค.
์ ๋ ฅ ์์ ์์๋ 3 * 3์ 2์ฐจ์ ๋ฐฐ์ด์ ๊ฐ๋ค์ ์ ๋ ฌํ์ ๋, 7๋ฒ์งธ ๊ฐ์ ๋ถ๋ฌ์์ผ ํ๋ค.
์ฐ์ ๋ฐฐ์ด ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฌํด ๋ณด๋ฉด 1, 2, 2, 3, 3, 4, 6, 6, 9์ ์์๋๋ก ์ ๋ ฌ์ด ๊ฐ๋ฅํ๊ณ , ์ด ์ค 7๋ฒ์งธ ์๋ ์ฒซ ๋ฒ์งธ 6์ด๋ค.
์ฐ๋ฆฌ๊ฐ ์ฐพ์์ผ ํ๋ ๊ฐ์ด 7๋ฒ์งธ ๊ฐ์ด๋ค. ๊ทธ๋ฆฌ๊ณ B[7] = 6์ด๊ธฐ ๋๋ฌธ์ 6๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์๋ค์ด 7๊ฐ๊ฐ ์กด์ฌํ๋ค๋ ๋ป์ด ๋๋ค.
์ ๋ต์ ๊ตฌํ๊ธฐ ์ํด B[k] = T์์ T์ ๊ฐ์ ๋ณ๊ฒฝํด ๊ฐ๋ฉด์ ์ ๋ต์ ์ฐพ์๊ฐ์ผ ํ๋ค.
๊ทธ๋ฌ๋ฉด T์ ๋ง๋ k์ ๊ฐ์๋ฅผ ๊ตฌํ๊ธฐ ์ํด์๋ ์ด๋ป๊ฒ ๊ตฌํด์ผ ํ ๊น?
๋จผ์ ์์ ํ์์ 7๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ๊ฐ์๋ฅผ ๋ผ์ธ๋ณ๋ก ๊ตฌํด ๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
๋ฌผ๋ก ์ผ์ผ์ด ๊ตฌํ๋ ๋ฐฉ๋ฒ๋ ์์ง๋ง ๋ ๋น ๋ฅด๊ฒ ๊ตฌํ ์ ์๋ ๋ฐฉ๋ฒ์ด ์๋ค.
7 / ๋ผ์ธ์ ํด์ฃผ๋ฉด 7๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ๊ฐ์๋ฅผ ๊ตฌํ ์ ์๋ค. 2๋ฒ์งธ ์ค์ ๊ฐ์๋ 7 / 2์์ ์์์ ์ ๋ฒ๋ฆฐ 3์ด ๋๋ค.
ํ์ง๋ง ์ฌ๊ธฐ์ ๊ณ ๋ คํด์ผ ํ๋ ์ฌํญ์ด ์๋ค. ๋ฐ๋ก ๋๋ ๋ชซ์ด 5๋ณด๋ค ์ปค์ง๋ ๊ฒฝ์ฐ์ด๋ค. ๋ชซ์ด 5๋ณด๋ค ์ปค์ง๋ฉด 5๋ก ์กฐ์ ์ ํด์ฃผ์ด์ผ ํ๋ค.
1๋ฒ์งธ ์ค์ธ ๊ฒฝ์ฐ์๋ 7 / 1๋ก ๋ชซ์ด 7์ด ๋๋๋ฐ, ์๋ 5๊ฐ๊น์ง ์๊ธฐ ๋๋ฌธ์ ๋ชซ์ด 5๋ณด๋ค ์ปค์ง๊ฒ ๋๋ฉด ์๋์ผ๋ก 5๊ฐ ๋ ์ ์๋๋ก ๋ง๋ค์ด์ผ ํ๋ค.
์ด๋ฅผ kotlin ์ฝ๋๋ก ๋ํ๋ด๋ฉด ๋ค์๊ณผ ๊ฐ๋ค.
min(t / i, size)
i๋ฒ์งธ ์ค์์ t๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ๊ฐ์๋ฅผ ๊ตฌํ๋ค. ๊ทธ๋ฆฌ๊ณ ํ์ฌ ๋ผ์ธ ๋น ์์ ๊ฐ์๋ฅผ size๋ก ๋ฐ๊ณ ๋ ์์์ ๋ ์์ ๊ฐ์ ๊ตฌํ๋ค.
๊ทธ๋ฌ๋ฉด t / i๊ฐ size๋ณด๋ค ์ปค์ง ๋๋ size๋ก ๊ณ ์ ๋๋ค.
๋ฌธ์ ํด๊ฒฐ ์ฝ๋
import java.io.BufferedReader
import java.io.InputStreamReader
import kotlin.math.min
private var size: Int = 0
private var index: Int = 0
private var answer = 0
fun main() = with(BufferedReader(InputStreamReader(System.`in`))) {
size = readLine().toInt()
index = readLine().toInt()
binarySearch(1, index)
}
private fun binarySearch(start: Int, end: Int) {
val mid = (start + end) / 2
if (start > end) {
println(answer)
return
}
var cnt = 0
for (i in 1 .. size) {
cnt += min(mid / i, size)
}
if (cnt < index) binarySearch(mid + 1, end)
else {
answer = mid
binarySearch(start, mid - 1)
}
}
๋ฌธ์ ํ์ด
๋ฐฐ์ด์ ํฌ๊ธฐ์ ์ฐพ์์ผ ํ๋ index๋ฅผ ์ ๋ ฅ๋ฐ๊ณ binary search๋ฅผ ์ํํ๋ค.
binary search์ mid๊ฐ ๋ฐฐ์ด B์ index๋ฒ์งธ ๊ฐ์ ํ๋ณด๊ฐ ๋๋ค.
๋ฐ๋ณต์ ๋๋ ค์ mid๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ ์ด๊ฐ์๋ฅผ ๊ตฌํด ์ฃผ๊ณ , cnt๊ฐ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ์ ๋ต๋ณด๋ค ์์ผ๋ฉด mid ๊ฐ์ด ๋ ์ปค์ผ cnt์ ๊ฐ์๋ฅผ ๋ ๋๋ฆด ์ ์๋ค. ์ ๋ต๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ์ผ๋ฉด ๊ฐ์ด ๋ ์์์ ธ์ผ ํ๊ธฐ ๋๋ฌธ์ mid ๊ฐ์ด ๋ ์์์ ธ์ผ ํ๋ค.
๋ฌธ์ ํด๊ฒฐ ๊ณผ์
์ค๋๋ง์ ํ์ด๋ณด๋ ์ด๋ถ ํ์ ๋ฌธ์ ์๋ค.
๊ทธ๊ฑฐ์ ๋ณ๊ฐ๋ก ๊ทธ๋ฅ ์ด๋ ค์ ๋ค. ์ด๋ป๊ฒ ๋ฌธ์ ๋ฅผ ํ์ด์ผ ํ ์ง ๊ฐ์ด ์ ์กํ๋ค.
์ฌ์ง 1-1๊น์ง๋ ์๊ฐํด ๋ดค์ง๋ง ๊ทธ ์ด์์ ์์ด๋์ด๊ฐ ์๊ฐ๋์ง ์์๋ค.
๊ทธ๋์ ํ์ด๋ฅผ ์ฐธ๊ณ ํด์ ํด๊ฒฐํ์๋ค.
ํฌ์คํ ์ ์์ฑํ๋ฉด์ ๋ฌธ์ ๋ฅผ ๋ค์ ๋ณต๊ธฐํด ๋ณด๋ ๋ก์ง์ด ์ดํด๊ฐ ๋๊ธฐ ์์ํ๋ค. ๊ทธ๋์ ํฌ์คํ ๋ด์ฉ์ด ์ข ๋์กํ ์ ์๊ธฐ ๋๋ฌธ์ ๋ด๊ฐ ์ฐธ๊ณ ํ ๋ค๋ฅธ ๋ถ๋ค์ ํ์ด ํฌ์คํ ๋ ๋จ๊ฒจ ๋๊ฒ ๋ค.
๋ด๊ฐ ์ฐธ๊ณ ํ ๋ฌธ์ ํ์ด 1
'๐ฏ | ๋ฐฑ์ค > ๐ | Gold' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Kotlin, G4] ๋ฐฑ์ค 9935๋ฒ ๋ฌธ์์ด ํญ๋ฐ (0) | 2024.10.01 |
---|---|
[Kotlin, G5] ๋ฐฑ์ค 10827๋ฒ a^b (0) | 2024.09.19 |
[Kotlin, G5] ๋ฐฑ์ค 16928๋ฒ ๋ฑ๊ณผ ์ฌ๋ค๋ฆฌ ๊ฒ์ (0) | 2024.08.12 |
[Kotlin, G5] ๋ฐฑ์ค 1013๋ฒ Contact (0) | 2024.08.07 |
[Kotlin, G5] ๋ฐฑ์ค 1011๋ฒ Fly me to the Alpha Centauri (0) | 2024.07.30 |