[프로그래머스] 디스크 컨트롤러

회사에서 코드를 짤 때는 주로, Comparable을 구현해서 활용하거나 Comparator를 생성했다.

다른 코드를 보니까 ㅜ 부족함이 많이 느껴진다.

 

풀이

- 작업 요청 시간이 지난 작업 중, 작업 시간이 짧은 것부터 처리하도록 한다. -> 작업 시간을 기준으로 우선순위 큐 사용.

(대기하는 작업들의 대기 시간을 줄인다는 느낌)

 

개선점 1. 굳이 객체를 생성할 필요는 없었다.

개선점 2. compare 및 sorting 시에 람다 함수 활용.

나의 풀이...

import java.util.PriorityQueue;
import java.util.Comparator;
class Solution {
        public int solution(int[][] jobs) {
        int size = jobs.length;
        PriorityQueue<Job> pqTimeFirst = new PriorityQueue<>(new Comparator<Job>() {

            @Override
            public int compare(Job o1, Job o2) {
                if(o1.getTiming() == o2.getTiming()){
                    return o1.due-o2.due;
                }
                return o1.getTiming() - o2.getTiming();
            }
        });
        for (int[] job : jobs) {
            Job j = new Job(job[0], job[1]);
            pqTimeFirst.add(j);
        }

        PriorityQueue<Job> readyPQ = new PriorityQueue<>();

        Job job = pqTimeFirst.poll();
        int time = job.getTiming();
        int sum = 0;
        while (true) {
            time += job.getDue(); // 작업시간을 더해줌.
            sum += time - job.getTiming(); // 작업끝난시점 - 작업 시작 시점.
            System.out.println(time + " sum " + sum);
            if(pqTimeFirst.isEmpty() && readyPQ.isEmpty())break;
            while (!pqTimeFirst.isEmpty()&& pqTimeFirst.peek().getTiming() <= time) {
                readyPQ.add(pqTimeFirst.poll());
            }
            //당장 실행 할 수 있는게 없을 때.
            if(readyPQ.isEmpty()){
                job=pqTimeFirst.poll();
                time=job.getTiming();// 다음 요청으로 넘어간다.
            } 
            else job = readyPQ.poll();

        }

        return sum/size;
    }

    class Job implements Comparable<Job>{

        int timing;
        int due;
        public Job(int t, int d) {
            this.timing=t;
            this.due=d;
        }
        @Override
        public int compareTo(Job o) {
            return this.due-o.due;
        }


        public int getTiming() {
            return timing;
        }

        public int getDue() {
            return due;
        }

    }

}

직접 타이핑하므로써 제대로 읽어보기 위해 베껴왔다...

Arrays.sort(jobs, (o1,o2)->o1[0] -o2[0]); // 작업 요청 되는 시점 기준 오름 차순 정렬

// 작업 소요 시간 기준으로 오름 차순.
PriorityQueue<int[]> pq = new PriorityQueue<>((o1, o2)-> o1[1]-o2[1]);

int jobs_index =0;// 작업 배열 인덱스
int finish_job = 0; //처리 완료된 작업 개수.
int end_time = 0; //작업 처리 완료 시간.

while(true){
	if(finish_job==jobs.length) break;//모든 작업 처리 시 종료.
    
    // 이전 작업 중 요청 된 작업 add - 
    while(jobs_index<jobs.length && jobs[jobs_index][0]<=end_time){
    	pq.add(jobs[jobs_index++]);
    }
    
    if(!pq.isEmpty()){
    	int[] job=pq.poll();
        answer +=end_time -job[0]+job[1]; // 작업 요청부터 종료까지 걸린 시간. 추가.
        end_time+=job[1]; // 작업 처리 완료 시간 갱신.
        finish_job++; // 처리 완료 작업 수 증가.
    } else{ // 이전 작업 처리 중 요청된 작업 없는 경우.
    	end_time = jobs[jobs_index][0]; // 다음 작업 요청 시점으로 갱신.
    }
}
return answer/jobs.length;