1. Tutorial 8
An optional eighth tutorial will be held the week of March 6. This tutorial will give you practice with and feedback on oral presentation and slide design. If possible, bring your laptop with any slides you are developing for your presentation.
Monday, March 6: 1-2pm; 2-3pm (GB304)
Wednesday, March 8: 9-10am; 10-11am (BA1180)
Thursday, March 9: 3-4pm; 4-5pm (GB304)

2. Milestone 3: Finding Routes
ECE 297

3. Milestone 3 Overview Find shortest travel time routes
Between two intersections
From intersection to point of interest
e.g. Tim Horton’s with minimum travel time
13% of final mark
8% algorithm (automarked)
Find some path?
Find shortest travel time path?
Find it with low CPU time?
4% user interface (TA demo)
1% code style

4. Milestone 3 UI User Interface: 4% Requirements
Can click on two intersections  find path
Can enter intersection/POI names  find path
Visualize path in UI
Print or draw travel directions
Have help button or command
Optional Bonus: up to +1%:
Support partial name matches
E.g. Yong  might complete as Yonge Street

5. Milestone 3 UI Usability matters Travel directions:
Try it on a friend or family member!
Can he/she enter intersections without lots of pain?
Can he/she follow the travel directions and path display?
Travel directions:
Directions give info you need from start to finish?
Take street segment #21
then street segment #10 …
Unbelievably Bad!
Take Yonge Street
Then Yonge Street
Then Bloor Street
Still bad!

6. Planning Most teams find milestone 3 hardest Make plan to divide work
Start early!
Make plan to divide work
Too big for complete pair/triplet programming
Separate pieces for parallel development?
UI: input (text & mouse)
UI: output (directions & drawing)
Hard code path to test before algorithm working
Algorithm
Two path searches, quite related
Can split code & test
Or split some helper functions (needs close comm.)

7. Algorithmic Approaches

8. Directions: How?

9. Model as Graph Problem
(Node)
(Edge)
Bathurst
dest
source
Path: sequence of connected nodes from a source to a dest

10. Now sequence of nodes doesn’t uniquely describe path
Model as Graph Problem
Bathurst
back lane
Now sequence of nodes doesn’t uniquely describe path
dest
source
Path: store as sequence of nodes?

11. Model as Graph Problem
Bathurst
dest
source
Better: sequence of connected edges from a source to a dest

12. Finding Routes Find path from source to dest Any path? Fewest nodes?
Is there only one path?
Any path?
Fewest nodes?
Fewest edges?
Minimum travel time!
Graph texts: minimum weight path or shortest path
dest
source

13. Minimum Travel Time Definition
Distance / speed limit + turn_penalty per street change
Blue path:
200 m / 40 kmh m / 50 kmh + 1 turn  18 s s + 15 s = 54.6 s
300 m
dest
Red path:
100 m / 40 kmh m / 40 kmh m / 50 kmh + 2 turns  9 s + 18 s s + 2*15 s = 71.4 s
200 m
source
100 m
Which is better if turn_penalty = 15s?

14. Minimum Travel Time Definition
Don’t left turns take longer than right turns?
Yes, we’re ignoring to keep simple
Street change with no turn?
Still 15 s
No penalty
Yonge St.
Bloor St. West
Bloor St. East
15 s penalty
Yonge St.

15. Other Shortest Path Applications
Any Ideas?

16. Internet Routing Nodes: computers and switches Edges: cables
source
dest
Nodes: computers and switches
Edges: cables
Find a path to connect computers
Typical minimum weight path definition:
Fewest routers
Or least congested

17. Circuit Board Design Nodes: small square for metal
Edges: squares we can connect
Find paths to connect chip I/Os

18. Integrated Circuits Nodes: small grid squares for metal
Edges: squares we can connect
Find paths to connect gates
Huge graph (tens of millions of nodes)  need fast algorithms

19. Facebook Entire social network is stored as > billion-node graph
Shortest path: how close to knowing someone?
Algorithms built on shortest path: social marketing

20. Shortest Path Algorithm #1
Depth First Search
Shortest Path Algorithm #1

21. Recursion?
source
dest
int main () { Node *sourceNode = getNodebyID (sourceID); bool found = findPath (sourceNode, destID); } bool findPath (Node* currNode, int destID) { ...

22. Recursion?
bool findPath (Node* currNode, int destID) { if (currNode->id == destID) return (true); for each (outEdge of currNode) { Node *toNode = outEdge.toNode; bool found = findPath (toNode, destID); if (found) } return (false); 1
source
dest 2 3 4 3

23. Recursion? Infinite Loop!
bool findPath (Node* currNode, int destID) { if (currNode->id == destID) return (true); for each (outEdge of currNode) { Node *toNode = outEdge.toNode; bool found = findPath (toNode, destID); if (found) } return (false);
Infinite Loop!
source
dest

24. How to Fix?
bool findPath (Node* currNode, int destID) { if (currNode->id == destID) return (true); currNode->visited = true; for each (outEdge of currNode) { Node *toNode = outEdge.toNode; if (!toNode->visited) { bool found = findPath (toNode, destID); if (found) } return (false);
toNode visited
dest
source

25. Output? Says whether or not a path was found But not what the path is!
bool findPath (Node* currNode, int destID) { return (true); }
Says whether or not a path was found
But not what the path is!
Worst directions ever: yes, a path exists!
How to fix?
dest
source