๐ ๋ฌธ์
๋ฏผ์ค๋ 1๋ฒ๋ถํฐ N๋ฒ๊น์ง ์ด N๊ฐ์ ๋ฌธ์ ๋ก ๋์ด ์๋ ๋ฌธ์ ์ง์ ํ๋ ค๊ณ ํ๋ค. ๋ฌธ์ ๋ ๋์ด๋ ์์๋ก ์ถ์ ๋์ด ์๋ค. ์ฆ 1๋ฒ ๋ฌธ์ ๊ฐ ๊ฐ์ฅ ์ฌ์ด ๋ฌธ์ ์ด๊ณ N๋ฒ ๋ฌธ์ ๊ฐ ๊ฐ์ฅ ์ด๋ ค์ด ๋ฌธ์ ๊ฐ ๋๋ค.
์ด๋ค ๋ฌธ์ ๋ถํฐ ํ๊น ๊ณ ๋ฏผํ๋ฉด์ ๋ฌธ์ ๋ฅผ ํ์ด๋ณด๋ ๋ฏผ์ค๋, ๋ช๋ช ๋ฌธ์ ๋ค ์ฌ์ด์๋ '๋จผ์ ํธ๋ ๊ฒ์ด ์ข์ ๋ฌธ์ '๊ฐ ์๋ค๋ ๊ฒ์ ์๊ฒ ๋์๋ค. ์๋ฅผ ๋ค์ด 1๋ฒ ๋ฌธ์ ๋ฅผ ํ๊ณ ๋๋ฉด 4๋ฒ ๋ฌธ์ ๊ฐ ์ฝ๊ฒ ํ๋ฆฐ๋ค๊ฑฐ๋ ํ๋ ์์ด๋ค. ๋ฏผ์ค๋ ๋ค์์ ์ธ ๊ฐ์ง ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ฌธ์ ๋ฅผ ํ ์์๋ฅผ ์ ํ๊ธฐ๋ก ํ์๋ค.
1. N๊ฐ์ ๋ฌธ์ ๋ ๋ชจ๋ ํ์ด์ผ ํ๋ค.
2. ๋จผ์ ํธ๋ ๊ฒ์ด ์ข์ ๋ฌธ์ ๊ฐ ์๋ ๋ฌธ์ ๋, ๋จผ์ ํธ๋ ๊ฒ์ด ์ข์ ๋ฌธ์ ๋ฅผ ๋ฐ๋์ ๋จผ์ ํ์ด์ผ ํ๋ค.
3. ๊ฐ๋ฅํ๋ฉด ์ฌ์ด ๋ฌธ์ ๋ถํฐ ํ์ด์ผ ํ๋ค.
์๋ฅผ ๋ค์ด์ ๋ค ๊ฐ์ ๋ฌธ์ ๊ฐ ์๋ค๊ณ ํ์. 4๋ฒ ๋ฌธ์ ๋ 2๋ฒ ๋ฌธ์ ๋ณด๋ค ๋จผ์ ํธ๋ ๊ฒ์ด ์ข๊ณ , 3๋ฒ ๋ฌธ์ ๋ 1๋ฒ ๋ฌธ์ ๋ณด๋ค ๋จผ์ ํธ๋ ๊ฒ์ด ์ข๋ค๊ณ ํ์. ๋ง์ผ 4-3-2-1์ ์์๋ก ๋ฌธ์ ๋ฅผ ํ๊ฒ ๋๋ฉด ์กฐ๊ฑด 1๊ณผ ์กฐ๊ฑด 2๋ฅผ ๋ง์กฑํ๋ค. ํ์ง๋ง ์กฐ๊ฑด 3์ ๋ง์กฑํ์ง ์๋๋ค. 4๋ณด๋ค 3์ ์ถฉ๋ถํ ๋จผ์ ํ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค. ๋ฐ๋ผ์ ์กฐ๊ฑด 3์ ๋ง์กฑํ๋ ๋ฌธ์ ๋ฅผ ํ ์์๋ 3-1-4-2๊ฐ ๋๋ค.
๋ฌธ์ ์ ๊ฐ์์ ๋จผ์ ํธ๋ ๊ฒ์ด ์ข์ ๋ฌธ์ ์ ๋ํ ์ ๋ณด๊ฐ ์ฃผ์ด์ก์ ๋, ์ฃผ์ด์ง ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด์ ๋ฏผ์ค๊ฐ ํ ๋ฌธ์ ์ ์์๋ฅผ ๊ฒฐ์ ํด ์ฃผ๋ ํ๋ก๊ทธ๋จ์ ์์ฑํ์์ค.
๐์ ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฌธ์ ์ ์ N(1 ≤ N ≤ 32,000)๊ณผ ๋จผ์ ํธ๋ ๊ฒ์ด ์ข์ ๋ฌธ์ ์ ๋ํ ์ ๋ณด์ ๊ฐ์ M(1 ≤ M ≤ 100,000)์ด ์ฃผ์ด์ง๋ค. ๋์งธ ์ค๋ถํฐ M๊ฐ์ ์ค์ ๊ฑธ์ณ ๋ ์ ์์ ์์์ A,B๊ฐ ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ฃผ์ด์ง๋ค. ์ด๋ A๋ฒ ๋ฌธ์ ๋ B๋ฒ ๋ฌธ์ ๋ณด๋ค
๋จผ์ ํธ๋ ๊ฒ์ด ์ข๋ค๋ ์๋ฏธ์ด๋ค.ํญ์ ๋ฌธ์ ๋ฅผ ๋ชจ๋ ํ ์ ์๋ ๊ฒฝ์ฐ๋ง ์ ๋ ฅ์ผ๋ก ์ฃผ์ด์ง๋ค.
๐์ถ๋ ฅ
์ฒซ์งธ ์ค์ ๋ฌธ์ ๋ฒํธ๋ฅผ ๋ํ๋ด๋ 1 ์ด์ N ์ดํ์ ์ ์๋ค์ ๋ฏผ์ค๊ฐ ํ์ด์ผ ํ๋ ์์๋๋ก ๋น์นธ์ ์ฌ์ด์ ๋๊ณ ์ถ๋ ฅํ๋ค.
๐ ๋ฌธ์ ํ์ด
ํ ์๋ฃ๊ตฌ์กฐ๋ฅผ ์ฌ์ฉํ์ฌ ์์์ ๋ ฌ์ ํ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ฉด ๋์๋ค.
๋ฌธ์ ๋ฅผ ํธ๋ ์กฐ๊ฑด์ ๋ํด์ ์ฝ๊ฐ ํท๊ฐ๊ธธ ์๋ ์๋๋ฐ, ๋จผ์ ํธ๋ ๊ฒ์ด ์ข์ ์์๋ ์ ์งํ๋, ๋น ๋ฅธ ์ซ์๋ถํฐ ํธ๋ ๊ฒ์ด๋ค.
์๋ฅผ ๋ค์ด n์ด 6, ์์์ A, B๋ก 6 3๊ฐ ์ ๋ ฅ๋๋ค๋ฉด 6 - > 3 ์ด ์์๋ ์ ์งํด์ผ ํ๊ณ , ์ฌ์ด์ ์ซ์๊ฐ ๋ค์ด๊ฐ๋ฉด ๋๋ค.
๋ค์๊ณผ ๊ฐ์ ์ํฉ์๋ 1 -> 2 -> 4 -> 5 -> 6 -> 3 ์์๊ฐ ์ ๋ต์ด๋ค.
๐ป ์ฝ๋
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 | import sys, heapq input = sys.stdin.readline def solve(): n,m = map(int,input().split()) edges = [0]*(n+1) graph = [[] for _ in range(n+1)] for _ in range(m): a,b = map(int,input().split()) edges[b]+=1 graph[a].append(b) topology(n, graph, edges) def topology(n, graph, edges): ans = [] h = [] for i in range(1, n+1): if not edges[i]: heapq.heappush(h, i) while h: node = heapq.heappop(h) ans.append(node) for i in graph[node]: edges[i] -= 1 if not edges[i]: heapq.heappush(h, i) print(*ans) solve() | cs |
๐ญ ์ํ์ฐฉ์ค
๐ ๋ฌธ์ ๋งํฌ ๋ฌธ์ ์ง
'Problem Solving > ๋ฐฑ์ค' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
[๋ฐฑ์ค] 23291๋ฒ: ์ดํญ ์ ๋ฆฌ (0) | 2023.04.02 |
---|---|
[๋ฐฑ์ค] 16724๋ฒ ํผ๋ฆฌ ๋ถ๋ ์ฌ๋์ด (1) | 2023.03.10 |
[๋ฐฑ์ค] 1719๋ฒ: ํ๋ฐฐ - ํ์ด์ฌ (0) | 2022.12.21 |
[๋ฐฑ์ค] 2133๋ฒ ํ์ผ ์ฑ์ฐ๊ธฐ - ํ์ด์ฌ, ์๋ฐ (0) | 2022.12.20 |
[๋ฐฑ์ค] 1261๋ฒ: ์๊ณ ์คํ (0) | 2022.11.23 |