Curriculum Roadmap

Day 1
A2SV LEARNING PATH

From fundamentals to competitive programming.

Follow a structured path through programming fundamentals, core data structures and algorithms, advanced problem solving, and competitive programming across 43 weekly modules.

4 Progressive Phases43 Weekly Modules180+ Curated Problems41 Lecture Slides

Curriculum Overview

Click a phase to jump to its modules
Foundation
W1–W12

Foundation

Build strong programming fundamentals, problem-solving habits, and core Python skills.

12 Weeks·44 Problems
Core DSA
W13–W25

Phase 1 — Core DSA

Master essential data structures and algorithms through structured problem solving.

13 Weeks·51 Problems
Advanced DSA
W26–W36

Phase 2 — Advanced DSA

Explore graphs, dynamic programming, trees, greedy algorithms, and advanced problem solving.

11 Weeks·51 Problems
CP Track
W37–W43

Phase 3 — Competitive Programming

Put your DSA skills to work through advanced techniques and competitive programming.

7 Weeks·43 Problems
FoundationW1–12Phase 1 — Core DSAW13–25Phase 2 — Advanced DSAW26–36Phase 3 — Competitive ProgrammingW37–43
01
Foundation
Weeks 1 to 12 · 12 Weeks Total

Foundation

Establish core programming competencies in Python, best coding practices, clean architecture, complexity analysis (Big-O), the 7-step problem-solving methodology, and essential built-in data structures (Lists, Tuples, Sets, Dictionaries, Classes).

01
Foundation
Week 1 of 43

Onboarding & Best Coding Practices

Introduces the A2SV DSA learning journey and core engineering standards for writing clean, readable, and maintainable code from day one.

Meaningful NamingDRY PrincipleClean Formatting & ModularityEssential Comments
0 Problems1 Slide Deck
Study Week
02
Foundation
Week 2 of 43

Python Fundamentals, Conditionals, Loops & Functions

Covers essential Python programming mechanics including conditional logic, iteration with for/while loops, function definitions, and anonymous lambda expressions.

Conditionals & Control FlowLoops & IterationFunctions & Lambda ExpressionsCommon Prefix Matching
⚡ String Prefix Matching, Modular Exponentiation📦 Strings, Integers
5 Problems1 Slide Deck
Study Week
03
Foundation
Week 3 of 43

Clean Coding Standards & Code Review

Focuses on writing production-quality code, following industry-standard code styling, and conducting effective peer code reviews during algorithmic problem solving.

Code Review GuidelinesSelf-Documenting CodeArray Concatenation & Transformation
⚡ String Reversal, Character Frequency Counting📦 Arrays/Lists, Strings
3 Problems1 Slide Deck
Study Week
04
Foundation
Week 4 of 43

Problem-Solving Session: Arrays & Simulation

An intensive hands-on problem-solving session designed to test fundamentals through practical algorithmic challenges on LeetCode and Codeforces without lectures.

Problem DecompositionArray Monotonicity VerificationKeyboard Row Character Mapping
⚡ Non-decreasing Array Modification, String Length Filtering & Abbreviation📦 Arrays/Lists, Strings
4 Problems
Study Week
05
Foundation
Week 5 of 43

Data Structure Basics: Lists & Tuples (+ Saturday Contest 1)

Explores Python lists and immutable tuples, list comprehensions, indexing/slicing mechanics, and incorporates Saturday Contest 1 competitive programming problems.

Python ListsList ComprehensionsPython TuplesContest Problem-Solving
⚡ Array Permutation Mapping, Maximum Product Selection📦 Lists, Tuples
9 Problems1 Slide Deck
Study Week
06
Foundation
Week 6 of 43

Soft Skills: Focus, Planning & Time Management

A dedicated soft-skills unit focusing on deep concentration, personal planning roadmaps, time management strategies, and community collaboration.

Deep FocusGoal Planning RoadmapsTime ManagementSource Code Parsing Simulation
⚡ State Machine String Parsing, Query-based Array Value Updates📦 Lists, Strings
2 Problems2 Slide Decks
Study Week
07
Foundation
Week 7 of 43

Data Structure Basics: Sets & Dictionaries

Covers Python hash-based data structures (Sets and Dictionaries), their internal mechanics, valid key types, $O(1)$ lookups, and practical frequency tracking.

