https://school.programmers.co.kr/learn/courses/30/lessons/42628
ํ๋ก๊ทธ๋๋จธ์ค
์ฝ๋ ์ค์ฌ์ ๊ฐ๋ฐ์ ์ฑ์ฉ. ์คํ ๊ธฐ๋ฐ์ ํฌ์ง์ ๋งค์นญ. ํ๋ก๊ทธ๋๋จธ์ค์ ๊ฐ๋ฐ์ ๋ง์ถคํ ํ๋กํ์ ๋ฑ๋กํ๊ณ , ๋์ ๊ธฐ์ ๊ถํฉ์ด ์ ๋ง๋ ๊ธฐ์ ๋ค์ ๋งค์นญ ๋ฐ์ผ์ธ์.
programmers.co.kr
1. ๋ฌธ์
๊ฐ ๋ช ๋ น์ด์ ๋ฐ๋ผ ์ด์ค์ฐ์ ์์ํ์ ์ฐ์ฐ์ด ์ฒ๋ฆฌ๋๋ค.
I ์ซ์ => ํ์ ์ซ์ ์ฝ์
D 1 => ํ์์ ์ต๋๊ฐ ์ญ์
D -1 => ํ์์ ์ต์๊ฐ ์ญ์
์ต๋๊ฐ, ์ต์๊ฐ์ return ํ๋, ํ๊ฐ ๋น์ด์์ ๊ฒฝ์ฐ [0,0] ์ returnํ๋ค.
2. ํ์ด
์ฐ์ ์์ํ 2๊ฐ๋ฅผ ์ฌ์ฉํ๋ค.
ํ๋๋ ์ค๋ฆ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ์ธ ์ต์ํ,
๋ค๋ฅธ ํ๋๋ ๋ด๋ฆผ์ฐจ์์ผ๋ก ์ ๋ ฌํ๋ ํ์ธ ์ต๋ํ
์ผ๋ก ํ์ฉํ๋ค.
์ฌ๊ธฐ์ ํต์ฌ์ "์ต์ํ์ ์ต๋ํ์ ์์๋ฅผ ๋์ผํ๊ฒ ํด์ค์ผ ํ๋ค"๋ ๊ฒ์ด๋ค.
๋ฌด์จ ๋ง์ด๋๋ฉด, ์ต๋๊ฐ ์ญ์ ํ๋ผ๊ณ ํด์ ์ต๋ํ์์๋ง pollํ๋ฉด ์๋๋ค๋ ์๋ฏธ์ด๋ค.
์ต๋ํ์์๋ ์ญ์ ํด์ฃผ๊ณ ์ต์ํ์์๋ ์ญ์ ํด์ค์ผ ํ๋ค๋ ๊ฒ์ด๋ค.
๊ทผ๋ฐ ์ต๋ํ์์ ์ญ์ ํ๋๊ฑด maxPq.poll() ํด์ฃผ๋ฉด ๋์ด๋ค. ๊ทธ๋ผ ์ต์ํ์์๋ ์ด๋ป๊ฒ ์ญ์ ํ๋?
๋ฐ๋ก remove ํจ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด๋ค.
pq.remove()๋ pq.poll()๊ณผ ์ญํ ์ด ๋์ผํ๋ค. ์ฐ์ ์์ํ์ ๋งจ ์ ์์๋ฅผ ์ญ์ ํด์ค๋ค๋ ๊ณตํต์ ์ด ์๋ค.
๋์ ์ฐจ์ด์ ์ remove()๋ ํ๊ฐ ๋น์ด์์ ๊ฒฝ์ฐ Exception์ด ๋ฐ์ํ๊ณ , poll()์ null์ ๋ฐํํ๋ค.
ํ์ง๋ง ํน์ด์ ์ด ์๋ค.
pq.remove(์์)๋ฅผ ํ ๊ฒฝ์ฐ, ์ฐ์ ์์ ํ์์ ํด๋น ์์๊ฐ ์ญ์ ๋๋ค.
๋ง์ฝ ํ์ ํด๋น ์์๊ฐ ์์ด๋ Exception์ ๋ฐ์ํ์ง ์๋๋ค. ์ญ์ ๊ฐ ๋์ง ์์ ๋ฟ์ด๋ค.
์ด๋ฌํ ๋ฌ๋ฌํ ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์์ฝ๊ฒ ์ด ๋ฌธ์ ๋ฅผ ํ ์ ์๋ค.
3. ์ฝ๋
์ฐ์ฐ์๊ฐ D์ด๊ณ ํ๊ฐ ๋น์์ ๊ฒฝ์ฐ์ ๋ฐ๋ก continueํด์คฌ๋ค. ๋ฐ์ ๋ ๋ณผ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ด๋ค.
import java.io.*;
import java.util.*;
class Solution {
public int[] solution(String[] operations) {
PriorityQueue<Integer> minPq = new PriorityQueue<> (); // ์ต์ํ
PriorityQueue<Integer> maxPq = new PriorityQueue<> ((o1, o2) -> o2-o1);
StringTokenizer st = null;
for (String item : operations) {
st = new StringTokenizer(item);
String oper = st.nextToken();
int num = Integer.parseInt(st.nextToken());
if ("D".equals(oper) && minPq.isEmpty()) {
continue;
}
if ("I".equals(oper)) {
minPq.offer(num);
maxPq.offer(num);
continue;
}
// ์ต์๊ฐ ์ญ์
if (num < 0) {
maxPq.remove(minPq.poll());
continue;
}
// ์ต๋๊ฐ ์ญ์
minPq.remove(maxPq.poll());
}
if (minPq.isEmpty()) {
return new int[] {0,0};
}
return new int[] {maxPq.poll(), minPq.poll()};
}
}
4. ์ฌ๋ด
์ฐ์ ์์ํ๋ฅผ ์ฌ์ฉํ๋ ๋ฌธ์ ๋ ํญ์ ์ฌ๋ฐ๋ ๊ฒ ๊ฐ๋ค.
๋ด๋ฆผ์ฐจ์ํ ๋ ํญ์ ๋๋ค๋ก (o1, o2) -> o2-o1์ ํ์ฉํ๋๋ฐ
Collections.reverseOrder()๋ ์๋ค๋๊ฑธ ์์ง๋ง์ !
'Algorithm > Programmers' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Programmers] ์ต๊ณ ์ ์งํฉ - Java (0) | 2023.08.20 |
---|---|
[Programmers] ์ ์์ผ๊ฐํ - Java (0) | 2023.08.19 |
[Programmers] ์ ํ์ ์๊ฐ์ด๋ - Java (0) | 2023.08.11 |
[Programmers] ๊ตฌ๋ช ๋ณดํธ - Java (0) | 2023.07.10 |
[Programmers] ์นดํซ - Java (0) | 2023.07.09 |