31-wnsmir

[wnsmir]

🔗 문제 링크

https://school.programmers.co.kr/learn/courses/30/lessons/150369

✔️ 소요된 시간

1.5h

✨ 수도 코드

그리디 문제입니다.
최단거리? 순열? 생각해봤지만 매번 참고해야하는 기준이 달라져 그리디임을 직감했습니다.

문제를 잘읽어보면 결국 한번 다녀오는길에 최대한 멀리있는집부터 배송/수거를 해야합니다. 먼길을 다시갈수록 중첩해서 가는길이 늘어나기 때문입니다. 즉 한번 출발할떄 가장먼 수거 혹은 배달할 집을 정하고, 그 거리의 두배(왕복)을 답에 추가해줍니다.

도착한 집은 cap의 여유가 되는만큼 배송/수거 해주고, 다음집으로 넘어갑니다.

이를 배송, 수거물량이 0이될때까지 반복해주면 풀립니다.

뭔가 어려운문제는 아닌데 애매한걸 확실히 구현함에 있어서 까다로운 유형이 그리디인것 같습니다.

def solution(cap, n, deliveries, pickups):
    answer = 0
    last_del = n-1
    last_pick = n-1
    
    # 아직 배달, 수거할 집이 남아있다면 반복
    while last_del >= 0 or last_pick >= 0:
        # 가장 먼 배달/수거할 집 업데이트
        while last_del >= 0 and deliveries[last_del] == 0:
            last_del -= 1
        while last_pick >= 0 and pickups[last_pick] == 0:
            last_pick -= 1
        
        # 이번턴에 갈 가장 마지막집
        far = max(last_pick, last_del) + 1
        answer += far * 2

        # deliver == 한번에 가능한 배달 수
        deliver = cap
        
        # 배달도 가능하고, 배달해야할 집이 남았디면
        while deliver > 0 and last_del >= 0:
            # 집이 비었을떄 다음집으로
            if deliveries[last_del] == 0:
                last_del -= 1
                continue
            
            # 최대용량보다 배달할게 적을때 최대용량 줄이고 다음집
            if deliveries[last_del] <= deliver:
                deliver -= deliveries[last_del]
                deliveries[last_del] = 0
                last_del -= 1
            
            # 최대용량을 넘어설때 최대용량만큼 배달하고 종료
            else:
                deliveries[last_del] -= deliver
                deliver = 0

        pick = cap
        while pick > 0 and last_pick >= 0:
            if pickups[last_pick] == 0:
                last_pick -= 1
                continue
                
            if pickups[last_pick] <= pick:
                pick -= pickups[last_pick]
                pickups[last_pick] = 0
                last_pick -= 1
                
            else:
                pickups[last_pick] -= pick
                pick = 0

    return answer

[9kyo-hwang]

이것도 2년 전의 와타시가 풀었었군요... 과거의 전 알고리즘만 하루종일 했나 봅니다.

결국 가장 먼 집부터 배달/수거를 해야하는 점은 다들 캐치하실 것 같습니다. 저는 이거를 보고 stack 자료구조가 적합하다는 생각이 들더라구요.

1. 맨 뒤부터 cap만큼 배달하기
2. 맨 뒤부터 cap만큼 수거하기
3. 1, 2 과정을 모든 집이 요구하는 물량을 쳐낼 때까지 반복, 그 과정에서 배달/수거 중 더 긴 거리를 누적

#include <string>
#include <vector>

using namespace std;

long long solution(int cap, int n, vector<int> deliveries, vector<int> pickups) {   
    // 요구 개수가 0인 건 미리 쳐냅니다.
    while(!deliveries.empty() && deliveries.back() == 0) deliveries.pop_back();
    while(!pickups.empty() && pickups.back() == 0) pickups.pop_back();
    size_t answer = max(deliveries.size(), pickups.size());  // 최초 이동 거리는 둘 중 더 긴 것
    
    while(!deliveries.empty() || !pickups.empty()) {
        size_t capacity = 0;
        while(!deliveries.empty()) {  // 우선 배달을 쳐냅니다.
            capacity += deliveries.back();
            deliveries.pop_back();
            
            if(capacity > cap) {  // 초과분은 다시 맨 끝에 삽입하여 다음 루프에서 처리
                deliveries.emplace_back(capacity - cap);
                break;
            }
        }
        
        capacity = 0;
        while(!pickups.empty()) {  // 다음은 수거
            capacity += pickups.back();
            pickups.pop_back();

            if(capacity > cap) {  // 동일하게 초과분은 다시 맨 끝에 삽입하여 다음 루프에서 처리
                pickups.emplace_back(capacity - cap);
                break;
            }
        }
        
        // 둘 중 다음 이동거리가 더 긴 것을 누적
        answer += max(deliveries.size(), pickups.size());
    }
    
    // 왕복이므로 2배
    return answer * 2;
}

