UCS415: Design & Analysis
of Algorithms

1.1 · Essential Data Structures

Before analysing algorithms, you need to know what each data structure does and its time complexity. Every algorithm uses one or more of these.

1.2 · Asymptotic Notation

We analyse algorithms by how their running time grows as input size n → ∞. We ignore constants and lower-order terms because they don't matter at scale.

The Three Notations

How to simplify: drop constants & lower terms

Order of Growth — Memorise this hierarchy

1.3 · Recurrence Relations

Recursive algorithms have running times defined by recurrences: equations that express T(n) in terms of T of smaller inputs. We solve them to find the closed-form complexity.

Method 1: Master Theorem (fastest method — use this first)

For recurrences of the form T(n) = aT(n/b) + f(n) where a ≥ 1, b > 1:

Worked Examples — trace every step

Common Recurrences — Must Memorise

1.4 · Analysing Iterative & Recursive Algorithms

Rule for iterative analysis: count innermost operations

// Example 1: Single loop
for i = 1 to n:
    print(i)          // runs exactly n times → O(n)

// Example 2: Nested loops
for i = 1 to n:
    for j = 1 to n:
        print(i, j)   // runs n × n = n² times → O(n²)

// Example 3: Dependent loops
for i = 1 to n:
    for j = i to n:
        print(i, j)   // n + (n-1) + ... + 1 = n(n+1)/2 → O(n²)

// Example 4: Logarithmic inner loop
for i = 1 to n:
    j = 1
    while j < n:
        j = j * 2    // inner runs log₂n times → O(n log n) total

2.1 · The General Method

Every divide-and-conquer algorithm follows exactly three steps:

2.2 · Binary Search

Finds a target in a sorted array by repeatedly halving the search space.

BinarySearch(A, low, high, target):
    if low > high: return -1  // not found
    mid = (low + high) / 2
    if A[mid] == target: return mid
    else if A[mid] < target: return BinarySearch(A, mid+1, high, target)
    else: return BinarySearch(A, low, mid-1, target)

2.3 · Merge Sort

Splits array in half, recursively sorts each half, then merges the two sorted halves.

MergeSort(A, low, high):
    if low < high:
        mid = (low + high) / 2
        MergeSort(A, low, mid)      // sort left half
        MergeSort(A, mid+1, high)  // sort right half
        Merge(A, low, mid, high)    // merge: O(n) step

Trace on [5, 2, 8, 1, 9, 3]

Split:  [5,2,8] | [1,9,3]
        [5,2]|[8] | [1,9]|[3]
        [5]|[2]|  | [1]|[9]|

Merge:  [2,5] | [8] | [1,9] | [3]
        [2,5,8]   | [1,3,9]
        [1,2,3,5,8,9]  ← final

2.4 · Quick Sort — Critical for Exam

Picks a pivot, partitions array so all elements less than pivot are left and greater are right, then recursively sorts both halves.

QuickSort(A, low, high):
    if low < high:
        pivot_index = Partition(A, low, high)
        QuickSort(A, low, pivot_index - 1)   // left of pivot
        QuickSort(A, pivot_index + 1, high)  // right of pivot

2.5 · Maximum Subarray & Peak Element

Maximum Subarray (D&C approach)

