[Boj_2696] ์ค์๊ฐ ๊ตฌํ๊ธฐ
๐ ๋ฌธ์ ๋งํฌ
https://www.acmicpc.net/problem/2696
โธ ๋ฌธ์
์ด๋ค ์์ด์ ์ฝ๊ณ , ํ์๋ฒ์งธ ์๋ฅผ ์ฝ์ ๋ ๋ง๋ค, ์ง๊ธ๊น์ง ์ ๋ ฅ๋ฐ์ ๊ฐ์ ์ค์๊ฐ์ ์ถ๋ ฅํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์๋ฅผ ๋ค์ด, ์์ด์ด 1, 5, 4, 3, 2 ์ด๋ฉด, ํ์๋ฒ์งธ ์๋ 1๋ฒ์งธ ์, 3๋ฒ์งธ ์, 5๋ฒ์งธ ์์ด๊ณ , 1๋ฒ์งธ ์๋ฅผ ์ฝ์์ ๋ ์ค์๊ฐ์ 1, 3๋ฒ์งธ ์๋ฅผ ์ฝ์์ ๋๋ 4, 5๋ฒ์งธ ์๋ฅผ ์ฝ์์ ๋๋ 3์ด๋ค.
โธ ์ ๋ ฅ
์ฒซ์งธ ์ค์ ํ ์คํธ ์ผ์ด์ค์ ๊ฐ์ T(1 ≤ T ≤ 1,000)๊ฐ ์ฃผ์ด์ง๋ค. ๊ฐ ํ ์คํธ ์ผ์ด์ค์ ์ฒซ์งธ ์ค์๋ ์์ด์ ํฌ๊ธฐ M(1 ≤ M ≤ 9999, M์ ํ์)์ด ์ฃผ์ด์ง๊ณ , ๊ทธ ๋ค์ ์ค๋ถํฐ ์ด ์์ด์ ์์๊ฐ ์ฐจ๋ก๋๋ก ์ฃผ์ด์ง๋ค. ์์๋ ํ ์ค์ 10๊ฐ์ฉ ๋๋์ด์ ธ์๊ณ , 32๋นํธ ๋ถํธ์๋ ์ ์์ด๋ค.
โธ ์ถ๋ ฅ
๊ฐ ํ ์คํธ ์ผ์ด์ค์ ๋ํด ์ฒซ์งธ ์ค์ ์ถ๋ ฅํ๋ ์ค์๊ฐ์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๊ณ , ๋์งธ ์ค์๋ ํ์ ๋ฒ์งธ ์๋ฅผ ์ฝ์ ๋ ๋ง๋ค ๊ตฌํ ์ค์๊ฐ์ ์ฐจ๋ก๋๋ก ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํ์ฌ ์ถ๋ ฅํ๋ค. ์ด๋, ํ ์ค์ 10๊ฐ์ฉ ์ถ๋ ฅํด์ผ ํ๋ค.
๐ ๋ฌธ์ ์ ๋ณด
- ๐ฅ ๋ฌธ์ ๋ ๋ฒจ : ๊ณจ๋ 2
- ๐ ๋ฌธ์ ์ ํ : ์๋ฃ ๊ตฌ์กฐ, ์ฐ์ ์์ ํ
- ๐ฌ ํ์ด ์ธ์ด : JAVA
๐ค ๋ฌธ์ ํ์ด
๋ฐฑ์ค 1655 ๊ฐ์ด๋ฐ๋ฅผ ๋งํด์์ ๋น์ทํ ๋ฌธ์ ์ด๋ค.
์ฐ์ ์์ ํ ๋ ๊ฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ค์๊ฐ์ ์ฐพ์ ์ ์๋ค.
๋จผ์ , ์ต๋ ํ๊ณผ ์ต์ ํ์ ๊ตฌํํ ์ฐ์ ์์ ํ ๋ ๊ฐ๋ฅผ ์ ์ธํ๋ค.
์ต๋ ํ์ ์ต๋๊ฐ์ ์ ๋ ฌํ๋๋ก ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๊ณ ,
์ต์ ํ์ ์ต์๊ฐ์ ์ ๋ ฌํ๋๋ก ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ค.
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
๋ฒ๊ฐ์๊ฐ๋ฉฐ ๊ฐ๊ฐ ํ์ ๊ฐ์ ๋ฃ์ด์ค๋ค.
if (minHeap.size() == maxHeap.size()) maxHeap.offer(num);
else minHeap.offer(num);
์ต๋ ํ์ ์ต๋๊ฐ > ์ต์ ํ์ ์ต์๊ฐ์ผ๋, ๋ ๊ฐ์ ๊ตํํ๋ค.
if (maxHeap.peek() > minHeap.peek()) {
int tmp = minHeap.poll();
minHeap.offer(maxHeap.poll());
maxHeap.offer(tmp);
}
๊ทธ๋ฌ๋ฉด ์ต๋ ํ์๋ ์ค์๊ฐ ์ดํ์ ์๋ง, ์ต์ ํ์๋ ์ค์๊ฐ ์ด๊ณผ์ ์๋ง ์กด์ฌํ๊ฒ ๋๋ค.
๊ทธ๋ ๊ธฐ ๋๋ฌธ์, ์ต๋ ํ์๋ ํญ์ ์ค์๊ฐ์ด ์กด์ฌํ๊ฒ ๋๋ค.
๋ง์ง๋ง์ผ๋ก, ํ์๋ฒ์งธ ์๋ฅผ ์ฝ์ ๋๋ง ์ต๋ ํ์์ ์ค์๊ฐ์ ๊ฐ์ ธ์ค๋ฉด ๋๋ค.
์ ํ์ด๋ฅผ ์ฝ๋๋ก ์์ฑํด ๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
โ ์ต์ข ์ฝ๋
๋ฉ๋ชจ๋ฆฌ : 15924KB
์๊ฐ : 152ms
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Comparator;
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));
StringBuilder sb = new StringBuilder();
StringTokenizer st = null;
int t = Integer.parseInt(br.readLine()); // ํ
์คํธ ์ผ์ด์ค ์
while (t --> 0) {
// ์ต๋ํ
PriorityQueue<Integer> maxHeap = new PriorityQueue<>(Comparator.reverseOrder());
// ์ต์ํ
PriorityQueue<Integer> minHeap = new PriorityQueue<>();
int m = Integer.parseInt(br.readLine());
sb.append((m/2)+1).append("\n"); // ์ค์ ๊ฐ ๊ฐ์
int cnt = 0;
for (int i = 0; i < m; i++) {
if (i % 10 == 0) { // ์์๋ ํ์ค์ 10๊ฐ์ฉ
st = new StringTokenizer(br.readLine());
}
// ์ค์ ๊ฐ ๊ตฌํ๊ธฐ
int num = Integer.parseInt(st.nextToken());
if (minHeap.size() == maxHeap.size()) maxHeap.offer(num);
else minHeap.offer(num);
if (!minHeap.isEmpty() && !maxHeap.isEmpty()) {
if (maxHeap.peek() > minHeap.peek()) {
int tmp = minHeap.poll();
minHeap.offer(maxHeap.poll());
maxHeap.offer(tmp);
}
}
// ํ์ ๋ฒ์งธ ์๋ฅผ ์ฝ์ ๋๋ง๋ค
if (i % 2 == 0) {
// ์ถ๋ ฅ๋ ํ ์ค์ ์์ 10๊ฐ์ฉ
if (cnt == 9 || i == m-1) {
sb.append(maxHeap.peek()).append("\n");
cnt = 0;
} else {
sb.append(maxHeap.peek()).append(" ");
}
cnt++;
}
}
}
System.out.println(sb);
}
}
์ ์ ๊ฐ์ด๋ฐ๋ฅผ ๋งํด์ ๋ฌธ์ ๋ฅผ ํ๋ฉด์ ์ฐ์ ์์ ํ ๋ ๊ฐ๋ฅผ ์ฌ์ฉํ์ฌ ์ค์๊ฐ์ ์ฐพ๋ ๋ค๋ฅธ ์ฌ๋์ ํ์ด๊ฐ ๊ต์ฅํ ์ ๊ธฐํ๊ณ ์ธ์ ๊น์๋ค. ๊ทธ๋์ ์ด๋ฒ ๋ฌธ์ ๋ฅผ ํ ๋ ๊ทธ๋ ํ์ด๋ฅผ ํ์ฉํ๊ณ , ๋ธ๋ก๊ทธ์ ํฌ์คํ ํ๋ฉฐ ๋ค์ ํ๋ฒ ์ ๋ฆฌํ๋ค.
๋ถ์ง๋ฐํ ๋ ์ด์ฌํ ๊ณต๋ถํด์ผ์ง...๐ญ