39-pknujsp

[pknujsp]

🔗 문제 링크

디스크 컨트롤러

✔️ 소요된 시간

1시간 10분

✨ 수도 코드

모든 작업의 요청부터 종료까지 걸린 시간의 평균을 최소화하기

• jobs를 요청 시간 순으로 정렬
• 남은 작업이 없을 때 까지 다음 과정을 반복한다
  • 현재 시간curr_time 에 처리 가능한 모든 작업을 최소 힙에 추가
    • 실행 시간을 기준으로 힙에 추가
    • 실행 시간이 짧은 작업 부터 먼저 처리 하도록 한다
  • 힙에 작업이 있다면, 추출하여 해당 작업을 처리한다
    • 현재 시간을 작업의 실행 시간 만큼 증가 시킨다
    • 작업의 대기 시간만큼 wait_time을 증가 시킨다
  • 작업이 없다면, 1초 뒤로 이동한다

요청 시간 순으로 정렬한 후 짧은 작업부터 처리하는 이유

대기 시간을 최소화하기 위함이다.
짧은 작업을 먼저 처리하면, 다음 작업의 대기 시간이 줄어듦. 시스템이 더 많은 작업을 더 빠르게 처리할 수 있다.

• ex) [1, 2, 4] : 처리 시간이 1, 2, 4초
  • 짧은 작업부터 처리 : (1 + 3) / 3 = 4 / 3 = 1.3
  • 긴 작업부터 처리 : (4 + 5) / 3 = 9 / 3 = 3

긴 작업부터 처리 시
1.3초에서 3초로 평균 대기 시간이 크게 늘어난다

def solution(jobs):
    jobs = deque(sorted(jobs))
    jobs_num = len(jobs) 
    
    curr_time = wait_time = 0
    heap = []
    
    while heap or jobs:
        while jobs and jobs[0][0] <= curr_time:
            # 현재 시각 내에 처리가능한 작업을 모두 힙에 추가
            requested_time, duration = jobs.popleft()
            heappush(heap, (duration, requested_time))
            
        if heap:
            duration, requested_time = heappop(heap)
            
            curr_time += duration
            wait_time += curr_time - requested_time
        else:
            curr_time += 1
    
    return wait_time // jobs_num

📚 새롭게 알게된 내용

[tgyuuAn]

from heapq import *
from collections import deque

def solution(jobs):
    n = len(jobs)
    jobs.sort()
    jobs = deque(jobs)
    heap = []
            
    answer = 0
    now = -1
    while jobs:
        input_time, duration_time = jobs.popleft()
        print()
        print(answer)
        print(now)
        print(heap)
        print(input_time, duration_time)
        
        if input_time == now:
            keep_job = [now+duration_time, duration_time, input_time]
            heappush(heap, keep_job)
        
        elif input_time > now:
            
            # 수행하고 있지 않을 경우 먼저 들어온 것을 수행
            if len(heap) == 0:
                now = input_time + duration_time
                answer += duration_time
                continue
            
            # 현재 시간을 기준으로 갱신
            while heap[0][0] != now + heap[0][1]:
                temp = heappop(heap)
                heappush(heap, [now + temp[1], temp[1], temp[2]])
            
            peek = heappop(heap)
            now = peek[0]
            answer += peek[0] - peek[2]
            
            keep_job = [now+duration_time, duration_time, input_time]
            heappush(heap, keep_job)
        
        # 수행하고 있는 작업이 있을 경우,
        else:
            # 지금 진행중인 작업이 끝나자마자 넣었을 경우 끝나는 시간, 요청, 걸리는 시간
            keep_job = [now+duration_time, duration_time, input_time]
            heappush(heap, keep_job)
    
    while heap:
        print()
        print(answer)
        print(now)
        print(heap)
        
        while heap[0][0] != now + heap[0][1]:
            temp = heappop(heap)
            heappush(heap, [now + temp[1], temp[1], temp[2]])
            
        peek = heappop(heap)
        if peek[1] + peek[2] >= peek[0]:
            now = peek[1]+ peek[2]
            answer += peek[1]
            
        else:
            now = peek[0]
            answer += peek[0] - peek[2]
    
    print(now)
    print(answer)
    
    return answer//n

# 데이터 들어오면 힙으로 집어넣음.
# 기다리는 시간 + 진행되는 시간이 가장 적은 것 부터 실행시킴.

이 코드가 계속 9번 테스트 케이스에 걸려요..

1시간 째인데 잘 모르겠네요..

jobs = [[0, 6], [2, 8], [3, 7], [7, 1], [11, 11], [19, 25], [30, 15], [32, 6], [40, 3]]
answer : 19

가 나와야 하는데 자꾸 18이 나오네요... 왜죠 ㅠㅠ... 하..

[H0ngJu]

import heapq

def solution(jobs):
    jobs.sort()
    current_time = 0
    total_time = 0 
    heap = []
    jobs_done = 0
    index = 0
    jobs_len = len(jobs)
    
    while jobs_done < jobs_len:
        # 현재 시간 전에 요청되는 process는 heap에 넣기
        while index < jobs_len and jobs[index][0] <= current_time:
            heapq.heappush(heap, (jobs[index][1], jobs[index][0]))
            index += 1
        
        # 최소 시간 부터 작업 시작
        if heap:
            process_time, req_time = heapq.heappop(heap)
            current_time += process_time 
            total_time += current_time - req_time
            jobs_done += 1 
        else:
            # 힙이 비어있는 경우
            if index < jobs_len: current_time = jobs[index][0]
            else: current_time = current_time + 1
    
    return total_time // jobs_len

