Fall Quarter, 2004

Intermediate Data Structures and Algorithms

News

Final syllabus posted

Warm-up questions (with some solutions)

Homework 3 solution posted

Project 3 deadline extended to December 1st.

Project 3 posted

Quiz 2 syllabus posted

Warm-up questions (with some solutions) and a sample quiz2 (with solution) posted

Homework 3 posted

Homework 2 solution posted

Quiz 2 is Wednesday November 17, in class (covers all the material up to the lecture on Friday November 12th)

Project 2 posted

Quiz 1 syllabus posted

Warm-up questions (with some solutions) and a sample quiz1 (with solution) posted

Homework 2 posted

Quiz 1 is Wednesday October 27, in class (covers all the material up to the lecture on Friday October 22nd)

Homework 1 solution posted

Project 1 posted

Homework 1 posted

Chapter 5 of Algorithm Design is available at the UCR Printing and Reprographics (by the Bookstore)

The first lab is Friday, Sept 24th

Lecture Schedule Lab Session Topics Email list Turnin Grade mapping Previous offerings Resources Tutorials Animations

Overview

CS 141 introduces what many say is the core of Computer Science: data structures like graphs, and problem solving techniques. This material is essential in almost all of our upper-division courses.

Catalog description: CS 141. Intermediate Data Structures and Algorithms. (4) Lecture, three hours; laboratory, three hours. Prerequisite(s): CS 014 with a grade of "C-" or better; MATH 009C or MATH 09HC; CS/MATH 111 or MATH 112; proficiency in C++. Explores basic algorithm analysis using asymptotic notations, summation and recurrence relations, and algorithms and data structures for discrete structures including trees, strings, and graphs. Also covers general algorithm design techniques including "divide-and-conquer," the greedy method, and dynamic programming. Homework and programming assignments integrate knowledge of data structures, algorithms, and programming.
UCR course schedule, UCR course catalog. Note: Students receiving less than a C- in the CS 14 prerequisite will be dropped automatically a few weeks into the quarter, as the course relies heavily on basic knowledge of and skills in data structures, discrete mathematics, and programming.

Basic information

Syllabus: Download the PDF file.

Instructor: Stefano Lonardi (stelo@cs.ucr.edu)
Office hours: Monday 5-6pm and Thursday 5-6pm. Office: Surge Bldg. 320.
Teaching Assistants and office hours:

Sam Meshkin (smeshkin@cs.ucr.edu), Office hours: Tue 10-11am

Serdar Bozdag (sbozdag@cs.ucr.edu), Office hours: Wed 2-3pm

Luke Keppler (lkeppler@cs.ucr.edu), Office hours: TBA

Kin Fai Kan (kkan@cs.ucr.edu), Office hours: Wed 3-4pm

Lectures: Attendance is strongly recommended.

(1) MWF 10:10-11:00, GEOL 1408

(2) MWF 11:10-12:00, GEOL 1408

Labs: Attendance is mandatory.

Sec 21, Fri, 8:10am-11am, SURGE 283, Serdar

Sec 22, Fri, 11:10am-2pm, SURGE 283, Kin

Sec 23, Fri, 2:10pm-5pm, SURGE 283, Luke

Sec 24, Fri, 6:10pm-9pm, SURGE 170, Sam

Text Book:

Data Structures and Algorithms in C++ by Michael T. Goodrich, Roberto Tamassia, and David M. Mount, Wiley.

Chapter 5 of Algorithm Design (Foundations, Analysis, and Internet Examples): available at the end of the first week at the UCR Printing and Reprographics (by the Bookstore)

References:

Algorithm Design (Foundations, Analysis, and Internet Examples) by Michael T. Goodrich and Roberto Tamassia, Wiley.

Introduction to Algorithms (2nd Edition) by Thomas H. Cormen, Charles E. Leiserson, Ronald L. Rivest, and Cliff Stein, MIT Press.

Approximate Time Requirements: This is a four-unit CS course. As such, you should expect to spend the following approximate amount of time: 3 hours/week in lecture
3 hours/week in lab
6 to 10 hours/week doing individual study (readings, homeworks, programming assignments, preparation for lectures, etc).
Please don't underestimate the time you will need to spend on this course. These are real time amounts spent by average successful past students. Computer Science and Engineering are challenging disciplines requiring extensive time to master.

Lectures

See the syllabus. Read the book before lecture! Reading ahead is one of the most effective ways of doing better in class -- you'll be amazed how much more comprehensible and useful the lectures will be. The schedule is subject to change as the quarter progresses.

Lecture Notes:

Course Overview [PDF format 2 slides/page]

Algorithm Analysis [PDF format 2 slides/page]

Greedy, Divide&Conquer, Dynamic Programming [PDF format 2 slides/page]

Graphs [PDF format 2 slides/page]

Weighted Graphs [PDF format 2 slides/page]

Tentative list of topics

week 1: Course overview, analysis of algorithms

week 2: Discrete math for algorithm analysis

week 3: Greedy approach for algorithm design

