Algorithms Study Notes

0/1 Knapsack Problem

Learn the classic 0/1 knapsack DP formulation, its O(nW) recurrence, and how to reconstruct the chosen items.

Activity Selection Problem

Select the maximum number of non-overlapping activities from a schedule using a greedy earliest-finish-time strategy.

Algorithm Analysis and Complexity

Learn Big-O, Big-Omega, and Big-Theta notation to analyze and compare the time and space efficiency of algorithms.

Algorithm Complexity Cheat Sheet

A reference summary of time and space complexities for the major algorithms covered in this course.

Algorithm Design Paradigms Overview

A map of the major algorithm design paradigms, divide and conquer, greedy, dynamic programming, and backtracking, with canonical examples.

Common Algorithm Interview Questions

A curated set of frequently asked algorithm interview questions with clear, technically accurate answers.

The Backtracking Paradigm

Learn how backtracking systematically builds candidate solutions and abandons paths that cannot possibly succeed.

Bellman-Ford Algorithm

A single-source shortest path algorithm that handles negative edge weights and detects negative-weight cycles.

Choosing the Right Algorithmic Approach

A decision framework mapping problem characteristics to the correct algorithmic paradigm.

Closest Pair of Points

Use divide and conquer with a strip-checking merge step to find the closest pair among n points in O(n log n).

Coin Change Problem

Solve the minimum-coins and count-ways variants of the coin change problem using DP in O(n * amount) time.

Common Algorithmic Pitfalls

The recurring mistakes engineers make with recursion, DP, greedy, and graph algorithms, and how to catch them.

The Divide and Conquer Paradigm

Learn how divide, conquer, and combine steps break large problems into smaller solvable subproblems.

Edit Distance

Compute the minimum number of insertions, deletions, and substitutions to transform one string into another using O(mn) DP.

Floyd-Warshall Algorithm

A dynamic-programming algorithm that computes shortest paths between every pair of vertices in O(V^3) time.

Fractional Knapsack Problem

Maximize the value of items packed into a capacity-limited knapsack when items can be split, using a greedy value-density strategy.

The Greedy Algorithm Paradigm

Learn how greedy algorithms build solutions one locally optimal choice at a time, and when that strategy actually yields a global optimum.

Huffman Coding

Build optimal prefix-free binary codes for data compression using a greedy, frequency-driven priority-queue algorithm.

Introduction to Algorithms

What an algorithm is, why it matters, and how to reason about correctness and efficiency before writing code.

Introduction to Dynamic Programming

Learn what dynamic programming is and the two conditions — overlapping subproblems and optimal substructure — that make it applicable.

Longest Common Subsequence

Master the LCS DP recurrence for finding the longest shared subsequence between two strings in O(mn) time.

Longest Increasing Subsequence

Find the length of the longest strictly increasing subsequence in an array using O(n^2) DP and an O(n log n) optimization.

Longest Palindromic Substring

Find the longest substring that reads the same forwards and backwards using the expand-around-center technique.

The Master Theorem

Apply the Master Theorem's three cases to quickly solve divide-and-conquer recurrences of the form T(n) = aT(n/b) + f(n).