Computer Science/Algorithm

[Algorithm] Dynamic Programming(4) - ๋ฒจ๋งŒํฌ๋“œ(Bellman-Ford)

์ดํƒœํ™ 2022. 11. 19. 22:07

๐Ÿค”Dynamic Programming

๋‹ค์ด๋‚˜๋ฏน ํ”„๋กœ๊ทธ๋ž˜๋ฐ์ด๋ž€ ํฐ ๋ฌธ์ œ๋ฅผ ์ž‘์€๋ฌธ์ œ๋กœ ๋‚˜๋ˆ„์–ด ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” ๊ฒƒ์„ ๋งํ•ฉ๋‹ˆ๋‹ค.

 

๋‹ค์ด๋‚˜๋ฏน ํ”„๋กœ๊ทธ๋ž˜๋ฐ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์ด์šฉํ•˜๋Š” ๋‹ค์–‘ํ•œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์— ๋Œ€ํ•ด ์•Œ์•„๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

 

์ด๋ฒˆ ํฌ์ŠคํŒ…์—์„œ๋Š” ์ตœ๋‹จ ๊ฒฝ๋กœ ๋ฌธ์ œ์ค‘ ํ•˜๋‚˜์ธ ๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์— ๋Œ€ํ•ด ์•Œ์•„๋ณด๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

๐Ÿ”Ž ์ตœ๋‹จ ๊ฒฝ๋กœ ๋ฌธ์ œ(Shortest Path Problem)

โœ๏ธ ์ตœ๋‹จ ๊ฒฝ๋กœ ๋ฌธ์ œ๋ž€?

๊ทธ๋ž˜ํ”„ G = (V, E)์˜ ์ƒ์—์„œ ์ •์  u์—์„œ v๋กœ์˜ ๊ฐ€์žฅ ์งง์€ ๊ฒฝ๋กœ์˜ ๊ธธ์ด๋ฅผ ๊ตฌํ•˜๋Š” ๋ฌธ์ œ๋ฅผ ์ตœ๋‹จ ๊ฒฝ๋กœ ๋ฌธ์ œ๋ผ๊ณ  ํ•ฉ๋‹ˆ๋‹ค.

 

์šฐ๋ฆฌ๋Š” edge-weighted graph์˜ ๊ฒฝ์šฐ๋งŒ์„ ์ƒ๊ฐํ•˜๋„๋ก ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค. ( ์ด๋•Œ |V| = n, |E| = m )

 

 

 

 

 

โœ๏ธ Edge-weighted graph

๊ทธ๋ž˜ํ”„ G์˜ edge(a, b)์— ๊ฐ€์ค‘์น˜ w(a, b)๊ฐ€ ์žˆ๋Š” ๊ทธ๋ž˜ํ”„๋ฅผ ๋งํ•ฉ๋‹ˆ๋‹ค.

 

์ด๋•Œ ์ •์  u์—์„œ v๋กœ์˜ ๊ฒฝ๋กœ์˜ ๊ธธ์ด๋Š” u์—์„œ v๋กœ์˜ ๊ฒฝ๋กœ ์ƒ์˜ edge๋“ค์˜ ์ด ๊ฐ€์ค‘์น˜์˜ ํ•ฉ์ด ๋ฉ๋‹ˆ๋‹ค.

 

์•„๋ž˜์˜ ๊ทธ๋ž˜ํ”„์—์„œ ์ •์  '0' ์—์„œ๋ถ€ํ„ฐ '2'๊นŒ์ง€์˜ ๋นจ๊ฐ„์ƒ‰ ๊ฒฝ๋กœ์˜ ๊ฑฐ๋ฆฌ๋Š” '8 + 7 = 15' ์ž…๋‹ˆ๋‹ค.

 

 

 

 

