journey

문제 설명

Leo는 카펫을 사러 갔다가 아래 그림과 같이 중앙에는 노란색으로 칠해져 있고 테두리 1줄은 갈색으로 칠해져 있는 격자 모양 카펫을 봤습니다.

Leo는 집으로 돌아와서 아까 본 카펫의 노란색과 갈색으로 색칠된 격자의 개수는 기억했지만, 전체 카펫의 크기는 기억하지 못했습니다.

Leo가 본 카펫에서 갈색 격자의 수 brown, 노란색 격자의 수 yellow가 매개변수로 주어질 때 카펫의 가로, 세로 크기를 순서대로 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항

• 갈색 격자의 수 brown은 8 이상 5,000 이하인 자연수입니다.
• 노란색 격자의 수 yellow는 1 이상 2,000,000 이하인 자연수입니다.
• 카펫의 가로 길이는 세로 길이와 같거나, 세로 길이보다 깁니다.

입출력 예

brownyellowreturn

#풀이

class Solution {
		public int[] solution(int brown, int yellow) {
			int[] answer = new int[2];

			int sqrt = (int) Math.sqrt(yellow);
			int width = sqrt;
			int length = sqrt;

			while (width >= 1 && length >= 1) {
				if (width * length > yellow) {
					length--;
					continue;
				} else if (width * length < yellow) {
					width++;
					continue;
				} else {
					if (brown == width * 2 + length * 2 + 4) {
						answer[0] = width + 2;
						answer[1] = length + 2;
						break;
					}
				}
			}

			return answer;

		}

	}

먼저, 노란색타일의 제곱근을 구한다. width 와 length에 값을 넣어준다. 이 후 이 곱(총갯수)가 주어진 yellow보다 크면 length를 하나씩 감소시키고, 작으면 width를 하나씩 증가시킨다(문제에서 가로>=세로). 만약에 yellow와 같다면, yellow의 가로세로를 알아낸 것이다. 이후 추론한 것이 정확한것인지 확인하려면 brown의 갯수까지 확인하는 과정을 거치고나면 답이 나온다.

문제 설명

한자리 숫자가 적힌 종이 조각이 흩어져있습니다. 흩어진 종이 조각을 붙여 소수를 몇 개 만들 수 있는지 알아내려 합니다.

각 종이 조각에 적힌 숫자가 적힌 문자열 numbers가 주어졌을 때, 종이 조각으로 만들 수 있는 소수가 몇 개인지 return 하도록 solution 함수를 완성해주세요.

제한사항

• numbers는 길이 1 이상 7 이하인 문자열입니다.
• numbers는 0~9까지 숫자만으로 이루어져 있습니다.
• "013"은 0, 1, 3 숫자가 적힌 종이 조각이 흩어져있다는 의미입니다.

입출력 예

numbersreturn

입출력 예 설명

예제 #1
[1, 7]으로는 소수 [7, 17, 71]를 만들 수 있습니다.

예제 #2
[0, 1, 1]으로는 소수 [11, 101]를 만들 수 있습니다.

• 11과 011은 같은 숫자로 취급합니다.

#풀이

import java.util.List;
import java.util.ArrayList;
import java.util.Set;
import java.util.HashSet;



	class Solution {
	Set<Integer> set;
	List<Character> list;
	boolean[] check;
		public int solution(String numbers) {
			int answer = 0;

			set = new HashSet<Integer>();
			list = new ArrayList<Character>();
			check = new boolean[numbers.length()];

			for (int i = 0; i < numbers.length(); i++) {
				list.add(numbers.charAt(i));
			}

			for (int i = 0; i < numbers.length(); i++) {
				make(0, i + 1, "");
			}

			answer = set.size();
			return answer;
		}

		private void make(int cur, int max, String str) {

			if (cur == max) {
				isPrime(Integer.parseInt(str));
				return;
			}

			for (int i = 0; i < list.size(); i++) {
				if (!check[i]) {
					check[i] = true;
					str += list.get(i);
					make(cur + 1, max, str);
					str = str.substring(0, str.length() - 1);
					check[i] = false;
				}
			}
		}

		private void isPrime(int num) {

			int sqrt = (int) Math.sqrt(num);

			if (num == 2) {
				set.add(num);
			}
            
			if (num == 1 || num % 2 == 0) {
				return;
			}


			for (int i = 3; i <= sqrt; i += 2) {
				if (num % i == 0) {
					return;
				}
			}

			set.add(num);

		}
	}