Divide array in half. Max subarray is either: entirely in left half, entirely in right half, or crosses the midpoint. The crossing case can be found in O(n). Recurrence: T(n) = 2T(n/2) + n = O(n log n). (Kadane's DP does it in O(n) — covered in Topic 4.)

Peak Element

An element is a peak if it is greater than or equal to both neighbours. Find it using binary search:

3.1 · The Greedy Strategy

A greedy algorithm builds a solution step by step, always making the choice that looks best right now (locally optimal) without reconsidering past choices. It works correctly only when the problem has:

3.2 · Activity Selection Problem

Given n activities each with a start time sᵢ and finish time fᵢ, select the maximum number of mutually compatible activities (no two overlap).

Worked Example

Time: O(n log n) for sorting + O(n) scan = O(n log n) total.

3.3 · Minimum Number of Platforms

Given arrival and departure times of trains, find the minimum number of platforms needed so no train waits.

Example: Arrivals [900, 940, 950, 1100, 1500, 1800], Departures [910, 1200, 1120, 1130, 1900, 2000]

After sorting departures: [910, 1120, 1130, 1200, 1900, 2000]. Trace: max platforms needed = 3.

3.4 · Coin Change Problem

Given coin denominations and a target amount, find the minimum number of coins to make change.

3.5 · Huffman Coding

Assigns variable-length binary codes to characters. Higher-frequency characters get shorter codes. This minimises the total encoded length.

Example: Frequencies a=5, b=9, c=12, d=13, e=16, f=45

Step 1: Merge a(5) + b(9) = 14
Step 2: Merge c(12) + d(13) = 25
Step 3: Merge 14 + e(16) = 30
Step 4: Merge 25 + 30 = 55
Step 5: Merge f(45) + 55 = 100 (root)

Tree depth:
f → 0         (1 bit)   depth 1
c → 100       (3 bits)  depth 3
d → 101       (3 bits)  depth 3
a → 1100      (4 bits)  depth 4
b → 1101      (4 bits)  depth 4
e → 111       (3 bits)  depth 3

3.6 · Job Sequencing with Deadlines

Given jobs with deadlines and profits, find a sequence that maximises total profit. Each job takes 1 unit of time.

Example

Selected: J1 (profit 100) + J2 (profit 19) = 119 total profit.

3.7 · Fractional Knapsack

Given items with weights and values, and a knapsack of capacity W, maximise total value. You CAN take fractions of items.

4.1 · General Method

Dynamic Programming (DP) solves problems by breaking them into subproblems, solving each subproblem once, and storing results in a table to avoid repeated computation.

4.2 · Matrix Chain Multiplication

Given a chain of matrices A₁ × A₂ × ... × Aₙ, find the parenthesisation that minimises the number of scalar multiplications. Matrix multiplication is associative, so different parenthesisations give the same result but very different computation costs.

Example from your paper (Q9): A(5×10), B(10×4), C(4×20)

Option 1: (A×B)×C
  Step 1: A(5×10) × B(10×4) = 5×10×4 = 200 ops → result: (5×4) matrix
  Step 2: (5×4) × C(4×20) = 5×4×20 = 400 ops
  Total: 200 + 400 = 600 ops ← MINIMUM

Option 2: A×(B×C)
  Step 1: B(10×4) × C(4×20) = 10×4×20 = 800 ops → result: (10×20) matrix
  Step 2: A(5×10) × (10×20) = 5×10×20 = 1000 ops
  Total: 800 + 1000 = 1800 ops ← MAXIMUM

General DP Formulation

For chain A₁...Aₙ with dimensions p₀×p₁, p₁×p₂, ..., pₙ₋₁×pₙ:

Base case: m[i][i] = 0 (single matrix, no multiplication needed). Fill table diagonally. Time: O(n³), Space: O(n²).

4.3 · 0/1 Knapsack Problem

Given n items each with weight wᵢ and value vᵢ, and a knapsack of capacity W. Either take a whole item (1) or skip it (0). Maximise total value without exceeding W.

Worked Example: Capacity W=5, Items: (w=2,v=3), (w=3,v=4), (w=4,v=5)

Maximum value = 7 (take item 1: value 3 + item 2: value 4, total weight = 2+3 = 5 ≤ W).

4.4 · Longest Common Subsequence (LCS)

A subsequence is obtained by deleting zero or more elements from a sequence WITHOUT changing the order. LCS finds the longest subsequence common to two sequences.

Example: LCS of "ABCBDAB" and "BDCAB" is "BCAB" — length 4. Note: a subsequence does NOT need to be contiguous.

Worked trace: X = "QRSTUQRST", Y = "QSBUQCSRSQT" (from your paper Q6)

Fill the table row by row. When characters match, take diagonal+1. Else take max(left, above). Final answer at bottom-right = 7. Answer: C in your paper.

Simple trace: X = "ABCD", Y = "ACDF"

LCS = 3 (ACD). To recover the actual subsequence, backtrack from bottom-right: where c[i][j] = c[i−1][j−1]+1 (diagonal), that character is in LCS.

4.5 · Maximum Independent Set in a Tree

An independent set is a set of vertices where no two vertices are adjacent (connected by an edge). Find the maximum-size independent set in a tree.

4.6 · Maximum Sum Subarray — Kadane's Algorithm

Find the contiguous subarray with the largest sum. This is the DP approach — O(n) time, O(1) space.

Kadane(A, n):
    maxSoFar = A[0]
    maxEndingHere = A[0]

    for i = 1 to n-1:
        // Either extend previous subarray, or start fresh from A[i]
        maxEndingHere = max(A[i], maxEndingHere + A[i])
        maxSoFar = max(maxSoFar, maxEndingHere)

    return maxSoFar

Trace on [-2, 1, -3, 4, -1, 2, 1, -5, 4]

Maximum sum = 6, from subarray [4, -1, 2, 1].

5.1 · Introduction to Backtracking

Backtrack(state):
    if state is a complete solution:
        record solution
        return
    for each choice in validChoices(state):
        makeChoice(state, choice)
        if promising(state):    // pruning condition
            Backtrack(state)
        undoChoice(state, choice)  // backtrack!

5.2 · N-Queens Problem

Place N queens on an N×N chessboard such that no two queens attack each other. Queens attack along rows, columns, and diagonals.

4-Queens: All Solutions

Solution 1:         Solution 2:
. Q . .             . . Q .
. . . Q             Q . . .
Q . . .             . . . Q
. . Q .             . Q . .

There are exactly 2 solutions for 4-queens. (8-queens has 92 solutions.)

5.3 · Graph Coloring

Assign colors to vertices of a graph such that no two adjacent vertices share the same color. The minimum number of colors needed is the chromatic number χ(G).

Why odd cycles need 3 colors — C₅ example

Vertices: A-B-C-D-E-A (pentagon)
Try 2 colors:
A=Red, B=Blue, C=Red, D=Blue, E=?
E is adjacent to D(Blue) and A(Red)
→ E needs a THIRD color!
∴ χ(C₅) = 3

6.1 · Graph Basics

A graph G = (V, E) consists of vertices V and edges E. Understanding graph representations is essential.

Reading degree from adjacency matrix (critical for Euler circuits)

In the adjacency matrix, the degree of vertex i = sum of row i (for undirected graphs, where A is symmetric).

6.2 · Euler Graphs — Most Tested in Your Exam

From your paper Q4 — Reading an adjacency matrix

Given matrix for graph with vertices A, B, C, D, E, F:

     A  B  C  D  E  F
A  [ 0  1  0  1  0  0 ]  → degree = 1+1 = 2 (even)
B  [ 1  0  1  0  0  0 ]  → degree = 1+1 = 2 (even)
C  [ 0  1  0  1  0  1 ]  → degree = 1+1+1 = 3 (ODD)
D  [ 1  0  1  0  1  0 ]  → degree = 1+1+1 = 3 (ODD)
E  [ 0  0  0  1  0  1 ]  → degree = 1+1 = 2 (even)
F  [ 0  0  1  0  1  0 ]  → degree = 1+1 = 2 (even)

Vertices C and D have odd degree → No Euler Circuit. Answer: D from your paper.

Hierholzer's Algorithm — Find Euler Circuit

6.3 · Hamiltonian Paths & Circuits

6.4 · Topological Sort

A topological ordering of a DAG (Directed Acyclic Graph) is a linear ordering of its vertices such that for every directed edge u → v, vertex u comes before v.

Applications of Topological Sort

6.5 · Strongly Connected Components (SCC)

6.6 · Max Flow — Ford-Fulkerson Algorithm

In a flow network, each edge has a capacity. Find the maximum flow from source s to sink t.