๋ฌธ์ (์ถ์ฒ: https://www.acmicpc.net/problem/1068)
<ํธ๋ฆฌ>
๋ฌธ์
ํธ๋ฆฌ์์ ๋ฆฌํ ๋ ธ๋๋, ์์์ ๊ฐ์๊ฐ 0์ธ ๋ ธ๋๋ฅผ ๋งํ๋ค.
ํธ๋ฆฌ๊ฐ ์ฃผ์ด์ก์ ๋, ๋ ธ๋ ํ๋๋ฅผ ์ง์ธ ๊ฒ์ด๋ค. ๊ทธ๋, ๋จ์ ํธ๋ฆฌ์์ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ๊ตฌํ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค. ๋ ธ๋๋ฅผ ์ง์ฐ๋ฉด ๊ทธ ๋ ธ๋์ ๋ ธ๋์ ๋ชจ๋ ์์์ด ํธ๋ฆฌ์์ ์ ๊ฑฐ๋๋ค.
์๋ฅผ ๋ค์ด, ๋ค์๊ณผ ๊ฐ์ ํธ๋ฆฌ๊ฐ ์๋ค๊ณ ํ์.
ํ์ฌ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ 3๊ฐ์ด๋ค. (์ด๋ก์ ์์น ๋ ๋ ธ๋) ์ด๋, 1๋ฒ์ ์ง์ฐ๋ฉด, ๋ค์๊ณผ ๊ฐ์ด ๋ณํ๋ค. ๊ฒ์ ์์ผ๋ก ์์น ๋ ๋ ธ๋๊ฐ ํธ๋ฆฌ์์ ์ ๊ฑฐ๋ ๋ ธ๋์ด๋ค.
์ด์ ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ 1๊ฐ์ด๋ค.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ํธ๋ฆฌ์ ๋ ธ๋์ ๊ฐ์ N์ด ์ฃผ์ด์ง๋ค. N์ 50๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋์งธ ์ค์๋ 0๋ฒ ๋ ธ๋๋ถํฐ N-1๋ฒ ๋ ธ๋๊น์ง, ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ๊ฐ ์ฃผ์ด์ง๋ค. ๋ง์ฝ ๋ถ๋ชจ๊ฐ ์๋ค๋ฉด (๋ฃจํธ) -1์ด ์ฃผ์ด์ง๋ค. ์ ์งธ ์ค์๋ ์ง์ธ ๋ ธ๋์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
์ฒซ์งธ ์ค์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ํธ๋ฆฌ์์ ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง ๋ ธ๋๋ฅผ ์ง์ ์ ๋, ๋ฆฌํ ๋ ธ๋์ ๊ฐ์๋ฅผ ์ถ๋ ฅํ๋ค.
๋ฌธ์ ํ์ด
- my solution (Python)
import sys
def delnode(graph, start):
queue=[start]
while queue:
temp=queue.pop(0)
for i in graph[temp]: # ์ง์ธ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋
ธ๋
queue.append(i)
del graph[temp]
if __name__ =='__main__':
n=int(input()) # ๋
ธ๋์ ๊ฐ์
graph={}
for i in range(n):
graph[i]=[]
info=list(map(int, sys.stdin.readline().split())) # ๊ฐ ๋
ธ๋์ ๋ถ๋ชจ
for i in range(len(info)):
if info[i]==-1: # ๋ฃจํธ
pass
else:
graph[info[i]].append(i)
d=int(input()) # ์ง์ธ ๋
ธ๋์ ๋ฒํธ
answer=0 # ๋ฆฌํ ๋
ธ๋์ ๊ฐ์
delnode(graph, d)
for key,value in graph.items():
if d in value: # ๋
ธ๋ ์ง์
graph[key].remove(d)
if len(value)==0: # ๋ฆฌํ ๋
ธ๋ ๊ฐ์
answer+=1
print(answer)
- my solution (JAVA)
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Scanner;
public class Main {
static int answer=0; //๋ฆฌํ ๋
ธ๋์ ๊ฐ์
static void delnode(HashMap graph, int d ) {
List<Integer> queue=new ArrayList<>();
queue.add(d);
while(queue.size()!=0) { // queue๊ฐ ๋น ๋๊น์ง
int temp=queue.remove(0);
List<Integer>a=(List<Integer>) graph.get(temp);
if(a.size()>0) { // ์ง์ธ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋
ธ๋
for(int i=0; i<a.size(); i++) {
queue.add(a.get(i));
}
}
graph.remove(temp);
}
}
public static void main(String[] args) {
Scanner input=new Scanner(System.in);
HashMap<Integer, List> graph=new HashMap<>();
int n=input.nextInt(); // ๋
ธ๋์ ๊ฐ์
for(int i=0; i<n; i++) {
List<Integer> a=new ArrayList<>();
graph.put(i, a);
}
int info[]=new int[n];
for(int i=0; i<n; i++) { // ๊ฐ ๋
ธ๋์ ๋ถ๋ชจ
info[i]=input.nextInt();
}
for(int i=0; i<info.length; i++) {
if(info[i]==-1) { // ๋ฃจํธ
continue;
}else {
List<Integer>temp=graph.get(info[i]);
temp.add(i);
graph.put(info[i], temp);
}
}
int d=input.nextInt(); // ์ง์ธ ๋
ธ๋์ ๋ฒํธ
delnode(graph,d);
graph.forEach((key, value) ->{
if(value.contains(d)) { // ์ง์ธ ๋
ธ๋์ ๋ฒํธ๊ฐ ํฌํจ๋์ด์๋ค๋ฉด ์ญ์
List<Integer> delkey=graph.get(key);
delkey.remove(Integer.valueOf(d));
graph.put(key, delkey);
}
if(value.size()==0) { // ๋ฆฌํ ๋
ธ๋์ ๊ฐ์ ์ถ๊ฐ
answer+=1;
}
});
System.out.println(answer);
}
}
- delnode
: ์ฒ์์ queue์ ์ง์ธ ๋ ธ๋์ ๋ฒํธ๋ฅผ ๋ด์ ํ temp์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ queue์ ๋ด๊ณ graph์์ temp๋ฅผ ํค๋ก ๊ฐ์ง ๊ฒ์ ์ญ์ - Main
:๋ ธ๋์ ๊ฐ์, ๊ฐ ๋ ธ๋์ ๋ถ๋ชจ, ์ง์ธ ๋ ธ๋์ ๋ฒํธ ์ ๋ ฅ
: answer = ๋ฆฌํ ๋ ธ๋์ ๊ฐ์
: graph = [key: ๋ ธ๋์ ๋ถ๋ชจ, value: ๋ ธ๋]
: delnode ํธ์ถ ( graph, ์ง์ธ ๋ ธ๋์ ๋ฒํธ)
: graph์๋ ์ง์ธ ๋ ธ๋์ ๋ฒํธ์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ ์ง์ด ํ์ ์ํ๋ก ์กด์ฌ. ์ง์ธ ๋ ธ๋์ ๋ฒํธ๊ฐ value์ ์กด์ฌํ๋์ง ํ์ธ ํ ์กด์ฌํ๋ค๋ฉด value์์ ์ญ์ . value์ ๊ธธ์ด๊ฐ 0์ด๋ผ๋ฉด ๋ฆฌํ ๋ ธ๋์ด๋ฏ๋ก answer +1
โ ์ฒ์์ ์ ํ๋ ธ๋๊ฐ?
์ง์ธ ๋ ธ๋์ ๋ฒํธ๊ฐ ์์ ๋ ธ๋์ ์์๋ ์์ ๋ ธ๋์์ ์ญ์ ํ๋ ๊ฒ์ ๋นผ๋จน์๊ธฐ ๋๋ฌธ์ด๋ค. ๋งจ ์ฒ์ ์์ฑํ ์ฝ๋๋ ์ง์ธ ๋ ธ๋์ ๋ฒํธ๋ฅผ key๊ฐ์ผ๋ก ๊ฐ์ง ๊ฒ์ ์ญ์ ํ๋ฉฐ, ์ง์ธ ๋ ธ๋์ ๋ฒํธ์ ์ฐ๊ฒฐ๋ ๋ ธ๋๋ค์ ์ญ์ ํ๋ ๊ฒ์ด์๋ค. ์ด ๊ฒฝ์ฐ ์ง์ธ ๋ ธ๋์ ๋ฒํธ๋ฅผ value๋ก ๊ฐ์ง ๋ value์์ ์ญ์ ํ์ง ์์ ๋ต์ด ๋ค๋ฅด๊ฒ ๋์๋ ๊ฒ์ด์๋ค.
์๊ฐ๐ค
์ค๋๋ง์ JAVA๋ก๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํด๋ดค๋ค.
๋จผ์ Python์ผ๋ก ๊ตฌํ ํ JAVA๋ก ๊ตฌํํ๋ ๊ฒ์์๋ ์ค๋๋ง์ด๋ผ ์กฐ๊ธ ์ค๋ ๊ฑธ๋ ธ๋ ๊ฒ ๊ฐ๋ค.
'๐Algorithm > ๐ฅBaekjoon' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[Baekjoon] 6198_์ฅ์ ์ ์ ๊พธ๋ฏธ๊ธฐ (0) | 2022.03.29 |
---|---|
[Baekjoon] 2493_ํ (0) | 2022.03.28 |
[Baekjoon] 3190_๋ฑ (0) | 2022.03.23 |
[Baekjoon] 7569_ํ ๋งํ (0) | 2022.03.22 |
[Baekjoon] 7576_ํ ๋งํ (0) | 2022.03.21 |