DFS를 사용하였다. DFS를 사용할 메서드 make를 선언했고, 이 make를 for문 안에 넣어서, 자릿수 설정을 했다. make에는 새롭게수를추가할인덱스(cur), 자릿수(max), 직전문자열(str)을 매개변수로 받게설정했다.

문제 설명

수포자는 수학을 포기한 사람의 준말입니다. 수포자 삼인방은 모의고사에 수학 문제를 전부 찍으려 합니다. 수포자는 1번 문제부터 마지막 문제까지 다음과 같이 찍습니다.

1번 수포자가 찍는 방식: 1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...
2번 수포자가 찍는 방식: 2, 1, 2, 3, 2, 4, 2, 5, 2, 1, 2, 3, 2, 4, 2, 5, ...
3번 수포자가 찍는 방식: 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, 3, 3, 1, 1, 2, 2, 4, 4, 5, 5, ...

1번 문제부터 마지막 문제까지의 정답이 순서대로 들은 배열 answers가 주어졌을 때, 가장 많은 문제를 맞힌 사람이 누구인지 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한 조건

• 시험은 최대 10,000 문제로 구성되어있습니다.
• 문제의 정답은 1, 2, 3, 4, 5중 하나입니다.
• 가장 높은 점수를 받은 사람이 여럿일 경우, return하는 값을 오름차순 정렬해주세요.

입출력 예

answersreturn

입출력 예 설명

입출력 예 #1

• 수포자 1은 모든 문제를 맞혔습니다.
• 수포자 2는 모든 문제를 틀렸습니다.
• 수포자 3은 모든 문제를 틀렸습니다.

따라서 가장 문제를 많이 맞힌 사람은 수포자 1입니다.

입출력 예 #2

• 모든 사람이 2문제씩을 맞췄습니다.

#풀이

import java.util.List;
import java.util.ArrayList;

class Solution {
	    public List<Integer> solution(int[] answers) {
	    	List<Integer> answer = new ArrayList<Integer>();
	        int MAX = -1;
	        
	        int[] a1 = { 1, 2, 3, 4, 5 };
	        int[] a2 = { 2, 1, 2, 3, 2, 4, 2, 5 };
	        int[] a3 = { 3, 3, 1, 1, 2, 2, 4, 4, 5, 5 };
	        int[] c = new int[3];
	        
	        for (int i = 0; i < answers.length; i++) {
	        	if (answers[i] == a1[i % a1.length]) {
	        		c[0]++;
	        	}
	        	
	        	if (answers[i] == a2[i % a2.length]) {
	        		c[1]++;
	        	}
	        	
	        	if (answers[i] == a3[i % a3.length]) {
	        		c[2]++;
	        	}
	        }
	        
	        for (int i = 0; i < 3; i++) {
	        	if (MAX < c[i]) {
	        		MAX = c[i];
	        	}
	        }
	        
	        for (int i = 0; i < 3; i++) {
	        	if (MAX == c[i]) {
	        		answer.add(i + 1);
	        	}
	        }
	        
	        
	        return answer;
	    }
	}

%연산자를 이용하면 쉽게 풀이가 가능하다.

문제 설명

H-Index는 과학자의 생산성과 영향력을 나타내는 지표입니다. 어느 과학자의 H-Index를 나타내는 값인 h를 구하려고 합니다. 위키백과1에 따르면, H-Index는 다음과 같이 구합니다.

어떤 과학자가 발표한 논문 n편 중, h번 이상 인용된 논문이 h편 이상이고 나머지 논문이 h번 이하 인용되었다면 h의 최댓값이 이 과학자의 H-Index입니다.

어떤 과학자가 발표한 논문의 인용 횟수를 담은 배열 citations가 매개변수로 주어질 때, 이 과학자의 H-Index를 return 하도록 solution 함수를 작성해주세요.

제한사항

• 과학자가 발표한 논문의 수는 1편 이상 1,000편 이하입니다.
• 논문별 인용 횟수는 0회 이상 10,000회 이하입니다.

입출력 예

citationsreturn

입출력 예 설명

이 과학자가 발표한 논문의 수는 5편이고, 그중 3편의 논문은 3회 이상 인용되었습니다. 그리고 나머지 2편의 논문은 3회 이하 인용되었기 때문에 이 과학자의 H-Index는 3입니다.