[kangrae-jo]

저도 교황님의 추천으로 이 문제를 예전에 풀어본 것 같아요.
그래도 다시 한 번 풀어보고싶어서 시도해봤습니다.

출발할때 최대로 전부 놓으면서 가고, 돌아올때 최대로 전부 들고오는 방식을 생각하며 구현했습니다.

음... 저도 준용님 처럼 (인덱스로 배열에 접근하는 방식으로) 코드를 거의 비슷하게 짰는데
일부 케이스에서 틀리더라구요...

그래서 과거의 기억을 더듬어서 스택으로 풀어봤습니다.
그랬더니 풀리더군요...

구현은 참 신기합니다.
사고력과 집중력을 늘리기에도 좋은 유형인것 같네요.

#include <stack>
#include <vector>
#include <algorithm>

using namespace std;

void move(stack<int>& s, int capacity) {
    int carry = 0;
    while (!s.empty()) {
        int cur = s.top();
        s.pop();
        
        // 현재 가능한 만큼만 두고가기 or 들고가기
        if (carry + cur > capacity) {
            s.push(cur - (capacity - carry));
            break;
        }
        // 현재에 다 두고가기 or 들고가기
        carry += cur;
    }
}

long long solution(int cap, int n, vector<int> deliveries_, vector<int> pickups_) { 
    // 스택으로 표현
    stack<int> deliveries, pickups;
    for (int d : deliveries_) deliveries.push(d);
    for (int p : pickups_)    pickups.push(p);
    
    // 배달과 수거
    long long answer = 0;
    while (!deliveries.empty() || !pickups.empty()) {
        while (!deliveries.empty() && deliveries.top() == 0) deliveries.pop();
        while (!pickups.empty()    && pickups.top() == 0)    pickups.pop();
        answer += max(deliveries.size(), pickups.size());
        
        move(deliveries, cap);
        move(pickups, cap);
    }
    
    return answer * 2;
}

+) 아 그리고 교황님의 solution함수 return 방식이 마음에 들어서 따라해봤습니다
문제에서 요구하는 answer이 무조건 왕복이어서 가능한 트릭같네요.

++ ) 아 그리고 스택의 top == 0인 녀석들을 뺴주는 이유는 왕복 거리를 계산할때 문제가 되기 때문입니다!
move함수내에서는 0이라도 정상동작함으로 안해줘도 되나 싶지만,
거리를 측정할때는 top ==0 인 녀석이 size를 차지하기 때문에 빼주어야합니다.

실제로 저 두 while문을 없애고 제출해보면 딱 1개의 케이스에서 틀렸다고 뜹니다.

[kokeunho]

저는 급하게 풀어서 그런지 풀이를 떠올리지 못했습니다;
복잡하게 생각해서 그런거 같기도 하고요.

그리디 문제를 좀 더 많이 풀어봐야할 것 같습니다.
저번 준용님 PR부터 느낀 것인데 제가 이런 유형에 약한 것 같아요.

스택을 사용한 다른 분들과 달리 따로 인덱스 변수를 사용한 것만 빼면
풀이는 동일합니다.

수고하셨습니다.

Details

import java.util.*;

class Solution {
    public long solution(int cap, int n, int[] deliveries, int[] pickups) {
        long answer = 0;
        int dIdx = n - 1;
        int pIdx = n - 1;
        
        while (dIdx >= 0 || pIdx >= 0) {
            while (dIdx >= 0 && deliveries[dIdx] == 0) dIdx--;
            while (pIdx >= 0 && pickups[pIdx] == 0) pIdx--;
            
            int distance = Math.max(dIdx, pIdx);
            answer += (long)(distance+1) * 2;
            
            int deliverCap = cap;
            while (cap > 0 && dIdx >= 0) {
                if (deliverCap >= deliveries[dIdx]) {
                    deliverCap -= deliveries[dIdx];
                    deliveries[dIdx] = 0;
                    dIdx--;
                } else {
                    deliveries[dIdx] -= deliverCap;
                    break;
                }
            }
            
            int pickupCap = cap;
            while (pickupCap > 0 && pIdx >= 0) {
                if (pickupCap >= pickups[pIdx]) {
                    pickupCap -= pickups[pIdx];
                    pickups[pIdx] = 0;
                    pIdx--;
                } else {
                    pickups[pIdx] -= pickupCap;
                    break;
                }
            }
        }
        return answer;
    }
}

