๐ ๋ฌธ์ ๋งํฌ
https://www.acmicpc.net/problem/14464
โธ ๋ฌธ์
๋๋ถ ์กด์ ์๋ค์ ํจ์จ์ ์ผ๋ก ๊ธธ์ ๊ฑด๋๋ ๋ฐฉ๋ฒ์ ํฐ๋ํ๊ณ ์๋ค. ๊ทธ๋ค์ ๊ธธ ๊ฑด๋๊ธฐ์ ๋ฌ์ธ์ธ ๋ญ์ ๋์์ ๋ฐ๊ธฐ๋ก ํ๋ค.
์ํ๊น๊ฒ๋ ๋ญ์ ๋งค์ฐ ๋ฐ์ ๋๋ฌผ์ด๋ผ, ์๋ฅผ ๋์์ค ์๊ฐ์ด ๋ณ๋ก ์๋ค. ๋์ฅ์ C๋ง๋ฆฌ(1 ≤ C ≤ 20,000)์ ๋ญ์ด ์๊ณ , 1๋ฒ๋ถํฐ C๋ฒ๊น์ง ๋ฒํธ๊ฐ ๋ถ์ด ์๋ค. i๋ฒ ๋ญ์ ์ ํํ Ti์ด์๋ง ์๋ฅผ ๋์์ค ์ ์๋ค. ํ์ง๋ง ๋ญ์ ๊ธธ ๊ฑด๋๊ธฐ์ ๋ฌ์ธ์ด๋ฏ๋ก ์๋ฅผ ๋ฐ๋ฆฌ๊ณ ๋ ์์๊ฐ์ ๊ธธ์ ๊ฑด๋ ์ ์๋ค. ์๋ ํ ์ผ์ด ์์ด์ ์ฌ์ ๋กญ๊ฒ ๊ธธ์ ๊ฑด๋ ์ ์๋ค. ์๋ ์ด N๋ง๋ฆฌ(1 ≤ N ≤ 20,000)๊ฐ ์๊ณ , ๋ง์ฐฌ๊ฐ์ง๋ก 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ๋ฒํธ๊ฐ ๋ถ์ด ์๋ค. j๋ฒ ์๋ Aj์ด๋ถํฐ Bj์ด๊น์ง ๊ธธ์ ๊ฑด๋ ์ ์๋ค. j๋ฒ ์๊ฐ i๋ฒ ๋ญ์ ๋์์ ๋ฐ์ ๊ธธ์ ๊ฑด๋๋ ค๋ฉด Aj ≤ Ti ≤ Bj๋ฅผ ๋ง์กฑํด์ผ ํ๋ค.
์๋ ์ต๋ ํ ๋ง๋ฆฌ์ ๋ญ์๊ฒ๋ง ๋์์ ๋ฐ์ ์ ์๊ณ , ๋ญ ์ญ์ ์ต๋ ํ ๋ง๋ฆฌ์ ์๋ง ๋์์ค ์ ์๋ค. ๋์์ ๋ฐ์ ์ ์๋ ์๊ฐ ์ต๋ ๋ช ๋ง๋ฆฌ์ธ์ง ๊ตฌํด๋ณด์.
โธ ์ ๋ ฅ
์ฒซ ์ค์ C์ N์ด ์ฃผ์ด์ง๋ค. ๋ค์ C์ค์๋ T1…TC๊ฐ ์ฃผ์ด์ง๊ณ , ๊ทธ ๋ค์ N์ค์๋ Aj์ Bj(Aj ≤ Bj)๊ฐ ์ฃผ์ด์ง๋ค. A, B, T๋ ๋ชจ๋ ์ต๋ 1,000,000,000์ธ ์์ด ์๋ ์ ์์ด๊ณ , ๊ฐ์ ์๋ ์๋ค.
โธ ์ถ๋ ฅ
๋์์ ๋ฐ์ ์ ์๋ ์๊ฐ ์ต๋ ๋ช ๋ง๋ฆฌ์ธ์ง ์ถ๋ ฅํ๋ค.
๐ ๋ฌธ์ ์ ๋ณด
- ๐ฅ ๋ฌธ์ ๋ ๋ฒจ : ๊ณจ๋ 1
- ๐ ๋ฌธ์ ์ ํ : ์๋ฃ๊ตฌ์กฐ, ๊ทธ๋ฆฌ๋ ์๊ณ ๋ฆฌ์ฆ, ์ฐ์ ์์ ํ
- ๐ฌ ํ์ด ์ธ์ด : JAVA
๐ค ๋ฌธ์ ํ์ด
์ฐ์ ์์ ํ๋ฅผ ์ฌ์ฉํด์ ํด๊ฒฐํ ์ ์๋ ๋ฌธ์ ์๋ค.
๊ฐ์ฅ ๋น ๋ฅด๊ฒ ๋์์ ์ค ์ ์๋ ๋ญ์ ์ฐพ๊ธฐ ์ํด Ti๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
์๋์ ๊ฐ์ ์ผ์ด์ค์ ๊ฒฝ์ฐ๋ฅผ ๋๋นํ๊ธฐ ์ํด ์๋ Bj ๊ธฐ์ค์ผ๋ก, Bj๊ฐ ๊ฐ๋ค๋ฉด Aj๋ฅผ ๊ธฐ์ค์ผ๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
Ti : 2, 4
Aj Bj : 1 5, 2 3
ํ ๋ง๋ฆฌ์ ์์ฉ ์ํํ๋ฉฐ ๋์์ ๋ฐ์ ์ ์ ํ ๋ญ์ ์ฐพ์์ฃผ๋ฉด ๋๋ค.
์ ํ์ด๋๋ก ์ฝ๋๋ฅผ ์์ฑํด ๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
โ ์ต์ข ์ฝ๋
๋ฉ๋ชจ๋ฆฌ : 22244KB
์๊ฐ : 440ms
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.PriorityQueue;
import java.util.StringTokenizer;
public class Main {
static int c, n;
static int[] chickens;
static PriorityQueue<Pos> cows;
static public class Pos implements Comparable<Pos> {
int start; int end;
public Pos (int start, int end) {
this.start = start; this.end = end;
}
@Override
public int compareTo(Pos o) {
if (this.end != o.end) return this.end - o.end;
return this.start - o.start;
}
}
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
c = Integer.parseInt(st.nextToken()); // ๋ญ์ ์
n = Integer.parseInt(st.nextToken()); // ์์ ์
chickens = new int[c];
for (int i = 0; i < c; i++) {
chickens[i] = Integer.parseInt(br.readLine());
}
Arrays.sort(chickens);
cows = new PriorityQueue<>();
int s, e;
for (int i = 0; i < n ; i++) {
st = new StringTokenizer(br.readLine());
s = Integer.parseInt(st.nextToken());
e = Integer.parseInt(st.nextToken());
cows.offer(new Pos(s, e));
}
// ๋ช ๋ง๋ฆฌ์ ์๊ฐ ๋ญ์๊ฒ ๋์์ ๋ฐ์ ์ ์๋์ง
System.out.println(sol());
}
private static int sol() {
int cnt = 0;
while (!cows.isEmpty()) {
// ์๋ ์ต๋ ํ๋ฒ ๋ญ์ ๋์์ ๋ฐ์ ์ ์์
Pos now = cows.poll();
for (int i = 0; i < c; i++) {
// ์๊ฐ ๋ญ์๊ฒ ๋์์ ๋ฐ์ ์ ์์
if (chickens[i] >= now.start && chickens[i] <= now.end) {
cnt++;
// ๋ญ์ ์ต๋ ํ๋ฒ๋ง ์๋ฅผ ๋์์ค ์ ์์
chickens[i] = -1;
break;
}
}
}
return cnt;
}
}
ํด๊ฒฐ ์๋ฃ ! ๐ฅ
'Algorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Boj_20444] ์์ข ์ด์ ๊ฐ์ (1) | 2025.01.20 |
---|---|
[Boj_20183] ๊ณจ๋ชฉ ๋์ฅ ํธ์ - ํจ์จ์ฑ 2 (0) | 2025.01.18 |
[Boj_14466] ์๊ฐ ๊ธธ์ ๊ฑด๋๊ฐ ์ด์ 6 (0) | 2025.01.11 |
[Boj_12764] ์ธ์ง๋ฐฉ์ ๊ฐ ์คํ (0) | 2025.01.08 |
[Boj_14431] ์์๋ง์ (0) | 2024.12.26 |