๋ณธ๋ฌธ ๋ฐ”๋กœ๊ฐ€๊ธฐ

Algorithm/Programmers

[1์ฃผ์ฐจ] ํ”„๋กœ๊ทธ๋ž˜๋จธ์Šค ๋‹ค๋ฆฌ๋ฅผ ์ง€๋‚˜๋Š” ํŠธ๋Ÿญ

๋‹ค๋ฆฌ๋ฅผ ์ง€๋‚˜๋Š” ํŠธ๋Ÿญ ๋ฌธ์ œ ํ’€์ด

๐Ÿ’ป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;
    }
}โ€‹