Add homework assignments
This commit is contained in:
parent
b3b906dd90
commit
c7ce8a3107
|
|
@ -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