๋ฐฑ์ค 1068 ํธ๋ฆฌ[JAVA]
- -
๐๋งํฌ
1068 ํธ๋ฆฌ Gold5
โ ๏ธ๋ฌธ์
ํธ๋ฆฌ์์ ๋ฆฌํ ๋ ธ๋๋, ์์์ ๊ฐ์๊ฐ 0์ธ ๋ ธ๋๋ฅผ ๋งํ๋ค.
ํธ๋ฆฌ๊ฐ ์ฃผ์ด์ก์ ๋, ๋ ธ๋ ํ๋๋ฅผ ์ง์ธ ๊ฒ์ด๋ค. ๊ทธ ๋, ๋จ์ ํธ๋ฆฌ์์ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋ ธ๋๋ฅผ ์ง์ฐ๋ฉด ๊ทธ ๋ ธ๋์ ๋ ธ๋์ ๋ชจ๋ ์์์ด ํธ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ ํธ๋ฆฌ๊ฐ ์๋ค๊ณ ํ์.

ํ์ฌ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ 3๊ฐ์ด๋ค. (์ด๋ก์ ์์น ๋ ๋ ธ๋) ์ด๋, 1๋ฒ์ ์ง์ฐ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด ๋ณํ๋ค. ๊ฒ์ ์์ผ๋ก ์์น ๋ ๋ ธ๋๊ฐ ํธ๋ฆฌ์์ ์ ๊ฑฐ๋ ๋ ธ๋์ด๋ค.

