์ค ์ธ์ฐ๊ธฐ
๊ณจ๋ 3
N๋ช ์ ํ์๋ค์ ํค ์์๋๋ก ์ค์ ์ธ์ฐ๋ ค๊ณ ํ๋ค. ๊ฐ ํ์์ ํค๋ฅผ ์ง์ ์ฌ์ ์ ๋ ฌํ๋ฉด ๊ฐ๋จํ๊ฒ ์ง๋ง, ๋ง๋ ํ ๋ฐฉ๋ฒ์ด ์์ด์ ๋ ํ์์ ํค๋ฅผ ๋น๊ตํ๋ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๊ธฐ๋ก ํ์๋ค. ๊ทธ๋๋ง๋ ๋ชจ๋ ํ์๋ค์ ๋ค ๋น๊ตํด ๋ณธ ๊ฒ์ด ์๋๊ณ , ์ผ๋ถ ํ์๋ค์ ํค๋ง์ ๋น๊ตํด ๋ณด์๋ค.
์ผ๋ถ ํ์๋ค์ ํค๋ฅผ ๋น๊ตํ ๊ฒฐ๊ณผ๊ฐ ์ฃผ์ด์ก์ ๋, ์ค์ ์ธ์ฐ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
์ฒซ์งธ ์ค์ N(1 โค N โค 32,000), M(1 โค M โค 100,000)์ด ์ฃผ์ด์ง๋ค. M์ ํค๋ฅผ ๋น๊ตํ ํ์์ด๋ค. ๋ค์ M๊ฐ์ ์ค์๋ ํค๋ฅผ ๋น๊ตํ ๋ ํ์์ ๋ฒํธ A, B๊ฐ ์ฃผ์ด์ง๋ค. ์ด๋ ํ์ A๊ฐ ํ์ B์ ์์ ์์ผ ํ๋ค๋ ์๋ฏธ์ด๋ค.
ํ์๋ค์ ๋ฒํธ๋ 1๋ฒ๋ถํฐ N๋ฒ์ด๋ค.
์ฒซ์งธ ์ค์ ํ์๋ค์ ์์์๋ถํฐ ์ค์ ์ธ์ด ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ค. ๋ต์ด ์ฌ๋ฌ ๊ฐ์ง์ธ ๊ฒฝ์ฐ์๋ ์๋ฌด๊ฑฐ๋ ์ถ๋ ฅํ๋ค.
3 2
1 3
2 3
1 2 3
์์์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ
์์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์์๊ฐ ์ ํด์ ธ ์๋ ์ผ๋ จ์ ์์
์ ์ฐจ๋ก๋๋ก ์ฒ๋ฆฌํด์ผํ ๋ ์ฌ์ฉํ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
ํด๋น ๋ฌธ์ ๋ ์์๋๋ก ์ค์ ์ธ์์ผํ๋ ๊ฒฝ์ฐ์ด๊ธฐ ๋๋ฌธ์ ์์์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ผ๋ก ํ์ด๋ผ ์ ์๋ค.
์ด ๋ฌธ์ ์์ 1๋ฒ์ ํน์ ํ์ ์์ ์๋ ํ์์ ์๋ฅผ ๋ํ๋ด๊ณ ,
2๋ฒ์ ํน์ ํ์ ๋ค์ ์์ผ ํ๋ ํ์๋ค์ ๋ชฉ๋ก์ ๋ฆฌ์คํธ๋ก ๋ํ๋ธ๋ค.
์ดํ์ ํ๋ฅผ ์์ฑํ๊ณ , ์ง์
์ฐจ์๊ฐ 0์ธ ๋
ธ๋๋ค์ ํ์ ๋ฃ๋๋ค.
์ง์
์ฐจ์๊ฐ 0์ด๋ผ๋ ๋ป์ ์ ์ผ ์์ ์ฌ ์ ์๋ค๋ ๋ป์ด๋ค.
๊ทธ ๋ค์ q๋ฅผ ๋๋ฉด์ ํ์ฌ ๋
ธ๋์ ์ฐ๊ฒฐ๋ ๋ฆฌ์คํธ์ ์ง์
์ฐจ์๋ฅผ -1 ์ฒ๋ฆฌ๋ฅผ ํด์ค๋ค.
๊ทธ๋ฆฌ๊ณ ์ฐ๊ฒฐ๋ ๋
ธ๋์ ์ง์
์ฐจ์๊ฐ 0์ด ๋๋ฉด ํด๋น ๋
ธ๋๋ฅผ ํ์ ์ฝ์
ํ๋ค.

package Algorithm;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
public class backjoon_์ค์ธ์ฐ๊ธฐ {
public static void main(String[] args) throws FileNotFoundException {
System.setIn(new FileInputStream("src/input.txt"));
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int M = sc.nextInt();
//์ง์
์ฐจ์๋ฅผ ๋ฃ์ ๋ฐฐ์ด ๋ง๋ค๊ธฐ
int[] inDegrees = new int[N +1];
//์ฐ๊ฒฐ๋ ๊ฐ์ ์ ๋ด์ linkedList ๋ง๋ค๊ธฐ
LinkedList<Integer>[] map= new LinkedList[N+1];
for (int i = 0; i < N + 1; i++) {
map[i] = new LinkedList<>();
}
//์ฐ๊ฒฐ๋ ๊ฐ์ ์ถ๊ฐ
for (int i = 0; i < M; i++) {
int pre = sc.nextInt();
int next = sc.nextInt();
//์ฐ๊ฒฐ๋ ๊ฐ์ ์ถ๊ฐ
map[pre].add(next);
//์ง์
์ฐจ์ ์ถ๊ฐ
inDegrees[next] += 1;
}
//ํ ์์ฑ
Queue<Integer> q = new LinkedList<>();
//์ง์
์ฐจ์๊ฐ 0์ธ ๊ฒ๋ค ํ์ ๋ฃ๊ธฐ
for (int i = 1; i < N +1; i++) {
if (inDegrees[i] == 0) {
q.offer(i);
}
}
List<Integer> answer = new ArrayList<>();
//ํ์์ ํ๋์ฉ ๋นผ๋ฉด์ ์ง์
์ฐจ์ 0์ธ ๊ฑฐ ์ ๋ต ๋ฆฌ์คํธ์ ์ถ๊ฐํ๊ธฐ
while(!q.isEmpty()) {
int curr = q.poll();
answer.add(curr);
//์ฐ๊ฒฐ๋ ๋ฆฌ์คํธ์ ์ง์
์ฐจ์๋ฅผ -1 ์ฒ๋ฆฌํ๊ธฐ
for (int i = 0; i < map[curr].size(); i++) {
int next = map[curr].get(i);
inDegrees[next] -= 1;
if (inDegrees[next] == 0) {
q.offer(next);
}
}
}
//์ ๋ต ์ถ๋ ฅ
for (int i = 0; i < answer.size(); i++) {
System.out.print(answer.get(i) + " ");
}
}
}