(Update 12/30): Diane will be leaving at 3pm today (Dec 30) in case you were planning to pick up your exam today.

You guys were the strongest 331 class I’ve had so far and I had a lot of fun teaching algorithms to you guys this semester! Hope you guys had fun too. Please feel to stop by for a chat if you want to.

Also the blog will remain dormant till next fall, so if you do not want to get email notification for next year’s course, please unsubscribe/unfollow the blog. (I cannot do this for you– see this post for more details on how to do that.)

Happy New Year to y’all!

Below the fold are some jokes from the final exam.

Even though I mis-judged the difficulty of the final exam, some of you did write in your jokes:

• (Ryan Brown) Algorithms, love it or hate it, it grows on you
• (Jimmy Dobler) Algorithms fun? Wrote algorithm to see. Returned inline “true.”
• (Tim Hemingway) Does there exist a greedy algorithm to get an A in this course?
• (Jon Logan) Algorithms are fun. (Note: this is a joke.)

I will submit the final letter grades on Friday, so if you find any inaccuracies in any of your scores on UBLearns, please let me know by Thursday. Unless there is a totaling mistake, we will not entertain any regrading requests on anything except the final exam and HW 10. Again all of these should be done by Thursday.

Given all your scores (which you can find on UBLearns), here is how you can calculate your grade:

1. Add up your 7 best homework scores (i.e. drop the lowest three) to get the number , which is at most . (Note that if you submitted a homework late, then it would be counted as a .)
2. Your midterm score , which can be at most a . (Do not add the bonus points.)
3. Your final exam score , which can be at most a . (Do not add the bonus points.)
4. Compute the exam component of your grade as .
5. Also calculate your “promised” exam score as
6. Your class participation score , which can be at most a and is the sum of your blog post and group scribe leader part. To see your scores on the latter, check UBLearns.

Your “original” score  out of a can be computed by the following formula:

.

Your “promised” score out of a can be computed by the following formula:

.

Check your score with the table below. If you have a grade of A- or above then stop– you have figured out your final grade. If not, use your score with the table below to figure out your final letter grade:

• : A
• : A-
• : B+
• : B
• : B-
• : C+
• : C
• : C-
• : D+
• : D
• : F

Please don’t come to me and argue about the boundaries: in a few cases the boundaries are clear but in most cases, they had to drawn somewhere.

Have a good break!

Here are the stats:

• Mean: 46.31
• Median: 45.5
• Std Deviation: 19.81

The final exam score will be up on UBLearns by 12:30pm today (Tue, Dec 20). Also you can pick up your final between 1-5 pm today from my office (Davis 319).

Below is the grading rubric that was used to score the final (along with the name of the grader). If you have any regrade request(s), please contact whoever graded the question you want regraded. Please note, as always, the rubric is a guideline– there might be some variations based on a case by case basis.

1. (Jiun-Jie) 2 for a correct T/F answer, 0 otherwise
2. (Atri) 2 points for a correct T/F answer; 4 for correct justification for a correct answer. Up to 2 points for a partially correct justification for a correct answer. No points if the answer is wrong.
3. (Jiun-Jie)  20 for the algorithm, 3 for Correctness and 2 for time analysis. There are two common wrong answers for this problem. If your answer is one of them, you will get partial credits as follows. (1) For each edge, set and run Dijkstra’s algorithm. In this case, you get– Algorithm: 7/20. Correctness: 0/3. Time Analysis: 2/2 (if your algorithm takes . (2) Use Prim’s algorithm or Kruskal’s algorithm to find maximum spanning tree T. Output the path from s to t in the spanning tree T. Algorithm: 2/20. Correctness 0/3. Time Analysis: 2/2 (if your algorithm takes .
4. (Jesse) 12 for the algorithm, 3 for correctness argument, 2 for run time analysis and 3 points for temporary space argument.  5 points for cases as mentioned in the final. 2 points if run a sorting algorithm in the values (and mentioned runtime).
5. (Atri) 12 points for example and 3 points for correctness argument. 3 points, if you got the idea behind the example but did not give any specific example.  3 points for presenting an example as mentioned in the question or presenting an example with fresh entries.

Without zero′s
Mean: 82
Median: 85
Standard Deviation: 19

With zero′s
Mean: 23
Median: 0
Standard Deviation: 38

Q1 and Q2 were graded by Jiun-Jie and Q3 was graded by Jesse.

As the stats show, many of you used this homework as a drop, and those that handed it in did pretty well. If there are any questions, feel free to contact us.

We’re on schedule to have the final exams graded and the letter grades assigned by tomorrow morning. I’ll put up a post once the grades have been finalized.

Unless you hear otherwise, you can pick-up your final exam (and any unclaimed HWs including HW 10) from 1-5pm tomorrow (Tue, Dec 20) in my office, Davis 319. (If you have not been there: take the elevator to the 3rd floor– when you get out, take a left, then an immediate left and then the next left (after the bathrooms)– 319 is immediately on the right  after you turn left.)

We’re on track for the grade to be assigned by Tuesday. Tentatively, your final (and HW 10) should be available for pickup from 1-5pm on Tuesday. Keep tuned for the final details.

As always, please do not try to read much into whether this is directly related to the content of the final exam. This seemed like a basic mis-understanding and I wanted to clarify it. As usual, make extrapolations at your own risk!

It has always been the case that the run time is measured in terms of the size of the input (say in bits). E.g., see slide 15 here. Thus, when one says a polynomial time algorithm, it is always in terms of of the input size. (I had mentioned this in the beginning of the semester and then I mostly neglected to mention this except when we were talking about Dijkstra’s algorithm I talked about the input size when the edge weights are arbitrary. Sorry for not stressing this enough.)

It has often been the case that the input size happens to be , where is some natural parameter in the problem input– in most cases it has been the number of input items. Thus, in this case an algorithm whose running time is polynomial in indeed has a polynomial run time.

However, this is not always the case. Here are two examples:

• In the stable marriage problem, the input size is , where is the number of men and women. Thus, the Gale- Shapely algorithm that runs in  time is actually a linear-time algorithm.
• Another example is problem 2(a) in the sample final exam. In this problem, the input itself is a number is but the input size, which is the number of bits needed to represent the number is , which is the input size.  (E.g., the input could be a number , in which case the input size is .) Hence, the algorithm presented in the problem has an exponential run time.

Hope this helps!

I have corrected two (small) errors in the sample mid-term solution and sample final solution. The links now point to the corrected solutions.

• In solution to 1(c) in the sample mid-term solution, it previously (incorrectly) stated that could be discovered from either or – this has been corrected to say that can be discovered from either or .
• In solution to 3(b) in the sample final, there was some confusion because of the difference on the convention that we used in the lectures and what the book uses. The solution has now been updated to reflect this and follow the convention of the lectures. (The end time of job is not instead of the earlier . Also added a footnote explaining the difference in the conventions.)