- Today
- Total
- ์์์ ๋ ฌ
- Graph
- OOP
- dp
- ์๋ฐ์์ ์
- Algorithm
- ์ธํด
- ๊ตฌํ
- CS
- ๋ฐฑ์๋
- ๋ค์ต์คํธ๋ผ
- ์๋ฃ๊ตฌ์กฐ
- array
- ์กธ์ ์ํ
- java
- spring
- ๋ฒจ๋งํฌ๋
- ๋ฐฑ์ค
- MST
- database
- leetcode
- PS
- ๋ฌธ๋ฒ
- ๋ฐ์ดํฐ๋ฒ ์ด์ค
- tree
- BFS
- ๊ทธ๋ฆฌ๋
- ํ๋ก๊ทธ๋๋จธ์ค
- pytorch
- ์๋ฐ
Partially Committed
[๋ฐฑ์ค 1068] ํธ๋ฆฌ (JAVA) ๋ณธ๋ฌธ
https://www.acmicpc.net/problem/1068
๋ฌธ์
ํธ๋ฆฌ์์ ๋ฆฌํ ๋ ธ๋๋, ์์์ ๊ฐ์๊ฐ 0์ธ ๋ ธ๋๋ฅผ ๋งํ๋ค.
ํธ๋ฆฌ๊ฐ ์ฃผ์ด์ก์ ๋, ๋ ธ๋ ํ๋๋ฅผ ์ง์ธ ๊ฒ์ด๋ค. ๊ทธ ๋, ๋จ์ ํธ๋ฆฌ์์ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋ ธ๋๋ฅผ ์ง์ฐ๋ฉด ๊ทธ ๋ ธ๋์ ๋ ธ๋์ ๋ชจ๋ ์์์ด ํธ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ ํธ๋ฆฌ๊ฐ ์๋ค๊ณ ํ์.
ํ์ฌ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ 3๊ฐ์ด๋ค. (์ด๋ก์ ์์น ๋ ๋ ธ๋) ์ด๋, 1๋ฒ์ ์ง์ฐ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด ๋ณํ๋ค. ๊ฒ์ ์์ผ๋ก ์์น ๋ ๋ ธ๋๊ฐ ํธ๋ฆฌ์์ ์ ๊ฑฐ๋ ๋ ธ๋์ด๋ค.
์ด์ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ 1๊ฐ์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ํธ๋ฆฌ์ ๋ ธ๋์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. N์ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค์๋ 0๋ฒ ๋ ธ๋๋ถํฐ N-1๋ฒ ๋ ธ๋๊น์ง, ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ๊ฐ ์ฃผ์ด์ง๋ค. ๋ง์ฝ ๋ถ๋ชจ๊ฐ ์๋ค๋ฉด (๋ฃจํธ) -1์ด ์ฃผ์ด์ง๋ค. ์ ์งธ ์ค์๋ ์ง์ธ ๋ ธ๋์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ํธ๋ฆฌ์์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ธ๋๋ฅผ ์ง์ ์ ๋, ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
์์ ์ ๋ ฅ 1
5
-1 0 0 1 1
2
์์ ์ถ๋ ฅ 1
2
์์ ์ ๋ ฅ 2
5
-1 0 0 1 1
1
์์ ์ถ๋ ฅ 2
1
์์ ์ ๋ ฅ 3
5
-1 0 0 1 1
0
์์ ์ถ๋ ฅ 3
0
์์ ์ ๋ ฅ 4
9
-1 0 0 2 2 4 4 6 6
4
์์ ์ถ๋ ฅ 4
2
ํธ๋ฆฌ์์ ํน์ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ์์ ๋, ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ฉด ๋๋ค.
๋ง์ฝ์ ๋ฃจํธ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋ฉด 0์ ์ถ๋ ฅํ๋ค. ( ์์ธ ์ฒ๋ฆฌ )
๋ฃจํธ ๋ ธ๋ ์ด์ธ์ ๋ ธ๋๋ฅผ ์ ๊ฑฐํ๋ ๊ฒฝ์ฐ์๋,
dfs(๋ฃจํธ ๋ ธ๋) ๋ฅผ ์ํํ์ฌ
์ญ์ ํ ๋ ธ๋๋ฅผ ํ์ํ์ง ์๋๋ค๋ ์กฐ๊ฑด์ ์ถ๊ฐํ์ฌ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ์นด์ดํ ํด์ฃผ๋ฉด ๋๋ค.
๋ฆฌํ๋ ธ๋์ ๊ฐ์๋ฅผ ์นด์ดํ ํ๋ ๊ฒ์ ๊ฐ๋จํ๋ค.
int nodes = 0 ; ์ด๋ผ๊ณ ์์ ๋ ธ๋์ ๊ฐ์๋ฅผ ์นด์ดํ ํ๋ ๋ณ์๋ฅผ ์ ์ธํ์.
dfs ( v ) ๋ผ๊ณ ํ์ ๋,
v ์ ์ฐ๊ฒฐ๋ ์์ง ๋ฐฉ๋ฌธํ์ง ์์ ๋ ธ๋๋ฅผ ์ฐพ๊ณ nodes ๋ฅผ ํ๋ ์ฆ๊ฐํด์ค ๋ค์์, ํด๋น ๋ ธ๋๋ฅผ ์ฌ๊ท์ ์ผ๋ก ๋ฐฉ๋ฌธํ๋๋ก ํ๋ค.
dfs ํจ์๊ฐ ์ข ๋ฃ๋ ๋, nodes ์ ์ ์ฅ๋ ๊ฐ์ ํ์ธํ๋ค.
์ด๋ nodes ์ ์ ์ฅ๋ ๊ฐ์ด 0 ์ด๋ฉด ํด๋น dfs ํจ์๋ฅผ ์ฌ๊ท์ ์ผ๋ก ์คํ์ํจ(?) ๋ ธ๋๋ ์์ ๋ ธ๋๊ฐ ๋จ ํ๋๋ ์๋ ๋ฆฌํ ๋ ธ๋๋ผ๋ ๊ฒ์ด๋ค.
๊ทธ๋ฌ๋ฏ๋ก nodes ๊ฐ 0 ์ธ ๊ฒฝ์ฐ์๋ง ans ๋ฅผ ์ฆ๊ฐ์์ผ์ฃผ๋ฉด ๋๋ค.
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;
import java.util.StringTokenizer;
public class Main {
static ArrayList<Integer>[] graph;
static boolean visited[];
static int delete;
static int parent[];
static int ans;
public static void main(String[] args) throws IOException {
//System.setIn(new FileInputStream("src/input.txt"));
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
StringTokenizer stk;
int n = Integer.parseInt(br.readLine()); // ๋
ธ๋์ ๊ฐ์
graph = new ArrayList[n + 1];
visited = new boolean[n + 1];
parent = new int[n + 1];
for (int i = 0; i < n; i++)
graph[i] = new ArrayList<>();
int root = -1;
stk = new StringTokenizer(br.readLine());
for (int i = 0; i < n; i++) {
int p = Integer.parseInt(stk.nextToken());
if (p == -1) {
// i ๋
ธ๋๊ฐ ๋ฐ๋ก ๋ฃจํธ ๋
ธ๋
root = i; // ๋ฃจํธ ๋
ธ๋ ์ ๋ณด๋ฅผ ์ ์ฅํจ
} else {
// p ๊ฐ i ๋
ธ๋์ ๋ถ๋ชจ ๋
ธ๋์
graph[i].add(p);
graph[p].add(i); // ์๋ก ์ฐ๊ฒฐ
}
}
delete = Integer.parseInt(br.readLine());
if (delete == root) {
System.out.println(0);
return;
} else dfs(root);
System.out.println(ans);
}
static void dfs(int v) {
visited[v] = true;
int nodes = 0;
for (int cur : graph[v]) {
// ์ฐ๊ฒฐ ๋
ธ๋ ํ์
if (cur != delete && !visited[cur]) {
nodes++;
dfs(cur);
}
}
if (nodes == 0) {
ans++; // ์์ ๋
ธ๋๊ฐ ํ๋๋ ์์ผ๋ฉด ๋ฆฌํ ๋
ธ๋์
}
}
}
'๐ฅ Algorithm || ๋ฌธ์ ํ์ด > PS' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค 1256] ์ฌ์ (JAVA) (0) | 2023.01.26 |
---|---|
[๋ฐฑ์ค 1991] ํธ๋ฆฌ ์ํ (JAVA) (0) | 2023.01.22 |
[๋ฐฑ์ค 1414] ๋ถ์ฐ์ด์๋๊ธฐ (JAVA) (0) | 2023.01.20 |
[๋ฐฑ์ค 17472] ๋ค๋ฆฌ ๋ง๋ค๊ธฐ2 (JAVA) (0) | 2023.01.19 |
[๋ฐฑ์ค 1197] ์ต์ ์คํจ๋ ํธ๋ฆฌ (JAVA) (0) | 2023.01.19 |