회의실 배정

 

회의 종료 시간이 제일 빠른 순서대로 정렬한다.

회의 종료 시간이 같을 때는 시작 시간이 빠른 순서대로 정렬한다.(예시 입력2)

시작 시간을 s 종료 시간을 e로 둘거다.

다음 회의의 시작 시간이 이전 회의의 종료 시간과 같거나 클때 회의 수를 증가시켜준다.

그리고 다음 회의의 종료 시간을 다시 마지막 회의의 종료 시간 변수(et)에 넣어준다.

 

import java.util.*;

class Time implements Comparable<Time> {
    public int s, e;
    Time(int s, int e) {
        this.s = s;
        this.e = e;
    }

    @Override
    public int compareTo(Time o) {
        //끝나는 시간이 같으면 시작 시간도 오름차순을 한다.
        if(this.e==o.e) return this.s-o.s;
        //같지 않으면 끝나는 시간으로만 정렬
        else return this.e-o.e;
    }

}

class Main {
    public int solution(ArrayList<Time> arr, int n){
        //선발되는 인원 수
        int cnt = 0;

        //회의 시간 기준으로 오름차순 정렬
        Collections.sort(arr);
        //끝나는 시간
        int et = 0;
        for(Time ob : arr) {
            if(ob.s >= et) {
                cnt++;
                et = ob.e;
            }
        }

        return cnt;
    }

    public static void main(String[] args) {
        Main T = new Main();
        Scanner kb = new Scanner(System.in);
        int n = kb.nextInt();
        ArrayList<Time> arr = new ArrayList<>();
        for(int i = 0; i < n; i++) {
            int x = kb.nextInt();
            int y = kb.nextInt();
            arr.add(new Time(x, y));
        }
        System.out.println(T.solution(arr, n));

    }
}

import java.util.*;

public class Main {

    public static void main(String[] args) {
        Scanner kb = new Scanner(System.in);

        int n = kb.nextInt();
        int[][] arr = new int[n][2];

        ArrayList<Meet> list = new ArrayList<Meet>();
        for(int i = 0; i < n; i++) {
                list.add(new Meet(kb.nextInt(), kb.nextInt()));
            }

        //제일 빨리 끝나는 순서대로 정렬 시킨다!
        //1 3 1 3 3 3 이것도 2번으로 쳐야하니까 끝나는 시간이 같으면 시작 시간 기준으로 정렬시킨다.
        Collections.sort(list);

        //회의실 사용 횟수
        int cnt = 0;

        //끝나는 시간
        int end = 0;

        //현재 진행중인 회의의 끝나는시간 보다 시작시간이 같거나 늦으면 가능한 회의이다.
        //가능한 회의가 진행중인 회의가 되면 끝나는 시간을 해당 회의의 끝나는 시간으로 지정한다.
        for(int i = 0; i < list.size(); i++) {
            if(list.get(i).startTime >= end) {
                cnt++;
                end = list.get(i).endTime;
            }
        }

        System.out.println(cnt);

    }

    private static class Meet implements Comparable<Meet> {
        int startTime;
        int endTime;

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

        @Override
        public String toString() {
            return "Meet{" +
                    "startTime=" + startTime +
                    ", endTime=" + endTime +
                    '}';
        }

        @Override
        public int compareTo(Meet o) {
            //끝나는 시간 같으면 시작 시간 오름차순 정렬
            if (this.endTime == o.endTime) return this.startTime - o.startTime;
            //끝나는 시간 오름차순 정렬
            else return this.endTime - o.endTime;
        }
    }
}