Python SetsPython DictionariesHashability & Valid OperatorsDifference Transform Pattern
⚡ Duplicate Detection, Missing Number Identification📦 Sets, Dictionaries (Hash Maps)
4 Problems1 Slide Deck
Study Week
08
Foundation
Week 8 of 43

Contest Analysis & Upsolving Strategies

A dedicated session on contest review, peer walkthroughs, failure point analysis, and upsolving challenging multi-variable problems.

Contest Upsolving MethodologyPeer Code AnalysisAnagram Grouping via Canonical KeysTwo-Phase Hash Table Pair Sums
⚡ Anagram Hashing, Pairwise Sum Precomputation (4Sum II)📦 Hash Maps, Hash Sets
3 Problems
Study Week
09
Foundation
Week 9 of 43

Python Built-in Functions & Object-Oriented Classes

Explores Python built-in utilities (zip, enumerate, map, filter, sorted), object-oriented programming with classes, dunder methods, and common pitfalls.

Python Built-in Functional UtilitiesObject-Oriented Programming (OOP)Magic (Dunder) MethodsMutable Default Arguments Pitfall
⚡ Boyer-Moore Voting Algorithm, Custom Comparator Sorting📦 Classes, Dictionaries
3 Problems1 Slide Deck
Study Week
10
Foundation
Week 10 of 43

Asymptotic Analysis: Time & Space Complexity

Establishes formal theoretical principles for analyzing algorithm efficiency using Big-O notation, time-space trade-offs, and memory complexity.

Big-O Notation & Asymptotic BoundsTime vs. Space Trade-offsIn-place Array Index Negation
⚡ In-place Duplicate Finding, Monotonic Array Verification📦 Arrays, Hash Tables
4 Problems1 Slide Deck
Study Week
11
Foundation
Week 11 of 43

The 7 Steps of Highly Effective Problem Solving

Introduces A2SV's core structured methodology for approaching any algorithmic problem from initial reading through optimization and validation.

The 7 Steps FrameworkPigeonhole Principle in Problem SolvingInterval Coverage Check
⚡ Interval Coverage Verification, Pigeonhole Greedy Grouping (Rabbits in Forest)📦 Arrays, Hash Maps
4 Problems1 Slide Deck
Study Week
12
Foundation
Week 12 of 43

Problem-Solving Consolidation: Python Data Structures & Math

A comprehensive consolidation session applying all Foundation phase concepts (lists, sets, maps, classes, Big-O, 7-steps) to diverse challenge problems.

Digital Root & Math SimulationCharacter Frequency ValidationXOR Difference Detection
⚡ Digital Root Computation, Frequency Mapping📦 Hash Maps, Strings
3 Problems
Study Week
02
Core DSA
Weeks 13 to 25 · 13 Weeks Total

Phase 1 — Core DSA

Master foundational data structures and fundamental algorithmic paradigms: Arrays, Matrices, Elementary Sorting, Two Pointers, Sliding Window, Prefix Sum, Singly/Doubly Linked Lists, Stacks, Queues, Monotonic Structures, Recursion Fundamentals, and Binary Search.

13
Core DSA
Week 13 of 43

Array & List Operations (+ Saturday Contest 2)

Launches Phase 1 (Core DSA) with sequential memory structures, dynamic array resizing, in-place array mutation, and Saturday Contest 2 problems.

Contiguous Memory & Random AccessDynamic Array ResizingTwo-Pointer Zero Compaction
⚡ In-place Array Shifting, Relative Ordering Sort📦 Arrays / Dynamic Lists, Hash Maps
6 Problems1 Slide Deck
Study Week
14
Core DSA
Week 14 of 43

Matrices & 2D Grid Traversals

Covers two-dimensional array representations, row-major vs. column-major layouts, diagonal traversals, matrix transformations, and boundary edge cases.

2D Grid Coordinates & IndexingMatrix TranspositionDiagonal Invariant PropertiesMatrix Reshaping
⚡ Matrix Transposition, Horizontal Inversion & In-place Bit Inversion📦 2D Arrays / Matrices
3 Problems1 Slide Deck
Study Week
15
Core DSA
Week 15 of 43

Elementary Sorting Algorithms

