๐ 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. ๊ฐ์ ์ ํ ๋ฌธ์
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ฃผ์๊ฐ๊ฒฉ (์คํ/ํ)
๐ 1. ๋ฌธ์ ์ค๋ช ๐ก 2. ์ ๊ทผ๋ฐฉ์์ด์คfor๋ฌธํ์ฌ ์ธ๋ฑ์ค์ ์๋ ์์๊ณผ ์ดํ ๋ชจ๋ ๊ฐ์ ๋น๊ตํ๋ฉด์ ํ์ฌ ์์๊ฐ ๋น๊ตํ๊ณ ์๋ ์์๋ณด๋ค ์ปค์ง๋ฉด break;๋ฅผ ๊ฑธ์ด์ค๋ค. ๊ทธ ์ ๊น์ง๋ answer[i]++์ ํด ์ค๋ค.
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ํ๋ก์ธ์ค ๋ฌธ์ ํ์ด (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช ์์ #1๋ฌธ์ ์ ๋์จ ์์ ๊ฐ์ต๋๋ค. ์์ #26๊ฐ์ ํ๋ก์ธ์ค [A, B, C, D, E, F]๊ฐ ๋๊ธฐ ํ์ ์๊ณ ์ค์๋๊ฐ [1, 1, 9, 1, 1, 1] ์ด๋ฏ๋ก [C, D, E, F, A, B] ์์ผ๋ก ์คํ๋ฉ๋๋ค. ๋ฐ๋ผ์ A๋ 5๋ฒ์งธ๋ก ์ค
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์ ํ์ด (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช 2. ์ ๊ทผ๋ฐฉ์1) ์คํ์ ์ฌ์ฉํ์ง ์๊ณ ํ๊ธฐ๋ฌธ์์ด์ ์ํํ๋ฉฐ ๋ซํ ๊ดํธ์ ์ด๋ฆฐ ๊ดํธ์ ๊ฐฏ์๋ฅผ ๋ณ์์ ์ ์ฅํ๊ณ ๊ฐ์๊ฐ ๊ฐ์ผ๋ฉด true, ํ๋ฆฌ๋ฉด false ๋ฅผ ๋ฐํํ๋ ๋ฐฉ๋ฒ 2) ์คํ์ ์ฌ์ฉํ์ฌ
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๊ธฐ๋ฅ๊ฐ๋ฐ (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช ํ๋ก๊ทธ๋๋จธ์ค ํ์์๋ ๊ธฐ๋ฅ ๊ฐ์ ์์ ์ ์ํ ์ค์ ๋๋ค. ๊ฐ ๊ธฐ๋ฅ์ ์ง๋๊ฐ 100%์ผ ๋ ์๋น์ค์ ๋ฐ์ํ ์ ์์ต๋๋ค. ๋, ๊ฐ ๊ธฐ๋ฅ์ ๊ฐ๋ฐ์๋๋ ๋ชจ๋ ๋ค๋ฅด๊ธฐ ๋๋ฌธ์ ๋ค์ ์๋ ๊ธฐ๋ฅ์ด
awesomepossum.tistory.com
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๊ฐ์ ์ซ์๋ ์ซ์ด ๋ฌธ์ ํ์ด (์คํ/ํ)
1. ๋ฌธ์ ์ค๋ช ๋ฐฐ์ด arr๊ฐ ์ฃผ์ด์ง๋๋ค. ๋ฐฐ์ด arr์ ๊ฐ ์์๋ ์ซ์ 0๋ถํฐ 9๊น์ง๋ก ์ด๋ฃจ์ด์ ธ ์์ต๋๋ค. ์ด๋, ๋ฐฐ์ด arr์์ ์ฐ์์ ์ผ๋ก ๋ํ๋๋ ์ซ์๋ ํ๋๋ง ๋จ๊ธฐ๊ณ ์ ๋ถ ์ ๊ฑฐํ๋ ค๊ณ ํฉ๋๋ค. ๋จ, ์ ๊ฑฐ
awesomepossum.tistory.com
'Algorithm > Programmers_Best' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๋ ๋งต๊ฒ - ์ค์ฝ๋น์ง์ (ํ/Heap) Feat. ์ฐ์ ์์ํ (12) | 2024.11.12 |
---|---|
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ฃผ์๊ฐ๊ฒฉ (์คํ) (8) | 2024.11.11 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ํ๋ก์ธ์ค ๋ฌธ์ ํ์ด (ํ) (4) | 2024.11.09 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ์ฌ๋ฐ๋ฅธ ๊ดํธ ๋ฌธ์ ํ์ด (์คํ) (8) | 2024.11.08 |
[ํ๋ก๊ทธ๋๋จธ์ค] (Java) ๊ธฐ๋ฅ๊ฐ๋ฐ (ํ) (10) | 2024.11.07 |