Talk:Bellman–Ford algorithm: Difference between revisions

Content deleted Content added
mNo edit summary
 
(32 intermediate revisions by 17 users not shown)
Line 1:
{{WikiProject banner shell|class=C|vital=yes|1=
{{WikiProjectBannerShell|
{{mathsWikiProject rating|class=BMathematics|priority=Low|field=discrete|rating=poor}}
{{WikiProject Computer science|importance=mid|class=C}}
}}
{{User:MiszaBot/config
| algo=old(365d)
| archive=Talk:Bellman–Ford algorithm/Archive %(counter)d
| counter=31
| maxarchivesize=75K
| archiveheader={{Automatic archive navigator}}
Line 13:
}}
{{Archive box|auto=yes}}
== RELAX?!?!? DON'T TELL ME TO RELAX WITHOUT DEFINING IT!!! ==
What a terrible, atrocious article, made all the worse by that fact that I cannot find a single decent explanation of it online (at least nowhere on the first page of Google results). This article doesn't explain the algorithm. It just puts a bunch of jargon up and walks away. You call that an explanation? Fuck you and the jargon-speaking horse you rode in on! How do I submit this article for deletion? [[Special:Contributions/98.180.51.94|98.180.51.94]] ([[User talk:98.180.51.94|talk]]) 23:14, 30 April 2013 (UTC)
 
==== proposed answer ====
: Good job [https://en.wikipedia.org/w/index.php?title=Bellman%E2%80%93Ford_algorithm&diff=552968562&oldid=552967733 David Eppstein]! You seem like an awesome fellow! Hats off to you. :-) [[Special:Contributions/98.180.51.94|98.180.51.94]] ([[User talk:98.180.51.94|talk]]) 02:16, 1 May 2013 (UTC)
 
for i from 1 to size(vertices) - 1
yeah can find a decent step by step guide to this on line. one that describes each detail of each step otherwise im not going to get it. <span style="font-size: smaller;" class="autosigned">— Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/84.203.48.54|84.203.48.54]] ([[User talk:84.203.48.54|talk]]) 19:53, 21 May 2013 (UTC)</span><!-- Template:Unsigned IP --> <!--Autosigned by SineBot-->
is correct.
 
in other other words: you intentionally leave one vertex out.
== Assembly code==
reason:
Assembly code has no place in algorithm articles; it doesn't help explain the algorithm at all.
let a shortest path from '''s''' to an arbitrary vertex '''v''' contain ''k'' edges.
that means, the path ''p'' from s to v can be described as follows: ''p'' = ('''s''' = v<sub>0</sub>, v<sub>1</sub>, ..., v<sub>k-1</sub>, v<sub>k</sub> = '''v''').
in the worst case the shortest path visits all vertices of the graph. these are size(vertices). but the path between '''s''' and '''v''' only contains size(vertices) - 1 edges.
the algorithm tries to relax all edges for every edge on the shortest path - followingly, only size(vertices) - 1 relax-iterations have to be computed.
 
As for what '''u''' is supposed to be, '''(u, v)''' is the entire edge, starting at vertex '''u''' and finishing at vertex '''v'''. <!-- Template:Unsigned IP --><small class="autosigned">—&nbsp;Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/125.239.41.100|125.239.41.100]] ([[User talk:125.239.41.100#top|talk]]) 03:46, 24 November 2023 (UTC)</small> <!--Autosigned by SineBot-->
I removed the license notice and the attribution to "JellyWorld" from the C code. Fortunately, the license was GFDL-compatible, and it permitted the attribution to be removed.
 
==Bellman–Ford algorithm in the informational description of the black hole==
[[User:Rspeer|RSpeer]] 17:46, Apr 21, 2005 (UTC)
 
Write the text.
I changed the problem from weighted graph to weighted *digraph* because Bellman Ford fails spectacularly on undirected graphs: If there is a negative weight edge, say {u, v}, then Bellman-Ford will get stuck updating u and v foreover, even if there is no negative weight cycle. This subtlety may be worth mentioning in the main article. To find shortest paths in undirected graphs with negative edge weights, you can reduce the problem to weighted nonbipartite matching.
 
Does the shortest path of the informational chunks always result in a mixed state? We want that because a pure state will lead to informational loss. One other option is that informational loss exists, but isn't fundamental, because it is the result of untangling a more fundamental field, and dissipating that infoloss into the same spacetime field as virtual particles. <!-- Template:Unsigned IP --><small class="autosigned">—&nbsp;Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/2A02:587:4118:7CA3:2891:994B:40B:F97D|2A02:587:4118:7CA3:2891:994B:40B:F97D]] ([[User talk:2A02:587:4118:7CA3:2891:994B:40B:F97D#top|talk]]) 21:15, 7 August 2020 (UTC)</small> <!--Autosigned by SineBot-->
:Whether this has anything real to do with shortest paths, or is just buzzword salad, I'm not sure, but it doesn't appear to have anything to do with this article, which is about a specific method for finding shortest paths and not on the general topic of shortest paths. And it also appears to be off-topic for this talk page, which is about improvements to the article based on published [[WP:RS|reliable sources]]. —[[User:David Eppstein|David Eppstein]] ([[User talk:David Eppstein|talk]]) 21:42, 7 August 2020 (UTC)
 
== Animated example ==
If both loops cycle directly through the number of vertexes (on the top loop) and on the edges (the second one), how come it would be "forever"? In such a loop there's no way it will be infinit. Or am I picturing the whole thing wrong? <span style="font-size: smaller;" class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/87.196.85.225|87.196.85.225]] ([[User talk:87.196.85.225|talk]]) 02:02, 19 February 2009 (UTC)</span><!-- Template:UnsignedIP --> <!--Autosigned by SineBot-->
 
The animated gif in the article, while it is a very good initiative, seems to be either wrong or at least confusing.
== Negative weight cycles ==
 
First of all, what do the numbers next to the vertices mean? If they're the estimated distances, then iiuc they're not supposed to increase. But they do: v4 changes from 4 to 6 between frame #5 and frame #6, just as v3 does between frame #4 and frame #5.
Please cite a source saying that Bellman-Ford can be used to find simple paths on networks with negative cycles, or else correct this section. All sources I can find say that simple paths cannot be found on a network with negative cycles. This includes [http://reference.wolfram.com/mathematica/Combinatorica/ref/BellmanFord.html Wolfram's implementation] of Bellman-Ford, as well as Yen's 1971 paper "Finding the k shortest loopless paths in a network" published in Management Science (vol 17, no 11). Corman's book cited in the article also states that Bellman-Ford can't find paths in networks with negative cycles. <small><span class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[User:ToneDaBass|ToneDaBass]] ([[User talk:ToneDaBass|talk]] • [[Special:Contributions/ToneDaBass|contribs]]) 02:15, 3 August 2010 (UTC)</span></small><!-- Template:Unsigned --> <!--Autosigned by SineBot-->
 
Also, aren't there supposed to be 5 frames instead of 6? That is, the initial state plus the |V|-1 = 4 steps of the algorithm.
== Zero weight cycles ==
 
And what do the thick arrows and grey vertices mean? Are they the vertices we already have the final distances of, and the shortest paths leading to them? The problem with this is that the algorithm is not supposed to "know" these at that point - if we stop there, we cannot be sure that we would not get better results (shorter paths) for these vertices in a later step.
I seems to me that if a graph has some cycle that weighs zero between start and end, then there could be infinite shortest paths. If this is correct, then the correctnes proof should be rewritten a little so that it states all the cases. --[[User:Hdante|Hdante]] 18:40, 7 November 2005 (UTC)
 
From what I understand, there may be many more than a single shortest path (think of two equal routes), and Bellman-Ford is guaranteed to find one of them. Thus an infinite number of equal shortest paths is not a problem. The issue with negative weight cycles is that you can always find a better path by adding one more cycle to the path and as such there is no shortest path. [[User:Kyeprime|kyeprime]] ([[User talk:Kyeprime|talk]]) 19:17, 21 April 2010 (UTC)
 
==== Thoughts by another editor ====
In every finite graph, there is only a finite number of paths, because no path may visit a vertex or an edge twice. Therefore, there is only a finite number of shortest paths, too. However, finding a shortest path in graphs with arbitrary edge-weights is NP-hard. [[User:Morgurth|Morgurth]] ([[User talk:Morgurth|talk]]) 12:13, 1 November 2011 (UTC)
 
I agree with the confusion. I believe that v3 and v4 incorrectly update. There is no possible path by which the cost to v4 is 4, so there's no way the algorithm should ever update the weight to 4. And like the parent said, the algorithm should never increase the weight, so v3 shouldn't temporarily change to 6 and back to 4. I think the original creator of the gif simply swapped the two values by accident.
Note: And with path, I mean simple path in the terminology that is used on Wikipedia. [[User:Morgurth|Morgurth]] ([[User talk:Morgurth|talk]]) 12:32, 1 November 2011 (UTC)
 
It also converges after 3 cycles, which is common for this algorithm. In fact, this algorithm can converge after 1 cycle, if the optimal path is (randomly) selected.
== Counting to infinity ==
 
I think removing the bold edges, darkening of the vertexes, and stopping the animation after the 3rd frame would really help this page, but I didn't make the change in case I misunderstand the algorithm.
I didn't know what "counting to infinity" meant in the list of limitations of the distributed algorithm, so I searched around a bit and added a few words expressing what I found. But if anyone has a better explanation, please do add. -- [[User:Orbst|Orbst]] 15:29, 17 April 2006 (UTC)
 
P.S. First comment. Please don't bite the newcomer. I couldn't find a way to comment on the original post so I added to it.
== How do you compile the C code? ==
 
[[User:Lothsahn|Lothsahn]] ([[User talk:Lothsahn|talk]]) 21:47, 31 October 2021 (UTC)
That would be nice if you can modify the C source code so that it compiles with gcc. When I copy/paste the code and compiles it with gcc, it gives me:
 
:Seems that the gif has been updated since then, but I still think it's not correct. On the frame that "t" changes from 6 to 2, shouldn't z change to -2 too instead of happening in the next frame? It suggests that z updates on the next loop after the t update one, but if I'm not mistaken it should be on the same frame since t changes to 2 and then after checking x and y, when it checks for z it should see that t is now -2 and not 6. Atleast that's what I understand should happen after reading the pseudocode. [[User:Marco2124|Marco2124]] ([[User talk:Marco2124|talk]]) 20:01, 7 December 2022 (UTC)
/usr/lib/gcc/powerpc-linux-gnu/3.4.5/../../../../lib/crt1.o:(.rodata+0x4): undefined reference to `main'
collect2: ld returned 1 exit status
 
== New preprint ==
:Defining main() would probably be a good start. :P Compiling to object code works just fine; you've forgotten the "-o" flag to gcc. [[User:164.55.254.106|164.55.254.106]] 18:51, 31 May 2006 (UTC)
 
Seems soon (after peer-review) there finally might be an improvement to this absolutely classical algorithm
== Computational complexity ==
https://arxiv.org/abs/2311.02520 [[Special:Contributions/2A00:20:5:B593:5C8F:D801:68C2:458|2A00:20:5:B593:5C8F:D801:68C2:458]] ([[User talk:2A00:20:5:B593:5C8F:D801:68C2:458|talk]]) 00:29, 8 November 2023 (UTC)
Could you add info about computational complexity of the algorithm? ~~[[User:helix84|helix84]] 22:37, 4 October 2006 (UTC)
 
:Let's wait until it's at least been accepted to a conference before adding anything here. Anyway, the right place is [[Shortest path problem]], because it's a different algorithm than BF. —[[User:David Eppstein|David Eppstein]] ([[User talk:David Eppstein|talk]]) 05:02, 8 November 2023 (UTC)
In the worst case this algorithm uses O(V<sup>3</sup>) time in order to find single-source shortest paths. This is not very efficient. By a slight modification it can find all-pairs shortest paths in the same time. [[User:Tomo|Tomo]] 08:13, 16 December 2006 (UTC)
 
== sizeof ==
 
Comparing sizeof(int) and sizeof *distance form which both acomplish the same thing. The former form is much more idiom and recognisable to most programmers, the second is a less common form. Indeed the [http://publications.gbdirect.co.uk/c_book/chapter5/sizeof_and_malloc.html The C Book] says the form without brackets is rarely used. This particular instance is confusing for two reasons a) the * could be mistaken for multiplication b) as distance is declared on the same line it provokes the question as to whether the compiler knows about the size of *distance yet. If we are aiming more maximum comprehensability the former seems perferable. --[[User:Salix alba|Salix alba]] ([[User talk:Salix alba|talk]]) 00:55, 19 May 2007 (UTC)
 
== In popular culture ==
 
I don't know that this is encyclopedia worthy, but for folks working on this page, this might be an amusing reference:
: http://xkcd.com/69/
--[[User:JakeVortex|Jake]] 01:04, 11 September 2007 (UTC)
 
== A doubt ==
Are we sure this is the Bellman-Ford algorithm and not the generic labeling method? There's a source in which Bellman-Ford is described as an optimization of the labeling algorithm using a FIFO queue. (http://avglab.com/andrew/pub/neci-tr-96-029.ps). This is just a question, I am right now confused because of different sources describing a very different algorithm.
[[User:Vexorian|Vexorian]] ([[User talk:Vexorian|talk]]) 13:01, 17 January 2009 (UTC)
 
FIFO Bellman-Ford is an optimization for the Bellman-Ford algorithm.
The generic relabel-relax method is defined differently, informal description follows:
 
'''generic relabel-relax''':
''// I Initialize''
'''for each''' vertex v '''in''' vertices:
'''if''' v '''is''' source '''then''' v.distance := 0
'''else''' v.distance := '''infinity'''
v.predecessor := '''null'''
''// II Loop''
'''while''' (edge uv that can be relaxed) '''exists''':
relax (u, v, λ) <span style="font-size: smaller;" class="autosigned">— Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/188.192.84.92|188.192.84.92]] ([[User talk:188.192.84.92|talk]]) 11:54, 3 September 2011 (UTC)</span><!-- Template:Unsigned IP --> <!--Autosigned by SineBot-->
 
== Undefined Terms ==
 
This article uses the terms "relax" and "relaxation" in a specific technical sense, but gives no definition. The use of undefined terms in mathematical writing is considered poor form. -- [[Special:Contributions/172.191.112.126|172.191.112.126]] ([[User talk:172.191.112.126|talk]]) 23:08, 25 February 2009 (UTC)
 
Very much agreed, I have found many definitions of this and many other algorithms all with lack of definition of specific terms. <span style="font-size: smaller;" class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/66.119.173.210|66.119.173.210]] ([[User talk:66.119.173.210|talk]]) 17:11, 15 May 2009 (UTC)</span><!-- Template:UnsignedIP --> <!--Autosigned by SineBot-->
 
== Dijkstra is not greedy ==
 
The Shortest-Path-Problem for graphs with non-negative-weights doesn't have a [[matroid]] or [[greedoid]] structure. Therefore this problem cannot be solved by an greedy-algorithm. Therefore Dijkstra is not greedy. <span style="font-size: smaller;" class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/131.220.109.37|131.220.109.37]] ([[User talk:131.220.109.37|talk]]) 09:29, 23 March 2009 (UTC)</span><!-- Template:UnsignedIP --> <!--Autosigned by SineBot-->
 
:Have you read the Wikipedia article on [[Dijkstra's algorithm]]? Both that article and this one make a pretty good case for calling Dijkstra's algorithm "greedy" (in comparison to algorithms like this one that are more "open-minded" and can't be "tricked" by promising paths that turn out to be dead ends). See also [http://www.google.com/search?q=dijkstra%27s.algorithm.greedy Google.] I don't know what "[[matroid]] or [[greedoid]] structure" has to do with this article; I guess you're talking about a very highly specialized use of the word "greedy" that this article isn't using. Anyway, it would make sense to take this up at [[Talk:Dijkstra's algorithm]], at least until that article stops referring to Dijkstra's algorithm as "greedy". :) --[[User:Quuxplusone|Quuxplusone]] ([[User talk:Quuxplusone|talk]]) 06:45, 24 March 2009 (UTC)
 
Bellmam ford algorithm can be used in the network having negative terms in the nodes.I <span style="font-size: smaller;" class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/59.98.124.227|59.98.124.227]] ([[User talk:59.98.124.227|talk]]) 06:38, 24 March 2009 (UTC)</span><!-- Template:UnsignedIP --> <!--Autosigned by SineBot-->
 
The [[greedoid]] page that you linked to explicitly lists Dijkstra's algorithm as an example. So, uh, yeah. <span style="font-size: smaller;" class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/68.43.177.99|68.43.177.99]] ([[User talk:68.43.177.99|talk]]) 16:31, 7 May 2009 (UTC)</span><!-- Template:UnsignedIP --> <!--Autosigned by SineBot-->
 
== Implementation removed ==
 
I removed the "C implementation" section. This seems to be out of place in a wikipedia article. There is already the pseudocode, which conveys how that algorithm works. The C code is quite long, difficult to verify, and redundant. And a GFDL license is not really useful for sharing code. There is also a discussion at [http://en.wikipedia.org/wiki/Wikipedia_talk:WikiProject_Computer_science#Source_code_written_by_editors] that led me here. &mdash;&nbsp;Carl <small>([[User:CBM|CBM]]&nbsp;·&nbsp;[[User talk:CBM|talk]])</small> 00:24, 8 April 2009 (UTC)
 
== As hard as an NP-complete problem ==
 
The last paragraph in the summary, regarding "the shortest path that does not repeat any vertex in such a graph", states:
:"This problem is at least as hard as the NP-complete longest path problem."
This seems like a very silly expression. Doesn't it just mean that the problem at least as hard as '''any''' NP-complete problem - which can be best stated by just calling it [[NP-hard]]? ~&nbsp;[[User:Booyabazooka|Booya <sup>Bazooka</sup>]] 23:02, 4 October 2009 (UTC)
 
Perhaps what we should say is more along the lines of
:This problem is [[NP-hard]], which can be shown via a reduction to the [[longest path problem]].
~&nbsp;[[User:Booyabazooka|Booya <sup>Bazooka</sup>]] 20:50, 5 October 2009 (UTC)
 
== Path vs. Walk ==
 
The article consistently mentions ''path'' (which, by definition, is required to not duplicate any vertex) when it means ''walk'' (any sequence of adjacent edges, repeating vertices are possible). This should be imho fixed... In fact, Bellman-Ford algorithm finds shortest walks of length at most n. Requiring shortest ''paths'' is what makes the problem hard. <span style="font-size: smaller;" class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/129.132.153.228|129.132.153.228]] ([[User talk:129.132.153.228|talk]]) 12:44, 4 February 2010 (UTC)</span><!-- Template:UnsignedIP --> <!--Autosigned by SineBot-->
 
 
== Unclarity ==
 
Introduction says: "Bellman-Ford cannot find the shortest path that does not repeat any vertex in such a graph". I can't understand this sentence at all. Did someone want to say that B-F cannot find the negative cycle, it is only able to detect it? <span style="font-size: smaller;" class="autosigned">—Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/78.157.76.143|78.157.76.143]] ([[User talk:78.157.76.143|talk]]) 05:41, 21 April 2010 (UTC)</span><!-- Template:UnsignedIP --> <!--Autosigned by SineBot-->
: I made several changes. Hopefully, it's a little clearer. <b>[[User:Justin W Smith|Justin W Smith]]</b> <i><sup>[[User talk:Justin W Smith|talk]]</sup>/<sub>[[Special:Contributions/Justin W Smith|stalk]]</sub></i> 06:16, 21 April 2010 (UTC)
 
==Reduction from an NP-Complete problem?==
 
The lead cites a reduction by Sedgewick from the [[NP-Complete]] [[Hamiltonian path problem]] to the [[shortest path problem]]. Since the shortest path problem (even <ins>for all-pairs</ins> with <ins>edges of</ins> negative weight<del>s</del>) is not NP-Complete (i.e., Floyd-Warshall = O(n^3)), something needs to be clarified/corrected. <b>[[User:Justin W Smith|Justin W Smith]]</b> <i><sup>[[User talk:Justin W Smith|talk]]</sup>/<sub>[[Special:Contributions/Justin W Smith|stalk]]</sub></i> 06:15, 21 April 2010 (UTC)
: I think I figured out what was being said. If someone could verify this, I would appreciate it. <b>[[User:Justin W Smith|Justin W Smith]]</b> <i><sup>[[User talk:Justin W Smith|talk]]</sup>/<sub>[[Special:Contributions/Justin W Smith|stalk]]</sub></i> 14:08, 21 April 2010 (UTC)
 
The shortest (simple) path problem with arbitrary edge-weights is NP-hard. Moore-Bellman-Ford and Floyd-Warshall work only on graphs with conservative edge weights, i.e., there may be no cycles of negative total weight. In fact, MBF and FW compute a shortest walk with at most |V|-1 edges. In the case of conservative edge weights, these happen to be shortest (simple) paths. If there are negative cycles, this is not true. [[User:Morgurth|Morgurth]] ([[User talk:Morgurth|talk]]) 12:38, 1 November 2011 (UTC)
 
== Pseudocode bug? ==
Line 154 ⟶ 81:
for each edge (u, v) with weight w in edges:
in this line what is u ? I beleive u should be changed to i or vice versa. <span style="font-size: smaller;" class="autosigned">— Preceding [[Wikipedia:Signatures|unsigned]] comment added by [[Special:Contributions/49.203.64.216|49.203.64.216]] ([[User talk:49.203.64.216|talk]]) 08:38, 25 May 2014 (UTC)</span><!-- Template:Unsigned IP --> <!--Autosigned by SineBot-->
:If there are n vertices, the algorithm needs to iterate n-1 times (as in the given pseudocode), not n times (as your change would have it). It starts out with one vertex having the correct distance (the starting vertex) and each iteration adds one more, so only n-1 iterations are needed until all are correct. If you implemented it correctly the nth iteration would be useless. Further, the case where exactly n-1 iterations are necessary should be unusual: it only happens when the shortest path runs through all vertices and the order of relaxation within an iteration is backwards for the edges of this path. So I strongly suspect it is some other bug in your program. —[[User:David Eppstein|David Eppstein]] ([[User talk:David Eppstein|talk]]) 08:20, 24 November 2023 (UTC)
 
== Proposed Merger: [[SPFA]] into Optimizations ==
==== proposed answer ====
 
for i from 1 to size(vertices) - 1
is correct.
 
in other other words: you intentionally leave one vertex out.
reason:
let a shortest path from '''s''' to an arbitrary vertex '''v''' contain ''k'' edges.
that means, the path ''p'' from s to v can be described as follows: ''p'' = ('''s''' = v<sub>0</sub>, v<sub>1</sub>, ..., v<sub>k-1</sub>, v<sub>k</sub> = '''v''').
in the worst case the shortest path visits all vertices of the graph. these are size(vertices). but the path between '''s''' and '''v''' only contains size(vertices) - 1 edges.
the algorithm tries to relax all edges for every edge on the shortest path - followingly, only size(vertices) - 1 relax-iterations have to be computed.
 
Pretty much all in the title. The Moore Optimization has a whole article, which takes its name after that in the Fanding Duan article (1994) which popularized it in China. The relevance of having a whole article for it, since its worst case is the same as Bellman-Ford, does not seem to meet the standard. [[User:Wyrdwritere|Wyrdwritere]] ([[User talk:Wyrdwritere|talk]]) 03:51, 7 April 2024 (UTC)
== Improvement to Yen's improvement ==
 
:{{done}} —[[User:David Eppstein|David Eppstein]] ([[User talk:David Eppstein|talk]]) 01:13, 10 June 2024 (UTC)
Re the "Yen's improvement" section of our article: an additional improvement by a factor of 2/3 may be obtained by choosing the linear ordering of the vertices randomly rather than arbitrarily. See {{citation|contribution=Randomized speedup of the Bellman–Ford algorithm|first1=M. J.|last1=Bannister|first2=D.|last2=Eppstein|author2-link=David Eppstein|arxiv=1111.5414|title=Analytic Algorithmics and Combinatorics (ANALCO12), Kyoto, Japan|year=2012|pages=41–47|url=http://siam.omnibooksonline.com/2012ANALCO/data/papers/005.pdf}}. I'm leaving this note here rather than adding the reference myself because of the obvious conflict of interest. —[[User:David Eppstein|David Eppstein]] ([[User talk:David Eppstein|talk]]) 03:00, 10 December 2012 (UTC)