Examines foundational comparison-based sorts (Bubble, Selection, Insertion) and non-comparison Counting Sort, analyzing stability, in-place memory, and Big-O bounds.

Sorting StabilityBubble SortSelection SortInsertion Sort+1 more
⚡ Bubble Sort, Selection Sort📦 Arrays
3 Problems1 Slide Deck
Study Week
16
Core DSA
Week 16 of 43

Sorting Consolidation & Time Complexity Comparison

Compares Best, Average, and Worst-case complexities of elementary sorts, exploring adaptive optimizations and custom comparator ordering.

Asymptotic Complexity ComparisonAdaptive SortingCustom Comparator Ordering
⚡ Custom String Concatenation Sorting, Greedy Triplet Selection📦 Arrays, Strings
3 Problems
Study Week
17
Core DSA
Week 17 of 43

Two Pointers Technique

Replaces nested loop $O(n^2)$ brute forces with linear $O(n)$ scans using converging (opposite-direction) and fast-slow (same-direction) pointer patterns.

Two Pointers ParadigmConverging Pointers PatternGreedy Boundary SqueezingDuplicate Avoidance in K-Sum
⚡ Sorted Array Two Sum ($O(n)$), Container With Most Water Area Maximization📦 Arrays, Strings
3 Problems1 Slide Deck
Study Week
18
Core DSA
Week 18 of 43

Sliding Window Technique

Processes contiguous subarrays and substrings in linear $O(n)$ time using Fixed-Size and Dynamic (Variable-Size) window expansion and contraction.

Sliding Window ParadigmFixed-Size Window InvariantDynamic Window Expansion & Contraction
⚡ Maximum Average Subarray, Longest Substring Without Repeating Characters📦 Arrays, Strings
3 Problems1 Slide Deck
Study Week
19
Core DSA
Week 19 of 43

Prefix Sum Technique

Transforms $O(n)$ range sum queries into instantaneous $O(1)$ evaluations using precomputed cumulative sum arrays, combined with hash maps for subarray targets.

Prefix Sum PrecomputationsPrefix Sum + Hash Map TechniquePrefix & Suffix Accumulator Arrays
⚡ 1D Range Sum Query, Subarray Sum Equals K ($O(n)$)📦 Arrays, Hash Maps
3 Problems1 Slide Deck
Study Week
20
Core DSA
Week 20 of 43

Singly Linked Lists

Introduces pointer-based non-contiguous node data structures (`Node(val, next)`), head/tail insertion, node deletion, traversal, and the dummy node pattern.

Linked List Node StructureDummy / Sentinel Node PatternFast & Slow Pointers for Midpoint
⚡ Linked List Traversal, Node Deletion in $O(1)$ and $O(n)$📦 Singly Linked List
4 Problems1 Slide Deck
Study Week
21
Core DSA
Week 21 of 43

Advanced Linked Lists: Doubly Linked Lists & Fast/Slow Pointers

Covers Doubly Linked Lists, in-place list reversal, Floyd's cycle-finding algorithm (Tortoise and Hare), and cycle entry detection.

Doubly Linked List MechanicsIn-place Pointer ReversalFloyd's Cycle-Finding AlgorithmCycle Origin Mathematical Derivation
⚡ In-place Linked List Reversal, Floyd's Cycle Detection📦 Singly Linked List, Doubly Linked List
4 Problems1 Slide Deck
Study Week
22
Core DSA
Week 22 of 43

Stacks, Queues & Monotonicity Fundamentals

Covers LIFO Stack and FIFO Queue mechanics, $O(1)$ operations with collections.deque, stack/queue cross-emulation, and Min Stack design.

LIFO Stack PrincipleFIFO Queue PrinciplePython `collections.deque`Min Stack Auxiliary Tracking
⚡ Parentheses Matching & Bracket Validation, Queue Simulation Using Two Stacks📦 Stacks, Queues
4 Problems1 Slide Deck
Study Week
23
Core DSA
Week 23 of 43

Monotonic Stacks & Monotonic Queues

Explores the Monotonicity invariant, monotonic increasing/decreasing stacks/queues, amortized $O(n)$ analysis, and next greater/smaller element queries.

Monotonic Stack InvariantMonotonic Queue / DequeHistogram Area Calculation
⚡ Next Greater Element, Daily Temperatures📦 Monotonic Stack, Monotonic Deque
5 Problems1 Slide Deck
Study Week
24
Core DSA
Week 24 of 43

