๋ฌธ์ ์ค๋ช
[๋ณธ ๋ฌธ์ ๋ ์ ํ์ฑ๊ณผ ํจ์จ์ฑ ํ ์คํธ ๊ฐ๊ฐ ์ ์๊ฐ ์๋ ๋ฌธ์ ์ ๋๋ค.]
์นด์นด์ค ์ด๋ฑํ๊ต์ "๋๋์ฆ ์น๊ตฌ๋ค"์ด "๋ผ์ด์ธ" ์ ์๋๊ณผ ํจ๊ป ๊ฐ์ ์ํ์ ๊ฐ๋ ์ค์ ์ง๊ฒ๋ค๋ฆฌ๊ฐ ์๋ ๊ฐ์ธ์ ๋ง๋์ ๊ฑด๋ํธ์ผ๋ก ๊ฑด๋๋ ค๊ณ ํฉ๋๋ค. "๋ผ์ด์ธ" ์ ์๋์ "๋๋์ฆ ์น๊ตฌ๋ค"์ด ๋ฌด์ฌํ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ์ ์๋๋ก ๋ค์๊ณผ ๊ฐ์ด ๊ท์น์ ๋ง๋ค์์ต๋๋ค.
"๋๋์ฆ ์น๊ตฌ๋ค"์ ๊ฐ์ธ์ ์ผ์ชฝ์ ์์ผ๋ฉฐ, ๊ฐ์ธ์ ์ค๋ฅธ์ชฝ ๊ฑด๋ํธ์ ๋์ฐฉํด์ผ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ๊ฒ์ผ๋ก ์ธ์ ํฉ๋๋ค.
"๋๋์ฆ ์น๊ตฌ๋ค"์ ํ ๋ฒ์ ํ ๋ช ์ฉ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋์ผ ํ๋ฉฐ, ํ ์น๊ตฌ๊ฐ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๋ชจ๋ ๊ฑด๋ ํ์ ๊ทธ ๋ค์ ์น๊ตฌ๊ฐ ๊ฑด๋๊ธฐ ์์ํฉ๋๋ค.
๋๋ค๋์ ์ ํ ์ซ์๊ฐ ์์๋๋ก ๋ด๊ธด ๋ฐฐ์ด stones์ ํ ๋ฒ์ ๊ฑด๋๋ธ ์ ์๋ ๋๋ค๋์ ์ต๋ ์นธ์ k๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง ๋, ์ต๋ ๋ช ๋ช ๊น์ง ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ์ ์๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
[์ ํ์ฌํญ]
[์ ์ถ๋ ฅ ์]
stones | k | result |
---|---|---|
[2, 4, 5, 3, 2, 1, 4, 2, 5, 1] | 3 | 3 |
์ ์ถ๋ ฅ ์์ ๋ํ ์ค๋ช
์ ์ถ๋ ฅ ์ #1
์ฒซ ๋ฒ์งธ ์น๊ตฌ๋ ๋ค์๊ณผ ๊ฐ์ด ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ์ ์์ต๋๋ค.
์ฒซ ๋ฒ์งธ ์น๊ตฌ๊ฐ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ํ ๋๋ค๋์ ์ ํ ์ซ์๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ต๋๋ค.
๋ ๋ฒ์งธ ์น๊ตฌ๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ์ ์์ต๋๋ค.
๋ ๋ฒ์งธ ์น๊ตฌ๊ฐ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ํ ๋๋ค๋์ ์ ํ ์ซ์๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ต๋๋ค.
์ธ ๋ฒ์งธ ์น๊ตฌ๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ด ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ์ ์์ต๋๋ค.
์ธ ๋ฒ์งธ ์น๊ตฌ๊ฐ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ํ ๋๋ค๋์ ์ ํ ์ซ์๋ ์๋ ๊ทธ๋ฆผ๊ณผ ๊ฐ์ต๋๋ค.
๋ค ๋ฒ์งธ ์น๊ตฌ๊ฐ ์ง๊ฒ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด, ์ธ ๋ฒ์งธ ๋๋ค๋์์ ์ผ๊ณฑ ๋ฒ์งธ ๋๋ค๋๋ก ๋ค ์นธ์ ๊ฑด๋๋ฐ์ด์ผ ํฉ๋๋ค. ํ์ง๋ง k = 3 ์ด๋ฏ๋ก ๊ฑด๋๋ธ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ์ต๋ 3๋ช ์ด ๋๋ค๋์ ๋ชจ๋ ๊ฑด๋ ์ ์์ต๋๋ค.
์ด๋ถํ์ ๋ฌธ์ ์ธ๊ฑธ ๋ชจ๋ฅด๊ณ ํ์๋ค๊ฐ ํจ์จ์ฑ์ด ๋ชจ๋ 0์ ์ฒ๋ฆฌ ๋์ด ๊ต์ฅํ ๋นํฉ์ค๋ฌ์ ๋ ๋ฌธ์ ์ด๋ค.
์ง๋ฌธํ๊ธฐ๋ฅผ ํตํด ๋ค๋ฅธ๋ถ๋ค์ ์๊ฒฌ์ ์ดํด๋ณด๋ ๋ฒ์๊ฐ ๋งค์ฐ ๊ด๋ฒ์ํ ๊ฒฝ์ฐ 99% ์ด๋ถํ์ ๋ฌธ์ ๋ผ๋ ๋ง์์ ๋ฃ๊ณ ๋์์ผ ์ด๋ถํ์์ ๋์น์ฑ๊ณ ํ์๋ ๊ฒ ๊ฐ๋ค.
์ด๋ถํ์์ min ์ ๊ฐ๋ฅํ ์ต๋๊ฐ์ ์๋ฏธํ๊ณ max ๋ ๊ฐ๋ฅํ ์ต์๊ฐ์ ์๋ฏธํ๊ธฐ์ ํด๋น ๋ฌธ์ ๋ min ์ return ํด์ฃผ๋ฉด ๋
function solution(stones, k) {
// ๋ฌธ์ ์ ๋ช
์๋ ์ต์/์ต๋ ๊ฐ
let min = 1
let max = 200000000
while(min < max-1) {
// >> 0 ์ ๋๋จธ์ง๋ฅผ ๋ฒ๋ฆฌ๋ ๋นํธ ์ฐ์ฐ์ ๋งํจ
const mid = (min+max)/2 >> 0
let canJump = 0
for(let i = 0 ; i < stones.length ; i ++) {
// stones[i] < mid ๋ ํด๋น ์ธ๋ฑ์ค์ ๊ฐ์ด 0๋ณด๋ค ์์์ ์๋ฏธ
if(stones[i] < mid) canJump++
else {canJump=0}
// ์ ํํด๋ ๊ฑด๋๊ฐ์ง ๋ชปํ๋ฉด
if(canJump >= k) break
}
// ์ค๊ฐ๊ฐ์ ์ต๋๊ฐ์ ์ฝ์
if(canJump >= k) {max = mid;}
else {min= mid;}
}
// ๊ฐ๋ฅํ ์ต๋๊ฐ
return min
}