๋ค๋ฆฌ๋ฅผ ์ง๋๋ ํธ๋ญ ๋ฌธ์ ํ์ด
๐ปQ
ํธ๋ญ ์ฌ๋ฌ ๋๊ฐ ๊ฐ์ ๊ฐ๋ก์ง๋ฅด๋ ์ผ์ฐจ์ ๋ค๋ฆฌ๋ฅผ ์ ํด์ง ์์ผ๋ก ๊ฑด๋๋ ค ํฉ๋๋ค.
๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ์ต์ ๋ช ์ด๊ฐ ๊ฑธ๋ฆฌ๋์ง ์์๋ด์ผ ํฉ๋๋ค.
๋ค๋ฆฌ์๋ ํธ๋ญ์ด ์ต๋ bridge_length๋ ์ฌ๋ผ๊ฐ ์ ์์ผ๋ฉฐ, ๋ค๋ฆฌ๋ weight ์ดํ๊น์ง์ ๋ฌด๊ฒ๋ฅผ ๊ฒฌ๋ ์ ์์ต๋๋ค.
๋จ, ๋ค๋ฆฌ์ ์์ ํ ์ค๋ฅด์ง ์์ ํธ๋ญ์ ๋ฌด๊ฒ๋ ๋ฌด์ํฉ๋๋ค.
์๋ฅผ ๋ค์ด, ํธ๋ญ 2๋๊ฐ ์ฌ๋ผ๊ฐ ์ ์๊ณ ๋ฌด๊ฒ๋ฅผ 10kg๊น์ง ๊ฒฌ๋๋ ๋ค๋ฆฌ๊ฐ ์์ต๋๋ค. ๋ฌด๊ฒ๊ฐ [7, 4, 5, 6]kg์ธ ํธ๋ญ์ด ์์๋๋ก ์ต๋จ ์๊ฐ ์์ ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ด ๊ฑด๋์ผ ํฉ๋๋ค.
๋ฐ๋ผ์, ๋ชจ๋ ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ์ง๋๋ ค๋ฉด ์ต์ 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 ์ดํ์
๋๋ค.
์
์ถ๋ ฅ ์
๐กA
ํธ๋ญ์ ์ฐจ๋ก๋๋ก ์ง๋๊ฐ๊ฒ ํด์ผ ํ๊ณ ํธ๋ญ์ด ์ฌ๋ผ๊ฐ ์๋ ๋ค๋ฆฌ์ ๋ฌด๊ฒ๋ฅผ ๊ตฌํ๊ธฐ ์ํด ํ์ ์ ์ฅํ๋ค.
ํธ๋ญ์ด ๋ค๋ฆฌ๋ฅผ ๊ฑด๋๋ฉด ํธ๋ญ์ด ์ฌ๋ผ๊ฐ ์๋ ๋ค๋ฆฌ์ ๋ฌด๊ฒ์์ ๋นผ์ค๋ค.
๋ค๋ฆฌ์ ๋ฌด๊ฒ๋ณด๋ค ์ฌ๋ผ๊ฐ ์๋ ํธ๋ญ์ ๋ฌด๊ฒ๊ฐ ๋ ํฐ ๊ฒฝ์ฐ ์๊ฐ์ ๋๋ ค์ค๋ค.
๋ชจ๋ ํธ๋ญ์ด ์ง๋๊ฐ๋ฉด while๋ฌธ ์ข
๋ฃ.
๋ง์ง๋ง ํธ๋ญ์์ ๋ค๋ฆฌ์ ๊ธธ์ด์ ์๊ฐ์ ๋ํด์ฃผ๋ฉด ๋ชจ๋ ํธ๋ญ ํต๊ณผ ์๊ฐ์ด ๋๋ค.
import java.util.Queue;
import java.util.LinkedList;
class Solution {
public int solution(int bridge_length, int weight, int[] truck_weights) {
int answer = 0;
int count = 0, bridge_weight = 0;
Queue<Integer> cross = new LinkedList<>();
// ๋ค๋ฆฌ ๋ฌด๊ฒ = ํธ๋ญ ๋ฌด๊ฒ
while(true){
if(cross.size() == bridge_length){
bridge_weight -= cross.poll();
}else if(bridge_weight + truck_weights[count] > weight){
cross.offer(0);
answer++;
}else {
cross.offer(truck_weights[count]);
bridge_weight += truck_weights[count];
answer++;
count++;
}
if(count == truck_weights.length)
break;
}
return answer + bridge_length;
}
}โ