week 4: Divide and conquer, dynamic programming

week 5: Graphs, and their representation

week 6: Graph traversal, connectivity

week 7: Minimum cost spanning tree, single-source shortest path

week 8: All-pais shortest path

week 9: String matching, KMP

week 10: NP completeness, review

Actual list of topics

Sep 24th: Course overview
Sep 27th: Algorithm analysis [slides 1-20]
Sep 29th: Algorithm analysis [slides 21-33]
Oct 1st: Algorithm analysis [slides 34-45]
Oct 4th: Algorithm analysis [slides 46-68]
Oct 8th: Algorithm analysis [slides 69-94]
Oct 11th: Algorithm analysis [slides 95-103]
Oct 13th: Algorithm analysis [slides 103-117]
Oct 15th: Algorithm analysis [slides 117-end], Greedy [slides 1-10]
Oct 18th: Greedy [slides 11-27]
Oct 20th: Greedy [slides 28-40] (guest lecture by Sam)
Oct 22th: Divide and conquer [slides 41-48]
Oct 25th: Dynamic Programming [slides 67-86]
Oct 27th: Quiz 1 (in class, closed book, closed notes)
Oct 29th: Dynamic Programming [slides 87-106]
Nov 1st: Divide and conquer [slides 50-66], Dynamic Programming [slides 107-110]

Nov 3rd

Nov 5th: Graphs [13-37]
Nov 8th: Graphs [38-55]
Nov 10th: Graphs [56-92]
Nov 12th: Graphs [93-105]
Nov 15th: Graphs [106-end], Weighted Graphs [1-6]
Nov 17th: Quiz 2 (in class, closed book, closed notes)
Nov 19th: Weighted Graphs [7-17]
Nov 22th: Weighted Graphs [17-25]
Nov 24th: Weighted Graphs [26-42]
Nov 26th: Thanksgiving
Nov 29th: Weighted Graphs [43-65]
Dec 1st: Weighted Graphs [66-end]
Dec 3rd: Review
Dec 6th: Final section 001 - 11:30AM-2:30PM - GEOL 1408
Dec 8th: Final section 002 - 8:00AM-11:00AM - GEOL 1408

Do not put off reading the assignments or you will risk falling behind. Reading ahead is one of the most effective ways of doing better in class -- you'll be amazed how much more comprehensible and useful the lectures will be.

Homeworks

Homework 1 [posted Sept 27th, due Oct 11th]
Homework 1 solution
Homework 2 [posted Oct 18th, due Nov 3rd]
Homework 2 solution
Homework 3 [posted Nov 8th, due Nov 22nd]
Homework 3 solution

Projects

Project 1 [posted Oct 4th, due Oct 18th]
An implementation of Project 1 [string based]
Project 2 [posted Oct 25th, due Nov 8th, revised Nov 1st]
Project 2 test file
Executable for prj2
An implementation of Project 2 by Luke
Project 3 [posted Nov 15th, due Dec 1st]

Quizzes

Quiz 1 Winter 2004
Quiz 1 Winter 2004 solution (please attempt to solve the quiz before reading the solution)
Some warm-up questions for Quiz 1 (with some solutions)
Quiz 1 syllabus
Quiz 1/A with solutions
Quiz 1/B with solutions
Quiz 1/C with solutions
Quiz 1/D with solutions
Quiz 2 Winter 2004
Quiz 2 Winter 2004 solution (please attempt to solve the quiz before reading the solution)
Some warm-up questions for Quiz 2 (with some solutions)
Quiz 2 syllabus
Quiz 2/A with solutions
Quiz 2/B with solutions
Quiz 2/C with solutions
Quiz 2/D with solutions
Some warm-up questions (with some solutions)
Final syllabus

Labs

Friday, September 24th:
Introduction of TA; class accounts and mailing list
Debugging and testing in C++; working on Linux
Counting execution time of a program
Top-down design of algorithms; pseudo-code
Asymptotic (big-O, Theta) analysis of running time
More details

Friday, October 1st:
Preview the first homework.
More asymptotic analysis of algorithms
Treatment of for-loops using summation
Pointers and recursive algorithms/programs
More details

Friday, October 8th:
Preview the first programming assignment
Recurrence relations and analysis of recursive algorithms
STL: set
Recursive programming - computing the all the permutations of a word
More details
In-lab assignment solution

Friday, October 15th:
Review the first homework solution
Review the first programming assignment
Example of the greedy method
STL: priority queue
Implementation of the task scheduling algorithm
More details
In-lab assignment solution (by Richard Schumacher)

Friday, October 22th:
Preview the second homework
Review the warm-up questions and the sample quiz
Implementation of divide and conquer multiplication algorithm
More details

Friday, October 29th:
Address questions regarding the second homework
Preview the second programming assignment
Implementation of the 01-knapsack (dynamic programming) algorithm
More details

Friday, November 5th:
Review the second homework solution
Address questions regarding the second programming assignment
Implementation of the LCS algorithm
More details

