์ซ์ ์นด๋๋ ์ ์ ํ๋๊ฐ ์ ํ์ ธ ์๋ ์นด๋์ด๋ค. ์๊ทผ์ด๋ ์ซ์ ์นด๋ N๊ฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. ์ ์ M๊ฐ๊ฐ ์ฃผ์ด์ก์ ๋, ์ด ์๊ฐ ์ ํ์๋ ์ซ์ ์นด๋๋ฅผ ์๊ทผ์ด๊ฐ ๋ช ๊ฐ ๊ฐ์ง๊ณ ์๋์ง ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฒซ์งธ ์ค์ ์๊ทผ์ด๊ฐ ๊ฐ์ง๊ณ ์๋ ์ซ์ ์นด๋์ ๊ฐ์ N(1 โค N โค 500,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค์๋ ์ซ์ ์นด๋์ ์ ํ์๋ ์ ์๊ฐ ์ฃผ์ด์ง๋ค. ์ซ์ ์นด๋์ ์ ํ์๋ ์๋ -10,000,000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
์ ์งธ ์ค์๋ M(1 โค M โค 500,000)์ด ์ฃผ์ด์ง๋ค. ๋ท์งธ ์ค์๋ ์๊ทผ์ด๊ฐ ๋ช ๊ฐ ๊ฐ์ง๊ณ ์๋ ์ซ์ ์นด๋์ธ์ง ๊ตฌํด์ผ ํ M๊ฐ์ ์ ์๊ฐ ์ฃผ์ด์ง๋ฉฐ, ์ด ์๋ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถ๋์ด์ ธ ์๋ค. ์ด ์๋ -10,000,000๋ณด๋ค ํฌ๊ฑฐ๋ ๊ฐ๊ณ , 10,000,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ๋ค.
์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง M๊ฐ์ ์์ ๋ํด์, ๊ฐ ์๊ฐ ์ ํ ์ซ์ ์นด๋๋ฅผ ์๊ทผ์ด๊ฐ ๋ช ๊ฐ ๊ฐ์ง๊ณ ์๋์ง๋ฅผ ๊ณต๋ฐฑ์ผ๋ก ๊ตฌ๋ถํด ์ถ๋ ฅํ๋ค.
6 3 2 10 10 10 -10 -10 7 3
8
10 9 -5 2 3 4 5 -10
3 0 0 1 2 0 0 2
์ผ๋จ ๋ฌธ์ ๋ด์ฉ ์์ฒด๋ ์ด์ ์ ๋ฌธ์ ์ ์ ์ฌํ๋ค.
๋ค๋ง, ์ด๋ฒ์๋ ์
๋ ฅ ๊ฐ์ผ๋ก ์ค๋ณต์ด ํ์ฉ๋๊ณ , ๊ฐฏ์๋ฅผ countํด์ผ ํ๋ ๋ฌธ์ ์ด๊ธฐ ๋๋ฌธ์,
Hash Set ๋์ Hash Map์ ์ฌ์ฉํด์ ์ ๊ทผํ์๋ค.
import java.util.*;
public class Baekjoon_10816 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
HashMap<Integer, Integer> countMap = new HashMap<>();
StringBuilder result = new StringBuilder();
int N = sc.nextInt();
for (int i = 0; i < N; i++) {
int input = sc.nextInt(); // ์๊ทผ์ด์ ์นด๋ ์
๋ ฅ
if (!countMap.containsKey(input)) {
// Map์ ์์ผ๋ฉด ์
๋ ฅ๊ฐ์ key๋ก ๊ฐ์ง๋ value(๊ฐฏ์)๋ฅผ 1๋ก ์ ์ฅ
countMap.put(input, 1);
}
else {
// ์ด๋ฏธ ํด๋น ๊ฐ์ด ๋ค์ด์๋ค๋ฉด value(๊ฐฏ์)๋ฅผ 1์ฆ๊ฐ
countMap.replace(input, countMap.get(input) + 1);
}
}
int M = sc.nextInt();
for (int i = 0; i < M; i++) {
int input = sc.nextInt(); // ๊ฐฏ์๋ฅผ ์
์ ์ ์
๋ ฅ
if (countMap.containsKey(input)) {
// ์
๋ ฅ๋ ์ ์๊ฐ Map์ ์กด์ฌํ๋ค๋ฉด
// ํด๋น ์ ์๋ฅผ key๊ฐ์ผ๋ก ๊ฐ์ง๋ value(๊ฐ์) ๋ฐํ
result.append(Integer.toString(countMap.get(input)) + " ");
}
else {
// ์
๋ ฅ๋ ์ ์๊ฐ Map์ ์กด์ฌํ์ง ์๋๋ค๋ฉด
result.append("0 ");
}
}
System.out.println(result.toString().trim());
sc.close();
}
}
Map์ key์ value๋ฅผ ์ด๋ป๊ฒ ์ค์ ํด์ ์ ์ฅํด์ผ ๊ฐฏ์๋ฅผ countํ ๋, ๊ฐ์ฅ ํจ์จ์ ์ผ๋ก ๋์ํ ์ ์์ ์ง์ ๋ํด ๋จผ์ ์๊ฐํ๋ค.
์ฒ์์๋ ์๊ทผ์ด์ ์นด๋ ์ ๋ณด๋ฅผ ๊ทธ๋๋ก Map์ ์ ์ฅ์์ผ ๊ตฌํ์ ํ๋ ค ํ์๋๋ฐ, ์ด๋ป๊ฒ ํ๋ ์ํ๋ ์ ์๋ฅผ Map์์ ์ฐพ์ ๋ Map ์ ์ฒด๋ฅผ ์ํํ๊ฒ ๋์ด ์๊ฐ ๋ณต์ก๋๊ฐ ์ต์ ์ ๊ฒฝ์ฐ ๊น์ง ๋์ฌ ๊ฑฐ ๊ฐ์๋ค.
๊ทธ๋์ ์ข ๋ ํจ์จ์ ์ธ ๋ฐฉ๋ฒ์ ์ฐพ์๋๋ค.
๋ฐ๋ก, ์๊ทผ์ด์ ์นด๋๋ฅผ ์
๋ ฅ ๋ฐ์ ๋, Map์ ํด๋น ์
๋ ฅ๊ฐ์ ๋ํ ๊ฐฏ์๋ฅผ ๋ฏธ๋ฆฌ ๋ค ์ ์ฅ์์ผ ๋๋ ๋ฐฉ๋ฒ์ด๋ค.
์ ๋ ฅํ ์นด๋์ ์ซ์๋ฅผ key๊ฐ, ๊ฐ์ ์ซ์์ ์นด๋ ๊ฐฏ์๋ฅผ value๊ฐ์ผ๋ก ๊ฐ์ง๋ Map์ ์์์ ๋ง๋ค์ด ๋์ผ๋ฉด, ๋ค์์ ๋ฐ๋ก ๊ฐฏ์๋ฅผ ์ผ์ผ์ด ์ธ์ง ์์๋ ๋๋ค.
์ด๋ฅผ ๊ตฌํํ๊ธฐ ์ํด, ์๊ทผ์ด์ ์นด๋๋ฅผ ์ญ ์
๋ ฅ๋ฐ์ ๋,
Map์ ํด๋น ์ซ์์ ์นด๋๊ฐ ์์ผ๋ฉด, value(๊ฐฏ์)๋ฅผ 1๋ก ์ง์ ํด์ ์ ์ฅํด์ฃผ๊ณ ,
ํด๋น ์ซ์์ ์นด๋๊ฐ ์ด๋ฏธ ์์ผ๋ฉด, ํด๋น ์ซ์๋ฅผ key๊ฐ์ผ๋ก ๊ฐ์ง๋ value(๊ฐฏ์)์ 1์ ๋ํ๋๋ก ํด์ฃผ์๋ค.
์ด ๊ณผ์ ์ด ์๋ฃ๋๋ฉด, ์๊ทผ์ด๊ฐ ๊ฐ์ง๊ณ ์๋ ์นด๋์ ์ซ์๋ฅผ key, ํด๋น ์ซ์์ ์นด๋ ๊ฐฏ์๋ฅผ value๋ก ๊ฐ์ง๋ Map์ด ์์ฑ๋๋ค.
๋ฌธ์ ์ ์์ ์
๋ ฅ์ ์๋ก ๋ค๋ฉด ์๋์ ๊ฐ์ ๊ฒฐ๊ณผ๊ฐ ๋์จ๋ค.
์ด์ ์ฃผ์ด์ง ์ ์๋ค์ด ์๊ทผ์ด์ ์นด๋์ ์ผ์นํ๋ ๊ฒ์ด ์๋ ์ง, ์๋ค๋ฉด ๊ฐฏ์๋ฅผ ์ถ๋ ฅํด์ผ ํ๋ค.
์ด๋ฏธ ์นด๋๋ง๋ค์ ๊ฐฏ์๋ฅผ ๋ค ๊ตฌํด๋์๊ธฐ ๋๋ฌธ์, Map์ ํฌํจ๋๋ ์ซ์๋ ํด๋น value๋ฅผ ์ถ๋ ฅํด์ฃผ๋ฉด ๋๊ณ , ์์ผ๋ฉด 0์ ์ถ๋ ฅํด์ฃผ๋ฉด ์ต์ข
์ ์ผ๋ก ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค.
์กฐ๊ธ ๋ ๊ฐ๊ฒฐํ๊ณ ํจ์จ์ ์ผ๋ก ์ฝ๋๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด ๋ฐฉ๋ฒ์ ์ฐพ์๋ณด์๋ค.
์ฐ์ getOrDefault()
๋ฉ์๋๋ฅผ ํตํด, ์กฐ๊ฑด๋ฌธ์ ๊ฐ๋จํ๊ฒ ํํํ ์ ์๋ค.
for (int i = 0; i < N; i++) {
int input = sc.nextInt();
countMap.put(input, countMap.getOrDefault(input, 0) + 1);
}
์๊ทผ์ด์ ์นด๋๋ฅผ ์
๋ ฅ๋ฐ์ ๋ value์ธ์์ getOrDefault()
๋ฉ์๋๋ฅผ ์ฌ์ฉํ๊ฒ ๋๋ฉด, key๊ฐ ์กด์ฌํ์ง ์์ ๊ฒฝ์ฐ ๊ธฐ๋ณธ๊ฐ์ธ 0์ ๋ฐํํ๊ณ , ์กด์ฌํ๋ค๋ฉด ํด๋น input์ key๊ฐ์ผ๋ก ๊ฐ์ง๋ value๋ฅผ ๋ฐํํด์ฃผ๊ธฐ ๋๋ฌธ์, ์กฐ๊ฑด๋ฌธ์ ๋ฐ๋ก ์ฌ์ฉํ์ง ์์๋ ๋๋ค.
for (int i = 0; i < M; i++) {
int input = sc.nextInt();
result.append(countMap.getOrDefault(input, 0)).append(" ");
}
๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ ๋๋ ๋ง์ฐฌ๊ฐ์ง๋ก getOrDefault()
๋ฅผ ์ฌ์ฉํด ์ฃผ๋ฉด, ์กฐ๊ฑด๋ฌธ์ ์ฌ์ฉํ์ง ์๊ณ ๋ ๊ตฌํํ ์ ์๋ค.
์๊ธ๋ใ ...์์ฐจ์ฐจ ๊ฐ๋ฐ ๊ณ ์๊ฐ ๋๋ ๊ทธ๋ ๊น์ง...!