话不多说，拿来主义，直接上代码！
PS:打印最短路径我还不晓得怎么加，如有哪位大神知道，还请mark一下！
1 /***********************************************************************
2 * File: FibonacciHeap.java
3 * Author: Keith Schwarz ([email protected])
4 *
5 * An implementation of a priority queue backed by a Fibonacci heap,
6 * as described by Fredman and Tarjan. Fibonacci heaps are interesting
7 * theoretically because they have asymptotically good runtime guarantees
8 * for many operations. In particular, insert, peek, and decrease-key all
9 * run in amortized O(1) time. dequeueMin and delete each run in amortized
10 * O(lg n) time. This allows algorithms that rely heavily on decrease-key
11 * to gain significant performance boosts. For example, Dijkstra‘s algorithm
12 * for single-source shortest paths can be shown to run in O(m + n lg n) using
13 * a Fibonacci heap, compared to O(m lg n) using a standard binary or binomial
14 * heap.
15 *
16 * Internally, a Fibonacci heap is represented as a circular, doubly-linked
17 * list of trees obeying the min-heap property. Each node stores pointers
18 * to its parent (if any) and some arbitrary child. Additionally, every
19 * node stores its degree (the number of children it has) and whether it
20 * is a "marked" node. Finally, each Fibonacci heap stores a pointer to
21 * the tree with the minimum value.
22 *
23 * To insert a node into a Fibonacci heap, a singleton tree is created and
24 * merged into the rest of the trees. The merge operation works by simply
25 * splicing together the doubly-linked lists of the two trees, then updating
26 * the min pointer to be the smaller of the minima of the two heaps. Peeking
27 * at the smallest element can therefore be accomplished by just looking at
28 * the min element. All of these operations complete in O(1) time.
29 *
30 * The tricky operations are dequeueMin and decreaseKey. dequeueMin works
31 * by removing the root of the tree containing the smallest element, then
32 * merging its children with the topmost roots. Then, the roots are scanned
33 * and merged so that there is only one tree of each degree in the root list.
34 * This works by maintaining a dynamic array of trees, each initially null,
35 * pointing to the roots of trees of each dimension. The list is then scanned
36 * and this array is populated. Whenever a conflict is discovered, the
37 * appropriate trees are merged together until no more conflicts exist. The
38 * resulting trees are then put into the root list. A clever analysis using
39 * the potential method can be used to show that the amortized cost of this
40 * operation is O(lg n), see "Introduction to Algorithms, Second Edition" by
41 * Cormen, Rivest, Leiserson, and Stein for more details.
42 *
43 * The other hard operation is decreaseKey, which works as follows. First, we
44 * update the key of the node to be the new value. If this leaves the node
45 * smaller than its parent, we‘re done. Otherwise, we cut the node from its
46 * parent, add it as a root, and then mark its parent. If the parent was
47 * already marked, we cut that node as well, recursively mark its parent,
48 * and continue this process. This can be shown to run in O(1) amortized time
49 * using yet another clever potential function. Finally, given this function,
50 * we can implement delete by decreasing a key to -\infty, then calling
51 * dequeueMin to extract it.
52 */
53
54 import java.util.*; // For ArrayList
55
56 /**
57 * A class representing a Fibonacci heap.
58 *
59 * @param T The type of elements to store in the heap.
60 * @author Keith Schwarz ([email protected])
61 */
62 public final class FibonacciHeap<T> {
63 /* In order for all of the Fibonacci heap operations to complete in O(1),
64 * clients need to have O(1) access to any element in the heap. We make
65 * this work by having each insertion operation produce a handle to the
66 * node in the tree. In actuality, this handle is the node itself, but
67 * we guard against external modification by marking the internal fields
68 * private.
69 */
70 public static final class Entry<T> {
71 private int mDegree = 0; // Number of children
72 private boolean mIsMarked = false; // Whether this node is marked
73
74 private Entry<T> mNext; // Next and previous elements in the list
75 private Entry<T> mPrev;
76
77 private Entry<T> mParent; // Parent in the tree, if any.
78
79 private Entry<T> mChild; // Child node, if any.
80
81 private T mElem; // Element being stored here
82 private double mPriority; // Its priority
83
84 /**
85 * Returns the element represented by this heap entry.
86 *
87 * @return The element represented by this heap entry.
88 */
89 public T getValue() {
90 return mElem;
91 }
92 /**
93 * Sets the element associated with this heap entry.
94 *
95 * @param value The element to associate with this heap entry.
96 */
97 public void setValue(T value) {
98 mElem = value;
99 }
100
101 /**
102 * Returns the priority of this element.
103 *
104 * @return The priority of this element.
105 */
106 public double getPriority() {
107 return mPriority;
108 }
109
110 /**
111 * Constructs a new Entry that holds the given element with the indicated
112 * priority.
113 *
114 * @param elem The element stored in this node.
115 * @param priority The priority of this element.
116 */
117 private Entry(T elem, double priority) {
118 mNext = mPrev = this;
119 mElem = elem;
120 mPriority = priority;
121 }
122 }
123
124 /* Pointer to the minimum element in the heap. */
125 private Entry<T> mMin = null;
126
127 /* Cached size of the heap, so we don‘t have to recompute this explicitly. */
128 private int mSize = 0;
129
130 /**
131 * Inserts the specified element into the Fibonacci heap with the specified
132 * priority. Its priority must be a valid double, so you cannot set the
133 * priority to NaN.
134 *
135 * @param value The value to insert.
136 * @param priority Its priority, which must be valid.
137 * @return An Entry representing that element in the tree.
138 */
139 public Entry<T> enqueue(T value, double priority) {
140 checkPriority(priority);
141
142 /* Create the entry object, which is a circularly-linked list of length
143 * one.
144 */
145 Entry<T> result = new Entry<T>(value, priority);
146
147 /* Merge this singleton list with the tree list. */
148 mMin = mergeLists(mMin, result);
149
150 /* Increase the size of the heap; we just added something. */
151 ++mSize;
152
153 /* Return the reference to the new element. */
154 return result;
155 }
156
157 /**
158 * Returns an Entry object corresponding to the minimum element of the
159 * Fibonacci heap, throwing a NoSuchElementException if the heap is
160 * empty.
161 *
162 * @return The smallest element of the heap.
163 * @throws NoSuchElementException If the heap is empty.
164 */
165 public Entry<T> min() {
166 if (isEmpty())
167 throw new NoSuchElementException("Heap is empty.");
168 return mMin;
169 }
170
171 /**
172 * Returns whether the heap is empty.
173 *
174 * @return Whether the heap is empty.
175 */
176 public boolean isEmpty() {
177 return mMin == null;
178 }
179
180 /**
181 * Returns the number of elements in the heap.
182 *
183 * @return The number of elements in the heap.
184 */
185 public int size() {
186 return mSize;
187 }
188
189 /**
190 * Given two Fibonacci heaps, returns a new Fibonacci heap that contains
191 * all of the elements of the two heaps. Each of the input heaps is
192 * destructively modified by having all its elements removed. You can
193 * continue to use those heaps, but be aware that they will be empty
194 * after this call completes.
195 *
196 * @param one The first Fibonacci heap to merge.
197 * @param two The second Fibonacci heap to merge.
198 * @return A new FibonacciHeap containing all of the elements of both
199 * heaps.
200 */
201 public static <T> FibonacciHeap<T> merge(FibonacciHeap<T> one, FibonacciHeap<T> two) {
202 /* Create a new FibonacciHeap to hold the result. */
203 FibonacciHeap<T> result = new FibonacciHeap<T>();
204
205 /* Merge the two Fibonacci heap root lists together. This helper function
206 * also computes the min of the two lists, so we can store the result in
207 * the mMin field of the new heap.
208 */
209 result.mMin = mergeLists(one.mMin, two.mMin);
210
211 /* The size of the new heap is the sum of the sizes of the input heaps. */
212 result.mSize = one.mSize + two.mSize;
213
214 /* Clear the old heaps. */
215 one.mSize = two.mSize = 0;
216 one.mMin = null;
217 two.mMin = null;
218
219 /* Return the newly-merged heap. */
220 return result;
221 }
222
223 /**
224 * Dequeues and returns the minimum element of the Fibonacci heap. If the
225 * heap is empty, this throws a NoSuchElementException.
226 *
227 * @return The smallest element of the Fibonacci heap.
228 * @throws NoSuchElementException If the heap is empty.
229 */
230 public Entry<T> dequeueMin() {
231 /* Check for whether we‘re empty. */
232 if (isEmpty())
233 throw new NoSuchElementException("Heap is empty.");
234
235 /* Otherwise, we‘re about to lose an element, so decrement the number of
236 * entries in this heap.
237 */
238 --mSize;
239
240 /* Grab the minimum element so we know what to return. */
241 Entry<T> minElem = mMin;
242
243 /* Now, we need to get rid of this element from the list of roots. There
244 * are two cases to consider. First, if this is the only element in the
245 * list of roots, we set the list of roots to be null by clearing mMin.
246 * Otherwise, if it‘s not null, then we write the elements next to the
247 * min element around the min element to remove it, then arbitrarily
248 * reassign the min.
249 */
250 if (mMin.mNext == mMin) { // Case one
251 mMin = null;
252 }
253 else { // Case two
254 mMin.mPrev.mNext = mMin.mNext;
255 mMin.mNext.mPrev = mMin.mPrev;
256 mMin = mMin.mNext; // Arbitrary element of the root list.
257 }
258
259 /* Next, clear the parent fields of all of the min element‘s children,
260 * since they‘re about to become roots. Because the elements are
261 * stored in a circular list, the traversal is a bit complex.
262 */
263 if (minElem.mChild != null) {
264 /* Keep track of the first visited node. */
265 Entry<?> curr = minElem.mChild;
266 do {
267 curr.mParent = null;
268
269 /* Walk to the next node, then stop if this is the node we
270 * started at.
271 */
272 curr = curr.mNext;
273 } while (curr != minElem.mChild);
274 }
275
276 /* Next, splice the children of the root node into the topmost list,
277 * then set mMin to point somewhere in that list.
278 */
279 mMin = mergeLists(mMin, minElem.mChild);
280
281 /* If there are no entries left, we‘re done. */
282 if (mMin == null) return minElem;
283
284 /* Next, we need to coalsce all of the roots so that there is only one
285 * tree of each degree. To track trees of each size, we allocate an
286 * ArrayList where the entry at position i is either null or the
287 * unique tree of degree i.
288 */
289 List<Entry<T>> treeTable = new ArrayList<Entry<T>>();
290
291 /* We need to traverse the entire list, but since we‘re going to be
292 * messing around with it we have to be careful not to break our
293 * traversal order mid-stream. One major challenge is how to detect
294 * whether we‘re visiting the same node twice. To do this, we‘ll
295 * spent a bit of overhead adding all of the nodes to a list, and
296 * then will visit each element of this list in order.
297 */
298 List<Entry<T>> toVisit = new ArrayList<Entry<T>>();
299
300 /* To add everything, we‘ll iterate across the elements until we
301 * find the first element twice. We check this by looping while the
302 * list is empty or while the current element isn‘t the first element
303 * of that list.
304 */
305 for (Entry<T> curr = mMin; toVisit.isEmpty() || toVisit.get(0) != curr; curr = curr.mNext)
306 toVisit.add(curr);
307
308 /* Traverse this list and perform the appropriate unioning steps. */
309 for (Entry<T> curr: toVisit) {
310 /* Keep merging until a match arises. */
311 while (true) {
312 /* Ensure that the list is long enough to hold an element of this
313 * degree.
314 */
315 while (curr.mDegree >= treeTable.size())
316 treeTable.add(null);
317
318 /* If nothing‘s here, we‘re can record that this tree has this size
319 * and are done processing.
320 */
321 if (treeTable.get(curr.mDegree) == null) {
322 treeTable.set(curr.mDegree, curr);
323 break;
324 }
325
326 /* Otherwise, merge with what‘s there. */
327 Entry<T> other = treeTable.get(curr.mDegree);
328 treeTable.set(curr.mDegree, null); // Clear the slot
329
330 /* Determine which of the two trees has the smaller root, storing
331 * the two tree accordingly.
332 */
333 Entry<T> min = (other.mPriority < curr.mPriority)? other : curr;
334 Entry<T> max = (other.mPriority < curr.mPriority)? curr : other;
335
336 /* Break max out of the root list, then merge it into min‘s child
337 * list.
338 */
339 max.mNext.mPrev = max.mPrev;
340 max.mPrev.mNext = max.mNext;
341
342 /* Make it a singleton so that we can merge it. */
343 max.mNext = max.mPrev = max;
344 min.mChild = mergeLists(min.mChild, max);
345
346 /* Reparent max appropriately. */
347 max.mParent = min;
348
349 /* Clear max‘s mark, since it can now lose another child. */
350 max.mIsMarked = false;
351
352 /* Increase min‘s degree; it now has another child. */
353 ++min.mDegree;
354
355 /* Continue merging this tree. */
356 curr = min;
357 }
358
359 /* Update the global min based on this node. Note that we compare
360 * for <= instead of < here. That‘s because if we just did a
361 * reparent operation that merged two different trees of equal
362 * priority, we need to make sure that the min pointer points to
363 * the root-level one.
364 */
365 if (curr.mPriority <= mMin.mPriority) mMin = curr;
366 }
367 return minElem;
368 }
369
370 /**
371 * Decreases the key of the specified element to the new priority. If the
372 * new priority is greater than the old priority, this function throws an
373 * IllegalArgumentException. The new priority must be a finite double,
374 * so you cannot set the priority to be NaN, or +/- infinity. Doing
375 * so also throws an IllegalArgumentException.
376 *
377 * It is assumed that the entry belongs in this heap. For efficiency
378 * reasons, this is not checked at runtime.
379 *
380 * @param entry The element whose priority should be decreased.
381 * @param newPriority The new priority to associate with this entry.
382 * @throws IllegalArgumentException If the new priority exceeds the old
383 * priority, or if the argument is not a finite double.
384 */
385 public void decreaseKey(Entry<T> entry, double newPriority) {
386 checkPriority(newPriority);
387 if (newPriority > entry.mPriority)
388 throw new IllegalArgumentException("New priority exceeds old.");
389
390 /* Forward this to a helper function. */
391 decreaseKeyUnchecked(entry, newPriority);
392 }
393
394 /**
395 * Deletes this Entry from the Fibonacci heap that contains it.
396 *
397 * It is assumed that the entry belongs in this heap. For efficiency
398 * reasons, this is not checked at runtime.
399 *
400 * @param entry The entry to delete.
401 */
402 public void delete(Entry<T> entry) {
403 /* Use decreaseKey to drop the entry‘s key to -infinity. This will
404 * guarantee that the node is cut and set to the global minimum.
405 */
406 decreaseKeyUnchecked(entry, Double.NEGATIVE_INFINITY);
407
408 /* Call dequeueMin to remove it. */
409 dequeueMin();
410 }
411
412 /**
413 * Utility function which, given a user-specified priority, checks whether
414 * it‘s a valid double and throws an IllegalArgumentException otherwise.
415 *
416 * @param priority The user‘s specified priority.
417 * @throws IllegalArgumentException If it is not valid.
418 */
419 private void checkPriority(double priority) {
420 if (Double.isNaN(priority))
421 throw new IllegalArgumentException(priority + " is invalid.");
422 }
423
424 /**
425 * Utility function which, given two pointers into disjoint circularly-
426 * linked lists, merges the two lists together into one circularly-linked
427 * list in O(1) time. Because the lists may be empty, the return value
428 * is the only pointer that‘s guaranteed to be to an element of the
429 * resulting list.
430 *
431 * This function assumes that one and two are the minimum elements of the
432 * lists they are in, and returns a pointer to whichever is smaller. If
433 * this condition does not hold, the return value is some arbitrary pointer
434 * into the doubly-linked list.
435 *
436 * @param one A pointer into one of the two linked lists.
437 * @param two A pointer into the other of the two linked lists.
438 * @return A pointer to the smallest element of the resulting list.
439 */
440 private static <T> Entry<T> mergeLists(Entry<T> one, Entry<T> two) {
441 /* There are four cases depending on whether the lists are null or not.
442 * We consider each separately.
443 */
444 if (one == null && two == null) { // Both null, resulting list is null.
445 return null;
446 }
447 else if (one != null && two == null) { // Two is null, result is one.
448 return one;
449 }
450 else if (one == null && two != null) { // One is null, result is two.
451 return two;
452 }
453 else { // Both non-null; actually do the splice.
454 /* This is actually not as easy as it seems. The idea is that we‘ll
455 * have two lists that look like this:
456 *
457 * +----+ +----+ +----+
458 * | |--N->|one |--N->| |
459 * | |<-P--| |<-P--| |
460 * +----+ +----+ +----+
461 *
462 *
463 * +----+ +----+ +----+
464 * | |--N->|two |--N->| |
465 * | |<-P--| |<-P--| |
466 * +----+ +----+ +----+
467 *
468 * And we want to relink everything to get
469 *
470 * +----+ +----+ +----+---+
471 * | |--N->|one | | | |
472 * | |<-P--| | | |<+ |
473 * +----+ +----+<-\ +----+ | |
474 * \ P | |
475 * N \ N |
476 * +----+ +----+ \->+----+ | |
477 * | |--N->|two | | | | |
478 * | |<-P--| | | | | P
479 * +----+ +----+ +----+ | |
480 * ^ | | |
481 * | +-------------+ |
482 * +-----------------+
483 *
484 */
485 Entry<T> oneNext = one.mNext; // Cache this since we‘re about to overwrite it.
486 one.mNext = two.mNext;
487 one.mNext.mPrev = one;
488 two.mNext = oneNext;
489 two.mNext.mPrev = two;
490
491 /* Return a pointer to whichever‘s smaller. */
492 return one.mPriority < two.mPriority? one : two;
493 }
494 }
495
496 /**
497 * Decreases the key of a node in the tree without doing any checking to ensure
498 * that the new priority is valid.
499 *
500 * @param entry The node whose key should be decreased.
501 * @param priority The node‘s new priority.
502 */
503 private void decreaseKeyUnchecked(Entry<T> entry, double priority) {
504 /* First, change the node‘s priority. */
505 entry.mPriority = priority;
506
507 /* If the node no longer has a higher priority than its parent, cut it.
508 * Note that this also means that if we try to run a delete operation
509 * that decreases the key to -infinity, it‘s guaranteed to cut the node
510 * from its parent.
511 */
512 if (entry.mParent != null && entry.mPriority <= entry.mParent.mPriority)
513 cutNode(entry);
514
515 /* If our new value is the new min, mark it as such. Note that if we
516 * ended up decreasing the key in a way that ties the current minimum
517 * priority, this will change the min accordingly.
518 */
519 if (entry.mPriority <= mMin.mPriority)
520 mMin = entry;
521 }
522
523 /**
524 * Cuts a node from its parent. If the parent was already marked, recursively
525 * cuts that node from its parent as well.
526 *
527 * @param entry The node to cut from its parent.
528 */
529 private void cutNode(Entry<T> entry) {
530 /* Begin by clearing the node‘s mark, since we just cut it. */
531 entry.mIsMarked = false;
532
533 /* Base case: If the node has no parent, we‘re done. */
534 if (entry.mParent == null) return;
535
536 /* Rewire the node‘s siblings around it, if it has any siblings. */
537 if (entry.mNext != entry) { // Has siblings
538 entry.mNext.mPrev = entry.mPrev;
539 entry.mPrev.mNext = entry.mNext;
540 }
541
542 /* If the node is the one identified by its parent as its child,
543 * we need to rewrite that pointer to point to some arbitrary other
544 * child.
545 */
546 if (entry.mParent.mChild == entry) {
547 /* If there are any other children, pick one of them arbitrarily. */
548 if (entry.mNext != entry) {
549 entry.mParent.mChild = entry.mNext;
550 }
551 /* Otherwise, there aren‘t any children left and we should clear the
552 * pointer and drop the node‘s degree.
553 */
554 else {
555 entry.mParent.mChild = null;
556 }
557 }
558
559 /* Decrease the degree of the parent, since it just lost a child. */
560 --entry.mParent.mDegree;
561
562 /* Splice this tree into the root list by converting it to a singleton
563 * and invoking the merge subroutine.
564 */
565 entry.mPrev = entry.mNext = entry;
566 mMin = mergeLists(mMin, entry);
567
568 /* Mark the parent and recursively cut it if it‘s already been
569 * marked.
570 */
571 if (entry.mParent.mIsMarked)
572 cutNode(entry.mParent);
573 else
574 entry.mParent.mIsMarked = true;
575
576 /* Clear the relocated node‘s parent; it‘s now a root. */
577 entry.mParent = null;
578 }
579 }
1 /*****************************************************************************
2 * File: DirectedGraph.java
3 * Author: Keith Schwarz ([email protected])
4 *
5 * A class representing a directed graph where each edge has an associated
6 * real-valued length. Internally, the class is represented by an adjacency
7 * list.
8 */
9 import java.util.*; // For HashMap
10
11 public final class DirectedGraph<T> implements Iterable<T> {
12 /* A map from nodes in the graph to sets of outgoing edges. Each
13 * set of edges is represented by a map from edges to doubles.
14 */
15 private final Map<T, Map<T, Double>> mGraph = new HashMap<T, Map<T, Double>>();
16
17 /**
18 * Adds a new node to the graph. If the node already exists, this
19 * function is a no-op.
20 *
21 * @param node The node to add.
22 * @return Whether or not the node was added.
23 */
24 public boolean addNode(T node) {
25 /* If the node already exists, don‘t do anything. */
26 if (mGraph.containsKey(node))
27 return false;
28
29 /* Otherwise, add the node with an empty set of outgoing edges. */
30 mGraph.put(node, new HashMap<T, Double>());
31 return true;
32 }
33
34 /**
35 * Given a start node, destination, and length, adds an arc from the
36 * start node to the destination of the length. If an arc already
37 * existed, the length is updated to the specified value. If either
38 * endpoint does not exist in the graph, throws a NoSuchElementException.
39 *
40 * @param start The start node.
41 * @param dest The destination node.
42 * @param length The length of the edge.
43 * @throws NoSuchElementException If either the start or destination nodes
44 * do not exist.
45 */
46 public void addEdge(T start, T dest, double length) {
47 /* Confirm both endpoints exist. */
48 if (!mGraph.containsKey(start) || !mGraph.containsKey(dest))
49 throw new NoSuchElementException("Both nodes must be in the graph.");
50
51 /* Add the edge. */
52 mGraph.get(start).put(dest, length);
53 }
54
55 /**
56 * Removes the edge from start to dest from the graph. If the edge does
57 * not exist, this operation is a no-op. If either endpoint does not
58 * exist, this throws a NoSuchElementException.
59 *
60 * @param start The start node.
61 * @param dest The destination node.
62 * @throws NoSuchElementException If either node is not in the graph.
63 */
64 public void removeEdge(T start, T dest) {
65 /* Confirm both endpoints exist. */
66 if (!mGraph.containsKey(start) || !mGraph.containsKey(dest))
67 throw new NoSuchElementException("Both nodes must be in the graph.");
68
69 mGraph.get(start).remove(dest);
70 }
71
72 /**
73 * Given a node in the graph, returns an immutable view of the edges
74 * leaving that node, as a map from endpoints to costs.
75 *
76 * @param node The node whose edges should be queried.
77 * @return An immutable view of the edges leaving that node.
78 * @throws NoSuchElementException If the node does not exist.
79 */
80 public Map<T, Double> edgesFrom(T node) {
81 /* Check that the node exists. */
82 Map<T, Double> arcs = mGraph.get(node);
83 if (arcs == null)
84 throw new NoSuchElementException("Source node does not exist.");
85
86 return Collections.unmodifiableMap(arcs);
87 }
88
89 /**
90 * Returns an iterator that can traverse the nodes in the graph.
91 *
92 * @return An iterator that traverses the nodes in the graph.
93 */
94 public Iterator<T> iterator() {
95 return mGraph.keySet().iterator();
96 }
97 }
1 /**************************************************************************
2 * File: Dijkstra.java
3 * Author: Keith Schwarz ([email protected])
4 *
5 * An implementation of Dijkstra‘s single-source shortest path algorithm.
6 * The algorithm takes as input a directed graph with non-negative edge
7 * costs and a source node, then computes the shortest path from that node
8 * to each other node in the graph.
9 *
10 * The algorithm works by maintaining a priority queue of nodes whose
11 * priorities are the lengths of some path from the source node to the
12 * node in question. At each step, the algortihm dequeues a node from
13 * this priority queue, records that node as being at the indicated
14 * distance from the source, and then updates the priorities of all nodes
15 * in the graph by considering all outgoing edges from the recently-
16 * dequeued node to those nodes.
17 *
18 * In the course of this algorithm, the code makes up to |E| calls to
19 * decrease-key on the heap (since in the worst case every edge from every
20 * node will yield a shorter path to some node than before) and |V| calls
21 * to dequeue-min (since each node is removed from the prioritiy queue
22 * at most once). Using a Fibonacci heap, this gives a very good runtime
23 * guarantee of O(|E| + |V| lg |V|).
24 *
25 * This implementation relies on the existence of a FibonacciHeap class, also
26 * from the Archive of Interesting Code. You can find it online at
27 *
28 * http://keithschwarz.com/interesting/code/?dir=fibonacci-heap
29 */
30
31 import java.util.*; // For HashMap
32
33 public final class Dijkstra {
34 /**
35 * Given a directed, weighted graph G and a source node s, produces the
36 * distances from s to each other node in the graph. If any nodes in
37 * the graph are unreachable from s, they will be reported at distance
38 * +infinity.
39 *
40 * @param graph The graph upon which to run Dijkstra‘s algorithm.
41 * @param source The source node in the graph.
42 * @return A map from nodes in the graph to their distances from the source.
43 */
44 public static <T> Map<T, Double> shortestPaths(DirectedGraph<T> graph, T source) {
45 /* Create a Fibonacci heap storing the distances of unvisited nodes
46 * from the source node.
47 */
48 FibonacciHeap<T> pq = new FibonacciHeap<T>();
49
50 /* The Fibonacci heap uses an internal representation that hands back
51 * Entry objects for every stored element. This map associates each
52 * node in the graph with its corresponding Entry.
53 */
54 Map<T, FibonacciHeap.Entry<T>> entries = new HashMap<T, FibonacciHeap.Entry<T>>();
55
56 /* Maintain a map from nodes to their distances. Whenever we expand a
57 * node for the first time, we‘ll put it in here.
58 */
59 Map<T, Double> result = new HashMap<T, Double>();
60
61 /* Add each node to the Fibonacci heap at distance +infinity since
62 * initially all nodes are unreachable.
63 */
64 for (T node: graph)
65 entries.put(node, pq.enqueue(node, Double.POSITIVE_INFINITY));
66
67 /* Update the source so that it‘s at distance 0.0 from itself; after
68 * all, we can get there with a path of length zero!
69 */
70 pq.decreaseKey(entries.get(source), 0.0);
71
72 /* Keep processing the queue until no nodes remain. */
73 while (!pq.isEmpty()) {
74 /* Grab the current node. The algorithm guarantees that we now
75 * have the shortest distance to it.
76 */
77 FibonacciHeap.Entry<T> curr = pq.dequeueMin();
78
79 /* Store this in the result table. */
80 result.put(curr.getValue(), curr.getPriority());
81
82 /* Update the priorities of all of its edges. */
83 for (Map.Entry<T, Double> arc : graph.edgesFrom(curr.getValue()).entrySet()) {
84 /* If we already know the shortest path from the source to
85 * this node, don‘t add the edge.
86 */
87 if (result.containsKey(arc.getKey())) continue;
88
89 /* Compute the cost of the path from the source to this node,
90 * which is the cost of this node plus the cost of this edge.
91 */
92 double pathCost = curr.getPriority() + arc.getValue();
93
94 /* If the length of the best-known path from the source to
95 * this node is longer than this potential path cost, update
96 * the cost of the shortest path.
97 */
98 FibonacciHeap.Entry<T> dest = entries.get(arc.getKey());
99 if (pathCost < dest.getPriority())
100 pq.decreaseKey(dest, pathCost);
101 }
102 }
103
104 /* Finally, report the distances we‘ve found. */
105 return result;
106 }
107
108 public static void main(String[] argv)
109 {
110 DirectedGraph dg = new DirectedGraph();
111 dg.addNode("A");
112 dg.addNode("B");
113 dg.addNode("C");
114 dg.addNode("D");
115 dg.addNode("E");
116
117 dg.addEdge("A", "B", 1);
118 dg.addEdge("B", "C", 2);
119 dg.addEdge("A", "C", 4);
120 dg.addEdge("C", "D", 8);
121 dg.addEdge("D", "E", 16);
122 dg.addEdge("C", "E", 32);
123 dg.addEdge("E", "B", 64);
124
125 Map<String, Double> map = shortestPaths(dg, "A");
126 for (Map.Entry<String, Double> entry : map.entrySet()) {
127 System.out.println("key= " + entry.getKey() + " and value= " + entry.getValue());
128 }
129 }
130 }
时间： 2024-10-22 02:09:37