Recursion Fundamentals & Call Stack Mechanics

Covers recursive problem decomposition (base case vs. recursive step), call stack frames, activation records, and logarithmic power calculations.

Base Case vs. Recursive StepExecution Call Stack MechanicsBinary Exponentiation (Divide & Conquer Power)
⚡ Binary Exponentiation ($O(\log n)$), Recursive Fibonacci📦 System Call Stack, Recursion Tree
5 Problems1 Slide Deck
Study Week
25
Core DSA
Week 25 of 43

Binary Search & Search Space Reduction

Concludes Phase 1 with $O(\log n)$ Divide & Conquer search in sorted arrays, boundary invariants, lower/upper bounds, and Binary Search on the Answer Space.

Binary Search InvariantMidpoint Overflow PreventionBinary Search on Answer Space
⚡ Classic Binary Search ($O(\log n)$), First and Last Position Search📦 Sorted Arrays
5 Problems1 Slide Deck
Study Week
03
Advanced DSA
Weeks 26 to 36 · 11 Weeks Total

Phase 2 — Advanced DSA

Dive deep into non-linear data structures, advanced recursion, and foundational graph algorithms: Binary Trees, Binary Search Trees (BST), Backtracking, Divide & Conquer, Graph Representations, Depth-First Search (DFS), Breadth-First Search (BFS), Heaps/Priority Queues, Greedy Optimization, Topological Sort, and Dynamic Programming (Top-Down & Bottom-Up).

26
Advanced DSA
Week 26 of 43

Tree Data Structures & Tree Traversals

Opens Phase 2 (Advanced DSA) with hierarchical tree structures, binary trees, depth/height properties, DFS traversals (Pre-order, In-order, Post-order), and BFS level-order.

Hierarchical Tree TerminologyDepth-First Tree TraversalsLevel-Order Tree Traversal (BFS)
⚡ Pre-order Traversal, In-order Traversal📦 Binary Trees, Queues
4 Problems1 Slide Deck
Study Week
27
Advanced DSA
Week 27 of 43

Binary Search Trees (BST) & Invariant Properties

Explores the BST invariant property, $O(h)$ search, insertion, and three-case node deletion (using in-order successors), tree validation, and lowest common ancestors.

BST Invariant PropertyBST Node DeletionBST Range Validation
⚡ BST Search ($O(h)$), BST Insertion ($O(h)$)📦 Binary Search Tree (BST)
4 Problems1 Slide Deck
Study Week
28
Advanced DSA
Week 28 of 43

Advanced Recursion: Backtracking & Divide and Conquer

Covers combinatorial search, State-Space tree exploration, feasibility pruning (Choose-Explore-Unchoose), Subsets, Permutations, Combinations, and N-Queens.

Backtracking ParadigmState-Space Tree PruningCombinatorial Generation
⚡ Subsets Generation ($O(2^n)$), Permutations Generation ($O(n!)$)📦 Recursion Tree, State Lists
5 Problems1 Slide Deck
Study Week
29
Advanced DSA
Week 29 of 43

Graph Theory Fundamentals & Representations

Introduces Graph Theory terminology, directed/undirected edges, weighted/unweighted graphs, Adjacency Matrix vs. Adjacency List, node degrees, sources, and sinks.

Graph ClassificationsAdjacency MatrixAdjacency ListDegrees, Sources & Sinks
⚡ Graph Matrix-to-List Conversion, Degree Computation📦 Graphs (Adjacency Matrix, Adjacency List, Edge List)
4 Problems1 Slide Deck
Study Week
30
Advanced DSA
Week 30 of 43

Depth-First Search (DFS) & Graph Traversals

Covers graph DFS traversal using recursion and explicit stacks, visited set tracking, connected component counting, flood fill, and 2D grid graph traversal.

Graph DFS ParadigmVisited Set ManagementImplicit 2D Grid GraphsConnected Components Counting
⚡ Graph DFS ($O(V + E)$), Flood Fill Algorithm📦 Graphs, Call Stack
5 Problems1 Slide Deck
Study Week
31
Advanced DSA
Week 31 of 43