※ 공지 - 2019년 2월 28일 테스트 케이스가 추가되었습니다.

#풀이

	class Solution {
		public int solution(int[] citations) {
			int answer = 0;

			Arrays.sort(citations);
			for (int i = 0; i < citations.length; i++) {
				//오름차순: i 0부터 탐색하니깐 작은 수부터 선택됨.
				//h=citations[i]이상인 수 갯수
				int h = citations.length - i;
				//citations[i](현재제일작은수)가 h보다 크다면 그이후수도 다 만족하는것임
				if (citations[i] >= h) {
					answer = h;
					break;
				}

			}
			return answer;
		}
	}

풀이자체는 어렵지 않았는데 발상자체가 조금 어려웠다. 먼저 오름차순을 한 후, 작은 수부터 순서로 탐색한다. 문제의조건 'h번이상 인용된 논문이 h편이상' 가

citation[i]번 이상 인용된 논문이 citation.length - i(citations[i] 이상인 수의 갯수) 로 생각하면 된다.

문제 설명

0 또는 양의 정수가 주어졌을 때, 정수를 이어 붙여 만들 수 있는 가장 큰 수를 알아내 주세요.

예를 들어, 주어진 정수가 [6, 10, 2]라면 [6102, 6210, 1062, 1026, 2610, 2106]를 만들 수 있고, 이중 가장 큰 수는 6210입니다.

0 또는 양의 정수가 담긴 배열 numbers가 매개변수로 주어질 때, 순서를 재배치하여 만들 수 있는 가장 큰 수를 문자열로 바꾸어 return 하도록 solution 함수를 작성해주세요.

제한 사항

• numbers의 길이는 1 이상 100,000 이하입니다.
• numbers의 원소는 0 이상 1,000 이하입니다.
• 정답이 너무 클 수 있으니 문자열로 바꾸어 return 합니다.

입출력 예

numbersreturn

#풀이

import java.util.Arrays;
import java.util.Comparator;

class Solution {

		public String solution(int[] numbers) {
			String answer = "";
			StringBuilder sb = new StringBuilder();

			String[] num = new String[numbers.length];
			for (int i = 0; i < num.length; i++) {
				num[i] = String.valueOf(numbers[i]);

			}

			// 330, 303 배열 위해 o1 + o2 형태로 붙여서 비교
			Arrays.sort(num, new Comparator<String>() {

				@Override
				public int compare(String o1, String o2) {
					return (o2 + o1).compareTo(o1 + o2);
				}

			});
            
			if (num[0].equals("0")) {
				return "0";
			}
            
			for (int i = 0; i < num.length; i++) {
				sb.append(num[i]);
			}
			answer = sb.toString();

			return answer;
		}

	}

sort를 이용하면 되서 발상자체는 어렵지 않았다. 먼저 각 수를 String으로 바꾼 후 모두 sort하면 맨 앞자리 순으로 내림차순이 된다. 따라서 9가 30 보다 수 자체로 비교하면 더 작지만, String처리한 후 비교하면 더 큰것으로 여겨진다. 이때 문제점은 3과 30의 경우이다. 이 경우 String "30"이 String "3"보다 더 앞에 정렬된다. 그러나 만약 이 두 수를 붙이면 303 또는 330 의 경우가 있는데 배열이 내림차순 된 상태에서 차례대로 수들을 붙일경우 303이 채택되어 제일 큰 수를 만들지 못한다. 따라서 sort할 때 Comparator을 도입할 때 두 수를 붙여서 비교하면, 330 이 303보다 더 크게 되어, 3이 30보다 더 앞으로 정렬되게된다. 이 부분만 이해하고 넘어가면 그 후에는 간단했다.

문제 설명

배열 array의 i번째 숫자부터 j번째 숫자까지 자르고 정렬했을 때, k번째에 있는 수를 구하려 합니다.

예를 들어 array가 [1, 5, 2, 6, 3, 7, 4], i = 2, j = 5, k = 3이라면

1. array의 2번째부터 5번째까지 자르면 [5, 2, 6, 3]입니다.
2. 1에서 나온 배열을 정렬하면 [2, 3, 5, 6]입니다.
3. 2에서 나온 배열의 3번째 숫자는 5입니다.

