[스택/큐] 프린터, 탑, 쇠막대기, 다리를 지나는 트럭

스택 큐 문제는

어떤 패턴을 가지고 있느냐에 따라 결정된다.

그런 만큼 많이 풀어보고 다양한 상황에 대처 할 수 있는 수 밖에 없을 것 같다.

프린터

 

차분하게 조건에 따라 입력하자

function solution(priorities, location) {
    const map = priorities.map((value,index)=>{
        return {
            id : index,
            priorities : value
        }
    })
    let count = 0;
    while(true){
        let target = map.shift();
        let moreUpper = map.find((value)=>{
            return value.priorities > target.priorities
        })
        if(moreUpper){
            map.push(target);
        }else{
            count++;
        }
        if(!moreUpper && target.id == location){
            return count
        }
    }
    
}

탑

차분하게 조건에 따라 입력하자

function solution(heights) {
    var answer = [];
    const reverseHeights = heights.reverse()
    while(reverseHeights.length > 0) {
        let target = reverseHeights.shift();
        let taker = reverseHeights.findIndex((value,index)=>{
            return value > target
        })
        if(taker != -1)
            answer.unshift(heights.length - taker)
        else
            answer.unshift(0)
    }
    answer
    return answer;
}

0인 경우는 ()<- 레이저 인 경우.

( 하나 마다 전체 누적 케이스가 하나씩 늘어나고

레이저를 만나면 모든 누적 케이스가 한 번씩 추가된다.

)를 만나면 제일 최근의 누적케이스에 +1 (n개를 자르면 n+1개가 생성되기 때문에) 한다.

function solution(arrangement) {
    let answer = 0,
        stack = [];
 
    arrangement = arrangement.replace(/\(\)/g, 0);
 
    for (let i = 0; i < arrangement.length; i++) {
        switch (arrangement[i]) {
            case '(' :
                stack.push(0);
                break;
            case '0':
                stack = stack.map(v => v + 1);
                stack
                break;
            case ')':
                answer += stack[stack.length - 1] + 1;
                stack.pop();
                break;
        }
    }
 
    return answer;
}

class를 생성하여 문제를 해결하였고,

어려운 조건은 아니나,

정확하게 조건을 구현하지 않으면 정답 주의를 맴돌 수 있으니 주의하자.

class Truck {
    constructor(weight){
        this.weight = weight;
        this.wait = 1;
    }
}
 
function solution(bridge_length, weight, truck_weights) {
    var answer = 0
    const waitTruck = truck_weights.map((value)=>{
        return new Truck(value);
    })
    const moveTruck = [];
    
    let totalWeight = 0;
 
    while(waitTruck.length || moveTruck.length) {
        answer++
        if(!moveTruck.length) {
            let target = waitTruck.shift();
            totalWeight += target.weight;
            moveTruck.push(target)
            continue
        }
 
        moveTruck.map((value)=>{
            value.wait++
        })
 
        if(moveTruck[0].wait > bridge_length) {
            target = moveTruck.shift();
            totalWeight -= target.weight
        }
 
        if(totalWeight + waitTruck[0].weight <= weight) {
            target = waitTruck.shift();
            totalWeight += target.weight
            moveTruck.push(target)
        }
    }
 
    return answer;
}