๐ ๋ฌธ์
์ด๋ ์๊ตญ์ ํ๋ ์ด์์ ๋์๋ค์ด ์์ต๋๋ค. ์๊ตญ์ ์์ ์ ๋์๋ฅผ ์ง๊ธฐ๋ก ๊ฒฐ์ ํ์์ต๋๋ค. ํด๋น ๋์๋ฅผ ์ง๊ธฐ ์ํด์๋ ๋์๋ฅผ ์ง๋ ์ฅ์์ ๊ธ a kg๊ณผ ์ b kg์ด ์ ๋ฌ๋์ด์ผ ํฉ๋๋ค.
๊ฐ ๋์์๋ ๋ฒํธ๊ฐ ๋งค๊ฒจ์ ธ ์๋๋ฐ, i๋ฒ ๋์์๋ ๊ธ g[i] kg, ์ s[i] kg, ๊ทธ๋ฆฌ๊ณ ํธ๋ญ ํ ๋๊ฐ ์์ต๋๋ค. i๋ฒ ๋์์ ํธ๋ญ์ ์ค์ง ์ ๋์๋ฅผ ์ง๋ ๊ฑด์ค ์ฅ์์ i๋ฒ ๋์๋ง์ ์๋ณตํ ์ ์์ผ๋ฉฐ, ํธ๋๋ก ์ด๋ํ๋ ๋ฐ t[i] ์๊ฐ์ด ๊ฑธ๋ฆฌ๊ณ , ์ต๋ w[i] kg ๊ด๋ฌผ์ ์ด๋ฐํ ์ ์์ต๋๋ค. (๊ด๋ฌผ์ ๊ธ๊ณผ ์์
๋๋ค. ์ฆ, ๊ธ๊ณผ ์์ ๋์์ ์ด๋ฐํ ์ ์์ต๋๋ค.) ๋ชจ๋ ํธ๋ญ์ ๊ฐ์ ๋๋ก๋ฅผ ์ฌ๋ฌ ๋ฒ ์๋ณตํ ์ ์์ผ๋ฉฐ ์ฐ๋ฃ๋ ๋ฌดํ๋๋ผ๊ณ ๊ฐ์ ํฉ๋๋ค.
์ ์ a, b์ ์ ์ ๋ฐฐ์ด g, s, w, t๊ฐ ๋งค๊ฐ๋ณ์๋ก ์ฃผ์ด์ง๋๋ค. ์ฃผ์ด์ง ์ ๋ณด๋ฅผ ๋ฐํ์ผ๋ก ๊ฐ ๋์์ ํธ๋ญ์ ์ต์ ์ผ๋ก ์ดํํ์ ๋, ์๋ก์ด ๋์๋ฅผ ๊ฑด์คํ๊ธฐ ์ํด ๊ธ a kg๊ณผ ์ b kg์ ์ ๋ฌํ ์ ์๋ ๊ฐ์ฅ ๋น ๋ฅธ ์๊ฐ์ ๊ตฌํด return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํด์ฃผ์ธ์.
์ ํ์ฌํญ
- 0 ≤ a, b ≤ 109
- 1 ≤ g์ ๊ธธ์ด = s์ ๊ธธ์ด = w์ ๊ธธ์ด = t์ ๊ธธ์ด = ๋์ ๊ฐ์ ≤ 105
- 0 ≤ g[i], s[i] ≤ 109
- 1 ≤ w[i] ≤ 102
- 1 ≤ t[i] ≤ 105
- a ≤ g์ ๋ชจ๋ ์์ ํฉ
- b ≤ s์ ๋ชจ๋ ์์ ํฉ
์ ์ถ๋ ฅ ์
10 | 10 | [100] | [100] | [7] | [10] | 50 |
90 | 500 | [70,70,0] | [0,0,500] | [100,100,2] | [4,8,1] | 499 |
โ๏ธ ํ์ด
์ด์ ์ ํ์๋ ์ ์ ์ ์ถ ์ค์ผ์ค๋ง๊ณผ ๋น์ทํ ๋๋์ ๋ฐ์๊ธฐ์ ์ด๋ถํ์์ผ๋ก ์ ๊ทผํ๋ค. mid๋ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ์๋ฏธํ๋ค.
left, right๋ฅผ ์ ์ธํ๋ค. right๋ ์ต๋ ์๊ฐ์ด ๋์ด์ผ ํ๊ธฐ ๋๋ฌธ์ 10^5(์๊ฐ) * 10^9(๋ฌด๊ฒ) * ์๋ณต(2)์ ๊ณ ๋ คํด์ ๋๋ํ๊ฒ 10^15๋ก ์ ์ธํด์คฌ๋ค. ์ฎ๊ธธ ์ ์๋ ๊ธ๊ณผ ์์ ์์ ํ์ธํ๋ฉฐ ์งํํ๋ค. for๋ฌธ์ ์ฌ์ฉํ์ฌ ๋จผ์ ํธ๋๋ก ๊ด์์ ๋ณด๋ผ ์ ์๋์ง๋ฅผ ํ์ธํ๋ค. ์๋ณต์ด๋ผ๋ฉด ์๊ฐ์ 2๋ฅผ ๊ณฑํ๋งํผ ์๊ฐ์ด ๋ค๊ธฐ ๋๋ฌธ์ ํ์ฌ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ธ mid๋ฅผ ์๊ฐ * 2๋ก ๋๋ ๋๋จธ์ง๊ฐ ํ์ฌ ์๊ฐ๋ณด๋ค ํฐ์ง๋ฅผ ํ์ธํ๋ค. ๊ทธ ๋ค์ ํ์ฌ ๋์์์ ์ด๋๊ฐ๋ฅํ ๊ด์์ ์(availableWeight)์ ๊ตฌํ๋ค. ์๋ณต์ผ๋ก ๋ณด๋ผ ์ ์๋ ํ์(Math.floor(mid / (t[i] * 2)))์ ํ๋ฒ์ ๋ณด๋ผ ์ ์๋ ์(w[i])์ ๊ณฑํด์ฃผ๊ณ ์์ ํ์ธํ๋ ๋ง์ง๋ง์ ํธ๋๋ก ๋ณด๋ผ ์ ์๋์ง๋ฅผ ํ์ธํด ์ฌ๋ถ์ ๋ฐ๋ผ ์ถ๊ฐํ๋ค.
๋ค์์ผ๋ก ํ์ฌ ๋์์ ๊ธ, ์์ ์๊ณผ ๋น๊ตํ์ฌ ๋ณด๋ผ ์ ์๋ ๊ธ, ์์ ์์ ํ์ธํ๋ค. ๋ง์ฝ ๋ณด๋ผ ์ ์๋ ๊ด์์ ์๋ณด๋ค ๋์์์ ๋ณด์ ํ ๊ธ ๋๋ ์์ด ์์ ๊ฒฝ์ฐ ๋ณด์ ํ ๊ธ, ์ ์์ ๋ํด์ฃผ๊ณ ์๋ ๊ฒฝ์ฐ ์์ ๊ตฌํ ๋ณด๋ผ ์ ์๋ ์์ ๋ํ๋ค.
๊ธ๊ณผ ์์ ์์ด ๋ชจ๋ ์๊ตฌ๋๋ ์(a, b)๋ณด๋ค ํฐ ๊ฒฝ์ฐ right๋ฅผ mid๋ก ๋ฐ๊ฟ์ฃผ๊ณ answer๋ฅผ ์ฒดํฌํ์ฌ ์ต์ ํํ๋ค. ๋ฐ๋์ธ ๊ฒฝ์ฐ left๋ฅผ mid๋ก ์ฆ๊ฐ์ํจ๋ค.
์ฌ๊ธฐ์ ๋ด๊ฐ ๊ณ ๋ คํ์ง ๋ชปํ๋ ์ ์ด ์์๋๋ฐ ํ๋์ ๋์์์ ๊ธ๊ณผ ์์ ๋ชจ๋ ๋ณด์ ํ ๊ฒฝ์ฐ์๋ค. ์ง๊ธ๊น์ง์ ๋ด ํ์ด์ ๋ฐ๋ฅด๋ฉด ๋ฌธ์ ์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๊ธฐ์ค์ผ๋ก ๊ธ๊ณผ ์์ด 100์ฉ ์์ ๋ ์ ์ค๋ช ๋๋ก ์ฝ๋๋ฅผ ๋๋ฉด 30์ด๋ผ๋ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค. ์๋ํ๋ฉด ๋ณด๋ผ ์ ์๋ ์์ด ๊ธ๊ณผ ์์ ๋ชจ๋ ์ค์ฒฉ๋๊ธฐ ๋๋ฌธ์ด๋ค. ํ๋๋ฟ์ธ ๋์์์ ๋ณด๋ผ ์ ์๋ ์์ 14์ง๋ง ๊ธ๊ณผ ์์ ์์ ๊ฐ๊ฐ ๊ณ์ฐํ ๋ 14๋ผ๋ ๊ฐ์ ๋๊ณ ๊ณ์ฐํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๊ธฐ ์ํด ๊ณ ๋ฏผ์ ๋ง์ด ํ์ผ๋ ๊ฒฐ๊ตญ ๋ค๋ฅธ ๋ถ์ ํ์ด๋ฅผ ์ฐธ๊ณ ํ๋ค.
ํด๊ฒฐ๋ฐฉ๋ฒ์ total์ด๋ผ๋ ๋ณ์๋ฅผ ํ๋ ๋ ๋๋ ๊ฒ์ด์๋ค. ๋ณด๋ผ ์ ์๋ ๊ธ๊ณผ ์์ ์์ ๊ณ์ฐํ ๋์ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ณด์ ํ ๊ธ + ๋ณด์ ํ ์๊ณผ ๊ตฌํ ๋ณด๋ผ ์ ์๋ ์์ ๋น๊ตํ์ฌ ๋ํด๊ฐ์ค๋ค. ๋ฌธ์ ์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๊ธฐ์ค์ด๋ก 14๋ผ๋ ๋ณด๋ผ ์ ์๋ ๊ฐ์ด ๋์์ ๋ ๊ธ๊ณผ ์์ ์ด๋์ 20์ด๋ฏ๋ก total์๋ 14๊ฐ ํ ๋น๋๊ณ ํ์ํ ๊ธ, ์์ ๋น๊ตํ๋ ์๋ ์กฐ๊ฑด๋ฌธ์์ total๊ฐ๋ ํ์ธํด์ค๋ค.(total >= a + b) ๋ ๊ด๋ฌผ ๋ชจ๋ ๋ณด๋ผ ์ ์๋ค๋ฉด ์ ๋์ ์ผ๋ก ํ์ํ ๊ด์์ ๋ณด๋ด๋ฉด ๋๋๋ฐ ์ด๋ ๋ณด๋ผ ์ ์๋ ์์ด ํ์ํ ์์ ์ด๊ณผํ๋์ง ํ์ธํ๋ฉด ๋๋ ๊ฑฐ์๋ค...!
โจ๏ธ ์ฝ๋
function solution(a, b, g, s, w, t) {
var answer = Infinity;
const n = g.length;
let left = 1;
let right = 10 ** 15;
while (left < right) {
const mid = Math.floor((left + right) / 2);
let gold = 0;
let silver = 0;
let total = 0;
for (let i = 0; i < n; i++) {
const canOneWay = mid % (t[i] * 2) >= t[i];
let availableWeight = Math.floor(mid / (t[i] * 2)) * w[i];
if (canOneWay) availableWeight += w[i];
gold += availableWeight > g[i] ? g[i] : availableWeight;
silver += availableWeight > s[i] ? s[i] : availableWeight;
total += availableWeight > s[i] + g[i] ? s[i] + g[i] : availableWeight;
}
if (gold >= a && silver >= b && total >= a + b) {
right = mid;
answer = Math.min(answer, mid);
} else {
left = mid + 1;
}
}
return answer;
}
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Algorithm] ํํ ๊ฐ๋ฅํ ์ด์งํธ๋ฆฌ (0) | 2023.03.22 |
---|---|
[Algorithm] ์ซ์ ํ์ ๋ํ (0) | 2023.03.21 |
[Algorithm] ์ฐ์ ํ์ค ๋ถ๋ถ ์์ด์ ํฉ (0) | 2023.03.19 |
[Algorithm] ๊ฑฐ์ค๋ฆ๋ (0) | 2023.03.18 |
[Algorithm] ์ธ๋ฒฝ์ ๊ฒ (0) | 2023.03.17 |