[g0rnn]

재밌는 문제네요 뭔가 알고리즘적인 개념이 필요하다기보다 약간의 센스랑 구상하기 어려운 로직을 실수없이 구현해야해서 더 재밌었던거 같아요.

저도 다른분들처럼 가장 뒤에서부터 배달하며 시작하려했씁니다. 그래서 for(int i = n-1; i >= 0; i--)로 했더니 시간초과가 나더군요.. 시간초과를 예상하지 못한 제 실수입니다..

java code

class Solution {
    public long solution(int cap, int n, int[] deliveries, int[] pickups) {
        long answer = 0;
        int totalD = 0;
        int totalP = 0;
        int farHome = 0;
        for (int i = 0; i < n; i++) {
            totalD += deliveries[i];
            totalP += pickups[i];
            if (deliveries[i] != 0 || pickups[i] != 0) {
                farHome = i;
            }
        }
        
        while (!(totalD == 0 && totalP == 0)) {
            int tempDeliverCap = 0;
            int tempPickUpCap = 0;
            int stayIdx = -1;
            
            for (int i = n-1; i >= 0; i--) {
                if (tempDeliverCap < cap && deliveries[i] != 0) {
                    // 모두 내려놓기
                    // cap보다 크면 diff만큼 돌려놓고 temp도 수정
                    int curDeliverCap = cap - tempDeliverCap;
                    if (deliveries[i] - curDeliverCap >= 0) {
                        tempDeliverCap += curDeliverCap;
                        deliveries[i] -= curDeliverCap;// 가져간만큼
                    } else {
                        tempDeliverCap += deliveries[i];
                        deliveries[i] = 0;
                    }
                    if (stayIdx < i) {
                        stayIdx = i;
                    }
                }
                
                if (tempPickUpCap < cap && pickups[i] != 0) {
                    int curPickUpCap = cap - tempPickUpCap;
                    if (pickups[i] - curPickUpCap >= 0) {
                        tempPickUpCap += curPickUpCap;
                        pickups[i] -= curPickUpCap;
                    } else {
                        tempPickUpCap += pickups[i];
                        pickups[i] = 0;
                    }
                    if (stayIdx < i) {
                        stayIdx = i;
                    }
                }
                
                if (tempDeliverCap == cap && tempPickUpCap == cap) {
                    break;
                }
            }
            answer += (stayIdx+1) * 2;
            totalD -= tempDeliverCap;
            totalP -= tempPickUpCap;
        }
        
        return answer;
    }
}

(7초가 지나도 성공인걸로 보아 시간제한은 10초로 널널하군요)

아무튼 시간초과 후 다른 분들의 코드와 지피티의 도움을 살짝 받아 제 코드의 단점을 고쳤습니다.

class Solution {
    public long solution(int cap, int n, int[] deliveries, int[] pickups) {
        long answer = 0;
        int d = n - 1;
        int p = n - 1;
        
        while (true) {
            while (d >= 0 && deliveries[d] == 0) d--;
            while (p >= 0 && pickups[p] == 0) p--;
            
            if (d < 0 && p < 0) break;
            
            answer += (Math.max(d, p) * 2L) + 2L;
            
            int capD = cap;
            // 현재 용량을 다 채울 때까지 반복
            while (d >= 0 && capD > 0) {
                if (deliveries[d] - capD <= 0) {
                    capD -= deliveries[d];
                    deliveries[d] = 0;
                    d--;
                } else {
                    deliveries[d] -= capD;
                    capD = 0;
                }
            }
            
            int capP = cap;
            while (p >= 0 && capP > 0) {
                if (pickups[p] - capP <= 0) {
                    capP -= pickups[p];
                    pickups[p] = 0;
                    p--;
                } else {
                    pickups[p] -= capP;
                    capP = 0;
                }
            }
        }
        
        return answer;
    }
}