Add homework assignments
This commit is contained in:
parent
b3b906dd90
commit
c7ce8a3107
119
code/cs325langs/hws/hw1.txt
Normal file
119
code/cs325langs/hws/hw1.txt
Normal file

@ 0,0 +1,119 @@


CS 325001, 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/cs325001/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/cs325001/ to your $PATH:


$ export PATH=$PATH:/nfs/farm/classes/eecs/fall2019/cs325001/


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 bestcase, worstcase, and averagecase 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 bestcase, worstcase, and averagecase 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 (inplace) 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.



170
code/cs325langs/hws/hw10.txt
Normal file
170
code/cs325langs/hws/hw10.txt
Normal file

@ 0,0 +1,170 @@


CS 325, Algorithms (MS/MEnglevel), 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%


* 1best structure  2%


* number of structures  1%


* kbest 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/kleinbergtardos/




***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, '((.))')




Tiebreaking: 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. kbest structures: output the 1best, 2ndbest, ... kthbest structures.




>>> kbest("ACAGU", 3)


[(2, '((.))'), (1, '(...)'), (1, '.(.).')]




The list must be sorted.


Tiebreaking: 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, '((.).)(...((.(()()))).)()')]




42
code/cs325langs/hws/hw11.txt
Normal file
42
code/cs325langs/hws/hw11.txt
Normal file

@ 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/cs325001/submit hw11 edit.py




Implement two functions:


* distance1(s, t): Viterbistyle (either topdown or bottomup)


* distance2(s, t): Dijkstrastyle (bestfirst)




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

80
code/cs325langs/hws/hw2.txt
Normal file
80
code/cs325langs/hws/hw2.txt
Normal file

@ 0,0 +1,80 @@


CS 325001, Analysis of Algorithms, Fall 2019


HW2  Dividenconquer: 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/cs325001/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/cs325001/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 124679.




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.



83
code/cs325langs/hws/hw3.txt
Normal file
83
code/cs325langs/hws/hw3.txt
Normal file

@ 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 HW12).


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/cs325001/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/cs325001/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 builtin 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.



114
code/cs325langs/hws/hw4.txt
Normal file
114
code/cs325langs/hws/hw4.txt
Normal file

@ 0,0 +1,114 @@


CS 325001, 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/cs325001/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/cs325001/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/kleinbergtardos/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 (topdown)  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 reverselysorted 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) Dijkstrastyle bestfirst, 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. kway 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 builtin 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, popmin, 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.



130
code/cs325langs/hws/hw5.txt
Normal file
130
code/cs325langs/hws/hw5.txt
Normal file

@ 0,0 +1,130 @@


CS 532001, Algorithms, Fall 2019


HW5  DP (part 1: simple)




HWs 57 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/cs325001/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/cs325001/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 topdown (max_wis()) and bottomup (max_wis2()) solutions,


and make sure they produce exact same results.


We'll only grade the topdown version.




Tiebreaking: 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 nnode BSTs




input: n


output: number of nnode BSTs




>>> bsts(2)


2


>>> bsts(3)


5


>>> bsts(5)


42




[HINT] There are two 2node BSTs:


2 1


/ \


1 2


Note that all other 2node 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 3bit 0/1strings that have two consecutive 0s.


001 100 000


The other five 3bit 0/1strings 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.

114
code/cs325langs/hws/hw6.txt
Normal file
114
code/cs325langs/hws/hw6.txt
Normal file

@ 0,0 +1,114 @@


CS 325001, 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/cs325001/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/cs325001/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 137):


https://www.cs.princeton.edu/~wayne/kleinbergtardos/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.




tiebreaking: *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).




tiebreaking: 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.

147
code/cs325langs/hws/hw8.txt
Normal file
147
code/cs325langs/hws/hw8.txt
Normal file

@ 0,0 +1,147 @@


CS 325001, 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/cs325001/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/cs325001/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/kleinbergtardos/pdf/03Graphs.pdf


[4] Jeff Erickson: Ch. 5 (Basic Graph Algorithms):


http://jeffe.cs.illinois.edu/teaching/algorithms/book/05graphs.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/COLINGtutorialanim.pdf




Please answer noncoding 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 01 knapsack




Can you name a very big dense graph?




1. Topological Sort




For a given directed graph, output a topological order if it exists.




Tiebreaking: ARBITRARY tiebreaking. 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..(n1).




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)]) # selfloop


None




Tiebreaking: arbitrary (any valid topological order is fine).




filename: topol.py




questions:


(a) did you realize that bottomup implementations of DP use (implicit) topological orderings?


e.g., what is the topological ordering in your (or my) bottomup bounded knapsack code?


(b) what about topdown implementations? what order do they use to traverse the graph?


(c) does that suggest there is a topdown solution for topological sort as well?




2. [WILL BE GRADED]


Viterbi Algorithm For Longest Path in DAG (see DPV 4.7, [2], CLRS problem 151)




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..(n1).




Tiebreaking: 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.

166
code/cs325langs/hws/hw9.txt
Normal file
166
code/cs325langs/hws/hw9.txt
Normal file

@ 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/COLINGtutorialanim.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.awbc.com/info/kleinberg/assets/downloads/ch6.pdf


[5] KT slides: Greedy II (Dijkstra)


http://www.cs.princeton.edu/~wayne/kleinbergtardos/




***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 n1).




Edge weights are guaranteed to be nonnegative, 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 02),


but path 012 is better (length 1).




For example (return a pair of shortestdistance and shortestpath):




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 (n1) 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


01 23




>>> 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'.


Tiebreaking: 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 forloop (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.

Loading…
Reference in New Issue
Block a user