Competitive Programming for Beginners

Learn arrays as contiguous memory blocks storing items of the same type, using zero, one, or end-based indexing. Understand random access, cache locality, and fixed size with insertions and deletions.

Explore matrices, scalars, and vectors in competitive programming for beginners, learning matrix types (square, zero, identity, symmetric, triangular) and core operations—transpose, inverse, addition, subtraction, and matrix-vector multiplication.

Explore strings as a text data type, defined as an array of characters, including spaces and numbers, and learn operations like copy, concatenate, compare, and use of quotation marks.

Explore linked lists, a data structure of nodes with data and a next pointer, enabling insertion, deletion, and traversal. Learn singly, doubly, and circular lists that loop.

Explore binary trees: root node with left and right subtrees, and five types—full, complete, perfect, balanced, and degenerate—plus applications like binary search trees, heaps, and Huffman coding.

Explore binary search trees as ordered structures that store values with left subtrees less than the root and right subtrees greater, enabling fast lookup, insertion, and deletion via in-order successor.

Master stacks, a last in, first out structure with push, pop, top, size, and empty checks for expression evaluation and parentheses matching, and queues with enqueue, dequeue, front, back.

Explore heaps as a complete binary tree, defining root, parent, and child, and distinguish min-heap from max-heap; learn insertion by bubbling up to maintain the heap property, with priority queues.

Explore graphs as nodes and edges, including undirected and directed types. Compare adjacency matrix and adjacency list representations for efficiency and memory, noting applications like maps and state transition diagrams.

Explore tries, a string-based data structure with 26-child nodes to store prefixes, learn insertion from the root by traversing characters, and build prefix trees for search-related applications.

Explore depth first search (dfs) for traversing graphs with a stack, marking visited nodes, and backtracking to explore unvisited neighbors. Apply dfs to connected components, topological sorting, and cycle detection.

Demonstrate how breadth-first search uses a FIFO queue to traverse a graph, visiting unvisited vertices and enqueuing neighbors, with applications to shortest paths and minimum spanning tree in unweighted graphs.

Explore greedy algorithms that build solutions piece by piece by choosing the most immediate benefit. Understand how local optima can miss the global optimum, demonstrated with the fractional knapsack problem.

Backtracking uses a recursive approach to explore a decision tree, finding all possible combinations to solve optimization problems and reach a goal node, including puzzles such as Sudoku.