๐ 1. ๋ฌธ์ ์ค๋ช
๐ก 2. ์ ๊ทผ๋ฐฉ์
Queue
ํธ๋ญ ์ง์ ๋ก์ง: ๋ค๋ฆฌ์ ๋งจ ์ ํธ๋ญ์ด ๋๊ฐ๊ณ ์๋ก์ด ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ฌ๋ผ๊ฐ ์ ์๋์ง ํ์ธํ ํ ๋ค๋ฆฌ์ ์ถ๊ฐ
์ด๋์๊ฐ: ํธ๋ญ์ด ๋ค๋ฆฌ ์์ ์ค๋ฅด๋ฉด ๋งค 1์ด๋ง๋ค ํ ์นธ์ฉ ์์ผ๋ก ์ด๋ํจ.
์กฐ๊ฑด ๊ฒ์ฌ: ๋ค๋ฆฌ๊ฐ ๊ฒฌ๋ ์ ์๋ ๋ฌด๊ฒ๋ฅผ ์ด๊ณผํ์ง ์๋ ๊ฒฝ์ฐ์๋ง ํธ๋ญ์ ์ถ๊ฐํ๋ฉฐ, ๊ทธ๋ ์ง ์์ผ๋ฉด 0์ ์ถ๊ฐํด์ ๋น ๊ณต๊ฐ ๋ง๋ค๊ธฐ
- bridge_length ์ฌ์ด์ฆ์ Queue ๋ง๋ค๊ณ 0๊ฐ์ผ๋ก ์ด๊ธฐํ(๋ค๋ฆฌ์ ํธ๋ญ ํ๋๋ ์๋ ์ํ)
- ๋ณ์ currentWeight ํ์ฌ ๋ค๋ฆฌ ์์ ์ด ๋ฌด๊ฒ
- ๋ณ์ time ๊ฒฝ๊ณผ์๊ฐ(๋ฌธ์ ์์ returnํ ๊ฐ)
- ๋ค๋ฆฌ์ ๊ธธ์ด๊ฐ 1์ด๊ฑฐ๋ ํธ๋ญ์ ๊ฐ์๊ฐ 1 ์ผ๋๋ ํด๋น time ๋จผ์ return
- ํธ๋ญ์ ๊ฐฏ์๋งํผ ์๋์ ๊ณผ์ ์ ๋ฐ๋ณต
1. ๋ค๋ฆฌ์ ์๋ถ๋ถ ํธ๋ญ์ ํ์์ ์ ๊ฑฐ
2. ๋ค์ ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์ ํ ์ ์๋์ง ํ์ธ
- ํ์ฌ ๋ค๋ฆฌ ์์ ์๋ ํธ๋ญ ๋ฌด๊ฒ vs ๋ค๋ฆฌ๋ก ๋ค์ด์ฌ ํธ๋ญ ๋ฌด๊ฒ ๋น๊ต
3. ๋ฌด๊ฒ ์กฐ๊ฑด์ ๋ง๋๊ฐ?
- (Yes) ์๋ก์ด ํธ๋ญ์ด ๋ค๋ฆฌ๋ก ์ฌ๋ผ ๊ฐ
- (No) ๊ฒฌ๋ ์ ์๋ ๋ฌด๊ฒ๋ณด๋ค ํฌ๋ฉด ํ์ 0 ์ถ๊ฐ
2. ๋งค ๋ฐ๋ณต๋ง๋ค time++
5. ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ฉด ์ข ๋ฃ
๋ค๋ฆฌ์์ ํธ๋ญ์ด ๋๊ฐ๋ฉด currentWeight์์ ๋งจ ์ ํธ๋ญ์ ๋ฌด๊ฒ๋ฅผ ๋นผ์ค
๋ค๋ฆฌ์ ํธ๋ญ์ด ์ฌ๋ผ๊ฐ๋ฉด currentWiehgt์ ์๋ก์ด ํธ๋ญ์ ๋ฌด๊ฒ๋ฅผ ๋ํด์ค
โญ 3. ์ฝ๋
์ฒซ๋ฒ์งธ ์๋ ํ๋ฆผ
import java.util.*;
class Solution {
public int solution(int bridge_length, int weight, int[] truck_weights) {
// ๋ค๋ฆฌ ๊ธธ์ด๋งํผ ํ ์ ์ธ
Queue<Integer> bridge = new LinkedList<>();
// ๊ฑธ๋ฆฌ๋ ์ด ์๊ฐ
int time = 0;
// ํ์ฌ ๋ค๋ฆฌ ์์ ๋ฌด๊ฒ
int currentWeight = 0;
for(int i = 0; i < bridge_length; i++) {
bridge.add(0);
}
// ํ์ฌ ๋ค๋ฆฌ์ ์ค๋ฅผ ํธ๋ญ์ ์ธ๋ฑ์ค
int index = 0;
// ์์ง ๋ค๋ฆฌ์ ์ฌ๋ผ๊ฐ์ง ์์ ํธ๋ญ์ด ๋จ์์๋์ง
// ํ์ฌ ๋ค๋ฆฌ ์์ ํธ๋ญ์ด ๋จ์์๋์ง
while(index < truck_weights.length || currentWeight > 0) {
time++;
// ๋ค๋ฆฌ์ ๋งจ ์ ํธ๋ญ์ด ๋๊ฐ
int leftTruck = bridge.poll();
currentWeight -= leftTruck;
// ๋ค์ ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
ํ ์ ์๋์ง ์กฐ๊ฑด ํ์ธ
if(index < truck_weights.length) {
if(currentWeight + truck_weights[index] <= weight){
// ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
bridge.add(truck_weights[index]);
currentWeight += truck_weights[index];
index++;
}
} else {
// ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
ํ ์ ์์ผ๋ฉด ๋น ๊ณต๊ฐ ์ถ๊ฐ
bridge.add(0);
}
}
return time;
}
}
ํธ๋ญ์ด ๋ค๋ฆฌ ์๋ก ์ง์ ํ๋ ์กฐ๊ฑด์ ์ค๋ฅ๊ฐ ์์๋ค. index < truck_weights.length๋ง ์ฒดํฌํ๊ณ ์์ผ๋, ๋ค๋ฆฌ ์์ ์ฌ์ ๊ณต๊ฐ์ด ์๋์ง๋ ํ์ธํ๋ ์ฝ๋๊ฐ ๋น ์ ธ ์๋ ๊ฒ์ด๋ค. ์ฆ, ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์ ํ๋ ์กฐ๊ฑด์ ์ ๋๋ก ๊ฒํ ํ์ง ์์๊ธฐ ๋๋ฌธ์ ํ ์คํธ ์ผ์ด์ค 2๊ฐ๋ง ํต๊ณผ๋๊ณ ํ๋๋ ํต๊ณผ๋์ง ๋ชปํ๋ค.
ํธ๋ญ์ด ์ง์ ํ ์ ์์ ๋ ๋น ๊ณต๊ฐ์ ์ถ๊ฐํด ์ฃผ์ด์ผ ํ๋๋ฐ, index๊ฐ ๋ค๋ฆฌ ๊ธธ์ด๋ฅผ ๋์ด๊ฐ ๋๋ง ๊ณต๊ฐ์ ์ถ๊ฐํ๋๋ก ์ฝ๋๋ฅผ ์๋ชป ์งฐ๋ค. ๋ค๋ฆฌ์ ๋น ๊ณต๊ฐ์ ์ถ๊ฐํ๋ ๋ถ๋ถ์ ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์ ํ ์ ์๋ ๊ฒฝ์ฐ์๋ง ๋ฐ์ํด์ผ ํ๋ฏ๋ก else๋ฌธ์ if (index < truck_weights.length) ์์ ๋ฃ์ด์ผ ํ๋ค.
์ ๋ต์ฝ๋
import java.util.*;
class Solution {
public int solution(int bridge_length, int weight, int[] truck_weights) {
// ๋ค๋ฆฌ ๊ธธ์ด๋งํผ ํ ์ ์ธ
Queue<Integer> bridge = new LinkedList<>();
// ๊ฑธ๋ฆฌ๋ ์ด ์๊ฐ
int time = 0;
// ํ์ฌ ๋ค๋ฆฌ ์์ ๋ฌด๊ฒ
int currentWeight = 0;
for(int i = 0; i < bridge_length; i++) {
bridge.add(0);
}
// ํ์ฌ ๋ค๋ฆฌ์ ์ค๋ฅผ ํธ๋ญ์ ์ธ๋ฑ์ค
int index = 0;
// ์์ง ๋ค๋ฆฌ์ ์ฌ๋ผ๊ฐ์ง ์์ ํธ๋ญ์ด ๋จ์์๋์ง
// ํ์ฌ ๋ค๋ฆฌ ์์ ํธ๋ญ์ด ๋จ์์๋์ง
while(index < truck_weights.length || currentWeight > 0) {
time++;
// ๋ค๋ฆฌ์ ๋งจ ์ ํธ๋ญ์ด ๋๊ฐ
int leftTruck = bridge.poll();
currentWeight -= leftTruck;
// ๋ค์ ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
ํ ์ ์๋์ง ์กฐ๊ฑด ํ์ธ
if(index < truck_weights.length) {
if(currentWeight + truck_weights[index] <= weight){
// ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
bridge.add(truck_weights[index]);
currentWeight += truck_weights[index];
index++;
} else {
// ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
ํ ์ ์์ผ๋ฉด ๋น ๊ณต๊ฐ ์ถ๊ฐ
bridge.add(0);
}
} else {
// ํธ๋ญ์ด ๋ค๋ฆฌ์ ์ง์
ํ ์ ์์ผ๋ฉด ๋น ๊ณต๊ฐ ์ถ๊ฐ
bridge.add(0);
}
}
return time;
}
}
๊ทผ๋ฐ ์ index > truck_weight[index] ์ผ ๋๋ bridge.add(0)๋ก ๋น ๊ณต๊ฐ์ ์ถ๊ฐ ํด ์ค์ผ ํ๋๊ฑฐ์ง?
index > truck_weight[index] ์ํ
index๊ฐ truck_weights.length๋ณด๋ค ์ปค์ง๋ ๊ฒฝ์ฐ๋ ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ ์๋ก ์ฌ๋ผ๊ฐ์ ๋๋ฅผ ์๋ฏธํ๋ค. ์ฆ, ๋ ์ด์ ์ง์ ํ ํธ๋ญ์ด ์๋ค๋ ๋ป์ด๋ค.
์ bridge.add(0)์ ์ถ๊ฐํ๋๊ฐ?
ํธ๋ญ์ด ๋ค๋ฆฌ ์์ ์ฌ๋ผ๊ฐ๋ฉด, ๋ค๋ฆฌ ์์์ ํธ๋ญ๋ค์ด ์ด๋ํ๋ฉด์ ๋งค์ด๋ง๋ค ํ ์นธ์ฉ ์์ผ๋ก ๋์๊ฐ๋ค. bridge.add(0)์ ์ถ๊ฐํ๋ ์ด์ ๋ ๋ค๋ฆฌ ๊ธธ์ด๊ฐ ๊ณ ์ ๋์ด ์๊ธฐ ๋๋ฌธ์ด๋ค. ํธ๋ญ์ด ๋ค๋ฆฌ ์๋ก ์ฌ๋ผ๊ฐ๊ณ , ๋งค์ด๋ง๋ค ํ๋์ฉ ์ ์งํ๋ฉด์ ๋น ๊ณต๊ฐ์ ์ฑ์์ผ ํธ๋ญ๋ค์ด ์ ์์ ์ผ๋ก ์ด๋ํ๊ธฐ ๋๋ฌธ์ด๋ค.
๐๐ป 4. ๊ฐ์ ์ ํ ๋ฌธ์