배열 array, [i, j, k]를 원소로 가진 2차원 배열 commands가 매개변수로 주어질 때, commands의 모든 원소에 대해 앞서 설명한 연산을 적용했을 때 나온 결과를 배열에 담아 return 하도록 solution 함수를 작성해주세요.

제한사항

• array의 길이는 1 이상 100 이하입니다.
• array의 각 원소는 1 이상 100 이하입니다.
• commands의 길이는 1 이상 50 이하입니다.
• commands의 각 원소는 길이가 3입니다.

입출력 예

arraycommandsreturn

입출력 예 설명

[1, 5, 2, 6, 3, 7, 4]를 2번째부터 5번째까지 자른 후 정렬합니다. [2, 3, 5, 6]의 세 번째 숫자는 5입니다.
[1, 5, 2, 6, 3, 7, 4]를 4번째부터 4번째까지 자른 후 정렬합니다. [6]의 첫 번째 숫자는 6입니다.
[1, 5, 2, 6, 3, 7, 4]를 1번째부터 7번째까지 자릅니다. [1, 2, 3, 4, 5, 6, 7]의 세 번째 숫자는 3입니다.

#풀이

import java.util.Arrays;

class Solution {
    public int[] solution(int[] array, int[][] commands) {
    
        int[] answer = new int[commands.length];
        
        for (int i = 0; i < commands.length; i++) {
	            int start = commands[i][0] - 1;
	            int end = commands[i][1] - 1;
	            int idx = commands[i][2];
	            int[] temp = new int[end - start + 1];
	            System.arraycopy(array, start, temp, 0, temp.length);
	            Arrays.sort(temp);
	            answer[i] = temp[idx - 1];
	        }
	        
        
        
        
        return answer;
    }
}

문제 설명

이중 우선순위 큐는 다음 연산을 할 수 있는 자료구조를 말합니다.

명령어수신 탑(높이)

이중 우선순위 큐가 할 연산 operations가 매개변수로 주어질 때, 모든 연산을 처리한 후 큐가 비어있으면 [0,0] 비어있지 않으면 [최댓값, 최솟값]을 return 하도록 solution 함수를 구현해주세요.

제한사항

• operations는 길이가 1 이상 1,000,000 이하인 문자열 배열입니다.
• operations의 원소는 큐가 수행할 연산을 나타냅니다.
  • 원소는 “명령어 데이터” 형식으로 주어집니다.- 최댓값/최솟값을 삭제하는 연산에서 최댓값/최솟값이 둘 이상인 경우, 하나만 삭제합니다.
• 빈 큐에 데이터를 삭제하라는 연산이 주어질 경우, 해당 연산은 무시합니다.

입출력 예

operationsreturn

입출력 예 설명

16을 삽입 후 최댓값을 삭제합니다. 비어있으므로 [0,0]을 반환합니다.
7,5,-5를 삽입 후 최솟값을 삭제합니다. 최대값 7, 최소값 5를 반환합니다.

#풀이

	class Solution {
	    public int[] solution(String[] operations) {
	        int[] answer = new int[2];
	        int c1 = 0;
	        int c2 = 0;

	        PriorityQueue<Integer> pqMax = new PriorityQueue<Integer>(new Comparator<Integer>() {
				@Override
				public int compare(Integer o1, Integer o2) {
					return o2 - o1;
				}
	        });
	        
	        PriorityQueue<Integer> pqMin = new PriorityQueue<Integer>(new Comparator<Integer>() {
				@Override
				public int compare(Integer o1, Integer o2) {
					return o1 - o2;
				}
	        });

	        for (int i = 0; i < operations.length; i++) {
	        	if (operations[i].contains("I")) {
	        		pqMax.add(Integer.parseInt(operations[i].substring(2)));
	        		pqMin.add(Integer.parseInt(operations[i].substring(2)));
	        		c1++;
	        	}
	        	
	        	if (!pqMax.isEmpty()) {
		        	if (operations[i].contains("D 1")) {
		        		delete(pqMin, pqMax.poll());
		        		c2++;
		        	}
		        	if (operations[i].contains("D -1")) {
		        		delete(pqMax, pqMin.poll());
		        		c2++;
		        	}
	        	}
	        }

	        
	        if (c1 <= c2) {
		        answer[0] = 0;
		        answer[1] = 0;
	        } else {
		        answer[0] = pqMax.peek();
		        answer[1] = pqMin.peek();
	        }
	        return answer;
	    }
	    
	    public void delete(PriorityQueue<Integer> pq, int num) {
	    	
	    	List<Integer> temp = new ArrayList<Integer>();
	    	while (!pq.isEmpty()) {
	    		if (pq.peek() != num) {
	    			temp.add(pq.poll());
	    		} else {
	    			pq.poll();
	    			break;
	    		}
	    	}
	    	pq.addAll(temp);
	    	
	    }
	}

