๋ฌธ์ : ํ๋ก๊ทธ๋๋จธ์ค - ์ ๊ตญ์ฌ์ฌ
์นดํ ๊ณ ๋ฆฌ : ์ด๋ถํ์
์ถ์ฒ: ํ๋ก๊ทธ๋๋จธ์ค ์ฝ๋ฉ ํ ์คํธ ์ฐ์ต, https://school.programmers.co.kr/learn/challenges
์ด ๋ฌธ์ ๋ฅผ ๋ณด๊ณ ,
" ๋ชจ๋ ์ ๊ตญ์๊ฐ ๊ฐ ์ฌ์ฌ๊ด์๊ฒ ์ฌ์ฌ๋ฅผ ๋ฐ์์ ๋, ๋ชจ๋ ์ ๊ตญ์์ ์ฌ์ฌ๊ฐ ๋๋ฌ์ ๋ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด ์ต์๊ฐ ๋๋๋ก, ๊ฐ ์ ๊ตญ์๋ค ์ฌ์ฌ๊ด์๊ฒ ๋ฐฐ์ ํด์ผ ํ๋ค " ๋ผ๊ณ ์๊ฐํ๋ค.
๊ทธ๋์, ๊ฐ ์ฌ์ฌ๊ด๋ง๋ค ์ ๊ตญ์๋ฅผ ์ด๋ป๊ฒ ๋ฐฐ์ ํด์ผ ํ ์ง๋ฅผ ๊ณ ๋ฏผํ๋ค.
์๋ฅผ ๋ค์ด, ์ ๊ตญ์๊ฐ 5๋ช ์ด๊ณ , ๊ฐ ์ฌ์ฌ๊ด๋ค์ด 3๋ช ์ด๊ณ , ๊ฐ ์ฌ์ฌ๊ด์ด ํ ๋ช ์ ์ฌ์ฌํ๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ด [2, 3, 7] ์ด๋ผ๋ฉด
์ฌ์ฌ๊ด1 | ์ฌ์ฌ๊ด2 | ์ฌ์ฌ๊ด3 |
---|---|---|
5 | 0 | 0 |
4 | 1 | 0 |
3 | 1 | 1 |
์ด๋ ๊ฒ ๊ฐ case๋ฅผ ๋๋ ์, case๋ง๋ค ๊ฐ ์ฌ์ฌ๊ด์ด ๊ฐ ์ ๊ตญ์๋ค์ ์ฌ์ฌํ๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ ์ค ์ต๋๊ฐ์ ๊ตฌํ๊ณ , ์ด ๊ฐ๋ค์ case๋ง๋ค ๋น๊ตํด์, ๊ฐ์ฅ ์ต์์ธ ๊ฐ์ ์ ๋ต์ผ๋ก ํ๋จํ๋ ค๊ณ ํ๋ค.
ํ์ง๋ง, ์ด๋ ๊ฒ ๊ฐ case๋ฅผ ๋๋๋ ๋ฐฉ๋ฒ์, ๊ฒฐ๊ตญ ๋ชจ๋ case๋ฅผ ๋ค ํด๋ด์ผ ์ต์๊ฐ์ ์ ์ ์๊ณ , ๋๋ฌด ์๊ฐ๋ ์ค๋ ๊ฑธ๋ฆฌ๊ณ , ์ฌ์ค ์ด๋ป๊ฒ ๋๋ ์ผํ ์ง ๊ฐ๋ ์ค์ง ์์๋ค.
์ฐ์ ,
log n
) ์ผ๋ก๋ ๊ฑฐ์ ๋ถ๊ฐ๋ฅํ๋ค๊ณ ๋ณผ ์ ์๊ธฐ ๋๋ฌธ์, ๋ก๊ทธ์๊ฐ(log n
) ์ผ๋ก ํ์ด์ผ ํ๋ค์ 3๊ฐ์ง ์ฌํญ์ ๋ฐํ์ผ๋ก, ์ด ๋ฌธ์ ์ ์ด์ง ํ์์ ์ด๋ป๊ฒ ์ ์ฉํ ์ง ์๊ฐํด๋ณด๋ฉด,
์๊ฐ์ด ์ง๋จ์ ๋ฐ๋ผ ๊ฐ ์ฌ์ฌ๊ด๋ค์ด ๋ช ๋ช ์ ์ฒ๋ฆฌํ ์ ์๋์ง๋ฅผ ๊ธฐ์ค์ผ๋ก,
ํน์ ์๊ฐ์ด ์ง๋ฌ์ ๋, ๋ชจ๋ ์ฌ์ฌ๊ด๋ค์ด ์ฒ๋ฆฌํ ์ ์๋ ์ ๊ตญ์๋ค ์๋ฅผ ๊ณ์ฐํ๊ณ , ์ฃผ์ด์ง ์ ๊ตญ์ ์ n์ ๋ค ์ฒ๋ฆฌํ ์ ์๋ค๋ฉด ์๊ฐ์ ๋ ๋๋ฆฌ๊ณ , ์ฒ๋ฆฌํ ์ ์๋ค๋ฉด ์๊ฐ์ ๋ ์ค์ด๋ ๋ฐฉ์์ผ๋ก ์ด์ง ํ์์ ์งํํ ์ ์๋ค.
์ด๋ฅผ ํตํด ์ฃผ์ด์ง ์ ๊ตญ์ ์ n์ ์ฒ๋ฆฌํ๊ฒ ๋๋ ์ต์์ ์๊ฐ์ ๊ตฌํ๋ฉด ๋๋ค.
n๋ถ์ด ์ง๋ฌ์ ๋, ๊ฐ ์ฌ์ฌ๊ด ๋น ์ฒ๋ฆฌ ๊ฐ๋ฅํ ์ ๊ตญ์ ์
= n / ๊ฐ ์ฌ์ฌ๊ด์ ์ฌ์ฌ ์๊ฐ
์ผ๋ก ๊ตฌํ ์ ์๋ค.
์ฆ, ๋์ solution์ ์ ๊ทผ ๋ฐฉ์์ ๋น๊ตํ๋ฉด
my : ๊ฐ ์ฌ์ฌ๊ด์ด ๋ช ๋ช ์ ์ฒ๋ฆฌํ ์ง ๊ฒฐ์ => ์ด ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๊ณ์ฐ
solution : ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋จผ์ ๊ฒฐ์ => ๊ทธ ์๊ฐ ์์ ๊ฐ ์ฌ์ฌ๊ด๋ค์ด ๋ช ๋ช ์ ์ฒ๋ฆฌํ ์ ์๋์ง๋ฅผ ๊ณ์ฐ
์๋ก ๋ฐ๋ ๋ฐฉํฅ์ผ๋ก ์ ๊ทผํ์์ ์ ์ ์๋ค.
Binary Search ์งํ ์, ์ฃผ์ํ ์
๊ธฐ๋ณธ Binary Search๋ ํน์ ๊ฐ ๋๋ ํน์ ๊ฐ์ index๋ฅผ ๋ฐํํ์ง๋ง,
ํ์ฌ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ๊ฒ์ ํน์ ๊ฐ์ ๊ฐ์ง๋ index์ ์ต์๊ฐ ์ด๋ค.
=> ์ฃผ์ด์ง ์ ๊ตญ์ ์ n์ ์ฒ๋ฆฌํ ์ ์๊ฒ ๋๋ ์ต์์ ์๊ฐ ์ด๊ธฐ ๋๋ฌธ์ด๋ค.
์๋ฅผ ๋ฐํ์ผ๋ก Binary Search ํ์ ์กฐ๊ฑด๊ณผ return ๊ฐ์ ์์ ํด์ ์ฝ๋๋ฅผ ์์ฑํด์ผ ํ๋ค.
solution์ ๋ฐํ์ผ๋ก, ์ฝ๋๋ฅผ ์์ฑํด๋ณด์๋ค.
function solution(n, times) {
const sortedTimes = times.sort((a,b)=>a-b);
let left = 1;
let right = sortedTimes[sortedTimes.length-1]*n; // ์ต๋๋ก ํ๋ฅผ ์ ์๋ ์๊ฐ => ๊ฐ์ฅ ์ค๋๊ฑธ๋ฆฌ๋ ์ฌ์ฌ๊ด์ด ๋ชจ๋ ์
๊ตญ์๋ฅผ ์ฌ์ฌํ ๋
while(left<=right){
const mid = Math.floor((left+right)/2);
let testedPeople=0;
sortedTimes.map((testTime) => {
return Math.floor(mid/testTime); // ๊ฐ ๋ฉด์ ์ฌ์ฌ๊ด์ด mid๋ถ์ด ์ง๋ฌ์ ๋ ์ฌ์ฌํ ์ ์๋ ์ฌ๋ ์
}).forEach((testedPerson) => {
testedPeople+=testedPerson;
});
if(testedPeople < n){
left = mid+1;
}
else{
right = mid - 1;
}
}
return left;
}