Friday, November 12th:
Preview the third homework
Review the warm-up questions and the sample quiz
Give an example of the classification of the edges in a undirected graph according its DFS/BFS trees
Implement DFS for undirected graphs
More details

Friday, November 19th:
Answer questions about the third homework
Review the third programming assignment
Discuss Floyd-Warshall and topological sorting
Implement topological sorting
More details

Friday, November 26th:
No Lab (Thankgiving)

Friday, December 3rd:
Review session (in preparation for the final)

General course features and policies

Material covered: Lectures don't cover all required material, which also appears in the text and reference books and may be covered only in the lab sessions.
Academic dishonesty: Cheating will be strongly punished (typically with an F in the course). You can report cheating anonymously at: https://www.cs.ucr.edu/cheating/. Assignment submissions must represent your original work. Copying from any sources (web, other books, past or current students, etc.) is strictly prohibited -- learning to program requires you to learn to solve programming problems by yourself; using existing code and other resources becomes important later on in your studies. While discussing assignments together is encouraged, team coding (even of pseudo-code) or letting others see your code are specifically not allowed. Be aware that programs are automatically compared to the current and prior quarter's programs for plagiarism, using a sophisticated code-comparison tool that ignores insignificant differences (like whitespace and variable names). Be aware that a subset of exams may be photocopied, for comparison with exams submitted for regrades. Also, be aware that lying to an instructor in order to be able to makeup a missed exam or in other ways to obtain a better grade can be treated as academic dishonesty.
Regrade policy: Regrade requests must be submitted in writing and within two weeks of the distribution of the graded material. The entire homework/test/assignment may be regraded, not just the problem in question, so the grade may go up or down. Thus, think your regrade requests through carefully. To have a homework/test regraded, communicate with the TA(s) who graded the involved questions. For assignments, send email requests to the CS141 grader account (cs141-g) with detailed explanations. Recording errors should also be pointed out to TAs or the instructor before the last class.
Final grades: Per university policy, changes to your final grade will be made only in the event of a clerical error. Asking your instructor how far you were from a cutoff and what extra work you can do to improve the grade is not appropriate.
Communicating with the instructors and TAs: When sending electronic mail to the instructors or TAs or graders, please include your full name, student ID number, and UCR email address, so that we may properly identify you (remember, many students have similar names). Also, please try to be polite and use reasonable grammar and formatting.
Cell phones: During lectures and lab sessions, please turn off your cell phone. During exams, cell phones must not be visible (e.g., store them inside a backpack).
Written Assignments: All assignments and solutions will be posted on the class homepage. Write your full name with upper-case LAST name, assignment number, student ID, login, class section, lab section. Write legibly: what cannot be read will not be graded. Consider typing the assignment if you handwriting is hard to read. Written assignments have to be submitted before the beginning of the class on the due date on the instructor's desk. Include the following on first page ``I certify that this submission represent my own original work'' (date, signature). No late assignment will be accepted. Any problem with grading of a written assignment should be addressed at the latest two weeks after the assignment is returned to you.
Programming assignments: All programming assignments will be turned in electronically. Each file should begin with our report template header. Source code should comply with professionally accepted coding standards. In particular, all code must be compiled with the -Wall -W -Werror command line options, or else it will not be graded. Also, you must include a section explaining the design, structure, etc of your program and how it works. Comments in source code are important, but they are not a replacement for an explanatory section. Please remember that successfully writing a computer program that compiles and runs correctly is not something anyone can do in just a few minutes, even when it looks easy. Debugging typically takes three times longer than figuring out how to write your program. So don't leave your programming assignments to the last minute! For programming work only, we will accept work up to 1 day late for 10% penalty.
Reading: Read the current book sections before coming to lecture, and attend all lectures in their entirety. Feel free to ask questions.

Lab guidelines

Students are expected to attend the lab sessions in their entirety. The lab sessions typically consist of tutorials, discussions, reviews, practical exercises/tests, and time for students to work on homes and programming assignments.
During lab tutorial/discussion/review time, students should not use the computers. Ideally, students would move their chairs to the whiteboard area.
To reduce disruptions and provide for the best educational environment, all persons in lab during scheduled lab time should be formally registered in that section. In general, no swapping sections and no unregistered people in the lab are allowed, even if there are extra computers.

Electronic assignment turn-in

Anonymously report suspected cheating

Grade mapping

The following mapping shows how your overall numerical scores will be translated into letter grades at the end of the quarter:

90+ -> A+
85+ -> A
80+ -> A-
77+ -> B+
73+ -> B
70+ -> B-
67+ -> C+
63+ -> C
60+ -> C-
57+ -> D+
53+ -> D
50+ -> D-
49- -> F

Course email list

Course mailing list (send mail now or access the archive): Be sure to sign up to receive important announcements, which will be madeonlythrough the course email list. You must use your CS or EE account, or else some other UCR account, so be sure to learn how to read those accounts or at least automatically forward messages to your personal email address (just create in your home directory a file named ".forward" containing your personal email address).