Upload
miles-ryan
View
217
Download
0
Tags:
Embed Size (px)
Citation preview
Assumptions…
• Course emphasis is on preparing students to…– Design their own algorithms– Analyze and prove the correctness of those
algorithms• As opposed to what?– Emphasis on learning how a number of “classical”
algorithms work– Practice implementing existing algorithms
Assumptions…
• Course emphasis is on preparing students to…– Design their own algorithms– Analyze and prove the correctness of those
algorithms• As opposed to what?– Emphasis on learning how a number of “classical”
algorithms work– Practice implementing existing algorithms
if emphasis on design then
• Use a paradigmatic approach– Divide and conquer– Dynamic programming– Greed (and it’s dangers)– Amortized analyses– Integration of algorithms and data structures
Why Derive?
• It’s intellectually satisfying• Provides a deeper sense of how algorithms
are designed• Helps students remember algorithms• Provides students with confidence and skills to
design their own algorithms
A Derivation-First Approach
• A paradigmatic approach to algorithms is not necessarily one that emphasizes derivations
• We are using a derivation-based approach to teaching the undergraduate algorithms course at Harvey Mudd
• Currently about 20% of the material is being taught this way; we hope to do more in the future!
The Setting…
• Sophomore/Junior level algorithms course• 75-100 students• Two 75 minute lectures per week– Repeat about four cycles of:• 15 minutes of lecture• 5 minutes of pair work
Examples
• Deriving sorting algorithms• Deriving Dijkstra’s shortest path algorithm• Deriving Kruskal’s MST algorithm• Paper describes other examples• Disclaimer: Many of these ideas are known to computer
scientists and some appear in books or scholarly articles. But algorithms courses don’t appear to be taught in this way.
Sorting
• Observation: Selection sort and mergesort are “natural” but heapsort seems like magic
• Approach: Derive heapsort from selection sort and mergesort
• Assumptions:– Students have seen selection sort and mergesort
before (e.g., CS 1)– Students have seen heaps before (e.g., CS 2)– They might even have seen heapsort, but if so it
usually hasn’t stuck!
Mergesort and it’s analysis
42 23 5 16 47 3 8 12
T(n) = 2 T(n/2) + nT(1) = c
5 16 23 42 3 8 12 47
merge
Q(n log n)
If dividing in two is good…
Let’s try dividing into k pieces!
What’s the recurrence relation now?
T(n) = k T(n/k) + (k-1)nT(n) = c
Now we have k “fingers” at the front of k lists!
Now solve this!
If dividing in two is good…
T(n) = k T(n/k) + (k-1)nT(n) = c
T(n) = (k-1) n logk n
Now we have k “fingers” at the front of k lists!
• What do you expect it to be when k = 2?• Will it ever be asymptototically better
than n log n?• What do you expect it to be when k > 2?• What happens when k = n?
When k = n
T(n) = (k-1) n logk n = = (n-1) n which is Q(n2) Have you seen this algorithm before?
Now we have n “fingers” at the front of n lists!
…
When k = n
• This is Selection sort!• But it seems a bit crazy to do all of this work to
repeatedly find the minimum!
Now we have n “fingers” at the front of n lists!
…
When k = n
…
• Insert all elements into a heap• Repeatedly remove elements
from heap• Set up and solve recurrence
O(n log n)
Take-Away
• Mergesort generalizes naturally from 2-way to k-way splitting
• When k = n, mergesort “degenerates” to selection sort
• But, merging more cleverly results in heapsort• Important connections established• Heapsort is derived rather than pulled from a
hat!
Dijkstra
• Observation: Dijkstra’s algorithm is often presented and proved correct, but little intuition is offered and it’s hard to remember how it works.
• Approach: Motivate Dijkstra from BFS• Assumptions: Students have seen…– BFS (and the “wave” metaphor)– Heaps
What’s required to keep track of the wavefront?
• Deleting the item with minimum value• Updating values when they get better “offers”
Take-Away
• BFS is “natural” but Dijkstra is much less obvious
• But Dijkstra can be derived as an efficient implementation of BFS for weighted graphs (assuming integer weights)
• Now it makes sense to prove that Dijkstra also works for arbitrary non-negative real-valued edge weights
Deriving Kruskal’s MST Algorithm
• Observation: Minimum spanning tree algorithms are typically presented and then proved correct.
• Approach: Derive intuitively reasonable MST algorithms and then show that they are correct
• Assumptions: Students have seen some elementary graph theory and it is reviewed briefly here (e.g., trees and their properties, graph cuts).
Minimum Spanning Trees• Start with motivation of the problem• Begin by assuming all edge weights are distinct• Give one result: The cheapest edge crossing a
cut must be in every MST
5
1
Other derived algorithms
• Other shortest path algorithms• Other minimum spanning tree algorithms• Network flow algorithms
Outcomes
• “Standard” approach taught in 2011• “Derivation-first” approach taught in 2012– Only 5 of the 30 lectures changed
• Student course evals on 1-7 Likert Scale
2011 2012“Course promoted learning objectives” 6.52
6.80“Stimulated interest” 6.41
6.75“Learned a great deal” 6.59
6.82
Anecdotally
• A derivation-based approach appears to help students…– Feel intellectually engaged with the material– Feel a strong sense that “I could have done that!”– Remember how algorithms work and be able to
explain them to others– Derive their own algorithms!
Future work
• We are collecting data more methodically this year to better understand the impact of the derivation-based approach
• Developing a website where derivation “modules” can be contributed and borrowed