36-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

2023 현대모비스 알고리즘 경진대회 상담원 인원

✔️ 소요된 시간

1시간 + 안떠올라서 다른 블로그 참고...

✨ 수도 코드

1. 문제 설명

1~k번으로 분류되는 상담 유형이 존재하는데, 각 멘토는 k개의 상담 유형 중 하나를 담당한다.
n명의 멘토를 k개의 상담 유형에 적절히 배정해서 참가자들의 상담 대기 시간을 최소화 하고자 한다.
각 상담 유형 별로 멘토가 최소한 1명 이상 되도록 적절히 배정하여, 참가자들이 상담을 받기까지 기다린 시간을 모두 합한 값의 최솟값을 return 하도록 solution 함수를 완성하라.

2. 설명

5명의 멘토에 3개의 상담 유형이 있다고 가정해보자.
각 유형 별로 최소한 1명은 존재해야 하니까, 멘토는 (1, 1, 3), (1, 3, 1), ..., (1, 2, 2), (2, 1, 2), ... 이런 식으로 배치할 수 있다.
유형 개수는 $1 \le k \le 5$이고, 멘토 수는 $k \le n \le 20$으로 작아서 이 부분은 중복 조합을 이용해 모든 경우의 수를 만들어도 될 것 같다.

mento_assignment_combs = [
    prod for prod in product(range(1, n + 1), repeat=k) if sum(prod) == n  # [1, 2, ..., n] 리스트에서 k개를 뽑는데 뽑은 숫자들의 합이 n인 경우만 취한다.
]

이런 식으로 중복조합(product)을 이용해 (1, 1, 3), (1, 2, 2), ... 과 같은 배정 조합이 mento_assignment_combs에 저장된다.

이제 이 멘토 배정 조합을 이용해, 각 조합마다 대기시간을 구해보자.

ans = float('inf')
for mento_assignment_comb in mento_assignment_combs:
    waiting_cur_comb = sum(
        get_consultation_waiting(category, num_mento)
        for category, num_mento in enumerate(mento_assignment_comb)
    )
    ans = min(ans, waiting_cur_comb)

mento_assignment_combs안에 든 조합을 하나씩 꺼내 get_consultation_waiting() 함수를 호출해 대기 시간을 구한다.
이 함수는 인자로 유형(category)과 해당 유형의 멘토 수(num_mento)를 매개변수로 받아 해당 유형의 대기 시간을 반환해준다.

각 유형 별 멘토 수를 지정해줬는데, 여기서 어떤 식으로 대기 시간을 구할 수 있을까? 여기서 우선순위큐를 사용한다.

우선순위큐는 멘토의 상담 가능 시간을 담고 있다. 우선순위 큐를 쓰는 이유는 여러 명의 멘토가 있을 때, 상담 가능한 가장 빠른 멘토 시간을 바로 뽑아쓰기 위해서다.
그리고 멘토 수만큼 우선순위 큐의 원소가 존재하도록 설정한다. 이 부분은 코드로 보자.

def get_consultation_waiting(category, num_mento):
    mento_ticks = [0] * num_mento
    heapify(mento_ticks)
    waiting = 0
    ...

멘토 수만큼 0 개수를 집어넣어 heap으로 구성한다. 예를 들어 2명이면 [0, 0]으로 힙을 구성한다.
이런 식으로 멘토 수만큼 0을 집어넣으면, 자연스럽게 "비어있는 멘토로 먼저 다가가서 상담을 하는" 효과를 낼 수 있다.

이제 멘토들도 준비되었으니, 참가자들을 차례대로 상담해보자.

consultations = defaultdict(list)
for a, b, c in reqs:
    consultations[c - 1].append((a, b))

우선 각 유형 별로 참가자들을 분리해서 저장해준다.

for tick, consultation in consultations[category]:
    fastest_mento = heappop(mento_ticks)
    ....

해당 카테고리에 있는 참가자 정보들을 차례대로 꺼내 확인한다. tick은 상담 시작 시각, consultation은 소요 상담 시간을 의미한다.
우선 현재 가장 빨리 상담할 수 있는 멘토 한 명을 꺼낸다. 최초의 경우 0 시간으로 들어가있다.

if fastest_mento > tick:
    waiting += fastest_mento - tick
    heappush(mento_ticks, fastest_mento + consultation)
