**Danila Fedorin**2 years ago

**10 changed files**with

**1165 additions**and

**0 deletions**

`@ -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.` |
|||

```
``` |

`@ -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, '((.).)(...((.(()()))).)()')]` |
|||

`------` |

`@ -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` |

`@ -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.` |
|||

```
``` |

`@ -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.` |
|||

```
``` |

`@ -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.` |
|||

```
``` |

`@ -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.` |

`@ -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.` |

`@ -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.` |

`@ -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.` |

Loading…

Reference in new issue