diff --git a/code/cs325-langs/hws/hw1.txt b/code/cs325-langs/hws/hw1.txt
new file mode 100644
index 0000000..3c15ca5
--- /dev/null
+++ b/code/cs325-langs/hws/hw1.txt
@@ -0,0 +1,119 @@
+CS 325-001, Analysis of Algorithms, Fall 2019
+HW1 - Python 3, qsort, BST, and qselect
+Due electronically on flip on Monday 9/30 at 11:59pm. 
+No late submission will be accepted.
+
+Need to submit on flip: report.txt, qsort.py, and qselect.py.
+qselect.py will be automatically graded for correctness (1%).
+
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw1 qselect.py qsort.py report.txt
+
+Note:
+
+1. You can ssh to flip machines from your own machine by:
+   $ ssh access.engr.oregonstate.edu
+
+2. You can add /nfs/farm/classes/eecs/fall2019/cs325-001/ to your $PATH:
+   $ export PATH=$PATH:/nfs/farm/classes/eecs/fall2019/cs325-001/
+   and add the above command to your ~/.bash_profile,
+   so that you don't need to type it every time.
+
+   (alternatively, you can use symbolic links or aliases to avoid typing the long path)
+
+3. You can choose to submit each file separately, or submit them together.
+
+Textbooks for References:
+[1] CLRS Ch. 9.2 and Ch. 12
+
+0. Q: What's the best-case, worst-case, and average-case time complexities of quicksort.
+   Briefly explain each case.
+
+1. [WILL BE GRADED] 
+   Quickselect with Randomized Pivot (CLRS Ch. 9.2).
+
+   >>> from qselect import *
+   >>> qselect(2, [3, 10, 4, 7, 19])
+   4
+   >>> qselect(4, [11, 2, 8, 3])
+   11
+
+   Q: What's the best-case, worst-case, and average-case time complexities? Briefly explain.
+
+   Filename: qselect.py
+
+
+2. Buggy Qsort Revisited
+
+   In the slides we showed a buggy version of qsort which is weird in an interesting way:
+   it actually returns a binary search tree for the given array, rooted at the pivot:
+
+   >>> from qsort import *
+   >>> tree = sort([4,2,6,3,5,7,1,9])
+   >>> tree
+   [[[[], 1, []], 2, [[], 3, []]], 4, [[[], 5, []], 6, [[], 7, [[], 9, []]]]]
+
+   which encodes a binary search tree:
+
+                      4
+                    /   \
+                  2       6
+                 / \     / \
+                1   3   5   7
+                             \
+                              9
+   
+   Now on top of that piece of code, add three functions: 
+   * sorted(t): returns the sorted order (infix traversal)
+   * search(t, x): returns whether x is in t
+   * insert(t, x): inserts x into t (in-place) if it is missing, otherwise does nothing.
+
+   >>> sorted(tree)
+   [1, 2, 3, 4, 5, 6, 7, 9]
+   >>> search(tree, 6)
+   True
+   >>> search(tree, 6.5)
+   False
+   >>> insert(tree, 6.5)
+   >>> tree
+   [[[[], 1, []], 2, [[], 3, []]], 4, [[[], 5, []], 6, [[[], 6.5, []], 7, [[], 9, []]]]]
+   >>> insert(tree, 3)
+   >>> tree
+   [[[[], 1, []], 2, [[], 3, []]], 4, [[[], 5, []], 6, [[[], 6.5, []], 7, [[], 9, []]]]]
+
+   Hint: both search and insert should depend on a helper function _search(tree, x) which 
+   returns the subtree (a list) rooted at x when x is found, or the [] where x should 
+   be inserted.
+
+   e.g., 
+   >>> tree = sort([4,2,6,3,5,7,1,9])        # starting from the initial tree
+   >>> _search(tree, 3)
+   [[], 3, []]
+   >>> _search(tree, 0)
+   []
+   >>> _search(tree, 6.5)
+   []
+   >>> _search(tree, 0) is _search(tree, 6.5)
+   False
+   >>> _search(tree, 0) == _search(tree, 6.5)
+   True
+   
+   Note the last two []'s are different nodes (with different memory addresses): 
+   the first one is the left child of 1, while the second one is the left child of 7
+   (so that insert is very easy).
+   
+   Filename: qsort.py
+   
+   Q: What are the time complexities for the operations implemented?
+
+Debriefing (required!): --------------------------
+
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+4. How deeply do you feel you understand the material it covers (0%–100%)? 
+5. Any other comments?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
+
diff --git a/code/cs325-langs/hws/hw10.txt b/code/cs325-langs/hws/hw10.txt
new file mode 100644
index 0000000..e23ac8e
--- /dev/null
+++ b/code/cs325-langs/hws/hw10.txt
@@ -0,0 +1,170 @@
+CS 325, Algorithms (MS/MEng-level), Fall 2019
+
+HW10 - Challenge Problem - RNA Structure Prediction (6%)
+This problem combines dynamic programming and priority queues.
+
+Due Wednesday 12/4, 11:59pm.
+No late submission will be accepted.
+
+Include in your submission: report.txt, rna.py.
+Grading: 
+* report.txt -- 1%
+* 1-best structure -- 2%
+* number of structures -- 1%
+* k-best structures -- 2%
+
+Textbooks for References:
+[1] KT Ch. 6.5 (DP over intervals -- RNA structure)    
+[2] KT slides: DP I (RNA section)
+    http://www.cs.princeton.edu/~wayne/kleinberg-tardos/
+
+***Please analyze time/space complexities for each problem in report.txt.
+
+1. Given an RNA sequence, such as ACAGU, we can predict its secondary structure 
+   by tagging each nucleotide as (, ., or ). Each matching pair of () must be 
+   AU, GC, or GU (or their mirror symmetries: UA, CG, UG). 
+   We also assume pairs can _not_ cross each other. 
+   The following are valid structures for ACAGU:
+
+   ACAGU
+   .....
+   ...()
+   ..(.)
+   .(.).
+   (...)
+   ((.))    
+
+   We want to find the structure with the maximum number of matching pairs. 
+   In the above example, the last structure is optimal (2 pairs). 
+
+   >>> best("ACAGU")
+   (2, '((.))')
+
+   Tie-breaking: arbitrary. Don't worry as long as your structure
+   is one of the correct best structures.
+
+   some other cases (more cases at the bottom):
+
+   GCACG
+   (2, '().()')
+   UUCAGGA
+   (3, '(((.)))')
+   GUUAGAGUCU
+   (4, '(.()((.)))')
+   AUAACCUUAUAGGGCUCUG
+   (8, '.(((..)()()((()))))')
+   AACCGCUGUGUCAAGCCCAUCCUGCCUUGUU
+   (11, '(((.(..(.((.)((...().))()))))))')
+   GAUGCCGUGUAGUCCAAAGACUUCACCGUUGG
+   (14, '.()()(()(()())(((.((.)(.))()))))')
+   CAUCGGGGUCUGAGAUGGCCAUGAAGGGCACGUACUGUUU
+   (18, '(()())(((((.)))()(((())(.(.().()()))))))')
+   ACGGCCAGUAAAGGUCAUAUACGCGGAAUGACAGGUCUAUCUAC
+   (19, '.()(((.)(..))(((.()()(())))(((.)((())))))())')
+   AGGCAUCAAACCCUGCAUGGGAGCACCGCCACUGGCGAUUUUGGUA
+   (20, '.(()())...((((()()))((()(.()(((.)))()())))))()')
+
+2. Total number of all possible structures
+
+   >>> total("ACAGU")
+   6
+
+3. k-best structures: output the 1-best, 2nd-best, ... kth-best structures.
+
+   >>> kbest("ACAGU", 3)
+   [(2, '((.))'), (1, '(...)'), (1, '.(.).')]
+   
+   The list must be sorted. 
+   Tie-breaking: arbitrary.
+
+   In case the input k is bigger than the number of possible structures, output all.
+
+   Sanity check: kbest(s, 1)[0][0] == best(s)[0] for each RNA sequence s.
+
+All three functions should be in one file: rna.py.
+
+See more testcases at the end.
+   
+Debriefing (required!): --------------------------
+
+0. What's your name?
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+4. How deeply do you feel you understand the material it covers (0%-100%)? 
+5. Any other comments?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
+
+
+TESTCASES:
+
+for each sequence s, we list three lines:
+best(s)
+total(s)
+kbest(s, 10)
+
+
+
+ACAGU
+(2, '((.))')
+6
+[(2, '((.))'), (1, '.(.).'), (1, '..(.)'), (1, '...()'), (1, '(...)'), (0, '.....')]
+------
+AC
+(0, '..')
+1
+[(0, '..')]
+------
+GUAC
+(2, '(())')
+5
+[(2, '(())'), (1, '()..'), (1, '.().'), (1, '(..)'), (0, '....')]
+------
+GCACG
+(2, '().()')
+6
+[(2, '().()'), (1, '(..).'), (1, '()...'), (1, '.(..)'), (1, '...()'), (0, '.....')]
+------
+CCGG
+(2, '(())')
+6
+[(2, '(())'), (1, '(.).'), (1, '.().'), (1, '.(.)'), (1, '(..)'), (0, '....')]
+------
+CCCGGG
+(3, '((()))')
+20
+[(3, '((()))'), (2, '((.)).'), (2, '(.()).'), (2, '.(()).'), (2, '.(().)'), (2, '.((.))'), (2, '((.).)'), (2, '(.(.))'), (2, '(.().)'), (2, '((..))')]
+------
+UUCAGGA
+(3, '(((.)))')
+24
+[(3, '(((.)))'), (2, '((.).).'), (2, '((..)).'), (2, '(.(.)).'), (2, '((.))..'), (2, '.((.)).'), (2, '.((.).)'), (2, '.((..))'), (2, '((..).)'), (2, '((.)..)')]
+------
+AUAACCUA
+(2, '.((...))')
+19
+[(2, '((.)..).'), (2, '(()...).'), (2, '()(...).'), (2, '().(..).'), (2, '()....()'), (2, '.()(..).'), (2, '.()...()'), (2, '.(.)..()'), (2, '.((...))'), (2, '.(.(..))')]
+------
+UUGGACUUG
+(4, '(()((.)))')
+129
+[(4, '(())(.)()'), (4, '(()((.)))'), (3, '(().)..()'), (3, '(().).(.)'), (3, '(().)(..)'), (3, '((.))..()'), (3, '((.)).(.)'), (3, '((.))(..)'), (3, '(())(..).'), (3, '(())(.)..')]
+------
+UUUGGCACUA
+(4, '(.()()(.))')
+179
+[(4, '((()).).()'), (4, '((.)()).()'), (4, '(.()()).()'), (4, '.(()()).()'), (4, '.(()()(.))'), (4, '((()).(.))'), (4, '((.)()(.))'), (4, '((()())..)'), (4, '(.()()(.))'), (3, '((()).)...')]
+------
+GAUGCCGUGUAGUCCAAAGACUUC
+(11, '(((()()((()(.))))((.))))')
+2977987
+[(11, '(()())(((()().))(((.))))'), (11, '(()())(((()()).)(((.))))'), (11, '(()())(((()(.)))(((.))))'), (11, '(()()()((()(.)))(((.))))'), (11, '(((()()((()().)))((.))))'), (11, '(((()()((()(.))))((.))))'), (11, '(()()()((()()).)(((.))))'), (11, '(()()()((()().))(((.))))'), (11, '(((()()((()()).))((.))))'), (10, '(()()()((()().).)((.))).')]
+------
+AGGCAUCAAACCCUGCAUGGGAGCG
+(10, '.(()())...((((()()))).())')
+560580
+[(10, '.(()())...((((())())).)()'), (10, '.(()())...((((()()))).)()'), (10, '.(()())...(((()(()))).)()'), (10, '.(()())...(((()(()))).())'), (10, '.(()())...((((())())).())'), (10, '.(()())...((((()()))).())'), (9, '((.).)(...(.((()()))).)()'), (9, '((.).)(...(((.)(()))).)()'), (9, '((.).)(...(.(()(()))).)()'), (9, '((.).)(...((.(()()))).)()')]
+------
diff --git a/code/cs325-langs/hws/hw11.txt b/code/cs325-langs/hws/hw11.txt
new file mode 100644
index 0000000..597a440
--- /dev/null
+++ b/code/cs325-langs/hws/hw11.txt
@@ -0,0 +1,42 @@
+HW11 -- OPTIONAL (for your practice only -- solutions will be released on Tuesday)
+
+Edit Distance (see updated final review solutions)
+
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw11 edit.py
+
+Implement two functions:
+* distance1(s, t): Viterbi-style (either top-down or bottom-up)
+* distance2(s, t): Dijkstra-style (best-first)
+
+For Dijkstra, you can use either heapdict or heapq (see review problem 7).
+Given that this graph is extremely sparse (why?), heapq (ElogE) might be faster than heapdict (ElogV)
+because the latter has overhead for hash.
+
+They should return the same result (just return the edit distance).
+
+We have 10 testcases (listed below); the first 5 test distance1(), 
+and the second 5 test distance2() on the same 5 string pairs.
+
+My solutions (on flip2):
+Testing Case  1 (open)...	  0.001 s, Correct
+Testing Case  2 (open)...	  0.000 s, Correct
+Testing Case  3 (open)...	  0.012 s, Correct
+Testing Case  4 (open)...	  0.155 s, Correct
+Testing Case  5 (open)...	  0.112 s, Correct
+Testing Case  6 (hidden)...	  0.000 s, Correct
+Testing Case  7 (hidden)...	  0.000 s, Correct
+Testing Case  8 (hidden)...	  0.004 s, Correct
+Testing Case  9 (hidden)...	  0.009 s, Correct
+Testing Case 10 (hidden)...	  0.021 s, Correct
+Total Time: 0.316 s
+
+distance1("abcdefh", "abbcdfg") == 3
+distance1("pretty", "prettier") == 3
+distance1("aaaaaaadaaaaaaaaaaaaaaaaacaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxaaaaaaaaaaaaaaaaaaaaaa") == 5
+distance1('cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbxtwiqzvokqpkecyywrbvhlqgxzutdjfmvlhsezfbhfjbllmfhzlqlcwibubyyjupbwhztskyksfthkptxqlmhivfjbgclwsombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasomrhotoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwy', 'cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbtwiqzvokqpkecyywrbvhlqgxzutdjfmvlhsezfbhfjbllmfhzlqlcwibubyyjupbwhztskyksfthkptxqlmhivfbgclwsombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasonrhotoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwy') == 3
+distance1('cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbtwiqzvokqpasdfkecyywrbvhlqgxzutdjfmvlhsezfbhbllmfhzlqlcwibubyyjupbwhztsxyksfthkptxqlmhivfjbgclhombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasomrttoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwydmbihjkvziitusmkjljrsbafytsinql', 'cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbtwiqzvokqpkecyywrbvhlqgxzutdjfmvlhsezfbhfjbllmfhzlqlcwibubyyjupbwhztskyksfthkptxqlmhivfjbgclwsombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasomrhotoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwydmbihjkvziitusmkjljrsbafytsinql') == 11
+distance2("abcdefh", "abbcdfg") == 3
+distance2("pretty", "prettier") == 3
+distance2("aaaaaaadaaaaaaaaaaaaaaaaacaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", "aaaaaaaaaaaabaaaaaaaaaaaaaaaaaaaaaaaaaaaaaxaaaaaaaaaaaaaaaaaaaaaa") == 5
+distance2('cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbxtwiqzvokqpkecyywrbvhlqgxzutdjfmvlhsezfbhfjbllmfhzlqlcwibubyyjupbwhztskyksfthkptxqlmhivfjbgclwsombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasomrhotoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwy', 'cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbtwiqzvokqpkecyywrbvhlqgxzutdjfmvlhsezfbhfjbllmfhzlqlcwibubyyjupbwhztskyksfthkptxqlmhivfbgclwsombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasonrhotoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwy') == 3
+distance2('cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbtwiqzvokqpasdfkecyywrbvhlqgxzutdjfmvlhsezfbhbllmfhzlqlcwibubyyjupbwhztsxyksfthkptxqlmhivfjbgclhombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasomrttoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwydmbihjkvziitusmkjljrsbafytsinql', 'cpuyedzrwcbritzclzhwwabmlyresvewkdxwkamyzbtwiqzvokqpkecyywrbvhlqgxzutdjfmvlhsezfbhfjbllmfhzlqlcwibubyyjupbwhztskyksfthkptxqlmhivfjbgclwsombvytdztapwpzmdqfwwrhqsgztobeuiatcwmrzfbwhfnpzzasomrhotoqiwvexlgxsnafiagfewmopdzwanxswfsmbxsmsczbwsgnwydmbihjkvziitusmkjljrsbafytsinql') == 11
diff --git a/code/cs325-langs/hws/hw2.txt b/code/cs325-langs/hws/hw2.txt
new file mode 100644
index 0000000..9d9e37a
--- /dev/null
+++ b/code/cs325-langs/hws/hw2.txt
@@ -0,0 +1,80 @@
+CS 325-001, Analysis of Algorithms, Fall 2019
+HW2 - Divide-n-conquer: mergesort, number of inversions, longest path
+
+Due Monday Oct 7, 11:59pm (same submission instructions as HW1).
+No late submission will be accepted.
+
+Need to submit: report.txt, msort.py, inversions.py, and longest.py.
+longest.py will be graded for correctness (1%).
+
+To submit:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw2 report.txt {msort,inversions,longest}.py
+(You can submit each file separately, or submit them together.)
+
+To see your best results so far:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/query hw2
+
+
+Textbooks for References:
+[1] CLRS Ch. 2
+
+0. Which of the following sorting algorithms are (or can be made) stable?
+   (a) mergesort
+   (b) quicksort with the first element as pivot
+   (c) quicksort with randomized pivot
+   (d) selection sort
+   (e) insertion sort
+   (f) heap sort --- not covered yet (see CLRS Ch. 6)
+
+1. Implement mergesort.
+   
+   >>> mergesort([4, 2, 5, 1, 6, 3])
+   [1, 2, 3, 4, 5, 6]   
+   
+   Filename: msort.py
+   
+2. Calculate the number of inversions in a list.
+
+   >>> num_inversions([4, 1, 3, 2])
+   4
+   >>> num_inversions([2, 4, 1, 3])
+   3
+
+   Filename: inversions.py
+   Must run in O(nlogn) time.
+
+3. [WILL BE GRADED] 
+
+   Length of the longest path in a binary tree (number of edges).
+   
+   We will use the "buggy qsort" representation of binary trees from HW1:
+   [left_subtree, root, right_subtree]
+
+   >>> longest([[], 1, []])
+   0
+
+   >>> longest([[[], 1, []], 2, [[], 3, []]])
+   2
+
+   >>> longest([[[[], 1, []], 2, [[], 3, []]], 4, [[[], 5, []], 6, [[], 7, [[], 9, []]]]])
+   5
+
+   Note the answer is 5 because the longest path is 1-2-4-6-7-9.   
+
+   Filename: longest.py
+   Must run in O(n) time.
+
+Debriefing (required!): --------------------------
+
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+   Note you are encouraged to discuss with your classmates, 
+   but each students should submit his/her own code.
+4. How deeply do you feel you understand the material it covers (0%–100%)? 
+5. Any other comments?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
+
diff --git a/code/cs325-langs/hws/hw3.txt b/code/cs325-langs/hws/hw3.txt
new file mode 100644
index 0000000..28197da
--- /dev/null
+++ b/code/cs325-langs/hws/hw3.txt
@@ -0,0 +1,83 @@
+CS 325, Algorithms, Fall 2019
+HW3 - K closest numbers; Two Pointers
+
+Due Monday Oct 14, 11:59pm. (same submission instructions as HW1-2).
+No late submission will be accepted.
+
+Need to submit: report.txt, closest_unsorted.py, closest_sorted.py, xyz.py.
+closest_sorted.py will be graded for correctness (1%).
+
+To submit:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw3 report.txt {closest*,xyz}.py
+(You can submit each file separately, or submit them together.)
+
+To see your best results so far:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/query hw3
+
+
+1. Given an array A of n numbers, a query x, and a number k,
+   find the k numbers in A that are closest (in value) to x.
+   For example:
+
+   find([4,1,3,2,7,4], 5.2, 2)	returns   [4,4]
+   find([4,1,3,2,7,4], 6.5, 3)	returns   [4,7,4]
+   find([5,3,4,1,6,3], 3.5, 2)	returns   [3,4]
+
+
+   Filename: closest_unsorted.py
+   Must run in O(n) time. 
+   The elements in the returned list must be in the original order.
+   In case two numbers are equally close to x, choose the earlier one.
+
+
+2. [WILL BE GRADED]
+   Now what if the input array is sorted? Can you do it faster?
+
+   find([1,2,3,4,4,7], 5.2, 2) returns   [4,4]
+   find([1,2,3,4,4,7], 6.5, 3) returns   [4,4,7]
+
+   Filename: closest_sorted.py
+   Must run in O(logn + k) time.
+   The elements in the returned list must be in the original order.
+
+   Note: in case two numbers are equally close to x, choose the smaller one:
+   find([1,2,3,4,4,6,6], 5, 3) returns   [4,4,6]
+   find([1,2,3,4,4,5,6], 4, 5) returns   [2,3,4,4,5]
+
+   Hint: you can use Python's bisect.bisect for binary search.
+
+
+3. For a given array A of n *distinct* numbers, find all triples (x,y,z) 
+   s.t. x + y = z. (x, y, z are distinct numbers)
+
+   e.g.,
+   
+   find([1, 4, 2, 3, 5]) returns [(1,3,4), (1,2,3), (1,4,5), (2,3,5)]
+
+   Note that:
+   1) no duplicates in the input array
+   2) you can choose any arbitrary order for triples in the returned list.
+
+   Filename: xyz.py
+   Must run in O(n^2) time.
+
+   Hint: you can use any built-in sort in Python.
+
+
+Debriefing (required!): --------------------------
+
+0. What's your name?
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+   Note you are encouraged to discuss with your classmates, 
+   but each students should submit his/her own code.
+4. How deeply do you feel you understand the material it covers (0%-100%)? 
+
+5. Which part(s) of the course you like the most so far?
+6. Which part(s) of the course you dislike the most so far?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
+
diff --git a/code/cs325-langs/hws/hw4.txt b/code/cs325-langs/hws/hw4.txt
new file mode 100644
index 0000000..176497e
--- /dev/null
+++ b/code/cs325-langs/hws/hw4.txt
@@ -0,0 +1,114 @@
+CS 325-001, Algorithms, Fall 2019
+HW4 - Priority Queue and Heaps
+
+Due via the submit program on Monday Oct 21, 11:59pm.
+No late submission will be accepted.
+
+Need to submit: report.txt, nbest.py, kmergesort.py, datastream.py.
+datastream.py will be graded for correctness (1%).
+
+To submit:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw4 report.txt {nbest,kmergesort,datastream}.py
+(You can submit each file separately, or submit them together.)
+
+To see your best results so far:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/query hw4
+
+
+Textbooks for References:
+[1] CLRS Ch. 6
+[2] KT slides for binary heaps (only read the first 20 pages!): 
+    https://www.cs.princeton.edu/~wayne/kleinberg-tardos/pdf/BinomialHeaps.pdf
+[3] Python heapq module 
+
+0. There are two methods for building a heap from an unsorted array:
+   (1) insert each element into the heap  --- O(nlogn) -- heapq.heappush()
+   (2) heapify (top-down)                 --- O(n)     -- heapq.heapify()
+
+   (a) Derive these time complexities.
+   (b) Use a long list of random numbers to show the difference in time. (Hint: random.shuffle or random.sample)
+   (c) What about sorted or reversely-sorted numbers?
+
+1. Given two lists A and B, each with n integers, return
+   a sorted list C that contains the smallest n elements from AxB:
+
+     AxB = { (x, y) | x in A, y in B }
+
+   i.e., AxB is the Cartesian Product of A and B.
+
+   ordering:  (x,y) < (x',y') iff. x+y < x'+y' or (x+y==x'+y' and y<y')
+
+   You need to implement three algorithms and compare:
+
+   (a) enumerate all n^2 pairs, sort, and take top n.
+   (b) enumerate all n^2 pairs, but use qselect from hw1.
+   (c) Dijkstra-style best-first, only enumerate O(n) (at most 2n) pairs.
+       Hint: you can use Python's heapq module for priority queue.
+
+   Q: What are the time complexities of these algorithms? 
+
+   >>> a, b = [4, 1, 5, 3], [2, 6, 3, 4]
+   >>> nbesta(a, b)   # algorithm (a), slowest
+   [(1, 2), (1, 3), (3, 2), (1, 4)]
+   >>> nbestb(a, b)   # algorithm (b), slow
+   [(1, 2), (1, 3), (3, 2), (1, 4)]
+   >>> nbestc(a, b)   # algorithm (c), fast
+   [(1, 2), (1, 3), (3, 2), (1, 4)]
+
+   Filename: nbest.py
+
+2. k-way mergesort (the classical mergesort is a special case where k=2).
+
+   >>> kmergesort([4,1,5,2,6,3,7,0], 3)  # k=3
+   [0,1,2,3,4,5,6,7]
+
+   Q: What is the complexity? Write down the detailed analysis in report.txt.
+
+   Filename: kmergesort.py
+
+3. [WILL BE GRADED]
+   
+   Find the k smallest numbers in a data stream of length n (k<<n),
+   using only O(k) space (the stream itself might be too big to fit in memory).
+
+   >>> ksmallest(4, [10, 2, 9, 3, 7, 8, 11, 5, 7])
+   [2, 3, 5, 7]
+   >>> ksmallest(3, range(1000000, 0, -1))
+   [1, 2, 3]
+
+   Note: 
+   a) it should work with both lists and lazy lists
+   b) the output list should be sorted
+
+   Q: What is your complexity? Write down the detailed analysis in report.txt.
+   
+   Filename: datastream.py
+
+   [UPDATE] The built-in function heapq.nsmallest() is _not_ allowed for this problem.
+   	    The whole point is to implement it yourself. :)
+
+
+4. (optional) Summarize the time complexities of the basic operations (push, pop-min, peak, heapify) for these implementations of priority queue:
+   
+   (a) unsorted array
+   (b) sorted array (highest priority first)
+   (c) reversly sorted array (lowest priority first)
+   (d) linked list
+   (e) binary heap
+
+Debriefing (required!): --------------------------
+
+0. What's your name?
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+   Note you are encouraged to discuss with your classmates, 
+   but each students should submit his/her own code.
+4. How deeply do you feel you understand the material it covers (0%-100%)? 
+5. Which part(s) of the course you like the most so far?
+6. Which part(s) of the course you dislike the most so far?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
+
diff --git a/code/cs325-langs/hws/hw5.txt b/code/cs325-langs/hws/hw5.txt
new file mode 100644
index 0000000..e4d3a29
--- /dev/null
+++ b/code/cs325-langs/hws/hw5.txt
@@ -0,0 +1,130 @@
+CS 532-001, Algorithms, Fall 2019
+HW5 - DP (part 1: simple)
+
+HWs 5-7 are all on DPs.
+
+Due Monday Oct 28, 11:59pm.
+No late submission will be accepted.
+
+Need to submit report.txt, mis.py, bsts.py, bitstrings.py.
+mis.py will be graded for correctness (1%).
+
+To submit:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw5 report.txt {mis,bsts,bitstrings}.py
+(You can submit each file separately, or submit them together.)
+
+To see your best results so far:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/query hw5
+
+
+Textbooks for References:
+[1] CLRS Ch. 15
+[2] KT Ch. 6
+    or Ch. 5 in a previous version:
+    http://cs.furman.edu/~chealy/cs361/kleinbergbook.pdf   
+
+Hint: Among the three coding questions, p3 is the easiest, and p1 is similar to p3.
+      You'll realize that both are very similar to p0 (Fibonacci).
+      p2 is slightly different from these, but still very easy.
+
+0. (Optional) Is Fibonacci REALLY O(n)?
+   Hint: the value of f(n) itself grows exponentially.	    
+
+1. [WILL BE GRADED]
+   Maximum Weighted Independent Set 
+
+   [HINT] independent set is a set where no two numbers are neighbors in the original list.
+   	  see also https://en.wikipedia.org/wiki/Independent_set_(graph_theory)
+
+   input:  a list of numbers (could be negative)
+   output: a pair of the max sum and the list of numbers chosen
+
+   >>> max_wis([7,8,5])
+   (12, [7,5])
+
+   >>> max_wis([-1,8,10])
+   (10, [10])
+
+   >>> max_wis([])
+   (0, [])
+
+   [HINT] if all numbers are negative, the optimal solution is 0,
+          since [] is an independent set according to the definition above.
+
+   >>> max_wis([-5, -1, -4])
+   (0, [])
+
+   Q: What's the complexity?
+   
+   Include both top-down (max_wis()) and bottom-up (max_wis2()) solutions, 
+   and make sure they produce exact same results. 
+   We'll only grade the top-down version.
+
+   Tie-breaking: any best solution is considered correct.
+
+   Filename: mis.py
+
+   [HINT] you can also use the naive O(2^n) exhaustive search method to verify your answer.
+   
+
+2. Number of n-node BSTs
+
+   input: n
+   output: number of n-node BSTs
+
+   >>> bsts(2)
+   2
+   >>> bsts(3)
+   5
+   >>> bsts(5)
+   42
+
+   [HINT] There are two 2-node BSTs:
+      2    1
+     /      \
+    1        2
+   Note that all other 2-node BSTs are *isomorphic* to either one.
+      
+   Qa: What's the complexity of this DP?
+   
+   Qb: What's the name of this famous number series?
+
+   Feel free to use any implementation style.
+   
+   Filename: bsts.py
+
+3. Number of bit strings of length n that has
+
+   1) no two consecutive 0s.
+   2) two consecutive 0s.
+   
+   >>> num_no(3)
+   5
+   >>> num_yes(3)
+   3
+
+   [HINT] There are three 3-bit 0/1-strings that have two consecutive 0s.
+            001  100  000
+          The other five 3-bit 0/1-strings have no two consecutive 0s:
+	    010  011  101  110  111
+
+   Feel free to choose any implementation style.
+
+   Filename: bitstrings.py
+
+   [HINT] Like problem 1, you can also use the O(2^n) exhaustive search method to verify your answer.
+
+
+Debriefing (required!): --------------------------
+
+0. What's your name?
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+4. How deeply do you feel you understand the material it covers (0%-100%)? 
+5. Which part(s) of the course you like the most so far?
+6. Which part(s) of the course you dislike the most so far?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
diff --git a/code/cs325-langs/hws/hw6.txt b/code/cs325-langs/hws/hw6.txt
new file mode 100644
index 0000000..d6dbdf4
--- /dev/null
+++ b/code/cs325-langs/hws/hw6.txt
@@ -0,0 +1,114 @@
+CS 325-001, Algorithms, Fall 2019
+HW6 - DP (part 2)
+
+Due on Monday Nov 4, 11:59pm.
+No late submission will be accepted.
+
+Need to submit: report.txt, knapsack_unbounded.py, knapsack_bounded.py.
+knapsack_bounded.py will be graded for correctness (1%).
+
+To submit:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw6 report.txt knapsack*.py
+(You can submit each file separately, or submit them together.)
+
+To see your best results so far:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/query hw6
+
+Textbooks for References:
+[1] KT Ch. 6.4
+    or Ch. 5.3 in a previous version:
+    http://cs.furman.edu/~chealy/cs361/kleinbergbook.pdf   
+[2] KT slides for DP (pages 1-37):
+    https://www.cs.princeton.edu/~wayne/kleinberg-tardos/pdf/06DynamicProgrammingI.pdf
+[3] Wikipedia: Knapsack (unbounded and 0/1)
+[4] CLRS Ch. 15
+
+Please answer time/space complexities for each problem in report.txt.
+
+0. For each of the coding problems below:
+   (a) Describe a greedy solution.
+   (b) Show a counterexample to the greedy solution.
+   (c) Define the DP subproblem 
+   (d) Write the recurrence relations
+   (e) Do not forget base cases
+   (f) Analyze the space and time complexities
+
+1. Unbounded Knapsack
+
+   You have n items, each with weight w_i and value v_i, and each has infinite copies.
+   **All numbers are positive integers.**
+   What's the best value for a bag of W?
+
+   >>> best(3, [(2, 4), (3, 5)])
+   (5, [0, 1])
+
+   the input to the best() function is W and a list of pairs (w_i, v_i).
+   this output means to take 0 copies of item 1 and 1 copy of item 2.
+
+   tie-breaking: *reverse* lexicographical: i.e., [1, 0] is better than [0, 1]:
+   (i.e., take as many copies from the first item as possible, etc.)
+
+   >>> best(3, [(1, 5), (1, 5)])
+   (15, [3, 0])
+
+   >>> best(3, [(1, 2), (1, 5)])
+   (15, [0, 3])
+
+   >>> best(3, [(1, 2), (2, 5)])
+   (7, [1, 1])
+
+   >>> best(58, [(5, 9), (9, 18), (6, 12)])
+   (114, [2, 4, 2])
+
+   >>> best(92, [(8, 9), (9, 10), (10, 12), (5, 6)])
+   (109, [1, 1, 7, 1])
+
+   Q: What are the time and space complexities?
+
+   filename: knapsack_unbounded.py
+
+2. [WILL BE GRADED] 
+   Bounded Knapsack
+
+   You have n items, each with weight w_i and value v_i, and has c_i copies.
+   **All numbers are positive integers.**
+   What's the best value for a bag of W?
+
+   >>> best(3, [(2, 4, 2), (3, 5, 3)])
+   (5, [0, 1])
+
+   the input to the best() function is W and a list of triples (w_i, v_i, c_i).
+
+   tie-breaking: same as in p1:
+
+   >>> best(3, [(1, 5, 2), (1, 5, 3)])
+   (15, [2, 1])
+
+   >>> best(3, [(1, 5, 1), (1, 5, 3)])
+   (15, [1, 2])
+
+   >>> best(20, [(1, 10, 6), (3, 15, 4), (2, 10, 3)])
+   (130, [6, 4, 1])
+
+   >>> best(92, [(1, 6, 6), (6, 15, 7), (8, 9, 8), (2, 4, 7), (2, 20, 2)])
+   (236, [6, 7, 3, 7, 2])
+
+   Q: What are the time and space complexities?
+
+   filename: knapsack_bounded.py
+
+   You are encouraged to come up with a few other testcases yourself to test your code!
+   
+Debriefing (required!): --------------------------
+
+0. What's your name?
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+4. How deeply do you feel you understand the material it covers (0%-100%)? 
+5. Which part(s) of the course you like the most so far?
+6. Which part(s) of the course you dislike the most so far?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
diff --git a/code/cs325-langs/hws/hw8.txt b/code/cs325-langs/hws/hw8.txt
new file mode 100644
index 0000000..61d1c6d
--- /dev/null
+++ b/code/cs325-langs/hws/hw8.txt
@@ -0,0 +1,147 @@
+CS 325-001, Algorithms, Fall 2019
+HW8 - Graphs (part I); DP (part III)
+
+Due on Monday November 18, 11:59pm.
+No late submission will be accepted.
+
+Include in your submission: report.txt, topol.py, viterbi.py.
+viterbi.py will be graded for correctness (1%).
+
+To submit:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/submit hw8 report.txt {topol,viterbi}.py
+(You can submit each file separately, or submit them together.)
+
+To see your best results so far:
+flip $ /nfs/farm/classes/eecs/fall2019/cs325-001/query hw8
+
+Textbooks for References:
+[1] CLRS Ch. 23 (Elementary Graph Algorithms)
+[2] KT Ch. 3 (graphs), or Ch. 2 in this earlier version:
+    http://cs.furman.edu/~chealy/cs361/kleinbergbook.pdf
+[3] KT slides (highly recommend!):
+    https://www.cs.princeton.edu/~wayne/kleinberg-tardos/pdf/03Graphs.pdf
+[4] Jeff Erickson: Ch. 5 (Basic Graph Algorithms):
+    http://jeffe.cs.illinois.edu/teaching/algorithms/book/05-graphs.pdf
+[5] DPV Ch. 3, 4.2, 4.4, 4.7 (Dasgupta, Papadimitriou, Vazirani)
+    https://www.cs.berkeley.edu/~vazirani/algorithms/chap3.pdf (decomposition of graphs)
+    https://www.cs.berkeley.edu/~vazirani/algorithms/chap4.pdf (paths, shortest paths)
+[6] my advanced DP tutorial (up to page 16):
+    http://web.engr.oregonstate.edu/~huanlian/slides/COLING-tutorial-anim.pdf
+
+Please answer non-coding questions in report.txt.
+
+0. For the following graphs, decide whether they are
+   (1) directed or undirected, (2) dense or sparse, and (3) cyclic or acyclic:
+
+   (a) Facebook
+   (b) Twitter
+   (c) a family
+   (d) V=airports, E=direct_flights
+   (e) a mesh
+   (f) V=courses, E=prerequisites
+   (g) a tree
+   (h) V=linux_software_packages, E=dependencies
+   (i) DP subproblems for 0-1 knapsack
+
+   Can you name a very big dense graph?
+
+1. Topological Sort
+   
+   For a given directed graph, output a topological order if it exists.
+   
+   Tie-breaking: ARBITRARY tie-breaking. This will make the code 
+   and time complexity analysis a lot easier. 
+
+   e.g., for the following example:
+
+     0 --> 2 --> 3 --> 5 --> 6
+        /    \   |  /    \
+       /      \  v /      \
+     1         > 4         > 7
+
+   >>> order(8, [(0,2), (1,2), (2,3), (2,4), (3,4), (3,5), (4,5), (5,6), (5,7)])
+   [0, 1, 2, 3, 4, 5, 6, 7]
+
+   Note that order() takes two arguments, n and list_of_edges, 
+   where n specifies that the nodes are named 0..(n-1).
+
+   If we flip the (3,4) edge:
+
+   >>> order(8, [(0,2), (1,2), (2,3), (2,4), (4,3), (3,5), (4,5), (5,6), (5,7)])
+   [0, 1, 2, 4, 3, 5, 6, 7]
+
+   If there is a cycle, return None
+
+   >>> order(4, [(0,1), (1,2), (2,1), (2,3)])
+   None
+
+   Other cases:
+
+   >>> order(5, [(0,1), (1,2), (2,3), (3,4)])
+   [0, 1, 2, 3, 4]
+
+   >>> order(5, [])
+   [0, 1, 2, 3, 4]  # could be any order   
+
+   >>> order(3, [(1,2), (2,1)])
+   None
+
+   >>> order(1, [(0,0)]) # self-loop
+   None
+
+   Tie-breaking: arbitrary (any valid topological order is fine).
+   
+   filename: topol.py 
+
+   questions: 
+   (a) did you realize that bottom-up implementations of DP use (implicit) topological orderings?
+       e.g., what is the topological ordering in your (or my) bottom-up bounded knapsack code?
+   (b) what about top-down implementations? what order do they use to traverse the graph?
+   (c) does that suggest there is a top-down solution for topological sort as well? 
+
+2. [WILL BE GRADED]
+   Viterbi Algorithm For Longest Path in DAG (see DPV 4.7, [2], CLRS problem 15-1)
+   
+   Recall that the Viterbi algorithm has just two steps:
+   a) get a topological order (use problem 1 above)
+   b) follow that order, and do either forward or backward updates
+
+   This algorithm captures all DP problems on DAGs, for example,
+   longest path, shortest path, number of paths, etc.
+
+   In this problem, given a DAG (guaranteed acyclic!), output a pair (l, p) 
+   where l is the length of the longest path (number of edges), and p is the path. (you can think of each edge being unit cost)
+
+   e.g., for the above example:
+
+   >>> longest(8, [(0,2), (1,2), (2,3), (2,4), (3,4), (3,5), (4,5), (5,6), (5,7)])
+   (5, [0, 2, 3, 4, 5, 6])
+
+   >>> longest(8, [(0,2), (1,2), (2,3), (2,4), (4,3), (3,5), (4,5), (5,6), (5,7)])
+   (5, [0, 2, 4, 3, 5, 6]) 
+
+   >>> longest(8, [(0,1), (0,2), (1,2), (2,3), (2,4), (4,3), (3,5), (4,5), (5,6), (5,7), (6,7)])
+   (7, [0, 1, 2, 4, 3, 5, 6, 7])  # unique answer
+
+   Note that longest() takes two arguments, n and list_of_edges, 
+   where n specifies that the nodes are named 0..(n-1).
+
+   Tie-breaking: arbitrary. any longest path is fine.   
+
+   Filename: viterbi.py
+
+   Note: you can use this program to solve MIS, knapsacks, coins, etc.
+
+
+Debriefing (required!): --------------------------
+
+0. What's your name?
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+4. How deeply do you feel you understand the material it covers (0%-100%)? 
+5. Any other comments?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.
diff --git a/code/cs325-langs/hws/hw9.txt b/code/cs325-langs/hws/hw9.txt
new file mode 100644
index 0000000..24da089
--- /dev/null
+++ b/code/cs325-langs/hws/hw9.txt
@@ -0,0 +1,166 @@
+CS 325, Algorithms, Fall 2019
+HW9 - Graphs (part 2), DP (part 4)
+
+Due Monday Nov 25, 11:59pm. 
+No late submission will be accepted.
+
+Include in your submission: report.txt, dijkstra.py, nbest.py.
+dijkstra.py will be graded for correctness (1%).
+
+Textbooks for References:
+[1] CLRS Ch. 22 (graph)
+[2] my DP tutorial (up to page 16):
+    http://web.engr.oregonstate.edu/~huanlian/slides/COLING-tutorial-anim.pdf
+[3] DPV Ch. 3, 4.2, 4.4, 4.7, 6 (Dasgupta, Papadimitriou, Vazirani)
+    https://www.cs.berkeley.edu/~vazirani/algorithms/chap3.pdf
+    https://www.cs.berkeley.edu/~vazirani/algorithms/chap4.pdf
+    https://www.cs.berkeley.edu/~vazirani/algorithms/chap6.pdf
+[4] KT Ch. 6 (DP)
+    http://www.aw-bc.com/info/kleinberg/assets/downloads/ch6.pdf
+[5] KT slides: Greedy II (Dijkstra)
+    http://www.cs.princeton.edu/~wayne/kleinberg-tardos/
+
+***Please answer time/space complexities for each problem in report.txt.
+
+1. [WILL BE GRADED]
+   Dijkstra (see CLRS 24.3 and DPV 4.4)
+   
+   Given an undirected graph, find the shortest path from source (node 0)
+   to target (node n-1). 
+   
+   Edge weights are guaranteed to be non-negative, since Dijkstra doesn't work
+   with negative weights, e.g.
+ 
+       3
+   0 ------ 1   
+     \    /
+    2 \  / -2
+       \/
+       2
+   
+   in this example, Dijkstra would return length 2 (path 0-2), 
+   but path 0-1-2 is better (length 1).
+
+   For example (return a pair of shortest-distance and shortest-path):
+   
+       1
+   0 ------ 1   
+     \    /  \
+    5 \  /1   \6
+       \/   2  \
+       2 ------ 3
+            
+   >>> shortest(4, [(0,1,1), (0,2,5), (1,2,1), (2,3,2), (1,3,6)])
+   (4, [0,1,2,3])
+
+   If the target node (n-1) is unreachable from the source (0),
+   return None:
+
+   >>> shortest(5, [(0,1,1), (0,2,5), (1,2,1), (2,3,2), (1,3,6)])
+   None
+
+   Another example:
+
+      1          1
+   0-----1    2-----3
+
+   >>> shortest(4, [(0,1,1), (2,3,1)])
+   None
+
+   Tiebreaking: arbitrary. Any shortest path would do.
+
+   Filename: dijkstra.py
+
+   Hint: please use heapdict from here:
+   https://raw.githubusercontent.com/DanielStutzbach/heapdict/master/heapdict.py
+
+   >>> from heapdict import heapdict
+   >>> h = heapdict()
+   >>> h['a'] = 3
+   >>> h['b'] = 1
+   >>> h.peekitem()
+   ('b', 1)
+   >>> h['a'] = 0
+   >>> h.peekitem()
+   ('a', 0)
+   >>> h.popitem()
+   ('a', 0)
+   >>> len(h)
+   1
+   >>> 'a' in h
+   False
+   >>> 'b' in h 
+   True
+
+   You don't need to submit heapdict.py; we have it in our grader.
+
+
+2. [Redo the nbest question from Midterm, preparing for HW10 part 3]
+
+   Given k pairs of lists A_i and B_i (0 <= i < k), each with n sorted numbers,
+   find the n smallest pairs in all the (k n^2) pairs.
+   We say (x,y) < (x', y') if and only if x+y < x'+y'.
+   Tie-breaking: lexicographical (i.e., prefer smaller x).
+
+   You can base your code on the skeleton from the Midterm:
+
+    from heapq import heappush, heappop
+    def nbest(ABs):    # no need to pass in k or n
+        k = len(ABs)
+        n = len(ABs[0][0])
+        def trypush(i, p, q):  # push pair (A_i,p, B_i,q) if possible
+            A, B = ABs[i] # A_i, B_i
+            if p < n and q < n and ______________________________:
+                heappush(h, (________________, i, p, q, (A[p],B[q])))
+                used.add((i, p, q))
+        h, used = ___________________                 # initialize
+        for i in range(k):  # NEED TO OPTIMIZE
+            trypush(______________)
+        for _ in range(n): 
+            _, i, p, q, pair = ________________
+            yield pair     # return the next pair (in a lazy list)
+            _______________________
+            _______________________
+
+
+    But recall we had two optimizations to speed up the first for-loop (queue initialization):
+
+    (1) using heapify instead of k initial pushes. You need to implement this (very easy).
+
+    (2) using qselect to choose top n out of the k bests. This one is OPTIONAL.
+
+    Analyze the time complexity for the version you implemented.
+ 
+    >>> list(nbest([([1,2,4], [2,3,5]), ([0,2,4], [3,4,5])])) 
+
+    [(0, 3), (1, 2), (0, 4)]
+
+    >>> list(nbest([([-1,2],[1,4]), ([0,2],[3,4]), ([0,1],[4,6]), ([-1,2],[1,5])])) 
+    [(-1, 1), (-1, 1)]
+
+    >>> list(nbest([([5,6,10,14],[3,5,10,14]),([2,7,9,11],[3,8,12,16]),([1,3,8,10],[5,9,10,11]),([1,2,3,5],[3,4,9,10]),([4,5,9,10],[2,4,6,11]),([4,6,10,13],[2,3,5,9]),([3,7,10,12],[1,2,5,10]),([5,9,14,15],[4,8,13,14])]))
+
+    [(1, 3), (3, 1), (1, 4), (2, 3)]
+
+    >>> list(nbest([([1,6,8,13],[5,8,11,12]),([1,2,3,5],[5,9,11,13]),([3,5,7,10],[4,6,7,11]),([1,4,7,8],[4,9,11,15]),([4,8,10,13],[4,6,10,11]),([4,8,12,15],[5,10,11,13]),([2,3,4,8],[4,7,11,15]),([4,5,10,15],[5,6,7,8])]))
+
+    [(1, 4), (1, 5), (1, 5), (2, 4)]
+
+    This problem prepares you for the hardest question in HW10 (part 3).
+
+    Filename: nbest.py
+       
+
+
+Debriefing (required!): --------------------------
+
+0. What's your name?
+1. Approximately how many hours did you spend on this assignment?
+2. Would you rate it as easy, moderate, or difficult?
+3. Did you work on it mostly alone, or mostly with other people?
+4. How deeply do you feel you understand the material it covers (0%-100%)? 
+5. Any other comments?
+
+This section is intended to help us calibrate the homework assignments. 
+Your answers to this section will *not* affect your grade; however, skipping it
+will certainly do.