Days Class (6 Hours) Topic Details

Overview of C++ as a language and its evolution.

Basic structure of a C++ program, including #include, int main(), and return 0.
Writing and understanding your first program (“Hello, World!”).
Day 1 Class 1 Introduction to C++ Basic syntax, including keywords, identifiers, and comments.
Introduction to variables, data types (int, float, double, char, bool), and constants (const, #define).
Basic I/O operations using cin and cout.
Hands-on practice with simple programs (e.g., basic arithmetic operations).
Conditional statements: if-else, else-if, switch-case.
Loops: for, while, do-while.
Nested loops and conditionals.
Day 1 Class 2 Control Structures
Using break, continue, and goto statements.
Hands-on coding with problems involving control structures (e.g., checking prime numbers, factorial,
simple menu-driven programs).
Function declaration and definition.
Function return types and parameters.
Function overloading.
Day 2 Class 1 Functions in C++
Inline functions.
Recursion: Concept and implementation.
Hands-on practice with simple recursive problems (e.g., Fibonacci series, factorial calculation).
Introduction to arrays: Declaration, initialization, and accessing elements.
Multidimensional arrays.
Common array operations: Searching, sorting, and traversing.
Day 2 Class 2 Arrays and Strings Strings in C++: Declaration, initialization, and basic operations.
String functions from the <cstring> library (e.g., strlen, strcpy, strcmp).
Hands-on coding with array and string manipulation problems (e.g., reverse an array, check for
palindrome string).
Introduction to pointers: Declaration, initialization, and dereferencing.
Pointer arithmetic.
Pointers with arrays and functions.
Day 3 Class 1 Pointers and References Introduction to references: Reference variables and passing by reference.
Dynamic memory allocation using new and delete.
Hands-on practice with pointer-based problems (e.g., swapping values using pointers, dynamic array
creation).

Deep dive into dynamic memory allocation: Arrays, multi-dimensional arrays using pointers.
Introduction to the Standard Template Library (STL).
Dynamic Memory Allocation and Introduction to Overview of STL containers: vector, list, deque.
Day 3 Class 2
STL Iterators: Definition and usage with STL containers.
Basic operations using STL containers.
Hands-on coding with dynamic memory and STL (e.g., basic operations on vectors and lists).
 Basics of Object-Oriented Programming: Classes and Objects.
Creating classes and objects in C++.
Introduction to Object-Oriented Programming
Day 4 Class 1 Constructors and Destructors: Default, parameterized, and copy constructors.
(OOP)
Access specifiers: public, private, protected.
Hands-on practice by creating basic classes (e.g., Car class with attributes and methods).
Inheritance: Single and multiple inheritance.
Polymorphism: Compile-time (function overloading, operator overloading) and runtime (virtual
functions).
Day 4 Class 2 Advanced OOP Concepts Abstract classes and pure virtual functions.
Encapsulation and Data Hiding.
Hands-on coding with OOP concepts (e.g., designing a simple inheritance hierarchy, operator
overloading).
Detailed overview of STL containers: vector, set, map, stack, queue.
Iterators and their types: Input, output, forward, bidirectional, and random access iterators.
Day 5 Class 1 Standard Template Library (STL) Overview STL algorithms: sort, find, count, binary_search, lower_bound, upper_bound.
Function objects (functors) and their usage in STL algorithms.
Hands-on coding with STL (e.g., implementing algorithms using vector, set, map).
Introduction to bitwise operators: AND, OR, XOR, NOT, left shift, right shift.
Common bit manipulation tricks: Checking if a number is even/odd, finding the ith bit, setting/clearing
Day 5 Class 2 Bit Manipulation bits.
Hands-on practice with basic to intermediate bit manipulation problems (e.g., swapping two numbers
using XOR, counting set bits in an integer).
Problem-solving techniques: Brute force, optimization.
Day 6 Class 1 Time Complexity
Time complexity analysis: Big O notation, analyzing loops and recursive functions
Introduction to arrays in DSA: Advantages and limitations.
Prefix sum technique: Understanding and applications.
Day 6 Class 2 Arrays
Hands-on practice with array problems (e.g., finding subarrays with a given sum, two-pointer
problems).
Day 7 Class 1 Two Pointer Advanced problem-solving techniques: Two-pointer technique and Interview Questions
Advanced problem-solving techniques: Sliding Window of fixed and variable sizeand Interview
Day 7 Class 2 Sliding Window
Questions

Introduction to linked lists: Singly and doubly linked lists.

Basic operations: Insertion, deletion, traversal.
Day 8 Class 1 LinkedList
Advanced operations: Reversing a linked list, finding the middle element, detecting loops.
Hands-on coding with linked list problems (e.g., reversing a linked list, merging two sorted linked lists).

Day 8 Class 2 LinkedList

Introduction to stacks: LIFO structure, operations, and applications.
Introduction to queues: FIFO structure, operations, and applications.
Stacks and Queues
Day 9 Class 1 Implementation of stacks and queues using arrays and linked lists.
Hands-on practice with stack and queue problems (e.g., balanced parentheses, implementing a
queue using two stacks).
Stacks and Queues
Day 9 Class 2 Medium and Hard Level Interview Questions on stacks and Queues
 Introduction to hashing: Concept, applications, and collision resolution techniques.
Hash tables: Implementation and usage.
Day 10 Class 1 Hashing Common hash functions and their properties.
Hands-on coding with hashing problems (e.g., finding duplicates in an array, count frequency of
elements).
Understanding binary search: Concept, implementation, and analysis.
Binary search on arrays: Finding an element, first and last occurrence.
Day 10 Class 2 Binary Search Advanced binary search problems: Searching in rotated sorted arrays, finding peak elements.
Hands-on practice with binary search problems (e.g., binary search on a sorted array, finding square
roots using binary search).
Introduction to sorting: Need for sorting, basic concepts.
Quick Sort: Concept, implementation, and analysis.
Merge Sort: Concept, implementation, and analysis.
Day 11 Class 1 Sorting Algorithms
Comparison of sorting algorithms: Time complexity, space complexity, stability.
Hands-on coding with sorting problems (e.g., sorting an array using Quick Sort, merging two sorted
arrays).
Introduction to recursion: Concept, base case, and recursive case.
Day 11 Class 2 Recursion 1
Common recursive problems: Factorial, Fibonacci, Towers of Hanoi.
Day 12 Class 1 Recursion 2 Medium and Hard Level Interview Questions on Recursion
Introduction to backtracking: Concept and applications.
Backtracking problems: N-Queens, Sudoku Solver, Subset Sum Problem.
Day 12 Class 2 Backtracking 1
Hands-on practice with recursion and backtracking problems (e.g., solving N-Queens problem,
generating all subsets of a set).
Day 13 Class 1 Backtracking 2 More medium and hard Questions on backtrackig asked in interviews.
Introduction to dynamic programming: Concept, memoization, and tabulation.
Day 13 Class 2 Dynamic Programming (DP) 1 Common DP problems: Fibonacci, Knapsack Problem, Longest Common Subsequence (LCS).
Understanding overlapping subproblems and optimal substructure.

Introduction to dynamic programming: Concept, memoization, and tabulation.

Common DP problems: Fibonacci, Knapsack Problem, Longest Common Subsequence (LCS).
Day 14 Class 1 Dynamic Programming (DP) 2 Understanding overlapping subproblems and optimal substructure.
Hands-on coding with basic DP problems (e.g., solving the Fibonacci problem using DP, 0/1
Knapsack problem).
Introduction to trees: Definition, terminology, and types.
Binary Trees: Representation, traversal methods (inorder, preorder, postorder).
Day 14 Class 2 Trees Binary Search Trees (BST): Properties, insertion, deletion, and searching.
Hands-on coding with tree problems (e.g., constructing a binary tree from inorder and preorder
traversals, checking if a tree is a BST).
Detailed study of tree traversal techniques: Recursive and iterative methods.
Level-order traversal using queues.
Common tree problems: Finding the height of a tree, finding the diameter of a binary tree, lowest
Day 15 Class 1 Tree Traversals and Common Tree Problems
common ancestor (LCA).
Hands-on practice with tree traversal problems (e.g., level order traversal, calculating the height of a
binary tree).
 Introduction to graphs: Definition, representation (adjacency matrix, adjacency list).
Basic graph traversal techniques: Breadth-First Search (BFS) and Depth-First Search (DFS).
Day 15 Class 2 Graphs Understanding connected components in graphs.
Hands-on coding with basic graph traversal problems (e.g., BFS/DFS on an undirected graph,
detecting cycles in a graph).

Shortest Path Algorithms: Dijkstra’s algorithm for shortest paths from a single source.
Topological Sorting: Understanding the concept and its implementation using DFS.
Day 16 Class 1 Graph Problems
Hands-on practice with graph problems (e.g., finding the shortest path in a weighted graph using
Dijkstra, topological sorting of a DAG).

In-depth study of dynamic programming: Understanding the knapsack problem variants, subset sum
problem.
Memoization vs. Tabulation: Detailed examples and coding implementations.
Day 16 Class 2 Advanced Problems and Optimisations in DP
Solving complex DP problems: Longest Increasing Subsequence (LIS), Edit Distance problem.
Hands-on practice with advanced DP problems (e.g., solving the Longest Increasing Subsequence
using DP, solving the Edit Distance problem).
Introduction to greedy algorithms: Concept, properties, and when to use them.
Common greedy algorithms: Activity selection problem, Huffman coding.
Day 17 Class 1 Greedy Algorithms
Hands-on coding with greedy algorithm problems (e.g., solving the activity selection problem,
implementing Huffman coding).
Introduction to segment trees: Concept, construction, and applications.
Segment tree operations: Point updates and range queries.
Day 17 Class 2 Segment Trees Understanding lazy propagation in segment trees.
Hands-on coding with segment tree problems (e.g., constructing a segment tree for range sum
queries, implementing lazy propagation).
Solving advanced segment tree problems: Range minimum/maximum queries, range sum queries
with updates.
Day 18 Class 1 Segment Tree Problems Optimizing segment tree operations using lazy propagation.
Hands-on practice with segment tree problems (e.g., solving range minimum query problems,
implementing a segment tree with lazy propagation for range updates).
Introduction to Trie: Definition, applications, and basic operations.
Implementing a Trie from scratch: Insertion, searching, and deletion.
Day 18 Class 2 Trie Data Structure Applications of Trie: Autocomplete, spell checker, and dictionary implementation.
Hands-on coding with Trie problems (e.g., implementing a Trie for dictionary words, solving prefix-
based search problems).
Solving advanced Trie problems: Longest common prefix, word search in a grid.
Trie Problems
Optimization techniques for Trie operations.
Day 19 Class 1
Hands-on practice with Trie-based problems (e.g., solving the longest common prefix problem using
Trie, implementing a word search in a 2D grid).
Introduction to Disjoint Set Union (DSU): Concept, applications, and basic operations.
Union-Find algorithm: Implementation with path compression and union by rank.
Applications of DSU: Kruskal’s algorithm for Minimum Spanning Tree (MST).
Day 19 Class 2 Disjoint Set Union (DSU)
Hands-on coding with DSU problems (e.g., implementing union-find with path compression, solving
connectivity problems using DSU).
 Solving advanced DSU problems: Detecting cycles in an undirected graph, connected components in
a graph.
Day 20 Class 1 DSU Problems Applications of DSU in competitive programming.
Hands-on practice with DSU-based problems (e.g., solving the connectivity problem using DSU,
implementing Kruskal’s algorithm for MST).
Introduction to advanced graph algorithms: Dijkstra’s algorithm for shortest paths in weighted graphs.
Floyd-Warshall algorithm: All-pairs shortest path.
Day 20 Class 2 Advanced Graph Algorithms Applications of advanced graph algorithms in real-world problems.
Hands-on coding with advanced graph problems (e.g., implementing Dijkstra’s algorithm, solving all-
pairs shortest path using Floyd-Warshall).
Solving advanced graph problems: Minimum Spanning Tree (MST) using Kruskal’s and Prim’s
algorithms.
Day 21 Class 1 Graph Problems Understanding network flow: Introduction to Ford-Fulkerson algorithm.
Hands-on practice with advanced graph problems (e.g., solving MST problems using Kruskal’s
algorithm, implementing network flow algorithms).
Introduction to string algorithms: Importance in competitive programming.
KMP Algorithm: Knuth-Morris-Pratt algorithm for pattern matching.
Day 21 Class 2 String Algorithms Z Algorithm: Linear-time pattern matching algorithm.
Hands-on coding with string matching problems (e.g., implementing the KMP algorithm, solving
pattern matching problems using the Z algorithm).
Solving advanced string problems: Palindromic substrings, suffix arrays.
Optimization techniques for string problems.
Day 22 Class 1 Advanced String Problems
Hands-on practice with advanced string problems (e.g., finding the longest palindromic substring,
solving problems using suffix arrays).
Number theory basics: GCD, LCM, prime factorization, Sieve of Eratosthenes.
Modular arithmetic: Modular exponentiation, modular inverses, Chinese Remainder Theorem.
Day 22 Class 2 Mathematical Algorithms
Hands-on coding with number theory problems (e.g., solving problems on finding large prime
numbers, modular arithmetic applications).

Introduction to game theory: Grundy numbers, Nim game, and their applications.
Solving problems using combinatorial game theory (e.g., analyzing the winning strategy for Nim
Day 23 Class 1 Game Theory games).
Hands-on coding with game theory problems (e.g., determining the winner in a given game setup,
calculating Grundy numbers for complex games).

Understanding heaps: Max-heap, min-heap, and their applications.

Priority queues and their use in solving competitive programming problems.
Day 23 Class 2 Heaps and Priority Queues Hands-on coding with heap-based problems (e.g., solving k-largest elements problem,huffman
encoding implementing priority queues for efficient task scheduling).

Introduction to Mo's Algorithm: Concept and applications in answering range queries efficiently.
Implementation of Mo's Algorithm for range queries.
Day 24 Class 1 Mo's Algorithm
Hands-on coding with Mo's Algorithm problems (e.g., solving problems that involve answering range
queries on static arrays).
 Introduction to Fenwick Tree: Concept, construction, and use cases.
Operations on Fenwick Trees: Point updates, range queries.
Day 24 Class 2 Fenwick Tree (Binary Indexed Tree)
Hands-on coding with problems requiring efficient range queries and updates (e.g., solving range sum
queries using a Fenwick Tree).