else:
    heappush(mento_ticks, tick + consultation)

상황은 2가지다. 1. 멘토를 기다려야 하는 경우 2. 지금 바로 상담이 가능한 경우
1의 경우 (가장 빠른 멘토 시간 - 원하는 상담 시간)만큼 대기 시간이 발생해 이를 기록해주고, 힙에는 (멘토가 상담 가능한 시간 + 현재 참가자가 원하는 상담 시간)을 넣어준다.
2의 경우는 멘토가 진작에 앞선 상담을 끝낸 상태(fastest_mento < tick)거나, 방금 멘토가 앞선 상담을 막 끝낸 경우(fastest_mento == tick)이다. 이 경우에는 대기 시간이 발생하지 않으므로 기록할 필요는 없고, 힙에는 (참가자의 상담 시각 + 참가자의 상담 소요 시간)를 넣어준다.

return waiting

위 과정이 완료되면 기록한 대기 시간을 반환해준다.

ans = float('inf')
for mento_assignment_comb in mento_assignment_combs:
    waiting_cur_comb = sum(
        get_consultation_waiting(category, num_mento)
        for category, num_mento in enumerate(mento_assignment_comb)
    )
    ans = min(ans, waiting_cur_comb)
return ans

다시 이 코드로 돌아와서, get_consultation_waiting() 함수를 각 유형 별로 호출해 더한 waiting_cur_comb 값이 "현재 멘토 배정 조합"에서의 대기시간이다. 이를 모든 조합에 대해 검사해, 최소값을 ans에 기록한 뒤 반환하면 완성이다.

3. 전체 코드

from collections import defaultdict
from itertools import product
from heapq import heapify, heappop, heappush

def solution(k, n, reqs):
    # Generating all possible mentor assignment combinations
    mento_assignment_combs = [
        prod for prod in product(range(1, n + 1), repeat=k) if sum(prod) == n
    ]
    
    # Organizing consultations by category
    consultations = defaultdict(list)
    for a, b, c in reqs:
        consultations[c - 1].append((a, b))

    def get_consultation_waiting(category, num_mento):
        # Initialize heap with zeros
        mento_ticks = [0] * num_mento
        heapify(mento_ticks)
        waiting = 0
        
        for tick, consultation in consultations[category]:
            fastest_mento = heappop(mento_ticks)
            
            # Adjust waiting time based on consultation time and mentor availability
            if fastest_mento > tick:
                waiting += fastest_mento - tick
                heappush(mento_ticks, fastest_mento + consultation)
            else:
                heappush(mento_ticks, tick + consultation)
                
        return waiting

    # Calculate waiting time for each mentor assignment combination
    ans = float('inf')
    for mento_assignment_comb in mento_assignment_combs:
        waiting_cur_comb = sum(
            get_consultation_waiting(category, num_mento)
            for category, num_mento in enumerate(mento_assignment_comb)
        )
        ans = min(ans, waiting_cur_comb)
    return ans

#include <string>
#include <vector>
#include <queue>
#include <numeric>
#include <algorithm>

using namespace std;

vector<vector<int>> MentoAssignmentCombos;
vector<int> MentoNums;
vector<vector<pair<int, int>>> ConsultationInfo;

void GetMentoAssignmentCombos(vector<int> MentoCombo, int RemainCategory, int RemainMentoNum)
{
    if(RemainCategory == 0)
    {
        if(RemainMentoNum == 0)
        {
            MentoAssignmentCombos.emplace_back(MentoCombo);
        }
        return;
    }
    
    for(const int NumMento : MentoNums)
    {
        MentoCombo.emplace_back(NumMento);
        GetMentoAssignmentCombos(MentoCombo, RemainCategory - 1, RemainMentoNum - NumMento);
        MentoCombo.pop_back();
    }
}

int GetConsultationWaiting(const int Category, const int NumMento)
{
    priority_queue<int, vector<int>, greater<>> PQ;
    for(int i = 0; i < NumMento; ++i)
    {
        PQ.emplace(0);
    }
    
    int WaitingTime = 0;
    for(const auto& [Tick, Consultation] : ConsultationInfo[Category])
    {
        const int FastestMentoTick = PQ.top();
        PQ.pop();
        
        if(FastestMentoTick > Tick)
        {
            WaitingTime += FastestMentoTick - Tick;
            PQ.emplace(FastestMentoTick + Consultation);
        }
        else
        {
            PQ.emplace(Tick + Consultation);
        }
    }
    
    return WaitingTime;
}