๋‘ ์ •์  ์‚ฌ์ด์— ์—ฌ๋Ÿฌ ๊ฒฝ๋กœ๊ฐ€ ์กด์žฌํ•˜๋Š”๋ฐ ์šฐ๋ฆฌ๊ฐ€ ๊ณต๋ถ€ํ•˜๋Š” ์ตœ๋‹จ ๊ฒฝ๋กœ ๋ฌธ์ œ๋Š” ๊ทธ ์ค‘ ๊ฐ€์žฅ ๊ฑฐ๋ฆฌ๊ฐ€ ์งง์€ ๊ฒฝ๋กœ์˜ ๊ฑฐ๋ฆฌ๋ฅผ ๋ฐ˜ํ™˜ํ•ฉ๋‹ˆ๋‹ค.

 

์œ„์˜ ๊ทธ๋ฆผ์—์„œ๋Š” edge(0, 3)๊ณผ edge(3, 2)์˜ ๊ฐ€์ค‘์น˜๋ฅผ ๋”ํ•œ 14๊ฐ€ ์ตœ๋‹จ ๊ฒฝ๋กœ๊ฐ€ ๋ฉ๋‹ˆ๋‹ค.

 

 

 

 

 

โœ๏ธ ๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜(Dijkstra Algorithm)

๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์ตœ๋‹จ ๊ฒฝ๋กœ ๋ฌธ์ œ ์ค‘ ๊ฐ€์žฅ ๋Œ€ํ‘œ์ ์ธ ๋ฌธ์ œ ์ค‘ ํ•˜๋‚˜์ž…๋‹ˆ๋‹ค.

 

ํ•˜์ง€๋งŒ ์˜ค๋Š˜ ๋ฐฐ์šธ ๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ๋Š” ๋‹ค๋ฅด๊ฒŒ, ๊ทธ๋ž˜ํ”„์—์„œ ์Œ์ˆ˜ ๊ฐ€์ค‘์น˜๋ฅผ ๊ฐ€์ง€๋Š” edge๊ฐ€ ์กด์žฌํ•œ๋‹ค๋ฉด ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ๋™์ž‘ํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

 

๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ํ•ด๊ฒฐํ•˜๋Š” ๋ฐฉ๋ฒ•์€ ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

 

 

How To Solve

์‹œ์ž‘ ์ •์  s(source) ์—์„œ ๋‹ค๋ฅธ ๋ชจ๋“  ์ •์ ๋“ค ๊ฐ„์˜ ์ตœ๋‹จ ๊ฒฝ๋กœ์˜ ๊ธธ์ด๋ฅผ ๊ตฌํ•˜๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜

์ฆ‰, ๋‹ค๋ฅธ ๋ชจ๋“  ์ •์ ๋“ค๊ฐ„์˜ ๊ฑฐ๋ฆฌ๋Š” table๋กœ ์ €์žฅํ•˜๋ฉฐ, ์ •์ ์„ ํ•˜๋‚˜ ์”ฉ ๋ฐฉ๋ฌธํ•ด๊ฐ€๋ฉด์„œ table์„ ์—…๋ฐ์ดํŠธ ํ•ฉ๋‹ˆ๋‹ค.

 

 

 

Key Lemma

๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜์— ์ •์  s์—์„œ๋ถ€ํ„ฐ์˜ ๊ธธ์ด๊ฐ€ ๋ฐฉ๋ฌธํ•˜์ง€ ์•Š์€ ์ •์  ์ค‘ ๊ฐ€์žฅ ์งง์€ ์ •์ ์„ v๋ผ๊ณ  ํ•  ๋•Œ ํ•ด๋‹น ๊ธธ์ด๋Š” ์‹ค์ œ s์—์„œ v๋กœ์˜ ์ตœ๋‹จ ๊ฒฝ๋กœ ๊ธธ์ด์™€ ๊ฐ™๋‹ค.

 