Breadth-First Search (BFS) & Shortest Path in Unweighted Graphs

Covers level-order BFS exploration using FIFO queues, shortest path guarantees in unweighted graphs, multi-source BFS, and state-space transitions.

Graph BFS ParadigmShortest Path Guarantee in Unweighted GraphsMulti-Source BFS
⚡ Graph BFS ($O(V + E)$), Unweighted Shortest Path📦 Graphs, FIFO Queue (`collections.deque`)
5 Problems1 Slide Deck
Study Week
32
Advanced DSA
Week 32 of 43

Heaps & Priority Queues

Covers binary heap invariants (Min-Heap, Max-Heap), array-based tree indexing, $O(n)$ bottom-up heapify, Python heapq, Top-K elements, and running medians.

Heap InvariantLinear Heap Construction (Heapify)Two-Heap Running Median
⚡ Bottom-up Heapify ($O(n)$), Heap Sort ($O(n \log n)$)📦 Min-Heap, Max-Heap
5 Problems1 Slide Deck
Study Week
33
Advanced DSA
Week 33 of 43

Greedy Algorithms & Optimization Strategies

Covers greedy choices, local vs. global optimality, Greedy Choice Property, Optimal Substructure, proofing techniques (Induction, Contradiction, Exchange Arguments), and interval scheduling.

Greedy ParadigmGreedy Choice PropertyExchange Argument ProofInterval Scheduling Optimization
⚡ Interval Scheduling / Balloon Bursting ($O(n \log n)$), Greedy Coin/Bill Change📦 Arrays, Priority Queues
5 Problems1 Slide Deck
Study Week
34
Advanced DSA
Week 34 of 43

Topological Sort & Directed Acyclic Graphs (DAGs)

Covers linear task ordering on DAGs, dependency resolution systems, Kahn's algorithm (BFS with in-degrees), DFS post-order with 3-color cycle detection, and compiler build ordering.

Topological Sort DefinitionKahn's Algorithm (BFS In-Degree)3-Color DFS Cycle Detection
⚡ Kahn's Algorithm ($O(V + E)$), DFS 3-Color Topological Sort ($O(V + E)$)📦 Graph (Adjacency List), In-Degree Array
5 Problems1 Slide Deck
Study Week
35
Advanced DSA
Week 35 of 43

Dynamic Programming I: Top-Down Memoization

Introduces Dynamic Programming fundamentals, Overlapping Subproblems, Optimal Substructure, Top-Down Memoization, state space identification, and recurrence equations.

Overlapping SubproblemsOptimal SubstructureTop-Down Memoization Cache0/1 Knapsack Subsets Formulation
⚡ Top-Down Memoized Recursion, Climbing Stairs📦 Memoization Cache (Array / Hash Map), Recursion Call Stack
5 Problems1 Slide Deck
Study Week
36
Advanced DSA
Week 36 of 43

Dynamic Programming II: Bottom-Up Tabulation

Concludes Phase 2 with Bottom-Up Tabulation, iterative DP tables, base case seeding, space optimization (rolling arrays / state compression), and 2D grid DP.

Bottom-Up TabulationState Compression / Rolling Array2D Grid DP Transitions
⚡ Tabulated DP, Rolling Array Space Optimization📦 1D / 2D DP Tables / Arrays
4 Problems1 Slide Deck
Study Week
04
CP Track
Weeks 37 to 43 · 7 Weeks Total

Phase 3 — Competitive Programming

Tackle advanced competitive programming paradigms and specialized data structures: Bitwise Operations, Disjoint Set Union (Union-Find), Advanced & Non-Comparison Sorting, Numerics & Number Theory, Trie (Prefix Tree), All-Pairs & Single-Source Shortest Paths (Dijkstra, Bellman-Ford, Floyd-Warshall), and Advanced String Algorithms (KMP, Rabin-Karp, Z-Algorithm).

37
CP Track
Week 37 of 43

Bitwise Operations & Bit Manipulation

Opens Phase 3 (Competitive Programming) with bitwise operators, binary representations, bitmask tricks (LSB, clear bit, power of two), XOR properties, and subset generation.

Bitwise Primitive OperatorsLowest Set Bit (LSB) ExtractionBrian Kernighan’s AlgorithmBitmask Power Set Generation
⚡ Brian Kernighan's Bit Counting, Single Number via XOR📦 Integers / Bitmasks
6 Problems1 Slide Deck
Study Week
38
CP Track
Week 38 of 43

