{프로그래머스} 스택/큐 > 다리를 지나는 트럭 (Java, JavaScript ES5)

문제 링크

전 문제인 프린터와 마찬가지로 요소가 객체인 배열로 재정의하여 루프를 돌리려고 했고

루프안에서 어떻게 해야할지 계획을 안세우고 날코딩하다 역시나 망했다.

망한 풀이

function solution(bridge_length, weight, truck_weights) {
    var answer = 0;
    
    var index = 0;
    var wait = new Array();
    for(; index < truck_weights.length; index = index + 1){
        wait[0] = { weight : truck_weights[index], distance : 0 };
    }
    
    while (wait.length > 0){
        
        if( wait[0].weight < weight ){
            if( wait[0].distance <= bridge_length ){
                wait[0].distance += 1;
            }else{
                wait[0].shift();
            }
        }else{
            if( wait[0].weight + wait[1].weight <= weight ){
                wait[0].distance += 1;
                wait[1].distance += 1;
            }else{
                continue;
            }
        }
        
        
        
        // if( wait[0].distance > bridge_length ){
        //     wait[0].distance += 1;
        // }else{
        //     wait[0]
        // }
        answer++;
    }
    
    return answer;
}

이분꺼 참고해서 풀이했다.

핵심은 요소 값이 0으로 초기화된 다리 배열을 만들어 활용하는 것

어떻게 보면 사람의 사고 방식 그대로 풀이가 가능했는데 너무 어렵게 생각함

// 배열 요소 값의 총합을 구한다.
function getSumWeight(arr){
    var result = 0;
    if( arr.length ){
        for(var index = 0; index < arr.length; index++){
            result += arr[index];
        }
    }
    return result;
}

function solution(bridge_length, weight, truck_weights) {
    var answer = 0;    
    var bridge = new Array();
    var index;
    
    // 다리 배열을 만들자
    for(index = 0; index < bridge_length; index++){
        bridge[index] = 0;
    }    
    // 다리 배열이 존재할 때 까지
    while( bridge.length > 0 ){             
        // 한 턴에 한칸씩 앞으로 가므로, 다리 배열 맨 앞에 있는 한칸(트럭)을 뺀다.
        // 대기 중인 트럭이 있다면 나중에 한칸 추가할 것이고,
        // 대기 트럭이 없어지면 다리에서 계속 빠지기만 하므로 결국은 루프가 끝난다.
        bridge.shift();
        
        // 경과 시간을 증가시킨다.
        answer = answer + 1;
        
        // 대기 트럭이 존재할 때만 다리(배열)에 트럭(요소)을 추가한다.
        if( truck_weights.length > 0 ){
                       
            // 현재 다리(배열)에 올라가 있는 트럭의 무게 총합을 구한다.
            var sum = getSumWeight(bridge);
            
            // 현재 다리 위에 트럭의 무게 총합 + 대기 중인 트럭의 첫번째 차의 무게가 견딜 수 있는 무게인지 비교한다.
            if( sum + truck_weights[0] <= weight ){
                // 견딜 수 있다면 대기 트럭(배열)에서 뺀 후 다리(배열)에 추가한다.
                bridge.push(truck_weights.shift());
            }else{
                // 견딜 수 없다면 추가하지 않는다. (0으로 추가한다)
                bridge.push(0);
            }
        }
    }
    return answer;
}

Java
전체적인 로직은 비슷한데, 다리를 배열이 아닌 리스트로 정의하였다.
(삭제를 용이하게 하기 위함)

대기 트럭 배열은 굳이 리스트로 변경하지 않고, arrayShift함수를 따로 생성해서 사용하였음

import java.util.List;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.stream.Collectors;

class Solution {
    
    private int getSumWeight(List<Integer> bridge){
        int result = 0;
        for(Integer temp : bridge){
            result += temp;
        }
        // System.out.println(result);
        return result;
    }
    
    private static int[] arrayShift(int[] param, int deleteIndex){
        List<Integer> paramList = Arrays.stream(param).boxed().collect(Collectors.toList());
        paramList.remove(deleteIndex);

        int[] result = new int[paramList.size()];
        int index = 0;
        for(int temp : paramList){
            result[index] = temp;
            index++;
        }
        return result;
    }
    
    public int solution(int bridge_length, int weight, int[] truck_weights) {
        int answer = 0;
                
        List<Integer> bridge = new ArrayList<Integer>();
        for(int index = 0; index < bridge_length; index++){
            bridge.add(0);
        }
        
        while( bridge.size() > 0 ){
            bridge.remove(0);
            answer++;
            
            if( truck_weights.length > 0 ){
                int sum = getSumWeight(bridge);
                if( sum + truck_weights[0] <= weight ){
                    bridge.add(truck_weights[0]);
                    truck_weights = arrayShift(truck_weights, 0);
                }else{
                    bridge.add(0);
                }
            }
        }
        
        return answer;
    }
}