일단 우선순위 큐를 두개 만들었고, 모든 요소를 두 큐에 빠짐없이 넣었다. 이 때 큐 두개 중 하나는 오름차순, 하나는 내림차순으로 두었다. 그 후 D 1이 나오면 최댓값을 제거해야하므로 내림차순된 큐에서 poll, D -1이 나오면 최솟값을 제거해야하므로 오름차순된 큐에서 poll을 하면 안된다. 한 큐에서만 해당원소를 빼면 안되고 두 큐에서 해당원소를 빼야한다.

예를 들어 D 1이 나올때 내림차순된 큐에서는 poll하면 맨앞의 요소(최댓값)이 나오므로 손쉽게 제거 가능하지만, 오름차순된 큐에서는 맨뒤의 요소를 빼야한다. 그러나 그런 방법이 자바에서 따로 정의되지 않았다. 따라서 임의의 메서드 delete를 만들었다. 이 delete메서드는 (맨뒤의값을 빼야하는 queue, 제거해야하는 요소의 값) 이 두개를 매개변수로 받는다. 이후 임시로 저장할 List를 만든 후 queue를 제거해야할 값이 나오기 전까지 모두 poll하고 임시List에 넣는다. 제거해야할 값이 나왔을 경우 이 값은 List에 넣지않고, 그냥 while문을 빠져나온다. 그리고 제거한 모든 요소들을 다시 queue에 넣고 반환한다. 

다시 메인으로 돌아가면, 이렇게 해서 delete메서드를 호출할 경우 두가지 큐에서 모두 해당요소가 제거가능하다.

큐는 일방향성이기 때문에, 임의의 요소에 접근하려면 delete메서드를 구현한 것을 활용하면 될 것 같다. 앞선 힙 문제에서 향상된for문을 사용하여 모든 큐의 요소에 접근이 가능했지만, 수정은 불가능했다. 하지만 임의의 메서드를 구현하고 이 메서드의 매개변수로 (큐, 수정할 값)을 받고, 메서드 내부에는 임시저장용도인 리스트 하나를 구현하면 값을 손쉽게 수정할 수 있다.

문제 설명

하드디스크는 한 번에 하나의 작업만 수행할 수 있습니다. 디스크 컨트롤러를 구현하는 방법은 여러 가지가 있습니다. 가장 일반적인 방법은 요청이 들어온 순서대로 처리하는 것입니다.

예를들어

- 0ms 시점에 3ms가 소요되는 A작업 요청 - 1ms 시점에 9ms가 소요되는 B작업 요청 - 2ms 시점에 6ms가 소요되는 C작업 요청

와 같은 요청이 들어왔습니다. 이를 그림으로 표현하면 아래와 같습니다.

한 번에 하나의 요청만을 수행할 수 있기 때문에 각각의 작업을 요청받은 순서대로 처리하면 다음과 같이 처리 됩니다.

- A: 3ms 시점에 작업 완료 (요청에서 종료까지 : 3ms) - B: 1ms부터 대기하다가, 3ms 시점에 작업을 시작해서 12ms 시점에 작업 완료(요청에서 종료까지 : 11ms) - C: 2ms부터 대기하다가, 12ms 시점에 작업을 시작해서 18ms 시점에 작업 완료(요청에서 종료까지 : 16ms)

이 때 각 작업의 요청부터 종료까지 걸린 시간의 평균은 10ms(= (3 + 11 + 16) / 3)가 됩니다.

하지만 A → C → B 순서대로 처리하면

- A: 3ms 시점에 작업 완료(요청에서 종료까지 : 3ms) - C: 2ms부터 대기하다가, 3ms 시점에 작업을 시작해서 9ms 시점에 작업 완료(요청에서 종료까지 : 7ms) - B: 1ms부터 대기하다가, 9ms 시점에 작업을 시작해서 18ms 시점에 작업 완료(요청에서 종료까지 : 17ms)

