[백준 1931] 회의실 배정 (Java) - 정렬, 그리디

https://www.acmicpc.net/problem/1931

회의실 배정

문제

한 개의 회의실이 있는데 이를 사용하고자 하는 N개의 회의에 대하여 회의실 사용표를 만들려고 한다. 각 회의 I에 대해 시작시간과 끝나는 시간이 주어져 있고, 각 회의가 겹치지 않게 하면서 회의실을 사용할 수 있는 회의의 최대 개수를 찾아보자. 단, 회의는 한번 시작하면 중간에 중단될 수 없으며 한 회의가 끝나는 것과 동시에 다음 회의가 시작될 수 있다. 회의의 시작시간과 끝나는 시간이 같을 수도 있다. 이 경우에는 시작하자마자 끝나는 것으로 생각하면 된다.

입력

첫째 줄에 회의의 수 N(1 ≤ N ≤ 100,000)이 주어진다. 둘째 줄부터 N+1 줄까지 각 회의의 정보가 주어지는데 이것은 공백을 사이에 두고 회의의 시작시간과 끝나는 시간이 주어진다. 시작 시간과 끝나는 시간은 231-1보다 작거나 같은 자연수 또는 0이다.

출력

첫째 줄에 최대 사용할 수 있는 회의의 최대 개수를 출력한다.

예제 입력 1 복사

11
1 4
3 5
0 6
5 7
3 8
5 9
6 10
8 11
8 12
2 13
12 14

예제 출력 1 복사

4

힌트

(1,4), (5,7), (8,11), (12,14) 를 이용할 수 있다.

---

 

풀이

우선순위 큐 + 정렬 활용

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.PriorityQueue;
import java.util.StringTokenizer;

public class Main {
    public static void main(String[] args)throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine()); // 회의 수

        StringTokenizer st;
        PriorityQueue<Meeting> pq = new PriorityQueue<>();
        for (int i=0; i<N; i++){
            st = new StringTokenizer(br.readLine());
            int startTime = Integer.parseInt(st.nextToken()); // 회의 시작시간
            int endTime = Integer.parseInt(st.nextToken()); // 회의 끝나는 시간
            pq.add(new Meeting(startTime, endTime));
        }

        int lastEndTime = 1;
        int count = 0;
        while (!pq.isEmpty()){
            Meeting now = pq.poll();

            if (now.startTime < lastEndTime) continue;

            count++;
            lastEndTime = now.endTime;
        }
        System.out.println(count);
    }
}
class Meeting implements Comparable<Meeting>{
    int startTime; // 회의 시작시간
    int endTime; // 회의 끝나는 시간

    Meeting(int startTime, int endTime){
        this.startTime = startTime;
        this.endTime = endTime;
    }

    @Override
    public int compareTo(Meeting o) {
        if (this.endTime == o.endTime){
            // 끝나는 시간이 동일하다면 시작시간 오름차순 정렬
            return this.startTime - o.startTime;
        }else {
            // 끝나는 시간 오름차순 정렬 (빨리 끝나는 것)
            return this.endTime - o.endTime;
        }
    }
}

 

• 그리디, 정렬을 활용한 문제
• 회의의 끝나는 시간을 기준으로 오름차순 정렬한 후, 가능한 빨리 시작할 수 있는 회의를 선택한다.
• 끝나는 시간이 같을 경우 시작 시간 기준 오름차순으로 정렬
• Meeting이라는 클래스를 선언해준 뒤, Comparable을 implement해서 위 정렬 조건 2가지를 적용시킨다.
• 나는 우선순위 큐를 활용해서 풀이했다.
• 마지막으로 회의가 끝난시간을 기준으로 now.startTime >= lastEndTime이 될때까지 pq.poll()해준다.
• 조건을 충족하면, 회의가 배정되었다는 의미로 count를 1증가시켜준다.
• 그리고 lastEndTime = now.endTime으로 업데이트 해준다.

ArrayList + 정렬 활용

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

public class Main {
    static class Meeting implements Comparable<Meeting> {
        int start, end;

        Meeting(int start, int end) {
            this.start = start;
            this.end = end;
        }

        @Override
        public int compareTo(Meeting o) {
            if (this.end == o.end) {
                return this.start - o.start; // 끝나는 시간 같으면 시작 시간 오름차순
            }
            return this.end - o.end; // 끝나는 시간 기준 정렬
        }
    }

    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        int N = Integer.parseInt(br.readLine());
        List<Meeting> meetings = new ArrayList<>();

        for (int i = 0; i < N; i++) {
            StringTokenizer st = new StringTokenizer(br.readLine());
            int start = Integer.parseInt(st.nextToken());
            int end = Integer.parseInt(st.nextToken());
            meetings.add(new Meeting(start, end));
        }

        // 정렬
        Collections.sort(meetings);

        int count = 0;
        int lastEnd = 0;

        for (Meeting m : meetings) {
            if (m.start >= lastEnd) {
                count++;
                lastEnd = m.end;
            }
        }

        System.out.println(count);
    }
}