<script>!function(){functiont(t){document.documentElement.setAttribute("data-theme",t)}vare=function(){try{returnnewURLSearchParams(window.location.search).get("docusaurus-theme")}catch(t){}}()||function(){try{returnlocalStorage.getItem("theme")}catch(t){}}();t(null!==e?e:"light")}(),function(){try{constc=newURLSearchParams(window.location.search).entries();for(var[t,e]ofc)if(t.startsWith("docusaurus-data-")){vara=t.replace("docusaurus-data-","data-");document.documentElement.setAttribute(a,e)}}catch(t){}}()</script><divid="__docusaurus"><divrole="region"aria-label="Skip to main content"><aclass="skipToContent_fXgn"href="#__docusaurus_skipToContent_fallback">Skip to main content</a></div><navaria-label="Main"class="navbar navbar--fixed-top"><divclass="navbar__inner"><divclass="navbar__items"><buttonaria-label="Toggle navigation bar"aria-expanded="false"class="navbar__toggle clean-btn"type="button"><svgwidth="30"height="30"viewBox="0 0 30 30"aria-hidden="true"><pathstroke="currentColor"stroke-linecap="round"stroke-miterlimit="10"stroke-width="2"d="M4 7h22M4 15h22M4 23h22"></path></svg></button><aclass="navbar__brand"href="/"><bclass="navbar__title text--truncate">mf</b></a><divclass="navbar__item dropdown dropdown--hoverable"><ahref="#"aria-haspopup="true"aria-expanded="false"role="button"class="navbar__link">Additional FI MU materials</a><ulclass="dropdown__menu"><li><aaria-current="page"class="dropdown__link dropdown__link--active"href="/algorithms/">Algorithms</a></li><li><aclass="dropdown__link"href="/c/">C</a></li><li><aclass="dropdown__link"href="/cpp/">C++</a></li></ul></div><aclass="navbar__item navbar__link"href="/contributions/">Contributions</a><aclass="navbar__item navbar__link"href="/talks/">Talks</a></div><divclass="navbar__items navbar__items--right"><aclass="navbar__item navbar__link"href="/blog/">Blog</a><divclass="toggle_vylO colorModeToggle_DEke"><buttonclass="clean-btn toggleButton_gllP toggleButtonDisabled_aARS"type="button"disabled=""title="Switch between dark and light mode (currently light mode)"aria-label="Switch between dark and light mode (currently light mode)"aria-live="polite"><svgviewBox="0 0 24 24"width="24"height="24"class="lightToggleIcon_pyhR"><pathfill="currentColor"d="M12,9c1.65,0,3,1.35,3,3s-1.35,3-3,3s-3-1.35-3-3S10.35,9,12,9 M12,7c-2.76,0-5,2.24-5,5s2.24,5,5,5s5-2.24,5-5 S14.76,7,12,7L12,7z M2,13l2,0c0.55,0,1-0.45,1-1s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S1.45,13,2,13z M20,13l2,0c0.55,0,1-0.45,1-1 s-0.45-1-1-1l-2,0c-0.55,0-1,0.45-1,1S19.45,13,20,13z M11,2v2c0,0.55,0.45,1,1,1s1-0.45,1-1V2c0-0.55-0.45-1-1-1S11,1.45,11,2z M11,20v2c0,0.55,0.45,1,1,1s1-0.45,1-1v-2c0-0.55-0.45-1-1-1C11.45,19,11,19.45,11,20z M5.99,4.58c-0.39-0.39-1.03-0.39-1.41,0 c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0s0.39-1.03,0-1.41L5.99,4.58z M18.36,16.95 c-0.39-0.39-1.03-0.39-1.41,0c-0.39,0.39-0.39,1.03,0,1.41l1.06,1.06c0.39,0.39,1.03,0.39,1.41,0c0.39-0.39,0.39-1.03,0-1.41 L18.36,16.95z M19.42,5.99c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06c-0.39,0.39-0.39,1.03,0,1.41 s1.03,0.39,1.41,0L19.42,5.99z M7.05,18.36c0.39-0.39,0.39-1.03,0-1.41c-0.39-0.39-1.03-0.39-1.41,0l-1.06,1.06 c-0.39,0.39-0.39,1.03,0,1.41s1.03,0.39,1.41,0L7.05,18.36z"></path></svg><svgviewBox="0 0 24 24"width="24"height="24"class="darkToggleIcon_wfgR"><pathfill="currentColor"d="M9.37,5.51C9.19,6.15,9.1,6.82,9.1,7.5c0,4.08,3.32,7.4,7.4,7.4c0.68,0,1.35-0.09,1.99-0.27C17.45,17.19,14.93,19,12,19 c-3.86,0-7-3.14-7-7C5,9.07,6.81,6.55,9.37,5.51z M12,3c-4.97,0-9,4.03-9,9s4.03,9,9,9s9-4.03,9-9c0-0.46-0.04-0.92-0.1-1.36 c-0.98,1.37-2.58,2.26-4.4,2.26c-2.98,0-5.4-2.42-5.4-5.4c0-1.81,0.89-3.42,2.26-4.4C12.92,3.04,12.46,3,12,3L12,3z"></path></svg></button></div><divclass="navbarSearchContainer_Bca1"><buttontype="button"class="DocSearch DocSearch-Button"aria-label="Search"><spanclass="DocSearch-Button-Container"><svgwidth="20"height="20"class="DocSearch-Search-Icon"viewBox="0 0 20 20"><pathd="M14.38614.386l4.08774.0877-4.0877-4.0877c-2.
<p>We will <em>ease in</em> with our own algorithm to find the shortest path. We will
start by thinking about the ways we can achieve that. If we didn't have the <code>*</code>
cells, we could've easily run a BFS<sup><ahref="#user-content-fn-1"id="user-content-fnref-1"data-footnote-ref="true"aria-describedby="footnote-label">1</a></sup> and be done with it. Maybe it is a good
place to start, or isn't, there is only one way to find out though.</p>
<p><em>How does the BFS work?</em> We know the vertex where we start and we know the
vertex we want to find the shortest path to. Given this knowledge we
incrementally visit all of our neighbours and we do that over and over until the
destination is found<sup><ahref="#user-content-fn-2"id="user-content-fnref-2"data-footnote-ref="true"aria-describedby="footnote-label">2</a></sup>. Could we leverage this somehow?</p>
<h2class="anchor anchorWithStickyNavbar_LWe7"id="naïve-approach">Naïve approach<ahref="#naïve-approach"class="hash-link"aria-label="Direct link to Naïve approach"title="Direct link to Naïve approach"></a></h2>
<p>Well, we could probably start with all vertices being <em>unreachable</em> (having the
highest possible price) and try to improve what we've gotten so far until there
are no improvements. That sounds fine, we shall implement this. Since we are
going on repeat, we will name this function <code>bf()</code> as in <em>brute-force</em>, cause it
a better solution to the problem.</p><p>In general it is an approximation technique that <em>reduces</em> the problem of
finding the path <code>u → x1 → … → xn → v</code> to subproblems
<code>u → x1, x1 → x2, …, xn → v</code> such that the sum of the costs of each step is
<strong>minimal</strong>.</p></div></div>
<h3class="anchor anchorWithStickyNavbar_LWe7"id="correctness">Correctness<ahref="#correctness"class="hash-link"aria-label="Direct link to Correctness"title="Direct link to Correctness"></a></h3>
<p><em>Is our solution correct?</em> It appears to be correct… We have rather complicated
map and our algorithm has finished in an instant with the following output:</p>
<p>And we're somehow stuck… The issue comes from the fact that <em>spinning around</em> in
the vortices allows us to lower the cost infinitely. That's why after each
iteration there is still a possibility to lower the cost, hence the algorithm
doesn't finish. <em>What can we do about this?</em></p>
<divclass="theme-admonition theme-admonition-tip admonition_xJq3 alert alert--success"><divclass="admonitionHeading_Gvgb"><spanclass="admonitionIcon_Rf37"><svgviewBox="0 0 12 16"><pathfill-rule="evenodd"d="M6.5 0C3.48 0 1 2.19 1 5c0 .92.55 2.25 1 3 1.34 2.25 1.78 2.78 2 4v1h5v-1c.22-1.22.66-1.75 2-4 .45-.75 1-2.08 1-3 0-2.81-2.48-5-5.5-5zm3.64 7.48c-.25.44-.47.8-.67 1.11-.86 1.41-1.25 2.06-1.45 3.23-.02.05-.02.11-.02.17H5c0-.06 0-.13-.02-.17-.2-1.17-.59-1.83-1.45-3.23-.2-.31-.42-.67-.67-1.11C2.44 6.78 2 5.65 2 5c0-2.2 2.02-4 4.5-4 1.22 0 2.36.42 3.22 1.19C10.55 2.94 11 3.94 11 5c0 .66-.44 1.78-.86 2.48zM4 14h5c-.23 1.14-1.3 2-2.5 2s-2.27-.86-2.5-2z"></path></svg></span>tip</div><divclass="admonitionContent_BuS1"><p>This algorithm is correct as long as there are no negative loops, i.e. ways how
to lower the cost infinitely. Therefore we can also just lay a precondition that
requires no negative loops to be present.</p></div></div>
<h3class="anchor anchorWithStickyNavbar_LWe7"id="fixing-the-infinite-loop">Fixing the infinite loop<ahref="#fixing-the-infinite-loop"class="hash-link"aria-label="Direct link to Fixing the infinite loop"title="Direct link to Fixing the infinite loop"></a></h3>
<p>Our issue lies in the fact that we can endlessly lower the cost. Such thing must
surely happen in some kind of a loop. We could probably track the relaxations
and once we spot repeating patterns, we know we can safely terminate with <em>some</em>
results at least.</p>
<p>This approach will not even work on our 2D map, let alone any graph. Problem is
that the <em>negative loops</em> lower the cost in <strong>each</strong> iteration and that results
in lowering of the costs to the cells that are reachable from the said loops.
That's why this problem is relatively hard to tackle, it's not that easy to spot
the repeating patterns algorithmically.</p>
<p>On the other hand, we can approach this from the different perspective. Let's
assume the worst-case scenario (generalized for any graph):</p>
<blockquote>
<p>Let <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>K</mi><mi>n</mi></msub></mrow><annotationencoding="application/x-tex">K_n</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.8333em;vertical-align:-0.15em"></span><spanclass="mord"><spanclass="mord mathnormal"style="margin-right:0.07153em">K</span><spanclass="msupsub"><spanclass="vlist-t vlist-t2"><spanclass="vlist-r"><spanclass="vlist"style="height:0.1514em"><spanstyle="top:-2.55em;margin-left:-0.0715em;margin-right:0.05em"><spanclass="pstrut"style="height:2.7em"></span><spanclass="sizing reset-size6 size3 mtight"><spanclass="mord mathnormal mtight">n</span></span></span></span><spanclass="vlist-s"></span></span><spanclass="vlist-r"><spanclass="vlist"style="height:0.15em"><span></span></span></span></span></span></span></span></span></span> be complete graph. Let <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotationencoding="application/x-tex">P</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.6833em"></span><spanclass="mord mathnormal"style="margin-right:0.13889em">P</span></span></span></span> be the shortest path from <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mn>1</mn></msub></mrow><annotationencoding="application/x-tex">v_1</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.5806em;vertical-align:-0.15em"></span><spanclass="mord"><spanclass="mord mathnormal"style="margin-right:0.03588em">v</span><spanclass="msupsub"><spanclass="vlist-t vlist-t2"><spanclass="vlist-r"><spanclass="vlist"style="height:0.3011em"><spanstyle="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em"><spanclass="pstrut"style="height:2.7em"></span><spanclass="sizing reset-size6 size3 mtight"><spanclass="mord mtight">1</span></span></span></span><spanclass="vlist-s"></span></span><spanclass="vlist-r"><spanclass="vlist"style="height:0.15em"><span></span></span></span></span></span></span></span></span></span> to <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mi>n</mi></msub></mrow><annotationencoding="application/x-tex">v_n</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.5806em;vertical-align:-0.15em"></span><spanclass="mord"><spanclass="mord mathnormal"style="margin-right:0.03588em">v</span><spanclass="msupsub"><spanclass="vlist-t vlist-t2"><spanclass="vlist-r"><spanclass="vlist"style="height:0.1514em"><spanstyle="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em"><spanclass="pstrut"style="height:2.7em"></span><spanclass="sizing reset-size6 size3 mtight"><spanclass="mord mathnormal mtight">n</span></span></span></span><spanclass="vlist-s"></span></span><spanclass="vlist-r"><spanclass="vlist"style="height:0.15em"><span></span></span></span></span></span></span></span></span></span>
such that <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotationencoding="application/x-tex">P</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.6833em"></span><spanclass="mord mathnormal"style="margin-right:0.13889em">P</span></span></span></span> has <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>n</mi><mo>−</mo><mn>1</mn></mrow><annotationencoding="application/x-tex">n - 1</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.6667em;vertical-align:-0.0833em"></span><spanclass="mord mathnormal">n</span><spanclass="mspace"style="margin-right:0.2222em"></span><spanclass="mbin">−</span><spanclass="mspace"style="margin-right:0.2222em"></span></span><spanclass="base"><spanclass="strut"style="height:0.6444em"></span><spanclass="mord">1</span></span></span></span> edges, i.e. the shortest path between the two chosen
vertices visits all vertices (not necessarily in order) and has the lowest
cost.</p>
<p>In such scenario assume the worst-case ordering of the relaxations (only one
<em>helpful</em> relaxation per iteration). In this case, in each iteration we find
the next edge on our path <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotationencoding="application/x-tex">P</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.6833em"></span><spanclass="mord mathnormal"style="margin-right:0.13889em">P</span></span></span></span> as the last. This means that we need
<spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mimathvariant="normal">∣</mi><mi>V</mi><mimathvariant="normal">∣</mi><mo>−</mo><mn>1</mn></mrow><annotationencoding="application/x-tex">\vert V \vert - 1</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.22222em">V</span><spanclass="mord">∣</span><spanclass="mspace"style="margin-right:0.2222em"></span><spanclass="mbin">−</span><spanclass="mspace"style="margin-right:0.2222em"></span></span><spanclass="base"><spanclass="strut"style="height:0.6444em"></span><spanclass="mord">1</span></span></span></span> iterations to find the shortest path <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotationencoding="application/x-tex">P</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.6833em"></span><spanclass="mord mathnormal"style="margin-right:0.13889em">P</span></span></span></span>.</p>
<p>Because we have laid <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mi>P</mi></mrow><annotationencoding="application/x-tex">P</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.6833em"></span><spanclass="mord mathnormal"style="margin-right:0.13889em">P</span></span></span></span> as the shortest path from <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mn>1</mn></msub></mrow><annotationencoding="application/x-tex">v_1</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.5806em;vertical-align:-0.15em"></span><spanclass="mord"><spanclass="mord mathnormal"style="margin-right:0.03588em">v</span><spanclass="msupsub"><spanclass="vlist-t vlist-t2"><spanclass="vlist-r"><spanclass="vlist"style="height:0.3011em"><spanstyle="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em"><spanclass="pstrut"style="height:2.7em"></span><spanclass="sizing reset-size6 size3 mtight"><spanclass="mord mtight">1</span></span></span></span><spanclass="vlist-s"></span></span><spanclass="vlist-r"><spanclass="vlist"style="height:0.15em"><span></span></span></span></span></span></span></span></span></span> to <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mi>n</mi></msub></mrow><annotationencoding="application/x-tex">v_n</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.5806em;vertical-align:-0.15em"></span><spanclass="mord"><spanclass="mord mathnormal"style="margin-right:0.03588em">v</span><spanclass="msupsub"><spanclass="vlist-t vlist-t2"><spanclass="vlist-r"><spanclass="vlist"style="height:0.1514em"><spanstyle="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em"><spanclass="pstrut"style="height:2.7em"></span><spanclass="sizing reset-size6 size3 mtight"><spanclass="mord mathnormal mtight">n</span></span></span></span><spanclass="vlist-s"></span></span><spanclass="vlist-r"><spanclass="vlist"style="height:0.15em"><span></span></span></span></span></span></span></span></span></span> and it
visits all vertices, its prefixes are the shortest paths from <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><msub><mi>v</mi><mn>1</mn></msub></mrow><annotationencoding="application/x-tex">v_1</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:0.5806em;vertical-align:-0.15em"></span><spanclass="mord"><spanclass="mord mathnormal"style="margin-right:0.03588em">v</span><spanclass="msupsub"><spanclass="vlist-t vlist-t2"><spanclass="vlist-r"><spanclass="vlist"style="height:0.3011em"><spanstyle="top:-2.55em;margin-left:-0.0359em;margin-right:0.05em"><spanclass="pstrut"style="height:2.7em"></span><spanclass="sizing reset-size6 size3 mtight"><spanclass="mord mtight">1</span></span></span></span><spanclass="vlist-s"></span></span><spanclass="vlist-r"><spanclass="vlist"style="height:0.15em"><span></span></span></span></span></span></span></span></span></span> to any
other vertex in our graph.</p>
<p>Therefore, we can safely assume that any relaxation after <spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"><semantics><mrow><mimathvariant="normal">∣</mi><mi>V</mi><mimathvariant="normal">∣</mi><mo>−</mo><mn>1</mn></mrow><annotationencoding="application/x-tex">\vert V \vert - 1</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.22222em">V</span><spanclass="mord">∣</span><spanclass="mspace"style="margin-right:0.2222em"></span><spanclass="mbin">−</span><spanclass="mspace"style="margin-right:0.2222em"></span></span><spanclass="base"><spanclass="strut"style="height:0.6444em"></span><spanclass="mord">1</span></span></span></span>
iterations, is the effect of a negative loop in the graph.</p>
</blockquote>
<p><em>How can we leverage this?</em> We will go through the edges only as many times as
cells we have. Let's adjust the code to fix the looping:</p>
<h2class="anchor anchorWithStickyNavbar_LWe7"id="bellman-ford">Bellman-Ford<ahref="#bellman-ford"class="hash-link"aria-label="Direct link to Bellman-Ford"title="Direct link to Bellman-Ford"></a></h2>
<p>If you have ever attended any Algorithms course that had path-finding in its
syllabus, you probably feel like you've seen the algorithm above before<sup><ahref="#user-content-fn-3"id="user-content-fnref-3"data-footnote-ref="true"aria-describedby="footnote-label">3</a></sup>… And
yes, the first algorithm I have proposed is a very dumb version of the
<em>Bellman-Ford</em> algorithm, it's dumb, because it loops <!---->😉<!----> After our “looping”
prevention we got to the point that is almost the <em>Bellman-Ford</em> with the one
exception that it doesn't report whether there are any negative cycles, it just
ends.</p>
<p>Let's have a look at a proper implementation of the Bellman-Ford algorithm:</p>
<h3class="anchor anchorWithStickyNavbar_LWe7"id="on-the-bellman-ford">On the Bellman-Ford<ahref="#on-the-bellman-ford"class="hash-link"aria-label="Direct link to On the Bellman-Ford"title="Direct link to On the Bellman-Ford"></a></h3>
<p>You might be surprised that we have managed to iterate from a brute-force method
that mindlessly tries to find a better path until there are no better paths left
all the way to the Bellman-Ford algorithm.</p>
<p>I always say that Bellman-Ford is a <em>smart</em> brute-force. BF is also an algorithm
that leverages <em>dynamic programming</em>. You might wonder how can it utilize DP if
it is “technically” a brute-force technique. Table with the shortest distances
is the thing that makes it DP.</p>
<blockquote>
<p>I might not know the shortest path yet, but I do remember all of other paths,
and I can improve them, if possible.</p>
</blockquote>
<p>That's where the beauty of both <em>dynamic programming</em> and <em>relaxing</em> gets merged
together and does its magic.</p>
<p>Proof of the correctness of the BF is done via induction to the number of
iterations. I would suggest to try to prove the correctness yourself and
possibly look it up, if necessary.</p>
<p>Also the correctness of the BF relies on the conclusion we've made when fixing
the infinite-loop on our naïve BF solution.</p>
<h2class="anchor anchorWithStickyNavbar_LWe7"id="time-complexity">Time complexity<ahref="#time-complexity"class="hash-link"aria-label="Direct link to Time complexity"title="Direct link to Time complexity"></a></h2>
<p>Let's have a short look at the time complexities of the presented algorithms:</p>
<ol>
<li>
<p>naïve approach: given that there are no negative loops, we are bound by the
worst-case ordering of the relaxations which results in</p>
<spanclass="katex-display"><spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"display="block"><semantics><mrow><mimathvariant="script">O</mi><mostretchy="false">(</mo><mimathvariant="normal">∣</mi><mi>V</mi><mimathvariant="normal">∣</mi><mo>⋅</mo><mimathvariant="normal">∣</mi><mi>E</mi><mimathvariant="normal">∣</mi><mostretchy="false">)</mo></mrow><annotationencoding="application/x-tex">\mathcal{O}(\vert V \vert \cdot \vert E \vert)</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord mathcal"style="margin-right:0.02778em">O</span><spanclass="mopen">(</span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.22222em">V</span><spanclass="mord">∣</span><spanclass="mspace"style="margin-right:0.2222em"></span><spanclass="mbin">⋅</span><spanclass="mspace"style="margin-right:0.2222em"></span></span><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.05764em">E</span><spanclass="mord">∣</span><spanclass="mclose">)</span></span></span></span></span>
</li>
<li>
<p>our naïve approach with the fixed count of iterations instead of the
<code>do-while</code> loop results in the same worst-case time complexity:</p>
<spanclass="katex-display"><spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"display="block"><semantics><mrow><mimathvariant="normal">Θ</mi><mostretchy="false">(</mo><mimathvariant="normal">∣</mi><mi>V</mi><mimathvariant="normal">∣</mi><mo>⋅</mo><mimathvariant="normal">∣</mi><mi>E</mi><mimathvariant="normal">∣</mi><mostretchy="false">)</mo></mrow><annotationencoding="application/x-tex">\Theta(\vert V \vert \cdot \vert E \vert)</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord">Θ</span><spanclass="mopen">(</span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.22222em">V</span><spanclass="mord">∣</span><spanclass="mspace"style="margin-right:0.2222em"></span><spanclass="mbin">⋅</span><spanclass="mspace"style="margin-right:0.2222em"></span></span><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.05764em">E</span><spanclass="mord">∣</span><spanclass="mclose">)</span></span></span></span></span>
</li>
<li>
<p>and finally the well-known Bellman-Ford's algorithm time complexity:</p>
<spanclass="katex-display"><spanclass="katex"><spanclass="katex-mathml"><mathxmlns="http://www.w3.org/1998/Math/MathML"display="block"><semantics><mrow><mimathvariant="normal">Θ</mi><mostretchy="false">(</mo><mimathvariant="normal">∣</mi><mi>V</mi><mimathvariant="normal">∣</mi><mo>⋅</mo><mimathvariant="normal">∣</mi><mi>E</mi><mimathvariant="normal">∣</mi><mostretchy="false">)</mo></mrow><annotationencoding="application/x-tex">\Theta(\vert V \vert \cdot \vert E \vert)</annotation></semantics></math></span><spanclass="katex-html"aria-hidden="true"><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord">Θ</span><spanclass="mopen">(</span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.22222em">V</span><spanclass="mord">∣</span><spanclass="mspace"style="margin-right:0.2222em"></span><spanclass="mbin">⋅</span><spanclass="mspace"style="margin-right:0.2222em"></span></span><spanclass="base"><spanclass="strut"style="height:1em;vertical-align:-0.25em"></span><spanclass="mord">∣</span><spanclass="mord mathnormal"style="margin-right:0.05764em">E</span><spanclass="mord">∣</span><spanclass="mclose">)</span></span></span></span></span>
</li>
</ol>
<h2class="anchor anchorWithStickyNavbar_LWe7"id="small-refactor">Small refactor<ahref="#small-refactor"class="hash-link"aria-label="Direct link to Small refactor"title="Direct link to Small refactor"></a></h2>
<p>Since we are literally copy-pasting the body of the loops just for the sake of
relaxing, we can factor that part out into a separate function:</p>
both <em>Bellman-Ford</em> and <em>brute-force</em>. If you think about the way Bellman-Ford
algorithm works, you should realize that in the worst case it's updating the
shortest path till there no shorter path exists, so in a sense, you could really
consider it a brute-force algorithm.</p></div></div>
<sectiondata-footnotes="true"class="footnotes"><h2class="anchor anchorWithStickyNavbar_LWe7 sr-only"id="footnote-label">Footnotes<ahref="#footnote-label"class="hash-link"aria-label="Direct link to Footnotes"title="Direct link to Footnotes"></a></h2>
<ol>
<liid="user-content-fn-1">
<p><ahref="https://en.wikipedia.org/wiki/Breadth-first_search"target="_blank"rel="noopener noreferrer">Breadth-first search</a><ahref="#user-content-fnref-1"data-footnote-backref=""aria-label="Back to reference 1"class="data-footnote-backref">↩</a></p>
</li>
<liid="user-content-fn-2">
<p>Of course, there are some technicalities like keeping track of the visited
vertices to not taint the shortest path by already visited vertices. <ahref="#user-content-fnref-2"data-footnote-backref=""aria-label="Back to reference 2"class="data-footnote-backref">↩</a></p>
</li>
<liid="user-content-fn-3">
<p>or at least you should, LOL <ahref="#user-content-fnref-3"data-footnote-backref=""aria-label="Back to reference 3"class="data-footnote-backref">↩</a></p>