int solution(int k, int n, vector<vector<int>> Reqs) 
{
    MentoNums.assign(n, 0);
    iota(MentoNums.begin(), MentoNums.end(), 1);
    GetMentoAssignmentCombos({}, k, n);
    
    ConsultationInfo.assign(k, {});
    for(const auto& Req : Reqs)
    {
        ConsultationInfo[Req[2] - 1].emplace_back(Req[0], Req[1]);
    }
    
    int Answer = 1e9;
    for(const auto& MentoAssignmentCombo : MentoAssignmentCombos)
    {
        int WaitingCurCombo = 0;
        for(int i = 0; i < k; ++i)
        {
            WaitingCurCombo += GetConsultationWaiting(i, MentoAssignmentCombo[i]);
        }
        Answer = min(Answer, WaitingCurCombo);
    }
    return Answer;
}

📚 새롭게 알게된 내용

Ha... SRT에서 계속 고민해봤는데 감이 참 안잡혀서 결국 블로그를 참고해버렸다... 왤케 안보이는 걸까?

호우동의 개발 일지 : 프로그래머스 Level 3 상담원 인원

[tgyuuAn]

당신 왜 이런 걸 풀어서 기를 죽이고 그래요?!

[LJEDD2]

당신 왜 이런 걸 풀어서 기를 죽이고 그래요?!

[Dolchae]

문제가 정말 어렵네요..😂 상담 시간을 우선순위 큐로 해결하면서 초기값을 미리 0으로 채워놓는 아이디어 잘 배우고 갑니다👍 수고하셨어요😊

[gjsk132]

우으아ㅏㅇ왕 풀었다아ㅏ 🫠

저는 약간 다르게... 조합을 사용하지 않고 정렬하는 방식으로 구했습니다.

크게 4단계로 나누어 풀이했습니다.

1. 상담 유형별로 분리한다.
2. 상담 유형별로 배치할 수 있는 직원 수를 늘려서 각각 대기 시간을 기억한다.
3. 사람이 추가되면서 얼마나 대기 시간이 차이가 있는지를 구한다.
   (4번 계산할 때 누적된 부분 제외하기 위한 과정)
4. 모든 유형에서 대기 시간이 없을 때보다 몇 명 부족한지 구하고, 그 범위만큼 대기 시간 총합을 출력한다.

---

한 단계씩 알아보기

[ 1단계 ] 상담 유형별 분리

reqs_type = [[] for _ in range(k+1)]

for start, care, care_type in reqs:
    reqs_type[care_type].append((start, care))

유형의 종류만큼 리스트를 만들어준다. ( +1 >> 0 제외하기 위함 )

상담 유형에 따라 상담 시작 시간과 상담 시간을 다시 넣어준다.

---

[ 2단계 ] 유형별 직원 수에 따른 대기 시간 구하기

유형별 고객 리스트를 보고 직원 수에 따라 걸리는 대기 시간을 구해주면 된다.

직원 수의 경우 최대 가능한 직원 수까지 늘리면 된다.
( 다만 대기 시간이 0이 되면 의미 없어서 종료 )

상담원이 다음 고객을 받을 수 있는 시점을 우선순위 큐를 사용하여 갱신하면서
구하면 된다.

for customer_list in reqs_type[1:]:
    
    if customer_list == []:
        continue
    
    care_cnt = 1
    delay = 0
    delay_per_care = []
    
    while care_cnt <= max_care:
        
        # 상담원 수만큼 0을 만들어서 우선순위 큐를 통해 구한다.
        next_care = [0 for delay_per_care in range(care_cnt)]
        heapify(next_care)
        
        delay = 0
        
       # 먼저 상담이 끝나는 시간을 우선순위 큐를 이용하여 pop
       # 마지막 고객까지 돌면서 대기 시간을 더한다.
       # 끝나는 시간을 다시 push
        for start, care in customer_list:
            nc = heappop(next_care)
            delay += max(0, nc-start)
            heappush(next_care, max(nc, start)+care)
        
        if delay == 0:
            break
        
        delay_per_care.append(delay)
        care_cnt += 1

