๐ ์์ ์ ๋ ฌ
์์ ์ ๋ ฌ(topology sort)๋ ์ฌ์ดํด์ด ์๋ ๋ฐฉํฅ ๊ทธ๋ํ์์ ๋ ธ๋ ์์๋ฅผ ์ฐพ๋ ์๊ณ ๋ฆฌ์ฆ์ด๋ค.
ex) A๋ B๋ณด๋ค, C๋ D๋ณด๋ค, B๋ D๋ณด๋ค ์์ ์์ด์ผ ํ๋ค.
๊ฐ๋ฅํ ์์ ์ ๋ ฌ -> (A B C D), (A C B D)
์์ ๊ฐ์ด ์ฌ์ดํด์ด ์๋ ๋ฐฉํฅ ๊ทธ๋ํ ๋ฌธ์ ์์ ์์ ์ ๋ ฌ ์๊ณ ๋ฆฌ์ฆ์ ์ฌ์ฉํ๋ฉฐ ํญ์ ์ ์ผํ ๊ฐ์ผ๋ก ์ ๋ ฌ๋์ง ์๋๋ค.
์ง์ ์ฐจ์(in-degree) ๋ ์๊ธฐ ์์ ์ ๊ฐ๋ฆฌํค๋ ์์ง์ ๊ฐ์๋ค.
๐ ์ง์ ๋ฐฐ์ด ์ ๋ฐ์ดํธ
๋ ธ๋๊ฐ ์ด 5๊ฐ, ์์ง๊ฐ ์๋์ ๊ฐ์ด 6๊ฐ, ์ง์ ์ฐจ์ ๋ฐฐ์ด์ indegree[] ๋ผ๊ณ ํ ๋
1 -> 2, 3 ์ด ๋ ์ง์ ์ฐจ์ ๊ฐ ๊ณ์ฐ indegree[2]++, indegree[3]++
2 -> 4, 5 indegree[4]++, indegree[5]++
3 -> 4 indegree[4]++
4 -> 5 indegree[5]++
indegree[1] = 0,
indegree[2] = indegree[3] = 1,
indegree[4] = indegree[5] = 2
โ๏ธ์ง์ ์ฐจ์๊ฐ 0์ธ ๋ ธ๋๋ฅผ ํ์ ๋ฃ๊ณ poll์ ํ์ฌ ์์ ์ ๋ ฌ ๋ฐฐ์ด์ ์ถ๊ฐํ๋ค. ๊ทธ ํ ์ธ์ ๋ฆฌ์คํธ์์ ์ ํ๋ ๋ ธ๋๊ฐ ๊ฐ๋ฆฌํค๋ ๋ ธ๋๋ค์ ์ง์ ์ฐจ์๋ฅผ 1์ฉ ๋บ๋ค.
queue.add(1);
queue.poll(1);
indegree[2]--;
indegree[3]--;
๋ค์ ์ง์ ์ฐจ์๊ฐ 0์ธ ๋ ธ๋๋ฅผ ํ์ ๋ฃ์ผ๋ฉฐ ์ ๊ณผ์ ์ ํ์ ๊ฐ์ด ์์ด์ง ๋๊น์ง ๋ฐ๋ณตํ๋ค.
์๋๋ N๊ฐ์ ๋ ธ๋๊ฐ ์๊ณ , arr ๋ฐฐ์ด์ ์ธ์ ๋ ธ๋๊ฐ ์ ์ฅ๋์ด ์๊ณ , result ๋ฐฐ์ด๋ก ์์์ ๋ ฌ ๋ ธ๋๋ฅผ ์ ์ฅํ๋ ์์์ ๋ ฌ ๋ฉ์๋ ์ฝ๋์ด๋ค.
static void topoplogySort(){
Queue<Integer> queue = new LinkedList<>();
for (int i = 1; i <= N ; i++) {
if(indegree[i] == 0){
queue.add(i);
result.add(i);
}
}
while(!queue.isEmpty()){
int now = queue.poll();
for (Integer i : arr[now]) {
indegree[i]--;
if(indegree[i] == 0){
queue.add(i);
result.add(i);
}
}
}
}
๐ ๊ฒ์ ๊ฐ๋ฐ - ๋ฐฑ์ค 1516
https://www.acmicpc.net/problem/1516
๋ฌธ์
์ ํ์ฌ์์ ์ด๋ฒ์ ์๋ก์ด ์ ๋ต ์๋ฎฌ๋ ์ด์ ๊ฒ์ ์ธ์ค ํฌ๋ํํธ๋ฅผ ๊ฐ๋ฐํ๊ธฐ๋ก ํ์๋ค. ํต์ฌ์ ์ธ ๋ถ๋ถ์ ๊ฐ๋ฐ์ด ๋๋ ์ํ๊ณ , ์ข ์กฑ๋ณ ๊ท ํ๊ณผ ์ ์ฒด ๊ฒ์ ์๊ฐ ๋ฑ์ ์กฐ์ ํ๋ ๋ถ๋ถ๋ง ๋จ์ ์์๋ค.
๊ฒ์ ํ๋ ์ด์ ๋ค์ด๊ฐ๋ ์๊ฐ์ ์ํฉ์ ๋ฐ๋ผ ๋ค๋ฅผ ์ ์๊ธฐ ๋๋ฌธ์, ๋ชจ๋ ๊ฑด๋ฌผ์ ์ง๋๋ฐ ๊ฑธ๋ฆฌ๋ ์ต์์ ์๊ฐ์ ์ด์ฉํ์ฌ ๊ทผ์ฌํ๊ธฐ๋ก ํ์๋ค. ๋ฌผ๋ก , ์ด๋ค ๊ฑด๋ฌผ์ ์ง๊ธฐ ์ํด์ ๋ค๋ฅธ ๊ฑด๋ฌผ์ ๋จผ์ ์ง์ด์ผ ํ ์๋ ์๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ๊ฐ ๋จ์ํ์ง๋ง์ ์์ ์๋ ์๋ค. ์๋ฅผ ๋ค๋ฉด ์คํํฌ๋ํํธ์์ ๋ฒ์ปค๋ฅผ ์ง๊ธฐ ์ํด์๋ ๋ฐฐ๋ญ์ ๋จผ์ ์ง์ด์ผ ํ๊ธฐ ๋๋ฌธ์, ๋ฐฐ๋ญ์ ๋จผ์ ์ง์ ๋ค ๋ฒ์ปค๋ฅผ ์ง์ด์ผ ํ๋ค. ์ฌ๋ฌ ๊ฐ์ ๊ฑด๋ฌผ์ ๋์์ ์ง์ ์ ์๋ค.
ํธ์์ ์์์ ๋ฌดํํ ๋ง์ด ๊ฐ์ง๊ณ ์๊ณ , ๊ฑด๋ฌผ์ ์ง๋ ๋ช ๋ น์ ๋ด๋ฆฌ๊ธฐ๊น์ง๋ ์๊ฐ์ด ๊ฑธ๋ฆฌ์ง ์๋๋ค๊ณ ๊ฐ์ ํ์.
์ ๋ ฅ
์ฒซ์งธ ์ค์ ๊ฑด๋ฌผ์ ์ข ๋ฅ ์ N(1 ≤ N ≤ 500)์ด ์ฃผ์ด์ง๋ค. ๋ค์ N๊ฐ์ ์ค์๋ ๊ฐ ๊ฑด๋ฌผ์ ์ง๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ๊ณผ ๊ทธ ๊ฑด๋ฌผ์ ์ง๊ธฐ ์ํด ๋จผ์ ์ง์ด์ ธ์ผ ํ๋ ๊ฑด๋ฌผ๋ค์ ๋ฒํธ๊ฐ ์ฃผ์ด์ง๋ค. ๊ฑด๋ฌผ์ ๋ฒํธ๋ 1๋ถํฐ N๊น์ง๋ก ํ๊ณ , ๊ฐ ์ค์ -1๋ก ๋๋๋ค๊ณ ํ์. ๊ฐ ๊ฑด๋ฌผ์ ์ง๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ 100,000๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ์์ฐ์์ด๋ค. ๋ชจ๋ ๊ฑด๋ฌผ์ ์ง๋ ๊ฒ์ด ๊ฐ๋ฅํ ์ ๋ ฅ๋ง ์ฃผ์ด์ง๋ค.
์ถ๋ ฅ
N๊ฐ์ ๊ฐ ๊ฑด๋ฌผ์ด ์์ฑ๋๊ธฐ๊น์ง ๊ฑธ๋ฆฌ๋ ์ต์ ์๊ฐ์ ์ถ๋ ฅํ๋ค.
๐ ํต์ฌ ์์ด๋์ด
- ๊ฐ ๊ฑด๋ฌผ์ ์ง๋ ์๊ฐ ๋ฐฐ์ด, ์ง์ ์ฐจ์ ๋ฐฐ์ด, ์ ๋ต ๋ฐฐ์ด (๋จผ์ ์ง์ด์ผ ํ๋ ๊ฑด๋ฌผ๋ค ์ง๋ ์๊ฐ ํฉ + ํด๋น ๊ฑด๋ฌผ ์ง๋ ์๊ฐ) ์์ฑ
- ์ ๋ต ๋ฐฐ์ด ์ ๋ฐ์ดํธ ํ๋ ๋ฒ
์์ ์ ๋ ฌ for๋ฌธ ์์์ (์ด์ ๊ฑด๋ฌผ์ ์ ์ฅ๋ ์ต๋ ์๊ฐ + ์ด์ ๊ฑด๋ฌผ ์ง๋ ์๊ฐ) ๊ณผ ํ์ฌ ๊ฑด๋ฌผ ์ ๋ต ๋ฐฐ์ด์ ์ ์ฅ๋ ์๊ฐ ์ค ํฐ ๊ฐ์ผ๋ก ์ ๋ต ๋ฐฐ์ด์ ์ ๋ฐ์ดํธ ํด์ผํ๋ค.
๋ง์ง๋ง์ ์๊ธฐ ๊ฑด๋ฌผ์ ์ง๋ ๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ์ ๋ํด์ฃผ๊ณ ์ถ๋ ฅํ๋ค.
์ง๊ด์ ์ผ๋ก๋ ๋น์ฐํ ์ ์๋ก ์ ๋ฐ์ดํธํ๋ฉด ์๊ฐ์ด ๋์ด๋ ๊ฒ ๊ฐ์ง๋ง ์๋๋ค.
๋ฐ๋ก)
1, 2 ๊ฑด๋ฌผ ์ง๊ณ 3 ๊ฑด๋ฌผ์ ์ง์ด์ผ ํ๊ณ , ๊ฐ๊ฐ 30, 10, 10 ์๊ฐ์ด ๊ฑธ๋ฆฐ๋ค.
1, 2์ ์ง์ ์ฐจ์๋ 0์ด๊ณ , ๋ ๋ค ์ธ์ ๋ ธ๋๋ก 3์ ๊ฐ์ง๊ณ ์๋ค.
1์ ๋จผ์ ํ์ ๋ฃ์ผ๋ฉด 3์ ์ ๋ต ๋ฐฐ์ด์ 30์ผ๋ก ์ ๋ฐ์ดํธ๋๋ค.
๊ทธ๋ฆฌ๊ณ 2๋ฅผ ํ์ ๋ฃ์ผ๋ฉด 3์ ์ ๋ต ๋ฐฐ์ด์ ์ ์๋ก๋ง ์ ๋ฐ์ดํธ๋ฅผ ํ๋ฉด 10์ผ๋ก ์ค์ด๋ ๋ค.
๋ฐ๋ผ์ ํ์ฌ ์ ๋ต ๋ฐฐ์ด์ ์ ์ฅ๋ ์๊ฐ์ด ๋ ํฌ๋ค๋ฉด ์ ๋ฐ์ดํธ๋ฅผ ์ ํด์ค๋ ๋๋ค.
import java.util.ArrayList;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
ArrayList<ArrayList<Integer>> arr = new ArrayList<>();
for (int i = 0; i <= N ; i++) {
arr.add(new ArrayList<>());
}
int[] time = new int[N+1]; // ๊ฐ ๊ฑด๋ฌผ์ ์ง๋๋ฐ ๊ฑธ๋ฆฌ๋ ์๊ฐ
int[] indegree = new int[N+1]; // ์ง์
์ฐจ์ ๋ฐฐ์ด
int[] ans = new int[N+1]; // ์ ๋ต ๋ฐฐ์ด
for (int i = 1; i <= N; i++) {
time[i] = sc.nextInt();
int node = sc.nextInt();
while(node != -1){
arr.get(node).add(i);
indegree[i]++;
node = sc.nextInt();
}
}
// ์์ ์ ๋ ฌ
Queue<Integer> queue = new LinkedList<>();
for (int i = 1; i <= N ; i++) {
if(indegree[i] == 0)
queue.add(i);
}
while(!queue.isEmpty()){
int now = queue.poll();
for (Integer i : arr.get(now)) {
indegree[i]--;
ans[i] = Math.max(ans[now] + time[now], ans[i]);
if(indegree[i] == 0)
queue.add(i);
}
}
for (int i = 1; i <= N ; i++) {
System.out.println(ans[i]+time[i]);
}
}
}
์ฝํ ์ ๋ฆฌ ๊นํ๋ธ ๋งํฌ
GitHub - HyperAlgorithmStudy/BaekJoon: Do it! ์๊ณ ๋ฆฌ์ฆ ์ฝ๋ฉ ํ ์คํธ ์คํฐ๋
Do it! ์๊ณ ๋ฆฌ์ฆ ์ฝ๋ฉ ํ ์คํธ ์คํฐ๋. Contribute to HyperAlgorithmStudy/BaekJoon development by creating an account on GitHub.
github.com
์ฐธ๊ณ : Do it! ์๊ณ ๋ฆฌ์ฆ ์ฝ๋ฉ ํ ์คํธ: ์๋ฐ ํธ - ๊น์ข ๊ด
๋๊ธ