์ด์ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ 1๊ฐ์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ํธ๋ฆฌ์ ๋ ธ๋์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. N์ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค์๋ 0๋ฒ ๋ ธ๋๋ถํฐ N-1๋ฒ ๋ ธ๋๊น์ง, ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ๊ฐ ์ฃผ์ด์ง๋ค. ๋ง์ฝ ๋ถ๋ชจ๊ฐ ์๋ค๋ฉด (๋ฃจํธ) -1์ด ์ฃผ์ด์ง๋ค. ์ ์งธ ์ค์๋ ์ง์ธ ๋ ธ๋์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ํธ๋ฆฌ์์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ธ๋๋ฅผ ์ง์ ์ ๋, ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
๐๋ถ์
์ฒ์ ๋ด์ฉ์ ๋ดค์ ๋, ๊ฐ๋ ์ด ์ ๋์จํ์ธ๋๋ ๋น์ทํ ๋๋์ด ์๋๊น ์ถ์ด์, ๋น์ทํ ๊ฐ๋ ์ผ๋ก ๊ตฌํํด ๋ณด์๋ค. ๋จผ์ ๋ถ๋ชจ ๋ ธ๋๋ฅผ ์ ๋ ฅ๋ฐ์ผ๋ฉด์ ํด๋น ๋ถ๋ชจ์ ์์ ๊ฐ์๋ฅผ ๋ฐ๋ ๋ฐฐ์ด์ ์ ์ธํ๊ณ ์์์ ๊ฐ์๋ฅผ ๊ธฐ๋กํ๋ค. ์ด๋ ๊ฒ ํ๋ ์ด์ ๋ ํด๋น ๋ ธ๋๊ฐ ๋ฆฌํ๋ ธ๋์ธ์ง ์๋์ง ์ฒดํฌ๋ฅผ ํด์ผํ๊ธฐ ๋๋ฌธ์ด๋ค. ์ดํ, ํน์ ๋ ธ๋๊ฐ ์ง๋ช ๋์์ ๋ ํด๋น ๋ ธ๋์ ๋ถ๋ชจ๋ฅผ ๋๋๋ค. ๋ํ ๋ถ๋ชจ๋ฅผ ๋์์ผ๋ ํด๋น ๋ถ๋ชจ์ ์์ ์๋ -1์ ๊ธฐ๋กํด์ค๋ค.
์ด์ ๋ชจ๋ ๋ ธ๋๋ฅผ ์ํํ๋ฉด์, ๋ฆฌํ๋ ธ๋์ธ์ง ์ฒดํฌ๋ฅผํ๊ณ ํด๋น ๋ ธ๋์ ์ต ์๋จ ๋ถ๋ชจ๊ฐ ๋ฃจํธ ๋ ธ๋๋ผ๋ฉด ๋ชจ๋ ์กฐ๊ฑด์ ๋ถํฉํ๋ฏ๋ก ๊ฒฐ๊ณผ๊ฐ์ +1์ ํด์ฃผ๋ฉด ๋๋ค.
1. ๋ณ์ ์ ์ธ์ ์๋ ์ฝ๋์ ๊ฐ์ด ํ์๋ค. ๋ถ๋ชจ๋ ธ๋๋ฅผ ๊ธฐ๋กํ๋ parent๋ฐฐ์ด, ์์๋ ธ๋์ ๊ฐ์๋ฅผ ๋ํ๋ด๋ haveChildNode๋ฐฐ์ด์ ์ ์ธํ์ฌ ๋ฆฌํ๋ ธ๋์ธ์ง ์ฒดํฌํ๋๋ฐ ํ์ฉํ ๊ฒ์ด๋ค.
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st;
static int[] parent;
static int[] haveChildNode;
static int N, removeNode, result = 0;
2. ๋ค์์ ๋ถ๋ชจ๋ ธ๋๋ฅผ ๊ธฐ๋กํ๋ฉด์ ๋ถ๋ชจ๋ ธ๋์ ์์์ ๊ฐ์๋ฅผ ์นด์ดํธ ํด์ค๋ค. ๋ฃจํธ๋ ธ๋์ ์ซ์ -1์ผ ๊ฒฝ์ฐ ๋ฐฐ์ด์ด๊ณผ๊ฐ ๋๋ ์์ธ์ฒ๋ฆฌ๋ฅผ ์ ํด์ฃผ์ด์ผํ๋ค.
for (int i = 0; i < N; i++) {
int parentNode = Integer.parseInt(st.nextToken());
parent[i] = parentNode;
if (parentNode != -1) {
haveChildNode[parentNode]++;
}
}
3. ์ญ์ ํ ๋ ธ๋๋ฅผ ์ ๋ ฅ๋ฐ๊ณ , ํด๋น ๋ ธ๋๋ฅผ ๋์ด ๋ผ ๊ฒ์ด๋ ํด๋น ๋ ธ๋๊ฐ ๋ฃจํธ๋ ธ๋๊ฐ ์๋๋ผ๋ฉด, ํด๋น ๋ ธ๋์ ๋ถ๋ชจ๊ฐ ๊ฐ์ง ์์์ ์๋ฅผ 1 ๊ฐ์์ํค๊ณ , ๋ถ๋ชจ์ ๊ฐ์ ์๋ฏธ์๋ ๊ฐ -2๋ฅผ ์ง์ด๋ฃ๋๋ค. ์ดํ ๋ชจ๋ ๋ ธ๋๋ฅผ ์ํํ๋ฉฐ ๋ฆฌํ๋ ธ๋ ์ด๋ฉด์ ์ต์์ ๋ถ๋ชจ๊ฐ -1์ธ ๊ฒฝ์ฐ(์ต์์ ๋ ธ๋๊ฐ ๋ฃจํธ๋ ธ๋, ๋ง์ฝ ๋์ด๋ธ ๋ ธ๋๊ฐ ๋ถ๋ชจ๋ผ๋ฉด -2๋ฅผ ๋ฐํํ ๊ฒ์ด๋ค.)์ ์๊ฐ ํด๋น ๋ ๋, ๊ฒฐ๊ณผ ๊ฐ์ ์ฆ๊ฐ์ํจ๋ค.
removeNode = Integer.parseInt(br.readLine());
if(parent[removeNode] >= 0){
haveChildNode[parent[removeNode]]--;
}
parent[removeNode] = -2;
for (int i = 0; i < N; i++) {
if(haveChildNode[i] == 0 && findParent(i) == -1){
result++;
}
}
4.๋ถ๋ชจ๋ฅผ ์ฐพ๋ ๋ก์ง์ด๋ค. ์ฌ๊ท์ ์ผ๋ก ๋ถ๋ชจ๋ฅผ ์ฐพ๊ณ ํด๋น ์ต์์ ๋ถ๋ชจ๊ฐ -1์ด๊ฑฐ๋ -2์ผ ๊ฒฝ์ฐ(0๋ณด๋ค ์์ ๊ฒฝ์ฐ) ํด๋น ์ซ์๋ฅผ ๋ฐํํ๋ค. -1์ ๋ฐํํ๋๊ฒ์ ๋ฃจํธ๋ ธ๋๊ฐ ์ ์์ ์ธ ๋ฃจํธ๋ ธ๋์ธ ๊ฒ์ด๋ฉฐ, -2๋ฅผ ๋ฐํํ๋ ๊ฒฝ์ฐ๋ ๋ฃจํธ๋ ธ๋๊ฐ ๋์ด์ง ๋ ธ๋์ด๋ฏ๋ก ์นด์ดํธ ๋์ง ์์ ๊ฒ์ด๋ค.
public static int findParent(int node){
if(node < 0){
return node;
}
return findParent(parent[node]);
}
โ์ ์ฒด ์ฝ๋
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.StringTokenizer;
public class Main {
static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
static StringTokenizer st;
static int[] parent;
static int[] haveChildNode;
static int N, removeNode, result = 0;
public static void main(String[] args) throws IOException {
N = Integer.parseInt(br.readLine());
parent = new int[N];
haveChildNode = new int[N];
st = new StringTokenizer(br.readLine());
for (int i = 0; i < N; i++) {
int parentNode = Integer.parseInt(st.nextToken());
parent[i] = parentNode;
if (parentNode != -1) {
haveChildNode[parentNode]++;
}
}
removeNode = Integer.parseInt(br.readLine());
if(parent[removeNode] >= 0){
haveChildNode[parent[removeNode]]--;
}
parent[removeNode] = -2;
for (int i = 0; i < N; i++) {
if(haveChildNode[i] == 0 && findParent(i) == -1){
result++;
}
}
System.out.println(result);
}
public static int findParent(int node){
if(node < 0){
return node;
}
return findParent(parent[node]);
}
}
๐๊ฒฐ๊ณผ
์ด๋ฐ์ ๋ฃจํ ๋ ธ๋๋ฅผ ์ญ์ ํ ๋ ์ญ์ ๋ ธ๋์ ๋ถ๋ชจ๋ ธ๋๋ ๋ฆฌํ๋ ธ๋๊ฐ ๋ ์ ์๊ธฐ์ ์์ ์๋ฅผ ๊ฐ์์์ผ์ผ ํ๋๋ฐ ์ ๊ฒฝ์ ๋ชป์จ์ ํ ๋ฒ ํ๋ ธ๋ค. ๊ทธ๋๋ ์ง๊ด์ ์ธ ๋ฌธ์ ์ฌ์ ๋น ๋ฅด๊ฒ ํด๊ฒฐ ํ์ง๋ง, ์์ผ๋ก ๊ผผ๊ผผํ๊ฒ ํ์ด์ผ ํ๋ค๊ณ ๋๊ผ๋ค.
'Algorithm' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๋ฐฑ์ค 2668 ์ซ์๊ณ ๋ฅด๊ธฐ[JAVA] (0) | 2023.09.26 |
---|---|
๋ฐฑ์ค 1106 ํธํ [JAVA] (0) | 2023.08.02 |
๋ฐฑ์ค 1765 ๋ญ์ธ์ ํ ์ ํ๊ธฐ[JAVA] (0) | 2023.08.02 |
๋ฐฑ์ค 18430 ๋ฌด๊ธฐ๊ณตํ[JAVA] (0) | 2023.07.29 |
์์คํ ๊ณต๊ฐ ๊ฐ์ฌํฉ๋๋ค