๋”ฐ๋ผ์„œ ๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์ •์ ์„ local optimum(์ฃผ๋ณ€์˜ ๋‹ค๋ฅธ ๊ฐ’๋“ค๋ณด๋‹ค ๋” ์ข‹์€ ๊ฐ’)์— ๊ธฐ๋ฐ˜ํ•˜์—ฌ ํ•˜๋‚˜์”ฉ ๋ฐฉ๋ฌธํ•˜๋Š” ์ผ์ข…์˜ greedy ์•Œ๊ณ ๋ฆฌ์ฆ˜์ž…๋‹ˆ๋‹ค.

 

ํ•˜์ง€๋งŒ ์œ„์˜ Key Lemma๋Š” ๊ฐ€์ค‘์น˜๊ฐ€ ์Œ์ˆ˜์ธ edge๊ฐ€ ์กด์žฌํ•  ๊ฒฝ์šฐ ์„ฑ๋ฆฝํ•˜์ง€ ์•Š์Šต๋‹ˆ๋‹ค.

 

์•„๋ž˜์˜ ๊ทธ๋ž˜ํ”„์—์„œ ๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ Edge(s, v)๊ฐ€ s์™€ v ์‚ฌ์ด์˜ shorest path๋ผ๊ณ  ๋‹ตํ•ฉ๋‹ˆ๋‹ค.

 ํ•˜,

 

ํ•˜์ง€๋งŒ ์‹ค์ œ s์™€ v ์‚ฌ์ด์˜ ์ตœ๋‹จ ๊ฒฝ๋กœ๋Š” s - v' - v ์ž…๋‹ˆ๋‹ค.

 

 

 

 

 

 

 

 

 

๐Ÿ”Ž ๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜

๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€  ์ตœ๋‹จ ๊ฒฝ๋กœ ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•˜๋Š” DP(Dynamic Programming) ๊ธฐ๋ฐ˜์˜ ์•Œ๊ณ ๋ฆฌ์ฆ˜์ž…๋‹ˆ๋‹ค.

 

๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ ๋งˆ์ฐฌ๊ฐ€์ง€๋กœ ์‹œ์ž‘ ์ •์  s ์—์„œ ๊ทธ๋ž˜ํ”„ G์˜ ๋‹ค๋ฅธ ๋ชจ๋“  ์ •์ ๋“ค๊ฐ„์˜ ์ตœ๋‹จ ๊ฒฝ๋กœ์˜ ๊ธธ์ด ๋ฐ ๊ฒฝ๋กœ๋ฅผ ๊ตฌํ•˜๋ฉฐ, ๋งค ๋‹จ๊ณ„๋งˆ๋‹ค ํ•ด๋‹น ์ตœ๋‹จ ๊ฒฝ๋กœ๋“ค์˜ ๊ธธ์ด๋ฅผ ์—…๋ฐ์ดํŠธํ•ด ๋‚˜๊ฐ€๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์ž…๋‹ˆ๋‹ค.

 

๊ธฐ๋ณธ์ ์œผ๋กœ directed graph๋ฅผ ๊ฐ€์ •ํ•˜๋ฉฐ undirected graph๋Š” ๋‘ ์ •์ ๊ฐ„์˜ ๋ฐฉํ–ฅ์„ ๋ชจ๋‘ ๊ฐ€์ง€๋Š” directed graph๋กœ ์ƒ๊ฐํ•ฉ๋‹ˆ๋‹ค.

 

๋‹ค์ต์ŠคํŠธ๋ผ ์•Œ๊ณ ๋ฆฌ์ฆ˜๊ณผ๋Š” ๋‹ฌ๋ฆฌ๊ฐ€์ค‘์น˜๊ฐ€ ์Œ์ˆ˜์ธ edge๊ฐ€ ์กด์žฌํ•  ๋•Œ๋„ ์˜ฌ๋ฐ”๋ฅด๊ฒŒ ๋™์ž‘ํ•ฉ๋‹ˆ๋‹ค.

 

 

 

 

