Breadth-First Search: Complexity while (wavefront not empty && has entry < bestPathLen) { If we use a visited flag: Executes maximum N times Work in loop is O(1) O(N) ~100,000  10-7 < 1 s BFS with re-expansion: Difficult to bound But in practice much less than O(2N) of DFS with re-expansion How could we limit re-expansion?

Limiting Re-expansion Only re-visit a node in BFS when We find a new path with a lower cost to that node

Re-Expansion Wastes CPU

BFS Wavefront bool bfsPath (Node* sourceNode, int destID) { list<WaveElem> wavefront; while (wavefront not empty && has entry < bestPathLen) { WaveElem wave = wavefront.front (); wavefront.pop_front(); // Remove from wavefront Node *node = wave.node; if (wave.pathLen < node->pathLen) { ... wavefront.push_back ( WaveElem(toNode, outEdge.id, node.pathLen + travelTime (outEdge)); 78, 20s 2, 5s 39, 12s Wavefront: FIFO Queue

Take the Smallest Entry in Wavefront? source wavefront = {0/0s} {1/20s,1/10s} {1/20s,4/19s} {1/20s} {1/20s,3/16s} {1/20s,2/5s} b t = 5 s t = 20 s a 2 b, 5 s c t = 5 s c, 10 s 1 d t = 6 s d, 16 s 3 t = 3 s dest e Found shortest path with no / minimal re-expansion Djikstra’s algorithm e, 19 s 4

How Much Work To Get Smallest? list<WaveElem> wavefront Linked list Insertion: O(1) Remove smallest: scan entire list O(M), where M is active wavefront entries M can be up to O(N), but usually more like O(N0.5) Binary tree? Insertion: O(log M) Remove smallest O(log M)

Overall Complexity O(N) items added/removed in wavefront Work to remove next item: Linked list: O(M)  O(N0.5) to O(N) Binary tree: O(log M)  O (log N) Overall complexity Linked list: O(N1.5) to O(N2) N  100,000 and ~10-7 s per function 3.2 s to 1000 s (wide range!) Binary tree: O(N logN) <1 s

Anything Faster than Binary Tree? Heap Insertion: O(log N) Removal of smallest element: O(log N) But absolute time smaller than binary tree

(Min) Heap Like a binary tree Key of parent < key of children But not fully sorted Key of parent < key of children For all nodes in the tree Very good for priority queues Smallest item always at root of heap 3 20 36 40 35 37 60 No ordering between sibling nodes in the heap 50

Min Heap Update E.g. remove smallest item 1. Pop off top (smallest) 3 20 36 40 35 37 60 50 2. Move bottom (large) item to top

Min Heap Update E.g. remove smallest item 3. Compare to children; swap if necessary 50 20 36 40 35 37 60

Min Heap Update E.g. remove smallest item O(log N) levels 20 4. Repeat for each level 50 36 40 35 37 60 O(log N) levels  O(log N) work

BFS and Dijkstra Demo

Better than Dijkstra’s Algorithm?

Dijkstra: Not So Smart! Why are we examining nodes in the wrong direction? Wasted CPU time!

Ideas? Only look at nodes that take us closer to the destination? distToDest(node) < distToDest (predecessor) Too severe – can result in no path, or not shortest path

A* Algorithms Enhancements to Dijkstra’s algorithm Use domain-specific heuristics E.g. we are working in a map Can estimate which graph nodes are closer vs. further from dest Incorporate into the wavefront sorting/ordering Look at the most promising partial solutions first “Best-first search”

Can go around blockages (e.g. 401) A* Search Mostly searches in the right direction, but will explore some in other directions Can go around blockages (e.g. 401)

A* Demo

Milestone 3 Performance Tuning Tips

Speed Tuning Algorithm Data structures Low level code string streetName1, streetName2; if (streetName1 != streetName2) { ... int streetId1, streetId2; if (streetId1 != streetId2) { Any speed difference?

Debugging Algorithms Start with a very simple test case Adjacent intersections! Step / breakpoint code in debugger Make sure it does what you expect!

Debugging Algorithms Try a slightly harder case Two intersections apart Step / breakpoint code in debugger again! Make sure code behaving exactly as you expect

Bigger Cases: Graphics Helps Hard to see large amounts of data in debugger Use graphics to animate / visualize #define VISUALIZE while (wavefront.size() != 0) { WaveElem = wavefront.front(); #ifdef VISUALIZE draw_street_seg (WaveElem.edgeID); flushinput(); // Draw right away #endif ... Can’t leave this in when I submit (will fail unit tests). How do I turn this off when speed testing & before submitting code?