Day 24, Mat385

Last time

Next time

Announcements
- The Zooms continue
  A menu of our past zooms...
- Per Homework 7.3: I remember telling Ben that I'd give you a little more time on that.
  I think that I've got the homeworks back on track now. Let me know if things are still crazy.
  I made 6.3 an optional homework, to replace missing ones. I'll be dropping at least three of your homeworks (your lowest, of course); but if you do the optional one, I'll be effectively dropping your four lowest.
Last time:
- We finished Section 7.3: Shortest Paths and Minimal Spanning Trees, using a handout to practice with, and then;
- we got started on Section 7.4: Traversal Algorithms.
  We did a depth-first traversal, in which one effectively builds a tree, using a recursive strategy, to list the nodes of the graph.
Today:
- We'll finish Section 7.4: Traversal Algorithms:
  The breadth-first traversal, and how each traversal method works on rooted trees.
- Then it's on to Chapter 8, Section 8.1: Boolean Algebras.
  We have two more sections to go in chapter 8:
  1. Section 8.2: Logic Networks
  2. Section 8.3: Minimization
  Then it's on to our last section, Section 9.3: Finite State Machines (we'll get two days on that; it's one of my favorites!).
  That takes us up to a day of review, and then finals week.
  I hope that you're working on your projects!
Links:
- George Boole's biography
- Dijkstra's Algorithm (defined recursively): once a node is settled, its job is done. It can be "swallowed up" into a smaller graph, where its use as a shortcut has generally reduced the distance between other pairs of nodes.
  This was fun to program, but probably more trouble than it was worth. A direct approach, as in my implementation of Bellman-Ford below, would have been simpler to code. But, if I can do something recursively, I probably will...:)
- Bellman-Ford Algorithm: Bellman-Ford finds the shortest distances between the starting node and every other node, and the paths. It starts with paths of length one (the adjacency matrix row for the start node), and then adds in successively longer paths (and can't add more than n-1, or it would be repeating nodes -- which would make no sense).
- Floyd's algorithm: finds the shortest distances between any two nodes, but doesn't contain any path information.
- Graph traversals:
- EulerPath:
- Distilling Free-Form Natural Laws from Experimental Data. A computer rediscovers Newton's laws -- in a day!
  - Supplementary Material On-line
- Graph Terminology Handout
- Tree Terminology Handout
- If you check out this code, you'll see where I compute the power set ("all-subsets") of a set, to cover all the bases. I think that the end result is pretty beautiful, too!
- Recursive in-order, post-order, pre-order in lisp
- Recursive computation of Fibonacci numbers (in lisp)
- Recursive computation of rows from Pascal's triangle (in lisp)
- "String exponention" (in lisp)
- Here is the recursive selection sort algorithm, in lisp:
- Here is a recursive binary search algorithm in lisp:
- Closed-form computation of Fibonacci numbers (in lisp)
- Some examples of the Euclidean algorithm:
  1. Simple and clean recursive Euclidean Algorithm in lisp:
  2. Written as a while loop, using the recurrence relation:
- Here is a recursive bubbleSort algorithm in lisp
  
  (coded up following our author's algorithm, in section 3.3, p. 214, as closely as possible).
Details on why Dijkstra and Bellman-Ford work.

Website maintained by Andy Long. Comments appreciated.