โœ๏ธ Problem & Subproblem ์ •์˜

dist(u)๋ฅผ ์ •์  s ์—์„œ u๊นŒ์ง€์˜ ์‹ค์ œ ์ตœ๋‹จ ๊ฒฝ๋กœ์˜ ๊ธธ์ด๋ผ๊ณ  ํ•˜๊ณ  dis(i, u)๋ฅผ 'edge๋ฅผ i๊ฐœ ์ดํ•˜๋กœ ์‚ฌ์šฉํ•˜๋ฉด์„œ' vertex s ์—์„œ u๋กœ ๊ฐ€๋Š” shortest path์˜ ๊ธธ์ด'๋ผ๊ณ  ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

 

 

 

 

โœ๏ธ Lemma

๋ชจ๋“  i < j์— ๋Œ€ํ•ด dist(u) ≤ dist(j, u) ≤ dist(i, u)๊ฐ€ ์„ฑ๋ฆฝํ•œ๋‹ค.

๋”ฐ๋ผ์„œ G๊ฐ€ negative cycle(๊ฐ€์ค‘์น˜์˜ ํ•ฉ์ด negative๊ฐ€ ๋˜๋Š” cycle)์ด ์—†์„ ์‹œ, dist(u) = dist(|V|-1, u)๊ฐ€ ๋œ๋‹ค.

 

 

 

โœ๏ธ Recurrence Relation

base case) i = 0์ผ ๋•Œ, ์ฆ‰, dist(0, s) = 0 ๋‚˜๋จธ์ง€ v ∈ V์— ๋Œ€ํ•ด์„œ๋Š” dist(0, v) = ๋ฌดํ•œ๋Œ€๋กœ ๋‘ก๋‹ˆ๋‹ค.

 

induction step) dis(i, v)๊ฐ€ ์ฃผ์–ด์กŒ๋‹ค๊ณ  ํ•  ๋•Œ dis(i, v)๊ฐ€ ์ฃผ์–ด์กŒ๋‹ค๊ณ  ํ•  ๋•Œ dis(i + 1, v)๋ฅผ ์–ด๋–ป๊ฒŒ ๊ตฌํ• ๊นŒ? ๋ฌธ์ œ๋ฅผ ํ•ด๊ฒฐํ•ฉ๋‹ˆ๋‹ค.

 

