Outline

• Finish Activity Selector Problem
• Representations of Graphs
• Graph Traversals

Introduction

• On Monday, we finished talking about dynamic programming algorithms.
• We then started talking about Greedy algorithms.
• Like dynamic programming algorithms, greedy algorithms, usually are used to solve optimization problems.
• A greedy algorithm though when presented with a set of subproblems to select amongst will choose the locally best rather than test each one as might be done in a dynamic programming approach.
• Because of this a greedy solution can usually avoid a lookup table as might appear in a dynamic programming solution.
• On Monday, we gave the example of solving the make change problem with a greedy solution and then started talking about the activity selection problem.
• In the activity-selection problem we have a set of activities `S` that each make use of a common resource (say classes that make use of a room).
• Each activity `a_i` has a start time `s_i` and an end time `f_i` and two activities cannot be scheduled to make overlapping use of the resource.
• The goal of the problem is to choose a maximal-sized subset of activities that can be scheduled for the room.
• Let's briefly recall the optimal substructure we determined for this problem.

Last Day's Substructure Results

• Let `S_(ij)` be the set of activities that start after `a_i` finishes and that finish before `a_j` starts.
• Let `A_(ij)` denote a solution to the activity selector problem restricted to `S_(ij)`. Then if `a_k in A_{ij}` we have:
  `A_(ij) = A_(ik) cup {a_k} cup A_(kj)`
  from which we derived the size `c[i,j]` of the solution from `S_(ij)` satisfies the recurrence:
  `c[i,j] = { (0,if S_(ij) = emptyset),(max_(a_k in S_(ij)){c[i,k] + c[k,j] + 1},if S_(ij) ne emptyset):}`
• We said we could use the above to give a dynamic programming solution for activity selection, but that doing so would be very wasteful of memory.
• Instead, to reduce the memory consumption of the algorithm so far, we wanted some way to avoid computing `max_(a_k in S_(ij)){c[i,k] + c[k,j] + 1}`.
• So we said we should choose the activity that finishes first as it will leave the most time for the other activities.
• Let's try to argue that making such a choice will yield an optimal solution ...

Greed is Good (in this case)

Theorem. Consider any nonempty subproblem `S_k`, and let `a_m` be an activity in `S_k` with the earliest finish time (might be more than one). Then `a_m` is included in some maximum-size subset of mutually compatible activities of `S_k`.

Proof. Let `A_k` be a maximum-size subset of mutually compatible activities in `S_k` and let `a_j` be the activity in `A_k` with the earliest finish time. If `a_j = a_m` as then `a_m` would be in some maximal sized solution of the `S_k` subproblem. If `a_j ne a_m`, let `A_k' = (A_k - {a_j}) cup {a_m}`. The activities in `A_k'` are disjoint because the activities in `A_k` are disjoint, and `a_j` is the first activity in `A_k` to finish and `f_m le f_j`. Since `|A_k'| = |A_k|`, we conclude that `A_k'` is a solution as well. Moreover, it contains `a_m`. QED.

A Recursive Greedy Algorithm

• Assume that we store the start times and end times of an instance of activity-selection in arrays `s` and `f` respectively.
• The result of the last slide then justifies using the greedy algorithm below to solve the activity-selection problem.
• Here we assume we would call the code below with an initial call RECURSIVE_ACTIVITY-SELECTOR(s,f,0,n).
• The code in general solves the `S_(kn)` subproblem. Notice also it makes use of the fact that we assumes the activities were already ordered according to finish time.

RECURSIVE-ACTIVITY-SELECTOR(s,f,k,n)
1 m = k + 1
2 while m ≤ n and s[m] < f[k]
3     m = m + 1
4 if m ≤ n
5    return {a_m} ∪ RECURSIVE-ACTIVITY-SELECTOR(s, f, m, n)
6 else return 0.

RECURSIVE-ACTIVITY-SELECTOR in Action

