๋ฌธ์ ์ค๋ช
https://school.programmers.co.kr/learn/courses/30/lessons/42583
ํ๋ก๊ทธ๋๋จธ์ค
SW๊ฐ๋ฐ์๋ฅผ ์ํ ํ๊ฐ, ๊ต์ก, ์ฑ์ฉ๊น์ง Total Solution์ ์ ๊ณตํ๋ ๊ฐ๋ฐ์ ์ฑ์ฅ์ ์ํ ๋ฒ ์ด์ค์บ ํ
programmers.co.kr
ํธ๋ญ ์ฌ๋ฌ ๋๊ฐ ๊ฐ์ ๊ฐ๋ก์ง๋ฅด๋ ์ผ์ฐจ์ ๋ค๋ฆฌ๋ฅผ ์ ํด์ง ์์ผ๋ก ๊ฑด๋๋ ค ํฉ๋๋ค. ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ์ต์ ๋ช ์ด๊ฐ ๊ฑธ๋ฆฌ๋์ง ์์๋ด์ผ ํฉ๋๋ค. ๋ค๋ฆฌ์๋ ํธ๋ญ์ด ์ต๋ bridge_length๋ ์ฌ๋ผ๊ฐ ์ ์์ผ๋ฉฐ, ๋ค๋ฆฌ๋ weight ์ดํ๊น์ง์ ๋ฌด๊ฒ๋ฅผ ๊ฒฌ๋ ์ ์์ต๋๋ค. ๋จ, ๋ค๋ฆฌ์ ์์ ํ ์ค๋ฅด์ง ์์ ํธ๋ญ์ ๋ฌด๊ฒ๋ ๋ฌด์ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ํธ๋ญ 2๋๊ฐ ์ฌ๋ผ๊ฐ ์ ์๊ณ ๋ฌด๊ฒ๋ฅผ 10kg๊น์ง ๊ฒฌ๋๋ ๋ค๋ฆฌ๊ฐ ์์ต๋๋ค. ๋ฌด๊ฒ๊ฐ [7, 4, 5, 6]kg์ธ ํธ๋ญ์ด ์์๋๋ก ์ต๋จ ์๊ฐ ์์ ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ฑด๋์ผ ํฉ๋๋ค.
๊ฒฝ๊ณผ ์๊ฐ | ๋ค๋ฆฌ๋ฅผ ์ง๋ ํธ๋ญ | ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ํธ๋ญ | ๋๊ธฐ ํธ๋ญ |
0 | [] | [] | [7, 4, 5, 6] |
1~2 | [] | [7] | [4, 5, 6] |
3 | [7] | [4] | [5, 6] |
4 | [7] | [4, 5] | [6] |
5 | [7, 4] | [5] | [6] |
6~7 | [7, 4, 5] | [6] | [] |
8 | [7, 4, 5, 6] | [] | [] |
๋ฐ๋ผ์, ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ค๋ฉด ์ต์ 8์ด๊ฐ ๊ฑธ๋ฆฝ๋๋ค.
solution ํจ์์ ๋งค๊ฐ๋ณ์๋ก ๋ค๋ฆฌ์ ์ฌ๋ผ๊ฐ ์ ์๋ ํธ๋ญ ์ bridge_length, ๋ค๋ฆฌ๊ฐ ๊ฒฌ๋ ์ ์๋ ๋ฌด๊ฒ weight, ํธ๋ญ ๋ณ ๋ฌด๊ฒ truck_weights๊ฐ ์ฃผ์ด์ง๋๋ค. ์ด๋ ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ์ต์ ๋ช ์ด๊ฐ ๊ฑธ๋ฆฌ๋์ง return ํ๋๋ก solution ํจ์๋ฅผ ์์ฑํ์ธ์.
์ ํ ์ฌํญ
- bridge_length๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- weight๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- truck_weights์ ๊ธธ์ด๋ 1 ์ด์ 10,000 ์ดํ์ ๋๋ค.
- ๋ชจ๋ ํธ๋ญ์ ๋ฌด๊ฒ๋ 1 ์ด์ weight ์ดํ์ ๋๋ค.
์ ์ถ๋ ฅ ์
bridge_length | weight | truck_weights | return |
2 | 10 | [7, 4, 5, 6] | 8 |
100 | 100 | [10] | 101 |
100 | 100 | [10, 10, 10, 10, 10, 10, 10, 10, 10, 10] | 110 |
๋ด๊ฐ ์์ฑํ ์ฝ๋
import java.util.*;
class Solution {
public int solution(int bridge_length, int weight, int[] truck_weights) {
// ๊ฒฝ๊ณผ ์๊ฐ
int answer = 0;
// ๋ค๋ฆฌ ์์ ์ฌ๋ผ๊ฐ ํธ๋ญ๋ค์ ์ ์ฅํ Queue
// ๊ฐ ์์๋ [ํธ๋ญ์ ๋ฌด๊ฒ, ๋ค๋ฆฌ๋ฅผ ์์ ํ ๊ฑด๋๋ ์๊ฐ]
Queue<int[]> bridge = new LinkedList<>();
// ํ์ฌ ๋ค๋ฆฌ ์์ ์ฌ๋ผ๊ฐ ์๋ ํธ๋ญ๋ค์ ์ด ๋ฌด๊ฒ
int currentWeight = 0;
// ์์ง ๋ค๋ฆฌ์ ์ฌ๋ผ๊ฐ์ง ์์ ๋ค์ ํธ๋ญ์ ์ธ๋ฑ์ค
int idx = 0;
// ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋ ๋๊น์ง ๋ฐ๋ณต
while (idx < truck_weights.length || !bridge.isEmpty()) {
// 1์ด ๊ฒฝ๊ณผ
answer++;
// ๋ค๋ฆฌ์์ ๋ด๋ฆด ํธ๋ญ์ด ์๋ค๋ฉด
if (!bridge.isEmpty() && bridge.peek()[1] == answer) {
// ํธ๋ญ์ Queue์์ ๊บผ๋ด๊ณ , ํ์ฌ ๋ฌด๊ฒ์์ ์ ๊ฑฐ
currentWeight -= bridge.poll()[0];
}
// ์๋ก์ด ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ฌ๋ผ๊ฐ ์ ์๋ค๋ฉด
if (idx < truck_weights.length) {
// ๋ค์ ํธ๋ญ ๋ฌด๊ฒ์ ํ์ฌ ๋ฌด๊ฒ์ ํฉ์ด ์ ํ ๋ฌด๊ฒ ์ดํ์ด๊ณ , ๋ค๋ฆฌ ์ ํธ๋ญ์ ์๊ฐ ๋ค๋ฆฌ ๊ธธ์ด๋ณด๋ค ์๋ค๋ฉด
if (truck_weights[idx] + currentWeight <= weight && bridge.size() < bridge_length) {
// ํธ๋ญ์ ๋ฌด๊ฒ์ ๋ค๋ฆฌ๋ฅผ ๋ค ๊ฑด๋๋ ์๊ฐ(ํ์ฌ ์๊ฐ + ๋ค๋ฆฌ ๊ธธ์ด)๋ฅผ Queue์ ์ถ๊ฐ
bridge.add(new int[]{truck_weights[idx], answer + bridge_length});
// ๋ค๋ฆฌ ์ ์ด ๋ฌด๊ฒ ๊ณ์ฐ
currentWeight += truck_weights[idx];
// ๋ค์ ํธ๋ญ ์ธ๋ฑ์ค +1
idx++;
}
}
}
// answer ๋ฐํ
return answer;
}
}
๋ฌธ์ ๋ฅผ ํ๊ธฐ ์ํด ์๊ฐํ ๋ฐฉํฅ
์ด๋ป๊ฒ ํ์ด์ผ ํ ์ง ๊ฐ์ด ์์กํ์ ๋ค๋ฅธ ์ฌ๋์ ํ์ด๋ฅผ ๋ณด๋ฉด์ ์ดํดํ๋ ค๊ณ ๋ ธ๋ ฅํ๋ฉด์ ์ฝ๋๋ฅผ ์์ฑํ๋ค.
'๐งฉ ํ๋ก๊ทธ๋๋จธ์ค > ๐ต ์๊ณ ๋ฆฌ์ฆ ํ์ด(Java)' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ์ด์ง ๋ณํ ๋ฐ๋ณตํ๊ธฐ (1) | 2025.04.14 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ์ฃผ์๊ฐ๊ฒฉ (4) | 2025.04.11 |
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ํ๋ก์ธ์ค (1) | 2025.04.08 |
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ์์ (1) | 2025.04.07 |
[ํ๋ก๊ทธ๋๋จธ์ค/Java] ์ ํ๋ฒํธ ๋ชฉ๋ก (0) | 2025.04.07 |