๐ ๊ฐ๋ ๋ค์ง๊ธฐ
์ด๋ถ ํ์
ํ์ ๊ธฐ๋ฒ์ค ํ๋๋ก, ํ์ํ๊ณ ์ถ์ ๋ฒ์๋ฅผ ๋ ๋ถ๋ถ์ผ๋ก ๋ถํ ํด์ ์ฐพ๋ ๋ฐฉ๋ฒ์ด๋ค.
๋ ๋ถ๋ถ์ผ๋ก ๊ณ์ ๋ถํ ํด์ ์กฐ๊ฑด์ ๋ง๋์ง ์ฐพ์๊ฐ๊ธฐ ๋๋ฌธ์, ์๊ฐ ๋ณต์ก๋๊ฐ O(log n)์ผ๋ก ๋งค์ฐ ๋น ๋ฅธํธ์ด๋ค.
โ๏ธํ์ํ๋ ๋ฐฉ๋ฒ
- ๋ฐฐ์ด์ด ์ ๋ ฌ(sort)๋์ด ์์ด์ผํ๋ค.
- left์ right๋ฅผ ๋ฐฐ์ด์ ์ ๋์ผ๋ก ์ค์ ํ๋ค.
- mid = (left + right) / 2 ๋ก ์ค์ ํ์ฌ, mid ๊ฐ์ด ๊ธฐ์ค๊ฐ๋ณด๋ค ์๊ฑฐ๋ ํฐ์ง ํ์ธํ๋ค.
- (์ค๋ฆ์ฐจ ๋ฐฐ์ด ์ ๋ ฌ๋์ด์์ ๋) mid ๊ฐ์ด ๊ธฐ์ค๊ฐ ๋ณด๋ค ์๋ค๋ฉด, left๋ฅผ (mid+1)๋ก ์ค์ ํ๋ค.
- (์ค๋ฆ์ฐจ ๋ฐฐ์ด ์ ๋ ฌ๋์ด์์ ๋) mid ๊ฐ์ด ๊ธฐ์ค๊ฐ ๋ณด๋ค ํฌ๋ค๋ฉด, right๋ฅผ (mid-1)๋ก ์ค์ ํ๋ค.
- left > right ๊ฐ ๋ ๋ ๊น์ง 2,3 ๋ฒ์ ๋ฐ๋ณตํ๋ค.
โ๏ธ์ด๋ถ ํ์ ์์ 1
์์์ N๊ฐ์ ์ซ์๊ฐ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ก์ ๋, N๊ฐ ์๋ฅผ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ ๋ค์ N๊ฐ์ ์ ์ค ํ ๊ฐ์ ์์ธ M์ด ์ฃผ์ด์ง๋ค๋ฉด,
์ด๋ถ ํ์์ผ๋ก M์ด ์ ๋ ฌ๋ ์ํ์์ ๋ช ๋ฒ์งธ์ ์๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํด๋ผ. ์ค๋ณต๊ฐ์ ์กด์ฌํ์ง ์๋๋ค.
- ์
๋ ฅ๊ฐ
- nums : N(3<=N<=1,000,000)๊ฐ์ ์์ด
- m : ์ซ์ M
- ์ถ๋ ฅ๊ฐ
- ์ ๋ ฌํ ๋ค M์ ์ธ๋ฑ์ค ๊ฐ
- ์ ๋ ฅ ์์ : [23, 87, 65, 12, 57, 32, 99, 81], 32
- ์ถ๋ ฅ ์์ : 3
function solution(nums, m) {
let n = nums.length;
// ์ค๋ฆ์ฐจ์ ์ ๋ ฌ
nums.sort((a, b) => a - b);
// left, right๋ก ๋ฐฐ์ด์ ํ์
let lt = 0,
rt = n - 1;
// lt > rt์ผ ๋ ํ์ถ
while (lt <= rt) {
// mid๊ฐ ์ค์
let mid = Math.floor((lt + rt) / 2);
// m๊ณผ ๋น๊ตํ์ฌ lt์ rt ๋ณ๊ฒฝ. m๊ณผ ๋์ผํ๋ฉด ๊ทธ๋ mid๊ฐ ์ ๋ต์!
if (nums[mid] < m) {
lt = mid + 1;
} else if (nums[mid] > m) {
rt = mid - 1;
} else {
return mid;
}
}
}
console.log(solution([23, 87, 65, 12, 57, 32, 99, 81], 32)); // ์ ๋ต 2
๐์ฌํ ํ๊ธฐ
โ๏ธ์ด๋ถ ํ์ ์์ 2
์๋ฆฌํธ ํ์์ ์์ฒด์ ์ผ๋ก K๊ฐ์ ๋์ ์ ๊ฐ์ง๊ณ ์๋ค. ๊ทธ๋ฌ๋ K๊ฐ์ ๋์ ์ ๊ธธ์ด๊ฐ ์ ๊ฐ๊ฐ์ด๋ค.
์ ์๋์ ๋์ ์ ๋ชจ๋ N๊ฐ์ ๊ฐ์ ๊ธธ์ด์ ๋์ ์ผ๋ก ๋ง๋ค๊ณ ์ถ์๊ธฐ ๋๋ฌธ์ K๊ฐ์ ๋์ ์ ์๋ผ์ ๋ง๋ค์ด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด 300cm ์ง๋ฆฌ ๋์ ์์ 140cm ์ง๋ฆฌ ๋์ ์ ๋ ๊ฐ ์๋ผ๋ด๋ฉด 20cm ์ ๋ฒ๋ ค์ผ ํ๋ค. (์ด๋ฏธ ์๋ฅธ ๋์ ์ ๋ถ์ผ ์ ์๋ค.)
ํธ์๋ฅผ ์ํด ๋์ ์ ์๋ฅผ๋ ์์ค๋๋ ๊ธธ์ด๋ ์๋ค๊ณ ๊ฐ์ ํ๋ฉฐ, ๊ธฐ์กด์ K๊ฐ์ ๋์ ์ผ๋ก N๊ฐ์ ๋์ ์ ๋ง๋ค ์ ์๋ ๊ฒฝ์ฐ๋ ์๋ค๊ณ ๊ฐ์ ํ์.
๊ทธ๋ฆฌ๊ณ ์๋ฅผ ๋๋ ํญ์ ์ผํฐ๋ฏธํฐ ๋จ์๋ก ์ ์ ๊ธธ์ด๋งํผ ์๋ฅธ๋ค๊ณ ๊ฐ์ ํ์.
N๊ฐ๋ณด๋ค ๋ง์ด ๋ง๋๋ ๊ฒ๋ N๊ฐ๋ฅผ ๋ง๋๋ ๊ฒ์ ํฌํจ๋๋ค.
์ด๋ ๋ง๋ค ์ ์๋ ์ต๋ ๋์ ์ ๊ธธ์ด๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ ๋ ฅ | ๋งค๊ฐ๋ณ์ nums์ K๊ฐ์ ๊ฐ ๋์ ์ ๊ธธ์ด๊ฐ ์ฃผ์ด์ง๋๋ค. ๊ฐ ๋์ ์ ๊ธธ์ด๋ 1,000,000 ์ดํ์ด๋ค. ๋งค๊ฐ๋ณ์ n์ N์ด ์ฃผ์ด์ง๋๋ค. K๋ 1์ด์ 10,000์ดํ์ ์ ์์ด๊ณ , N์ 1์ด์ 1,000,000์ดํ์ ์ ์์ด๋ค. ๊ทธ๋ฆฌ๊ณ ํญ์ K โฆ N ์ด๋ค. |
[802, 743, 457, 539], 11 |
์ถ๋ ฅ | N๊ฐ๋ฅผ ๋ง๋ค ์ ์๋ ๋์ ์ ์ต๋ ๊ธธ์ด๋ฅผ ์ผํฐ๋ฏธํฐ ๋จ์์ ์ ์๋ก ๋ฐํํฉ๋๋ค. | 200 |
โ๏ธ์ ์ถ๋ ฅ ๋ถ์
์ ๋ ฅ์ด nums = [802, 743, 457, 539], n = 11 ์ผ ๋,
nums์ ๋ค์ด์๋ ๋์ ๋ค์ ๊ฐ์ง๊ณ 11๊ฐ์ ๊ฐ์ ๊ธธ์ด์ ๋์ ์ ๋ง๋ค๋ ค๊ณ ํ ๋, ๋ง๋ค ์ ์๋ ์ต๋ ๋์ ๊ธธ์ด๋ฅผ ๊ตฌํด์ผ ํ๋ค.
์ต๋ ๋์ ์ ๊ธธ์ด๋ 200์ผ๋ก,
802 = 200 + 200 + 200 + 200 + 2
743 = 200 + 200 + 200 + 143
457 = 200 + 200 + 57
539 = 200 + 200 + 139
์ผ ๋, ๊ธธ์ด 200์ ๋์ ์ด 11๊ฐ๋ก n๊ฐ์ ๋ง์กฑํ๋ฏ๋ก ์ ๋ต์ด๋ค.
โ๏ธ๋ฌธ์ ๋ถ์
์ต๋ ๋์ ๊ธธ์ด๋ nums์ K๊ฐ์ ๋์ ๊ธธ์ด๊ฐ ์ฃผ์ด์ง ๋, ๊ฐ์ฅ ๊ธด ๋์ ์ ๊ธธ์ด๋ฅผ ๋์ ์ ์๋ค.
์ฆ, ์์ ์์ ์์๋ 1 ~ 802 ์ฌ์ด์ ๊ฐ์ด ์๋ฅผ ์ ์๋ ๋์ ๊ธธ์ด๊ฐ ๋ ์ ์์ผ๋ฏ๋ก, ๊ทธ ์ฌ์ด์์ ์ ๋ต์ด ๋์จ๋ค.
๋ฐ๋ผ์ 1 ~ 802 ์ฌ์ด์ ๊ฐ์ ์ด๋ถํ์์ผ๋ก ๋๋ฉด์ m ๊ฐ์ ๋ง์กฑ์ํฌ ์ ์๋์ง ํ์ธํ๋ฉด ๋๋ค.
๊ทธ๋ผ nums๋ฐฐ์ด์ ์๋ ์ต๋๊ฐ์ ๊ผญ ์ฐพ์์ผ ํ ๊น?
์๋๋ค. ๋์ ์ ๊ธธ์ด๋ 1,000,000์ด ์ต๋์ด๋ฏ๋ก, ์ต๋ ๋์ ๊ธธ์ด๋ 1 ~ 1,000,000 ์ฌ์ด์ ์กด์ฌํ๋ค.
์ด๋ถํ์์ ์๊ฐ๋ณต์ก๋๋ O(log n)์ด๋ฏ๋ก, log 1,000,000 == log 2^20 == 20 ๋ฒ๋ง ํ์ํ๋ฉด ๋๋ค.
๋ฐ๋ผ์ 20๋ฒ ํ์ํ๋ฉด์, mid๊ฐ์ผ๋ก m๊ฐ์ ๋์ ์ ๋ง๋ค ์ ์๋์ง ํ์ธํ๋ ํจ์๋ฅผ ์ ์์ฑํด์ผ ํ๋ค.
ํ์ด ์ฝ๋๋ ๋ค์์ ์ฐธ๊ณ ํ์.
// ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ํ์ธํ๋ ํจ์
function cntNum(x, nums) {
let result = 0;
// ๊ธธ์ด x๋ก ๋์ ์ ์๋ผ์ ๋ง๋ค ์ ์๋ ๋์ ์ ๊ฐฏ์๋ฅผ ๊ตฌํจ
for (let i of nums) {
result += parseInt(i / x);
}
return result;
}
function solution(nums, n) {
// ๋์ ์ ์ต๋๊ธธ์ด๊ฐ 1000000์ด๋ฏ๋ก, ๊ทธ ์ฌ์ด ์์์ ์ ๋ต์ด ๋์จ๋ค. => ์ด๋ถํ์
let lt = 0,
rt = 1000000;
let answer;
while (lt <= rt) {
let mid = Math.floor((lt + rt) / 2);
let cnt = cntNum(mid, nums); // ์กฐ๊ฑด์ ๋ง์กฑํ๋์ง ํ์ธํ๋ ํจ์.
if (cnt >= n) {
answer = mid;
lt = mid + 1;
} else if (cnt < n) {
rt = mid - 1;
}
}
return answer;
}
console.log(solution([802, 743, 457, 539], 11)); // 200
'Algorithm > algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
ํฉ์งํฉ ์ฐพ๊ธฐ Union - Find Set ์๊ณ ๋ฆฌ์ฆ (0) | 2021.09.13 |
---|---|
๋๋น ์ฐ์ ํ์ BFS ์๊ณ ๋ฆฌ์ฆ - ๊ทธ๋ํ ํ์ (0) | 2021.09.11 |
๊น์ด ์ฐ์ ํ์ DFS ์๊ณ ๋ฆฌ์ฆ - ๊ทธ๋ํ ํ์ (0) | 2021.09.11 |
๋ค์ต์คํธ๋ผ Dijkstra ์๊ณ ๋ฆฌ์ฆ (0) | 2021.09.09 |
ํ๋ก์ด๋ ์์ฌ Floyd Warshall ์๊ณ ๋ฆฌ์ฆ (0) | 2021.09.09 |