60-9kyo-hwang

[9kyo-hwang]

🔗 문제 링크

과제 진행하기

✔️ 소요된 시간

1시간 조금 넘게...?

✨ 수도 코드

1. 문제

과제 수행에 대한 정보가 [name, start, playtime] 형태로 주어진다. name은 과제 이름, start는 hh:mm 형태의 시작 시각 문자열, playtime은 과제를 완료하는 데 걸리는 시간이다.

시간 순서에 맞게 과제를 시작하는데, 다음과 같은 규칙이 존재한다.

• 과제를 진행하는 도중에 새로운 과제를 시작해야 하는 시각이 되면, 기존 과제는 중단하고 새로운 과제를 시작한다.
• 진행 중이던 과제를 끝냈을 때, 잠시 중단했던 과제가 있다면 해당 과제를 마저 한다. 단 이 때 새로운 과제가 존재한다면, 중단했던 과제를 하지 않고 새로운 과제를 먼저 한다.
• 중단했던 과제가 여러 개라면 가장 최근에 멈춘 과제부터 시작한다.

과제를 끝낸 순서대로 이름을 배열에 담아 return하라.

2. 풀이

문제에서 제시한 로직을 차분히 코드로 구현하면 되는 문제다.

class FPlan
{
public:
    string Name;
    int Start;
    int Playtime;
    
    FPlan() {}
    FPlan(const string& InName, const string& InStart, const string& InPlaytime)
    {
        Name = InName;
        Start = stoi(InStart.substr(0, 2)) * 60 + stoi(InStart.substr(3, 2));
        Playtime = stoi(InPlaytime);
    }
    
    const bool operator<(const FPlan& Rhs) const
    {
        return Start < Rhs.Start;
    }
};

과제 정보에 대한 클래스를 새로 정의했다.

• start, playtime 정보가 문자열로 주어지기 때문에 int형으로 변환해 저장한다. 이 때 시각 정보는 분 단위로 변환한다.
• 또한 과제 정보 간에는 시작 시각을 기준으로 정렬돼야 하기 때문에, start 정보를 기준으로 비교할 수 있도록 < 연산자를 오버로딩했다(java의 compareTo() 메서드, 파이썬의 labmda x: x[1]과 동일한 역할).

vector<string> solution(vector<vector<string>> InPlans) 
{
    vector<FPlan> Plans;
    for(const vector<string>& Plan : InPlans)
    {
        Plans.push_back({Plan[0], Plan[1], Plan[2]});
    }
    
    sort(Plans.begin(), Plans.end());
    
    ...
}

기본적으로 주어지는 과제 정보들을 새로 정의한 FPlan 클래스로 변환해 저장한 뒤, 시작 시각 기준으로 정렬시킨다.

vector<string> Result;  // 완료된 과제 이름들을 저장할 리스트
vector<int> Paused;  // 일시적으로 중단한 과제들의 인덱스를 저장할 스택

for(int i = 0; i < Plans.size() - 1; ++i)
{
    ...
}

Result.emplace_back(Plans.back().Name);

저장된 과제 정보를 순회한다. 단 맨 마지막 정보는 순회할 필요 없이 마지막에 무조건 완료되기 때문에, Plans.size() - 1 만큼만 순회한다.

int TimeDifference = Plans[i + 1].Start - Plans[i].Start;
if(Plans[i].Playtime > TimeDifference)
{
    Plans[i].Playtime -= TimeDifference;
    Paused.emplace_back(i);
    continue;
}

...

i + 1번째 정보와 i번째 정보의 시작 시각의 차를 통해 시간 차 TimeDifference를 구한다.
해당 시간 차가 현재 i번째 과제 소요 시간보다 짧을 경우, i번째 과제는 TimeDifference만큼만 과제를 수행하고 Paused에 저장된다.

TimeDifference -= Plans[i].Playtime;
Plans[i].Playtime = 0;
Result.emplace_back(Plans[i].Name);

while(TimeDifference > 0 && !Paused.empty())
{
    int Index = Paused.back();
    if(Plans[Index].Playtime > TimeDifference)
    {
        Plans[Index].Playtime -= TimeDifference;
        break;
    }
    
    TimeDifference -= Plans[Index].Playtime;
    Plans[Index].Playtime = 0;
    Result.emplace_back(Plans[Index].Name);
    Paused.pop_back();
}

아니라면 i번째 과제는 완료할 수 있는 것이므로 Result 리스트에 해당 과제의 이름을 추가한다.
그 후 중단한 과제들을 확인한다.