• `a_0` is a fictitious activity with finish time `0`. It comes from the initial call RECURSIVE_ACTIVITY-SELECTOR(s,f,0,11)
• This call set `m=1` and then select `a_1`.
• As we go from the top of the picture done, activities which have already been selected are shaded, and those that are being considered are white.
• The dotted lines separate the recursive calls we make.
• If the start time of an activity occurs before the finish time of the most recently added activity it is rejected, otherwise it is selected.
• The last call RECURSIVE_ACTIVITY-SELECTOR(s,f,11,11) returns `emptyset`, and so the set of selected activities by our algorithm will be `{a_1, a_4, a_8, a_11}`

Elementary Graph Algorithms

• For the remainder of today we turn our attention to graph algorithms.
• We start by considering techniques for representing graphs.
• Then we consider techniques for search graphs.
• Recall a graph `G = (V,E)` is a collection of vertices `V` together with a set of edges `E` that exists between vertices.
• I.e., `E` will consist of pairs `(v, w)` where `v,w in V` in the case where the graph is directed and as pairs of pairs `(v,w)`, `(w,v)` when the graph is not.
• When directed, an edge like `(v, w)` means the edge starts at `v` and goes to `w`,
• For example, the graph in the image above is G=(V, E) where `V = {1,2,3,4,5}` and `E={(1, 2), (2,1), (1, 3), (3,1), (4, 5), (5,4)}`

Representations of Graphs

• Two common ways to represent graphs are (1) as a collection of adjacency lists, and (2) as an adjacency matrix.
• As we can see above, we can use either representation for both directed and undirected graphs.
• The adjacency-list representation of a graph `G = (V, E)` consists of an array `adj` of `|V|` lists, one for each vertex `V`. For each `u in V`, `Adj[u]` contains all the vertices `v` such that there exists an edge `(u,v) in E`. This representation is good when the total number of edges is closer to the total number of vertices. For example, if each vertex `u` was involved in fewer than some number `k` edges.
• The adjacency-matrix representation of `G=(V, E)` assumes the vertices are numbered `1,2, ... |V|`. It represents `G` as a `|V| times |V|` matrix `A=(a_(ij))` where
  `a_(ij) = { (1,if (i,j) in E),(0,text(otherwise)):}`.
• To indicate that a vertex or an edge has some attribute (for instance, a color or for edges a distance), we write expressions like v.attribute_name or (v,w).attribute_name .

Breadth-First Search

• Given a graph `G=(V, E)` and a distinguished vertex `s`, breadth-first search systematically explores the edges of `G` to "discover" every vertex that is reachable from `s`.
• It computes the distance (smallest number of edges) from `s` to each reachable vertex.
• It also produces a "breadth-first tree" with root `s` that contains all reachable vertices.
• The name breadth-first comes from the fact that it expands the frontier between discovered and undiscovered vertices uniformly across the breadth of the frontier.
• Breadth-first search color vertices either white, gray or black. A vertex is discovered the first time it is encountered during the search, at which time it becomes nonwhite. White vertices represent unexplored portions of the graph.
• Gray and black vertices have both been discovered. Gray vertices may have gray, white, and black neighbors. They represent the frontier of the graph. A black vertex gets labelled black when all of its neighbors have been discovered.

Breadth First Search Algorithm

• Given the nomenclature of the last slide, below is an algorithm for breadth-first search.
• Notice we keep track of attributes: color, parent (`\pi`), and distance `d` from the source `s`.
• We also assume we have access to a queue data structure.

BFS Example

• Above we see the sequence of steps that the BFS algorithm goes through on an 8 node graph.
• The state of the queue is indicated next to each figure.
• The center of the circle represents the distance computed so far to the source.
• The color of nodes is also indicated by their shading.
• Darkened edges mean that edge was traversed.

BFS Runtime

• After initialization, BFS never whitens a vertex, so line 13 ensures that each vertex is enqueued at most once.
• The enqueues and dequeues each take `O(1)`, and so the total time devoted to queueing is `O(|V|)`.
• We scan the adjacency list of each vertex only when the vertex is dequeued, so the adjacency list is scanned at most once.
• The sum of the lengths of the adjacency lists is `Theta(|E|)`, so the total time spent in scanning adjacency list is `O(|E|)`.
• The overhead for initialization is `O(|V|)`, and so the total run time of BFS is `O(|V| + |E|)`