dist(i, v) > dist(i, u) + w(u, v)๋ฅผ ๋งŒ์กฑํ•˜๋Š” ๋ชจ๋“  edge(u, v)๋“ค ์ค‘ ์˜ค๋ฅธ์ชฝ ํ•ญ์„ ๊ฐ€์žฅ ์ž‘๊ฒŒ ๋งŒ๋“œ๋Š” edge(u', v)๊ฐ€ ์žˆ๋‹ค๋ฉด

 

$$dis(i + 1, v) = dist(i, u') + w(u', v)$$์ž…๋‹ˆ๋‹ค.

 

ํ•ด๋‹น edge๊ฐ€ ์กด์žฌํ•˜์ง€ ์•Š๋Š” ๊ฒฝ์šฐ $dis(i+1, v) = dis(i, v)$์ž…๋‹ˆ๋‹ค.

 

 

 

ํ™•์ธ์„ ์œ„ํ•ด ์˜ˆ์ œ ๊ทธ๋ž˜ํ”„๋ฅผ ์‚ดํŽด๋ณด๊ฒ ์Šต๋‹ˆ๋‹ค.

 

 

example

 

 

์‹œ์ž‘ ์ •์  s์—์„œ i๊ฐœ ์ดํ•˜์˜ edge๋ฅผ ์ง€๋‚˜ v์— ๋„์ฐฉํ•˜๋Š” ๊ฒฝ์šฐ์ธ dis(i, v) = 3์ž…๋‹ˆ๋‹ค.

 

dis(i+1, v)๋ฅผ ๊ตฌํ•˜๊ธฐ ์œ„ํ•ด ์ •์  u์— ๋„๋‹ฌํ•  ๋•Œ dis(i, u) = 5๋ผ๊ณ  ํ•˜๊ฒ ์Šต๋‹ˆ๋‹ค.

 

edge(u, v)์˜ ๊ฐ€์ค‘์น˜๊ฐ€ -6์ด๋ผ ํ•  ๋•Œ, $dis(i+1, v) = dis(i, u) + w(u, v) = -1 < dis(i, v)$๋ฅผ ๋งŒ์กฑํ•˜๋ฏ€๋กœ ์œ„์˜ ๊ทธ๋ž˜ํ”„์—์„œ dis(i+1, v) = -1์ด ๋ฉ๋‹ˆ๋‹ค.

 

 

 

 

โœ๏ธ Algorithm outline

๊ทธ๋Ÿฌ๋ฏ€๋กœ ๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์•„๋ž˜์™€ ๊ฐ™์ด ๋‚˜ํƒ€๋‚ผ ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค. 

 

 

1. ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์ด 0 ~ n-1 ์˜ stage (iteration) ์œผ๋กœ ๊ตฌ์„ฑ๋˜๋ฉฐ, i ๋ฒˆ์งธ stage ๊ฐ€ ๋๋‚  ๋•Œ๋งˆ๋‹ค G ์˜ ๋ชจ๋“  vertex v ์— ๋Œ€ํ•ด dist (i, v) ๊ฐ€ dist (v) ์— ์ €์žฅ๋ฉ๋‹ˆ๋‹ค (invariant).


2. 0 ๋ฒˆ์งธ stage ์—์„œ๋Š” ์•ž์„  base case ์— ๋งž๊ฒŒ dist ๊ฐ’์„ ์ •ํ•ด ์ค๋‹ˆ๋‹ค.


3. ์ดํ›„ i ๋ฒˆ์งธ stage ๋งˆ๋‹ค ๋ชจ๋“  edge (u, v) ์— ๋Œ€ํ•ด ๋‹ค์Œ ์ž‘์—…์„ ๋ฐ˜๋ณตํ•ฉ๋‹ˆ๋‹ค.
→ dist (v) > dist(u) + w (u, v) ์ธ ๊ฒฝ์šฐ dist (v) ๋ฅผ dist (u) + w (u, v) ๋กœ update

 

 

 

 

 

 

 

 

์œ„์™€ ๊ฐ™์ด ๊ฐ’์„ updateํ•  ๋•Œ๋Š” ์ด์ „์˜ updateํ•œ ๊ฐ’์„ ์ด์šฉํ•ด์•ผ๋งŒ ํ•œ๋‹ค๋Š” ๊ฒƒ์ž…๋‹ˆ๋‹ค.

 

 

 

 

 

 

โœ๏ธ ์ˆ˜๋„์ฝ”๋“œ

์ด๋ฅผ ์ˆ˜๋„์ฝ”๋“œ๋กœ ๋‚˜ํƒ€๋‚ด๋ฉด ์•„๋ž˜์™€ ๊ฐ™์Šต๋‹ˆ๋‹ค.

 

 

 

 

โœ๏ธ ์‹ค์ œ shortest path๋ฅผ ๊ตฌํ•˜๋Š” ๋ฐฉ๋ฒ•

์œ„ ์•Œ๊ณ ๋ฆฌ์ฆ˜์—์„œ dis(v)๋ฅผ dis(u) + w(u, v) ๋กœ ์—…๋ฐ์ดํŠธ ํ•  ๋•Œ๋งˆ๋‹ค pre(v) = u๋กœ ์„ค์ •ํ•ฉ๋‹ˆ๋‹ค.

 

์‹ค์ œ ๊ฒฝ๋กœ๋Š” ์•Œ๊ณ ๋ฆฌ์ฆ˜์˜ ์ข…๋ฃŒ ํ›„ v์—์„œ๋ถ€ํ„ฐ pre(v)๋ฅผ ์—ญ์œผ๋กœ ๊ฑฐ์Šฌ๋Ÿฌ ์˜ฌ๋ผ๊ฐ€๋ฉฐ ์—ญ์ถ”์ ํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

 

 

 

โœ๏ธ Time Complexity

(n ๋ฒˆ์˜ stage = $O(n)$) x (๊ฐ stage ๋งˆ๋‹ค |E| = m ๊ฐœ์˜ edge๋ฅผ checkํ•˜๋ฉฐ dist ๊ฐ’์„ update = $O(m)$) = $O(nm)$

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

 

๐Ÿ”Ž Negative Cycle ํŒ๋ณ„ํ•˜๊ธฐ

Negative cycle์ด ์žˆ๋Š” ๊ฒฝ์šฐ ๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ path๊ฐ€ ์•„๋‹Œ ๊ฐ™์€ cycle์„ ๊ณ„์†ํ•ด์„œ ๋„๋Š” walk์˜ ๊ธธ์ด๋ฅผ retrun ํ•˜๊ฒŒ ๋ฉ๋‹ˆ๋‹ค.

 

์‰ฝ๊ฒŒ ๋งํ•ด cycle์„ ๋ฌดํ•œ๋ฒˆ ๋Œ๊ฒŒ ๋œ๋‹ค๋ฉด shortest path๋Š” -๋ฌดํ•œ๋Œ€๊ฐ€ ๋œ๋‹ค๋Š” ๋œป์ž…๋‹ˆ๋‹ค.

 

๊ทธ๋Ÿฌ๋ฏ€๋กœ ๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์€ ์Œ์˜ ๊ฐ€์ค‘์น˜ edge๊ฐ€ ์žˆ๋Š” undirected graph ์—์„œ๋Š” ๋™์ž‘ํ•˜์ง€ ์•Š๋Š”๋‹ค.( ์œ„์—์„œ ์ •์˜ํ–ˆ๋“ฏ undirected ๊ทธ๋ž˜ํ”„๋Š” ๊ฐ๊ฐ์˜ ์ •์ ๋ผ๋ฆฌ cycle์ด ์กด์žฌํ•˜๋Š” directed graph์™€ ๊ฐ™๊ธฐ ๋•Œ๋ฌธ)

 

๋˜ํ•œ ์œ„์˜ ์„ฑ์งˆ์„ ์—ญ์œผ๋กœ ์ด์šฉํ•˜์—ฌ ๋ฒจ๋งŒํฌ๋“œ ์•Œ๊ณ ๋ฆฌ์ฆ˜์„ ์ด์šฉํ•ด graph๊ฐ€ negative cycle์„ ๊ฐ€์ง€๊ณ  ์žˆ๋Š”์ง€ ํ™•์ธํ•  ์ˆ˜ ์žˆ์Šต๋‹ˆ๋‹ค.

 

 

Negative Cycle ํŒ๋ณ„๋ฒ•

n-1๋ฒˆ์งธ stageํ›„, n ๋ฒˆ์งธ stage๋ฅผ ์ถ”๊ฐ€๋กœ ์ˆ˜ํ–‰ํ•˜์—ฌ dist ๊ฐ’์ด update ๋˜๋Š” ๊ฒฝ์šฐ negative cycle์ด ์กด์žฌํ•ฉ๋‹ˆ๋‹ค.

 

 

๐Ÿ‘‰์ฆ๋ช…

๋”๋ณด๊ธฐ

ํ•ด๋ณด์ž ํ•ด๋ณด์ž~

 

๊ท€๋ฅ˜๋ฒ•์„ ์‚ฌ์šฉํ•˜์—ฌ ์ด๋ฅผ ํ•ด๊ฒฐํ•ฉ๋‹ˆ๋‹ค.