• 만약 중단한 과제가 남은 시간 차 안에 해결할 수 없다면 더 이상 확인하지 않고 새로운 과제 정보를 확인한다.
• 아니라면 중단한 과제를 완료하고 Stack에서 제거한다.
• 이 과정에서 남은 시간을 갱신한다

여담) 이 부분에서 삽질을 좀 해서 테케 4~6개를 계속 틀렸다... 중단된 과제를 2개 이상 해결할 수도 있기 때문에 while문으로 확인하고, 중단된 과제를 해결하면서 남은 시간 차가 줄어들기 때문에 이를 갱신해줘야 한다.

while(!Paused.empty())
{
    Result.emplace_back(Plans[Paused.back()].Name);
    Paused.pop_back();
}

이렇게 Plans 리스트에 있는 과제 정보를 모두 확인했다면, 마지막으로 중단된 과제들이 남아있는 지 한 번 더 확인해 마무리한다.

전체 코드

#include <string>
#include <vector>
#include <algorithm>

using namespace std;

class FPlan
{
public:
    string Name;
    int Start;
    int Playtime;
    
    FPlan() {}
    FPlan(const string& InName, const string& InStart, const string& InPlaytime)
    {
        Name = InName;
        Start = stoi(InStart.substr(0, 2)) * 60 + stoi(InStart.substr(3, 2));
        Playtime = stoi(InPlaytime);
    }
    
    const bool operator<(const FPlan& Rhs) const
    {
        return Start < Rhs.Start;
    }
};

vector<string> solution(vector<vector<string>> InPlans) 
{
    vector<FPlan> Plans;
    for(const vector<string>& Plan : InPlans)
    {
        Plans.push_back({Plan[0], Plan[1], Plan[2]});
    }
    
    sort(Plans.begin(), Plans.end());
    
    vector<string> Result;
    vector<int> Paused;
    
    for(int i = 0; i < Plans.size() - 1; ++i)
    {
        int TimeDifference = Plans[i + 1].Start - Plans[i].Start;
        if(Plans[i].Playtime > TimeDifference)
        {
            Plans[i].Playtime -= TimeDifference;
            Paused.emplace_back(i);
            continue;
        }
        
        TimeDifference -= Plans[i].Playtime;
        Plans[i].Playtime = 0;
        Result.emplace_back(Plans[i].Name);
        
        while(TimeDifference > 0 && !Paused.empty())
        {
            int Index = Paused.back();
            if(Plans[Index].Playtime > TimeDifference)
            {
                Plans[Index].Playtime -= TimeDifference;
                break;
            }
            
            TimeDifference -= Plans[Index].Playtime;
            Plans[Index].Playtime = 0;
            Result.emplace_back(Plans[Index].Name);
            Paused.pop_back();
        }
    }
    
    Result.emplace_back(Plans.back().Name);
    
    while(!Paused.empty())
    {
        Result.emplace_back(Plans[Paused.back()].Name);
        Paused.pop_back();
    }
    
    return Result;
}

📚 새롭게 알게된 내용

시간 다루는 문제는 항상 푸는 데 골치가 아프다...

[mjj111]

예전에 자바로 풀었을 때는 클래스 기준으로 풀었었는데,
파이썬으로 풀다보니 좀 더 간단하게 풀 수있었습니다!

저도 반복문으로 새로 주어진 과제를 갱신하고,
스택 하나로 이전 과제를 기록하는 방식으로 풀어봤습니닷.

def solution(plans):
    stack = []
    result = []
    
    for plan in plans:
        hour, minute = map(int, plan[1].split(':'))
        start_time = hour * 60 + minute
        plan[1] = start_time
        plan[2] = int(plan[2])
        
    # 시작 시간 기준으로 계획 정렬
    plans.sort(key=lambda x: x[1])
    
    for i in range(len(plans) - 1):
        current_plan = plans[i]
        next_plan = plans[i + 1]
        
        stack.append([current_plan[0], current_plan[2]])  
        time_gap = next_plan[1] - current_plan[1]  
        
        # 스택을 처리하면서 빈 시간을 소진
        while stack and time_gap > 0:
            top_plan, remaining_time = stack[-1] 
            
            if remaining_time <= time_gap:
                stack.pop()
                time_gap -= remaining_time
                result.append(top_plan)  
                
            else:
                stack[-1][1] -= time_gap
                time_gap = 0

    result.append(plans[-1][0])
    
    while stack:
        result.append(stack.pop()[0])
    
    return result