๐ ๋ฌธ์ ๋งํฌ
https://www.acmicpc.net/problem/20956
โธ ๋ฌธ์
์งํธ๋ ๋งค์ผ ์์ด์คํฌ๋ฆผ ๊ฐ๊ฒ์ ๋ฐฉ๋ฌธํ๋ค. ์์ด์คํฌ๋ฆผ์ ๋จน๋ ์งํธ๋ ๋๋ผ ์๋น ์ง ์๋ฐ์ ์์๋ค. ์ค์๋ก ๋ฏผํธ์ด์ฝ ๋ง์ ๋จน์๊ธฐ ๋๋ฌธ์ด๋ค. ๋๋ค์์ ์ฌ๋์ ์น์ฝ ๋ง์ด ๋๋ค๋ ์ด์ ๋ก ๋ฏผํธ์ด์ฝ๋ฅผ ์ซ์ดํ๋ค. ์์ด์คํฌ๋ฆผ์ผ๋ก ์ด๋ฅผ ๋ฆ๋๋ค๋ ๋ฐ์์ ๋๊ฐ ํ ๊ฒ์ธ์ง ๊ถ๊ธํ ๋ฟ์ด๋ค. ์๋ฌดํผ ๋งค๋ฒ ์์ด์คํฌ๋ฆผ์ ์ฌ ๋จน๋ ๊ฒ์ด ์ง๊ฒจ์์ง ์งํธ๋ ์ด์ ๋ถํฐ ์์ด์คํฌ๋ฆผ์ ํ์ณ ๋จน๊ธฐ๋ก ๊ฒฐ์ฌํ์๋ค.
์์ด์คํฌ๋ฆผ ๊ฐ๊ฒ์๋ ๋ค์ํ ๋ง์ ์์ด์คํฌ๋ฆผ N๊ฐ๊ฐ ํ ์ค๋ก ๋ฐฐ์น๋์ด ์๋ค. ์์ด์คํฌ๋ฆผ์๋ ๋ฒํธ๊ฐ ๋งค๊ฒจ์ ธ ์๋๋ฐ, ๊ฐ์ฅ ์ผ์ชฝ ์์ด์คํฌ๋ฆผ์ด 1๋ฒ, ๊ทธ ์ค๋ฅธ์ชฝ์ 2๋ฒ, ..., ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์์ด์คํฌ๋ฆผ์ N๋ฒ์ด๋ค. ์งํธ๋ ํญ์ ์์ด ๊ฐ์ฅ ๋ง์ ์์ด์คํฌ๋ฆผ์ ์ ํํ์ฌ ์ ๋ถ ๋จน๋๋ค. ์์ด ๊ฐ์ฅ ๋ง์ ์์ด์คํฌ๋ฆผ์ด ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด ๊ฐ์ฅ ์ผ์ชฝ์ ์๋ ๊ฒ์ ๋จน๋๋ค.
์งํธ๋ ๋๋ค์์ ์ฌ๋๊ณผ ๋ง์ฐฌ๊ฐ์ง๋ก ๋ฏผํธ์ด์ฝ ๋ง์ ์ซ์ดํ๋ค. ๋คํํ ์งํธ๋ ์์ด์คํฌ๋ฆผ์ ์์ด ์ฃผ์ด์ง ๋ ์์ด์คํฌ๋ฆผ์ ๋ง์ ์ ์ ์๋ค. ์งํธ์ ํ๋ณ๋ฒ์ ๋ฐ๋ฅด๋ฉด, ์์ด์คํฌ๋ฆผ์ ์์ด 7์ ๋ฐฐ์๋ผ๋ฉด ๋ฏผํธ์ด์ฝ ๋ง์ด๊ณ , ๊ทธ๋ ์ง ์๋ค๋ฉด ๋ฏผํธ์ด์ฝ ๋ง์ด ์๋๋ผ๊ณ ํ๋ค.
์งํธ๋ ๋ฏผํธ์ด์ฝ๋ฅผ ์ซ์ดํ๋ค๋ ์ฌ์ค์ ๋ช ์ฌํ๋ผ. ๋ฏผํธ์ด์ฝ ๋ง ์์ด์คํฌ๋ฆผ์ ๋จน์ ์งํธ๋ ํฌ๊ฒ ๋ถ๋ ธํ์ฌ ๋จ์ ์๋ ์์ด์คํฌ๋ฆผ์ ์์๋ฅผ ์ข์ฐ๋ก ๋ค์ง๋๋ค. ์ฆ, K๊ฐ์ ์์ด์คํฌ๋ฆผ์ด ์๋ค๋ฉด i๋ฒ์งธ ์์ด์คํฌ๋ฆผ๊ณผ (K - i + 1)๋ฒ์งธ ์์ด์คํฌ๋ฆผ์ ์์น๋ฅผ ๋ค๋ฐ๊พผ๋ค. (1 ≤ i ≤ ⌊K / 2⌋)
์งํธ๋ N๊ฐ์ ์์ด์คํฌ๋ฆผ ์ค M๊ฐ์ ์์ด์คํฌ๋ฆผ์ ๋จน์ผ๋ ค ํ๋ค. ์์ด์คํฌ๋ฆผ์ ์์ด ์ฃผ์ด์ก์ ๋, ์งํธ๊ฐ ๋จน์ ์์ด์คํฌ๋ฆผ์ ๋ฒํธ๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
โธ ์ ๋ ฅ
์ฒซ ๋ฒ์งธ ์ค์ ์ ์ฒด ์์ด์คํฌ๋ฆผ์ ๊ฐ์ N๊ณผ ์งํธ๊ฐ ๋จน์ ์์ด์คํฌ๋ฆผ์ ๊ฐ์ M์ด ์ฃผ์ด์ง๋ค.
๋ ๋ฒ์งธ ์ค์ N๊ฐ์ ์ ์ A1, A2, ..., AN์ด ์ฃผ์ด์ง๋ค. ์ด๋ Ai๋ i๋ฒ ์์ด์คํฌ๋ฆผ์ ์์ ์๋ฏธํ๋ค.
๋ชจ๋ ์ ๋ ฅ์ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด ์ฃผ์ด์ง๋ค.
โธ ์ถ๋ ฅ
M๊ฐ์ ์ค์ ๊ฑธ์ณ i(1 ≤ i ≤ M)๋ฒ์งธ ์ค์๋ ์งํธ๊ฐ i๋ฒ์งธ๋ก ๋จน์ ์์ด์คํฌ๋ฆผ์ ๋ฒํธ๋ฅผ ์ถ๋ ฅํ๋ค.
โธ ์ ํ
- 1 ≤ N ≤ 100,000
- 1 ≤ M ≤ N
- 1 ≤ Ai ≤ 1,000,000,000
๐ ๋ฌธ์ ์ ๋ณด
- ๐ฅ ๋ฌธ์ ๋ ๋ฒจ : ๊ณจ๋ 4
- ๐ ๋ฌธ์ ์ ํ : ์๋ฃ ๊ตฌ์กฐ, ์ ๋ ฌ, ๋ฑ
- ๐ฌ ํ์ด ์ธ์ด : JAVA
๐ค ๋ฌธ์ ํ์ด
์ด ๋ฌธ์ ๋ TreeMap๊ณผ TreeSet์ ํ์ฉํด์ ํด๊ฒฐํ๋ค.
๋จผ์ , TreeMap์ ์ ์ธํ ๋ค key, value๋ ๊ฐ๊ฐ ๋ค์๊ณผ ๊ฐ์ด ์ค์ ํ๋ค.
- key : ์์ด์คํฌ๋ฆผ ์ (amount)
- value : ๊ทธ ์์ ๊ฐ์ง ์์ด์คํฌ๋ฆผ๋ค์ ์ธ๋ฑ์ค๋ค (TreeSet<Integer>)
์ด๋, TreeSet<Integer>์ ์ฌ์ฉํ๋ ์ด์ ๋ ? ๐ค
๋ฌธ์ ์กฐ๊ฑด์ ๋ฐ๋ฅด๋ฉด '์์ด ๊ฐ์ฅ ๋ง์ ์์ด์คํฌ๋ฆผ์ด ์ฌ๋ฌ ๊ฐ๋ผ๋ฉด ๊ฐ์ฅ ์ผ์ชฝ์ ์๋ ๊ฒ์ ๋จน๋๋ค.'
๋ฐ๋ผ์ ๊ฐ์ ์์ ์์ด์คํฌ๋ฆผ์ด ์ฌ๋ฌ ๊ฐ ์์ ๊ฒฝ์ฐ,
๊ฐ์ฅ ์์ ์ธ๋ฑ์ค(๊ฐ์ฅ ์ผ์ชฝ)๋ฅผ ๊ฐ์ง ์์ด์คํฌ๋ฆผ์ ๋จน์ด์ผ ํ๋ค.
TreeSet<Integer>์ ์ธ๋ฑ์ค๋ฅผ ์๋์ผ๋ก ์ค๋ฆ์ฐจ์ ์ ๋ ฌํด์ ์ ์ฅํ๋ฏ๋ก,
- pollFirst() → ๊ฐ์ฅ ์ผ์ชฝ ์์ด์คํฌ๋ฆผ
- pollLast() → reverse ์ํ์ผ ๋ ๊ฐ์ฅ ์ค๋ฅธ์ชฝ ์์ด์คํฌ๋ฆผ
- ์ ๊ฐ๊ฐ ๋น ๋ฅด๊ฒ ๊บผ๋ผ ์ ์๋ค.
๐ก ์ฐธ๊ณ ๋ก ์ฝ๋์์ ์ฌ์ฉํ putIfAbsent() ๋ฉ์๋์ ๋ํด ์์๋ณด์๋ฉด,
putIfAbsent(key, value)๋ Java 8 ์ด์์์ ์ง์๋๋ฉฐ,
- ํด๋น ํค๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด value๋ฅผ ์ฝ์ ํ๊ณ
- ์ด๋ฏธ ์กด์ฌํ๋ฉด ์๋ฌด๊ฒ๋ ์ ํจ
์๋ฅผ ๋ค์ด, ์ด๋ค ์์ด 14์ธ ์์ด์คํฌ๋ฆผ์ด ์ฒ์ ๋ฑ์ฅํ๋ค๊ณ ๊ฐ์ ํ์.
if (!iceCreams.containsKey(14)) {
iceCreams.put(14, new TreeSet<>());
}
iceCreams.get(14).add(i);
์ด ์ฝ๋๋ฅผ ๊ฐ๋จํ ๋ฐ๊ฟ ์ ์๋ค.
iceCreams.putIfAbsent(14, new TreeSet<>());
iceCreams.get(14).add(i);
์ฆ, amount ์์ ์์ด์คํฌ๋ฆผ ๊ทธ๋ฃน(TreeSet<index>)์ด ์์ผ๋ฉด ์๋ก ๋ง๋ค๊ณ , ์์ผ๋ฉด ๊ธฐ์กด ๊ฑธ ์ฌ์ฉํด์ ํด๋น ์ธ๋ฑ์ค i๋ฅผ ์ถ๊ฐํ๋ ๊ตฌ์กฐ์ด๋ค.
์ ํ์ด์ ์ฝ๋๋ฅผ ๋ฐํ์ผ๋ก ์ ์ฒด์ ์ธ ์ฝ๋๋ฅผ ์์ฑํด ๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
โ ์ฝ๋
๋ฉ๋ชจ๋ฆฌ : 65092KB
์๊ฐ : 620ms
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;
public class Main {
static boolean isReverseOrder = false;
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer st = new StringTokenizer(br.readLine());
int n = Integer.parseInt(st.nextToken()); // ์ ์ฒด ์์ด์คํฌ๋ฆผ์ ๊ฐ์
int m = Integer.parseInt(st.nextToken()); // ์งํธ๊ฐ ๋จน์ ์์ด์คํฌ๋ฆผ์ ๊ฐ์
// ์์ด์คํฌ๋ฆผ์ ์, ๊ทธ ์์ ๊ฐ์ง ์์ด์คํฌ๋ฆผ์ ์ธ๋ฑ์ค๋ค
TreeMap<Integer, TreeSet<Integer>> iceCreams = new TreeMap<>();
st = new StringTokenizer(br.readLine());
for (int i = 1; i <= n; i++) {
int amount = Integer.parseInt(st.nextToken());
// ํด๋น ํค๊ฐ ์กด์ฌํ์ง ์์ผ๋ฉด value๋ฅผ ์ฝ์
ํ๊ณ
// ์ด๋ฏธ ์กด์ฌํ๋ฉด ์๋ฌด๊ฒ๋ ์ ํจ
iceCreams.putIfAbsent(amount, new TreeSet<>());
iceCreams.get(amount).add(i);
}
StringBuilder sb = new StringBuilder();
while (m --> 0) {
TreeSet<Integer> group = iceCreams.lastEntry().getValue(); // ๊ฐ์ฅ ์ ๋ง์ ๊ทธ๋ฃน
if (isReverseOrder) { // ์ข์ฐ๋ก ๋ค์ง์๋ค๋ฉด
sb.append(group.pollLast()).append("\n"); // ์ค๋ฅธ์ชฝ์์ ๋จน๊ธฐ
} else {
sb.append(group.pollFirst()).append("\n"); // ์ผ์ชฝ์์ ๋จน๊ธฐ
}
if (iceCreams.lastKey() % 7 == 0) { // ๋ฏผ์ด๋ฅผ ๋จน์๋ค๋ฉด
isReverseOrder = !isReverseOrder;
}
if (group.isEmpty()) {
iceCreams.pollLastEntry(); // ๋จน์ ๊ทธ๋ฃน ๋ค ๋น์ฐ๋ฉด ์ญ์
}
}
System.out.println(sb.toString());
br.close();
}
}
์ฒ์์ Deque๋ฅผ ์ฌ์ฉํด์ ๋ฌธ์ ๋ฅผ ํ์๋๋ฐ ๊ณ์ ์๊ฐ ์ด๊ณผ๊ฐ ๋ด๋ค..
๋์ ํ ์์ด๋์ด๊ฐ ์ ๋ ์ฌ๋ผ์ ๋ค๋ฅธ ๋ถ์ ํ์ด๋ฅผ ์ฐธ๊ณ ํด์ ํ์๋ค. ์ค๋๋ง์ TreeMap๊ณผ TreeSet์ ์ฌ์ฉํด ๋ฌธ์ ๋ฅผ ํ์๋๋ฐ,
์ฒ์ ๋ณด๋ ๋ฉ์๋์ ๋ํด์๋ ๊ณต๋ถํ ์ ์์๋ค. ์ด์ฉ๋ฉด ์ ๋ ฌ ๋ฌธ์ ๊ฐ ์ ์ผ ์ด๋ ค์ธ์ง๋ ๋ชจ๋ฅด๊ฒ ๋ค...โญ
'Algorithm > BOJ' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Boj_1450] ๋ ์๋ฌธ์ (3) | 2025.08.07 |
---|---|
[Boj_1561] ๋์ด ๊ณต์ (4) | 2025.08.05 |
[Boj_1194] ๋ฌ์ด ์ฐจ์ค๋ฅธ๋ค, ๊ฐ์. (0) | 2025.07.25 |
[Boj_17244] ์๋ง๋ค์ฐ์ฐ (1) | 2025.07.16 |
[Boj_15787] ๊ธฐ์ฐจ๊ฐ ์ด๋ ์ ํค์น๊ณ ์ํ์๋ฅผ (1) | 2025.07.03 |