1.6. Course Schedule

Here is a kind of approximate list of the topics we expect to cover in the course. So, after looking at a few examples, we will start with asymptotic complexity, which is the way of measuring the efficiency of algorithms and writing down this measure in a way that we can compare easily across algorithms.

In this part of the course, students will be introduced to the main topics. The focus will begin with asymptotic complexity, a method for assessing how efficient algorithms are based on their running time as input sizes increase. Understanding this concept is crucial because it allows for comparison of different algorithms and helps in choosing the best one for solving specific problems.

Imagine you are comparing two brands of bicycles that are supposed to get you to work. One is a fast racing bike, while the other is a heavier, sturdier bike. If you time each bike’s performance on the same route at different distances, you can determine which one is faster over 5 miles and which might be better for longer distances. Similarly, asymptotic complexity helps you evaluate and choose the best algorithm for your tasks based on speed and efficiency.

We will then move to the most basic problem that we have for arrays, which is to search an array for an element. And in the process, we will realize that it is important to be able to sort the array efficiently in order to arrange the elements in a way where we can search in an effective manner.

After understanding asymptotic complexity, the focus will shift to fundamental problems related to arrays, particularly searching for elements within them. Students will learn that efficient sorting of arrays is essential before searching can occur effectively. This section will cover various searching algorithms, such as binary search, as well as sorting algorithms like insertion sort and merge sort.

Think of a librarian looking for a specific book. If the library is organized (i.e., sorted by author or genre), finding a book becomes quick and easy—much like binary search. However, if all the books are randomly placed, it’s like searching through a messy room, which can take a long time. Sorting the books first (sorting the array) drastically reduces the time it takes to find the book (searching).

Moving on from searching and sorting, we come to graphs and graph algorithms. So, we will introduce graphs. We will see how we can use them to model certain types of problems. We need to know how to represent a graph. How do you? Graph is essentially a picture, so how do you translate this picture into something that an algorithm can manipulate?

This section introduces students to graphs and their importance in algorithm design. Graphs can model complex relationships between entities and can be used to solve various problems like finding the shortest path or determining connectivity. Students will learn how to represent graphs in a way that algorithms can process, which is foundational for later topics.

Consider a city map where intersections are dots (nodes) and the roads connecting them are lines (edges). Using a graph, you can model and solve problems like finding the quickest route from one location to another. Just as you would navigate a city based on its layout, algorithms navigate graphs to solve problems efficiently.

As we mentioned before, there are some basic algorithmic design techniques; which are applied across a class of problems. So, we will look in particular divide and conquer, greedy algorithms, and dynamic programming.

In this chunk, students will delve into essential algorithm design strategies that are widely used in computer science. Techniques like divide and conquer break problems into smaller parts, while greedy algorithms focus on making locally optimal choices. Dynamic programming is about storing solutions to subproblems to avoid redundant work. Understanding these methods will enhance a student’s problem-solving skill set.

Imagine planning a large event. Using divide and conquer, you could break tasks into smaller ones: venue, food, and entertainment. Each task can be handled separately yet contribute to the overall success. In contrast, a greedy algorithm could involve picking the vendor who offers the best deal at the moment without considering future implications. Dynamic programming is like keeping track of what has been done for future reference, so you don’t double book or overlook essential details.

Among the data structures that we will encounter in this course are priority queues, which are often implemented to heaps. You will look at binary search trees, which are efficient ways of maintaining information in a sorted order dynamically as information comes and goes.

This section familiarizes students with crucial data structures they will use throughout the course. Priority queues allow retrieval of the highest priority element quickly, and heaps are a common implementation. Binary search trees maintain sorted data, allowing for fast access and modifications. These structures are essential for implementing efficient algorithms correctly.

Think of a restaurant with a reservation system. A priority queue ensures that customers with urgent reservations get seated first, similar to how a healthcare system might prioritize emergency patients. A binary search tree is like a folder system where every folder is already arranged alphabetically; you can quickly add or remove files without disturbing the order.

This is an eight-week course. The tentative schedule is as follows: in the first week, we will do some motivating examples and we will look at some notations and work out some problems involving asymptotic complexity...

The course is structured into weekly segments, each focusing on different topics. Each week’s focus builds on the previous one, progressing from foundational concepts to more complex ideas. This week-by-week guide helps students understand what to expect and how to prepare for upcoming lessons.

Consider a series of cooking classes where each week teaches a different technique—sautéing, baking, or grilling. Just like how mastering each technique builds a better chef, this course's sequential weekly structure helps students build their understanding of algorithms step by step.

--