---

[ 3단계 ] 겹치는 대기 시간 빼주기

해당 반복문은 2단계의 반복문 안에 있습니다!
( 전체 코드보면 무슨 말인지 알 수 있어요!)

    for i in range(len(delay_per_care)):
        delay_meno.append(delay_per_care[i]
                        -(0 if i+1 == len(delay_per_care) else delay_per_care[i+1]))
                        
        delay_cnt += 1

한 유형에서 i명의 사람이 있을 때와 i+1명의 사람이 있을 때, 얼마나 대기 시간이 줄었는지를 delay_meno(대기시간 메모)에 넣어준다.

만약 i가 맨 끝에 도달했다면 맨 끝 값을 넣어주면 된다.

delay_cnt는 총 들어간 상담원을 계산하기 위한 값이기 때문에 1씩 더해준다.

4단계를 위한 과정이라고 보면 될 것 같다.
사람이 추가되면서 이전보다 얼마나 시간이 줄었는지 값이 모이게되고...
이 값들 하나하나는 결국 사람이 한 명 없을 때마다 생기는 대기 시간이라는 것을 알 수 있다.

---

[ 4단계 ] 사람이 부족한 만큼 추가로 걸리는 대기 시간의 합 구하기

대기 시간이 0이 되지 않는 이상 유형에서 매번 최대한으로 상담원을 넣었기 때문에
주어진 상담원보다 더 많은 상담원이 계산에 들어갔다.

주어진 상담원 수를 맞추면서
그만큼 늘어나는 대기 시간을 추가해주어야 한다.

상담원이 한 명 늘어나면, 이전에 비해 엄청나게 많은 대기 시간을 줄일 수 있다.
( 여러 번 중첩한 부분을 많이 없앨 수 있기 때문에 줄일 수 있기 때문이다. )
반면에 상담원이 점차 늘어날수록 이전에 비해 줄일 수 있는 대기 시간이 줄어든다.

쉽게 말하자면, 상담원 수를 한 명 빼면, 가장 작은 대기 시간을 더하면 된다.
( 어느 유형일지 상관없이 대기 시간만 따지기에 가능한 일이다. )

delay_meno.sort()
print(sum(delay_meno[:delay_cnt-(n-k)]))

그래서 대기 시간을 정렬하고,

구한 대기 시간의 수에서 ( delay_cnt )
여유 상담원 수를 빼주면 ( n-k : 각 유형에 1명씩 무조건 배치하고 남은 상담원 )
빼야하는 상담원 수가 나오기 때문에 그 수만큼 대기 시간을 더해주면 된다.

---

전체 코드

from heapq import *

def solution(k, n, reqs):
    reqs_type = [[] for _ in range(k+1)]
    
    for start, care, care_type in reqs:
        reqs_type[care_type].append((start, care))
        
    max_care = 1 + n - k

    delay_meno = []
    delay_cnt = 0

    for customer_list in reqs_type[1:]:

        if customer_list == []:
            continue

        care_cnt = 1
        delay = 0
        delay_per_care = []

        while care_cnt <= max_care:

            next_care = [0 for delay_per_care in range(care_cnt)]
            heapify(next_care)

            delay = 0

            for start, care in customer_list:
                nc = heappop(next_care)
                delay += max(0, nc-start)
                heappush(next_care, max(nc, start)+care)

            if delay == 0:
                break

            delay_per_care.append(delay)
            care_cnt += 1
        
        cnt = len(delay_per_care)
        for i in range(cnt):
            delay_meno.append(delay_per_care[i]-(0 if i+1 == cnt else delay_per_care[i+1]))
            delay_cnt += 1

    delay_meno.sort()
    return sum(delay_meno[:delay_cnt-(n-k)])

delay_meno... memo 오탄데 해 뜨기 직전에 거의 다 썼을 때 봐서... 고치기 귀찮... 힘들어서 내버려두겠습니당... 너그러이 봐주세욥 🫠

[xxubin04]

풀어볼까 했으나.. 역시 어렵네요...😂
상담 대기 시간을 최소화하고자 하는 문제인데 우선순위 큐를 떠올리지 못했네요..
그리고 두 가지 상황으로 나누어서 생각하는 부분도 저는 생각지 못했는데 역시..👍