중간에 준성님 수도 코드 참고하여서 작성하였습니다. 최종 코드를 보니 준성님 코드가 더 깔끔하고 효율적이네요 🙂 힙 다시 복습하고 갑니당 !
문제푸느라 수고하셨습니다 -!

[pknujsp]

from heapq import *
from collections import deque

def solution(jobs):
    n = len(jobs)
    jobs.sort()
    jobs = deque(jobs)
    heap = []
            
    answer = 0
    now = -1
    while jobs:
        input_time, duration_time = jobs.popleft()
        print()
        print(answer)
        print(now)
        print(heap)
        print(input_time, duration_time)
        
        if input_time == now:
            keep_job = [now+duration_time, duration_time, input_time]
            heappush(heap, keep_job)
        
        elif input_time > now:
            
            # 수행하고 있지 않을 경우 먼저 들어온 것을 수행
            if len(heap) == 0:
                now = input_time + duration_time
                answer += duration_time
                continue
            
            # 현재 시간을 기준으로 갱신
            while heap[0][0] != now + heap[0][1]:
                temp = heappop(heap)
                heappush(heap, [now + temp[1], temp[1], temp[2]])
            
            peek = heappop(heap)
            now = peek[0]
            answer += peek[0] - peek[2]
            
            keep_job = [now+duration_time, duration_time, input_time]
            heappush(heap, keep_job)
        
        # 수행하고 있는 작업이 있을 경우,
        else:
            # 지금 진행중인 작업이 끝나자마자 넣었을 경우 끝나는 시간, 요청, 걸리는 시간
            keep_job = [now+duration_time, duration_time, input_time]
            heappush(heap, keep_job)
    
    while heap:
        print()
        print(answer)
        print(now)
        print(heap)
        
        while heap[0][0] != now + heap[0][1]:
            temp = heappop(heap)
            heappush(heap, [now + temp[1], temp[1], temp[2]])
            
        peek = heappop(heap)
        if peek[1] + peek[2] >= peek[0]:
            now = peek[1]+ peek[2]
            answer += peek[1]
            
        else:
            now = peek[0]
            answer += peek[0] - peek[2]
    
    print(now)
    print(answer)
    
    return answer//n

# 데이터 들어오면 힙으로 집어넣음.
# 기다리는 시간 + 진행되는 시간이 가장 적은 것 부터 실행시킴.
jobs = [[0, 6], [2, 8], [3, 7], [7, 1], [11, 11], [19, 25], [30, 15], [32, 6], [40, 3]]
answer : 19

@tgyuuAn
너무 늦게 봤네요 지금은 푸셨나요
찾았는데

# 현재 시간을 기준으로 갱신
while heap[0][0] != now + heap[0][1]:
    temp = heappop(heap)
    heappush(heap, [now + temp[1], temp[1], temp[2]])

peek = heappop(heap)
now = peek[0]
answer += peek[0] - peek[2]

keep_job = [now + duration_time, duration_time, input_time]

여기서 [now +duration_time, duration_time, input_time] 를
[input_time + duration_time, duration_time, input_time] 으로 바꾸면 되네요.

heap에 작업을 추가할 때 정렬 기준이 문제였네요
기준이 작업 소요 시간이 되야하는데 지금은 now를 더하면서 예상 종료 시간이 기준이 되어버리는 거 같아요

테스트 : [[0, 6], [2, 8], [3, 7], [7, 1], [11, 11], [19, 25], [30, 15], [32, 6], [40, 3]]

기존 heap : [[39, 25, 19], [48, 15, 30], [42, 3, 40]]
수정 : [[43, 3, 40], [45, 15, 30], [44, 25, 19]]

[MunbinLee]

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

using namespace std;

int solution(vector<vector<int>> jobs) {
    sort(jobs.begin(), jobs.end());
    
    int currentTime = 0;
    int answer = 0;
    
    auto cmp = [](const auto &a, const auto &b) {
        if (a[1] == b[1]) return a[0] > b[0];
        return a[1] > b[1];
    };
    
    priority_queue<vector<int>, vector<vector<int>>, decltype(cmp)> pq(cmp);
    
    for (int i = 0; i < jobs.size();) {
        while (i < jobs.size() && jobs[i][0] <= currentTime) {
            pq.emplace(jobs[i]);
            i++;
        }
        
        if (pq.empty()) {
            currentTime = jobs[i][0] + jobs[i][1];
            answer += jobs[i][1];
            i++;
            continue;
        }
        
        auto job = pq.top();
        pq.pop();
        currentTime += job[1];
        answer += currentTime - job[0];
    }
    
    while (!pq.empty()) {
        auto job = pq.top();
        pq.pop();
        currentTime += job[1];
        answer += currentTime - job[0];
    }
    
    return answer / (int) jobs.size();
}

하드디스크가 작업을 수행하고 있지 않을 때에는 먼저 요청이 들어온 작업부터 처리합니다.

이 조건을 안 보고 풀다가 왜 이렇게 어렵지?? 했는데

나중에 문제 천천히 읽어보니 문제를 잘못 풀고 있다는 사실을 깨달았습니다.

진행할 수 있는 작업들 중 소요 시간이 짧은 것부터 그리디하게 처리하면 되므로 우선순위 큐 사용

딱히 태클 걸 곳이 없는 깔끔한 코드입니다.