1. ๋ฌธ์ ์ค๋ช
๊ฐ์์ ์์ ์๊ฐ๊ณผ ์ข ๋ฃ ์๊ฐ์ด ์ฃผ์ด์ก์ ๋ ํด๋น ๊ฐ์๋ค์ ์ ๋ถ ์ํํ ์ ์๋ ์ต์ ๊ฐ์ ์๋ฅผ ๊ตฌํ์ฌ๋ผ.
2. ํธ๋ ์๋ฆฌ
์ ๋ฒ์ ํ์๋๋ฐ ํ๋ ธ๋ค. ํ๋ฆฌ๋ ๋ฐฉ๋ฒ๋ ๋๊ฐ์๋ค ใ ใ . ๋ค์ ํธ๋ ๋ฐฉ๋ฒ์ ์ ๋ฆฌํด ๋ณด๊ฒ ๋ค.
- ๋ฐฐ์ด ํน์ List์ ๊ฐ์ ์์ ์๊ฐ์ด ๋น ๋ฅธ ์์ผ๋ก ๊ฐ์๋ฅผ ์ ๋ ฌํ๋ค.
- ๊ฐ์์ ๋ ์๊ฐ์ ๊ธฐ์ค์ผ๋ก ๊ฐ๋ค์ ์ ๋ฆฌํ๋ Priority Queue๋ฅผ ๋ง๋ ๋ค.
์ ์ด์ List์ ์กด์ฌํ๋ ๊ฐ๋ค์ ์ฐจ๋ก๋ก ์ํํ ๊ฒ์ด๋ค. ์ฐ๋ฆฌ๊ฐ ํ์ฌ ์กฐํํ๋ ๊ฐ์๋ฅผ A๋ผ๊ณ ํด๋ณด์. A์ ๊ฐ์ ์์ ์๊ฐ์ด ์คํ 1์๋ผ๊ณ ํ ๋, ํ์ฌ ์๊ฐ์ ์คํ 1์๋ผ๊ณ ๊ฐ์ ํ๋ ๊ฒ์ด๋ค. ์ด๋ ๊ฒ list์์ ํ์ฌ ์กฐํ ์ค์ธ ๊ฐ์์ ์์ ์๊ฐ์ ‘ํ์ฌ ์๊ฐ’์ด๋ผ๊ณ ๊ฐ์ ํ๊ฒ ๋ค. List๋ ์์ ์๊ฐ์ด ๋น ๋ฅธ ์์ผ๋ก ์ ๋ฆฌ ๋์ด์์ผ๋ฏ๋ก, ์ฐ๋ฆฌ๋ ์๊ฐ์ ๊ฒฝ๊ณผ์ ๋ฐ๋ผ ๊ฐ์๋ค์ ์ฐจ๋ก๋ก ์กฐํํ๊ฒ ๋ ๊ฒ์ด๋ค. PQ๋ ‘ํ์ฌ ์๊ฐ’์ ์งํํ๊ณ ์๋ ๊ฐ์๋ค์ด ๋ด๊ฒจ์ ธ์๋ค. ๋ฐ๋ผ์ PQ์ Size๋ ํ์ฌ ์งํ ์ค์ธ ๊ฐ์์ ๊ฐ์์ด๋ค. PQ์ ์์ ํ๋ ํ๋๋ฅผ ๊ฐ์์ค์ด๋ผ ์๊ฐํ๋ ํธ์ด ์ข๋ค. ์๋ฅผ ๋ค์ด ์ค๋ช ํ๊ฒ ๋ค.
- ๋ง์ฝ PQ๊ฐ Empty๋ผ๋ฉด ํ์ฌ ์กฐํ ์ค์ธ ๊ฐ์๋ฅผ ๋ฃ๊ณ , ๋ค์ ๊ฐ์๋ฅผ ์กฐํํ๋ค.
- ๋ง์ฝ PQ์ ๊ฐ์๊ฐ ์กด์ฌํ๋ค๋ฉด, PQ๋ ๊ฐ์๋ฅผ ์ข ๋ฃ์๊ฐ์ด ๋น ๋ฅธ ์์ผ๋ก ์ ๋ ฌํ์ ๊ฒ์์ผ๋ก, PQ.peek()์ ํ์ฌ PQ์ ๋ด๊ธด ๊ฐ์ ์ค ์ข ๋ฃ ์๊ฐ์ด ์ ์ผ ๋น ๋ฅธ ๊ฐ์ ์ด๋ค. ๋ง์ฝ PQ.peek()์ ์ข ๋ฃ์๊ฐ๋ณด๋ค ํ์ฌ ์กฐํ ์ค์ธ ๊ฐ์ A์ ๊ฐ์ ์์ ์๊ฐ์ด ๋ฆ๋ค๋ฉด! PQ.peek()์ ํด๋นํ๋ ๊ฐ์๋ ‘ํ์ฌ ์๊ฐ’์์ ๋๋ ๊ฐ์์์ผ๋ก PQ์์ poll()ํ๋ค. (์ฆ ๊ฐ์์ค์์ ๋๊ฐ๋ค.)
- ์ด๋ ๊ฒ (ํ์ฌ์๊ฐ ≥ ๊ฐ์์ ์ข ๋ฃ ์๊ฐ)์ธ PQ ์ ๊ฐ์๋ ๋ชจ๋ poll ํ๋ค๊ฐ ์ฒ์์ผ๋ก (ํ์ฌ ์๊ฐ ≤ ๊ฐ์์ ์ข ๋ฃ ์๊ฐ)์ธ ๊ฐ์๋ฅผ ๋ง๋๋ฉด ํ์ฌ ์กฐํ ์ค์ธ ๊ฐ์ A๋ฅผ PQ ์์ ๋ฃ๋๋ค.
- ์ด์ PQ ์์ ‘ํ์ฌ์๊ฐ’์ ๊ฐ์ ์ค์ธ ๊ฐ์๋ค๋ง ๋ค์ด๊ฐ ์๋ค. ์ด๋์ PQ์ Size ์ฆ ๊ฐ์์ค์ ๊ฐ์๋ฅผ ์ผ๋ค.
- ์ด๋ ๊ฒ ๋ชจ๋ list ์ ๊ฐ์๋ฅผ ์ํํ๊ณ , ์ง๊ธ๊น์ง ๋์๋ ๊ฐ์์ค ์ฌ์ฉ ๊ฐ์ ์ค ์ต๋ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
3. ์ฝ๋ ๋ถ์
import java.util.*;
import java.io.*;
public class Main{
static int N;
static int maxQsize = 0;
public static void main(String[] args) throws IOException {
BufferedReader br= new BufferedReader(new InputStreamReader(System.in));
N = Integer.parseInt(br.readLine());
Lecture2 [] list = new Lecture2[N];
// ๊ฐ ์
๋ ฅ ๋ฐ๊ธฐ
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());
list[i] = new Lecture2(start, end);
}
// ์์ ์์ผ๋ก ์ ๋ ฌ
Arrays.sort(list, Comparator.comparingInt(o -> o.start));
PriorityQueue<Integer> pq = new PriorityQueue<>();
for (int i = 0; i < list.length; i++) {
Lecture2 now = list[i];
if(pq.isEmpty()){
pq.offer(now.end);
}
else{
int Qsize = pq.size();
for (int j = 0; j < Qsize; j++) {
if(now.start >= pq.peek()) pq.poll();
else{
pq.add(now.end);
break;
}
}
maxQsize = Math.max(maxQsize, pq.size());
}
}
System.out.println(maxQsize);
}
}
class Lecture2 {
int start;
int end;
public Lecture2 (int start, int end) {
this.start = start;
this.end = end;
}
}