๋ฌธ์
ํธ๋ฆฌ์์ย ๋ฆฌํย ๋
ธ๋๋,ย ์์์ย ๊ฐ์๊ฐย 0์ธย ๋
ธ๋๋ฅผย ๋งํ๋ค.ย ํธ๋ฆฌ๊ฐย ์ฃผ์ด์ก์ย ๋,ย ๋
ธ๋ย ํ๋๋ฅผย ์ง์ธย ๊ฒ์ด๋ค.ย ๊ทธย ๋,ย ๋จ์ย ํธ๋ฆฌ์์ย ๋ฆฌํย ๋
ธ๋์ย ๊ฐ์๋ฅผย ๊ตฌํ๋ย ํ๋ก๊ทธ๋จ์ย ์์ฑํ์์ค.ย ๋
ธ๋๋ฅผย ์ง์ฐ๋ฉดย ๊ทธย ๋
ธ๋์ย ๋
ธ๋์ย ๋ชจ๋ ย ์์์ดย ํธ๋ฆฌ์์ย ์ ๊ฑฐ๋๋ค.ย ์๋ฅผย ๋ค์ด,ย ๋ค์๊ณผย ๊ฐ์ย ํธ๋ฆฌ๊ฐย ์๋ค๊ณ ย ํ์. ํ์ฌย ๋ฆฌํย ๋
ธ๋์ย ๊ฐ์๋ย 3๊ฐ์ด๋ค.ย (์ด๋ก์ย ์์น ๋ย ๋
ธ๋)ย ์ด๋,ย 1๋ฒ์ย ์ง์ฐ๋ฉด,ย ๋ค์๊ณผย ๊ฐ์ดย ๋ณํ๋ค.ย ๊ฒ์ ์์ผ๋กย ์์น ๋ย ๋
ธ๋๊ฐย ํธ๋ฆฌ์์ย ์ ๊ฑฐ๋ย ๋
ธ๋์ด๋ค. ์ด์ ย ๋ฆฌํย ๋
ธ๋์ย ๊ฐ์๋ย 1๊ฐ์ด๋ค.
์
๋ ฅ
์ฒซ์งธ ์ค์ ํธ๋ฆฌ์ ๋
ธ๋์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. N์ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค์๋ 0๋ฒ ๋
ธ๋๋ถํฐ N-1๋ฒ ๋
ธ๋๊น์ง, ๊ฐ ๋
ธ๋์ ๋ถ๋ชจ๊ฐ ์ฃผ์ด์ง๋ค. ๋ง์ฝ ๋ถ๋ชจ๊ฐ ์๋ค๋ฉด (๋ฃจํธ) -1์ด ์ฃผ์ด์ง๋ค. ์
์งธ ์ค์๋ ์ง์ธ ๋
ธ๋์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง ํธ๋ฆฌ์์ ์
๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋
ธ๋๋ฅผ ์ง์ ์ ๋, ๋ฆฌํ ๋
ธ๋์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์
โ
์
๋ ฅ 1
โ
์ถ๋ ฅ 1
โ
์
๋ ฅ 2
โ
์ถ๋ ฅ 2
โ
์
๋ ฅ 3
โ
์ถ๋ ฅ 3
โ
์
๋ ฅ 4
1
2
3
| 9
-1 0 0 2 2 4 4 6 6
4
|
โ
์ถ๋ ฅ 4
์์ฑ ์ฝ๋
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
| import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;
public class Main {
// ์ ์ญ ๋ณ์
static Map<Integer, List<Integer>> tree;
static int remove;
/**
* ๋ฉ์ธ ๋ฉ์๋
* @param args
* @throws IOException
*/
public static void main(String[] args) throws IOException {
// 1. ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
int n = Integer.parseInt(br.readLine());
int[] data = Arrays.stream(br.readLine().split("\\s+"))
.mapToInt(Integer::parseInt)
.toArray();
remove = Integer.parseInt(br.readLine());
int root = -1;
// 2. ํธ๋ฆฌ ์์ฑ
tree = new HashMap<>();
for (int i = 0; i < n; i++) {
// ๋ฃจํธ ์ถ์ถ
if (data[i] == -1) {
root = i;
continue;
}
// ํธ๋ฆฌ ์์ฑ ์ฒ๋ฆฌ
tree.putIfAbsent(data[i], new ArrayList<>());
tree.get(data[i]).add(i);
}
// 3. ๋
ธ๋ ์ญ์
if (data[remove] != -1 && tree.containsKey(data[remove])) {
tree.get(data[remove]).remove((Integer) remove);
}
// 4. ์ถ๋ ฅ
System.out.println((remove == root) ? 0 : dfs(root));
}
/**
* DFS ์ฒ๋ฆฌ
* @param node
* @return
*/
private static int dfs(int node) {
// 1. ์ญ์ ๋
ธ๋์ผ ๊ฒฝ์ฐ
if (node == remove) return 0;
// 2. ๋ฆฌํ ๋
ธ๋์ผ ๊ฒฝ์ฐ
if (!tree.containsKey(node) || tree.get(node).isEmpty()) return 1;
// 3. DFS ์ฒ๋ฆฌ
int count = 0;
for (int child : tree.get(node)) {
count += dfs(child);
}
// 4. ๋ฐํ
return count;
}
}
|
HashMap
์ ํตํด ํธ๋ฆฌ๋ฅผ ๊ตฌ์ฑํ๋ค.- ์์ ๋ง ์๊ฐํ๋ฉด ํท๊ฐ๋ฆด ์ ์๋ ๋ถ๋ถ์ด ์์๋ค.
-1
์ด ๋งจ ์์ ๋์ฌ ๊ฒ์ฒ๋ผ ๋์ด ์์ง๋ง ์ค์ ์ผ์ด์ค์์๋ ๋ค์์๋ ๋์ฌ ์ ์๋ค.
ํ๊ณ
- ๋ฉ๋ชจ๋ฆฌย ์ธก๋ฉด์์ ์์ ๊ฐ์ด ๊ฐ์ ํ ์ ์๋ค๊ณ ํ๋ค.