이렇게 A → C → B의 순서로 처리하면 각 작업의 요청부터 종료까지 걸린 시간의 평균은 9ms(= (3 + 7 + 17) / 3)가 됩니다.

각 작업에 대해 [작업이 요청되는 시점, 작업의 소요시간]을 담은 2차원 배열 jobs가 매개변수로 주어질 때, 작업의 요청부터 종료까지 걸린 시간의 평균을 가장 줄이는 방법으로 처리하면 평균이 얼마가 되는지 return 하도록 solution 함수를 작성해주세요. (단, 소수점 이하의 수는 버립니다)

제한 사항

• jobs의 길이는 1 이상 500 이하입니다.
• jobs의 각 행은 하나의 작업에 대한 [작업이 요청되는 시점, 작업의 소요시간] 입니다.
• 각 작업에 대해 작업이 요청되는 시간은 0 이상 1,000 이하입니다.
• 각 작업에 대해 작업의 소요시간은 1 이상 1,000 이하입니다.
• 하드디스크가 작업을 수행하고 있지 않을 때에는 먼저 요청이 들어온 작업부터 처리합니다.

입출력 예

jobsreturn

입출력 예 설명

문제에 주어진 예와 같습니다.

• 0ms 시점에 3ms 걸리는 작업 요청이 들어옵니다.
• 1ms 시점에 9ms 걸리는 작업 요청이 들어옵니다.
• 2ms 시점에 6ms 걸리는 작업 요청이 들어옵니다.

#풀이

	class Solution {
		public int solution(int[][] jobs) {
			// 0:시작시간 1:작업시간
			int answer = 0;

			LinkedList<Job> list = new LinkedList<Job>();
			// 2번째 sort : 길이 짧은순으로
			PriorityQueue<Job> queue = new PriorityQueue<Job>(new Comparator<Job>() {

				@Override
				public int compare(Job o1, Job o2) {
					return o1.len - o2.len;
				}

			});

			for (int i = 0; i < jobs.length; i++) {
				list.add(new Job(jobs[i][0], jobs[i][1]));
			}

			// 1번째 sort : 시작시간 빠른순으로(현재상태에서 작업가능한 작업순)
			Collections.sort(list, new Comparator<Job>() {
				@Override
				public int compare(Job o1, Job o2) {
					return o1.start - o2.start;
				}
			});

			// 완료된 원소 수 
			int count = 0;
			// 현재 시간
			int time = 0;

			// 원소 다 뽑을 때 까지
			while (count < jobs.length) {
// 직전 작업이 끝난 상태에서, 해당 작업이 시작가능한 상태인 원소 다 꺼냄
				while (!list.isEmpty() && list.peek().start <= time) {
					queue.add(list.poll());
				}

				// 만족하는 원소 중에서 두번째 sort 시작
				if (!queue.isEmpty()) {
					Job job = queue.poll();
					time += job.len;
					answer += (time - job.start);
					count++;
					// 만족하는 원소 없을경우, 시간만 1초씩 경과
				} else {
					time++;
				}
			}

			return (answer / count);
		}
	}

	class Job {

		int start;
		int len;

		Job(int start, int len) {
			this.start = start;
			this.len = len;
		}


	}

먼저 코드를 짜기전에 생각을 해보자면 먼저 현재시간보다 요청시간이 작은경우로 거르고, 그 후에는 작업시간이 짧은 작업이 먼저 진행되게 해야한다.

작업객체들을 담기 위해 Job클래스를 만들고 멤버변수로 start(해당 작업 요청시간), len(해당 작업 작업시간)을 선언한다. 이후 List에 각 작업들을 담고, 작업요청시간이 작은 순으로 담는다.

그래서 List에 모든 요소를 넣은 후 첫번째 sort로 요청시간이 작은 경우로 거른다. 그 후 이 조건을 만족하는 모든 요소를 우선순위큐에 넣는다. 우선순위큐에는 두번째 sort로 작업시간이 짧은 순으로 넣게된다.

우선순위큐에 parameter로 Comparator을 넣을 수 있다.

임의의 클래스를 받은 큐에서 queue.poll()로 해당 요소를 꺼낼 시, 따로 객체로 받을 경우(위의 Job job = queue.poll()) 활용성이 늘어나게 된다.