Disjoint Set Union (Union-Find)

Covers Disjoint Set Union (DSU), dynamic connectivity, Path Compression, Union by Rank/Size, Inverse Ackermann complexity $O(\alpha(n))$, and Kruskal's MST / graph cycle detection.

Dynamic ConnectivityPath CompressionUnion by Rank / SizeGraph Cycle Detection via DSU
⚡ DSU Find with Path Compression, DSU Union by Rank / Size📦 Disjoint Set Union (Parent & Rank Arrays)
6 Problems1 Slide Deck
Study Week
39
CP Track
Week 39 of 43

Advanced Sorting: Divide & Conquer and Non-Comparison Sorting

Covers advanced sorting algorithms: Merge Sort ($O(n \log n)$ stable), Quick Sort ($O(n \log n)$ avg, in-place), Quickselect ($O(n)$ avg), Radix Sort, Bucket Sort, and linked list sorting.

Merge Sort & Subarray MergingQuick Sort & Partitioning SchemesQuickselect ($k$-th Order Statistic)Non-Comparison Sorting (Radix & Bucket Sort)
⚡ Merge Sort ($O(n \log n)$), Quick Sort & 3-Way Partitioning📦 Arrays, Linked Lists
7 Problems2 Slide Decks
Study Week
40
CP Track
Week 40 of 43

Numerics & Number Theory

Covers fundamental number theory: Euclidean GCD algorithm ($O(\log n)$), Sieve of Eratosthenes ($O(n \log \log n)$), prime factorization, and modular arithmetic.

Euclidean GCD AlgorithmSieve of EratosthenesPrime FactorizationModular Arithmetic Laws
⚡ Euclidean GCD Algorithm ($O(\log n)$), Sieve of Eratosthenes ($O(n \log \log n)$)📦 Boolean Prime Arrays / Bitsets, Integers
6 Problems1 Slide Deck
Study Week
41
CP Track
Week 41 of 43

Tries (Prefix Trees) & Prefix Search

Covers Trie (Prefix Tree) data structures, node child pointers, end-of-word flags, $O(L)$ insertion/search/prefix matching, autocomplete suggestions, and wildcard searches.

Trie (Prefix Tree) Node StructureFast Prefix & Word LookupsShared Prefix Space Optimization
⚡ Trie Insertion ($O(L)$), Trie Word Search ($O(L)$)📦 Trie (Prefix Tree)
6 Problems1 Slide Deck
Study Week
42
CP Track
Week 42 of 43

Shortest Path Algorithms: Dijkstra, Bellman-Ford, Floyd-Warshall

Covers Single-Source and All-Pairs shortest path algorithms: Dijkstra ($O((V+E)\log V)$), Bellman-Ford ($O(V \cdot E)$ with negative cycle detection), SPFA ($O(E)$ avg), and Floyd-Warshall ($O(V^3)$).

Edge Relaxation PrincipleDijkstra's AlgorithmBellman-Ford & Negative CyclesFloyd-Warshall All-Pairs Algorithm
⚡ Dijkstra's Algorithm ($O((V + E) \log V)$), Bellman-Ford Algorithm ($O(V \cdot E)$)📦 Weighted Graphs, Min-Heap / Priority Queue
6 Problems1 Slide Deck
Study Week
43
CP Track
Week 43 of 43

Advanced String Algorithms: KMP, Rabin-Karp, Z-Algorithm

Concludes the 43-week curriculum with linear-time substring search: Knuth-Morris-Pratt (LPS array, $O(N+M)$), Rabin-Karp (Rolling Hash, $O(N+M)$ avg), Z-Algorithm ($O(N+M)$), and Manacher's Algorithm ($O(N)$).

Linear Substring Search ParadigmKMP Longest Prefix Suffix (LPS)Rabin-Karp Rolling HashZ-Algorithm & Z-Box Matching+1 more
⚡ Knuth-Morris-Pratt (KMP) Algorithm ($O(N + M)$), Rabin-Karp Rolling Hash Algorithm ($O(N + M)$ avg)📦 LPS Array, Z-Array
6 Problems1 Slide Deck
Study Week