Dynamic Programming Algorithms Master Course

Learn to set up Sublime Text for competitive programming, including a three-column layout and three files—new.cpp, input.txt, and output.txt—for in-window coding, input, and output.

Learn how to fix macOS clang missing bits/stdc++.h by creating a master header stdC++.h that aggregates standard headers, enabling a successful build and submission.

Explore how online judges validate code via input.txt and expected output, and use ifndef/ifdef to run locally with files while keeping compatibility on online judges.

Explore personalized competitive programming templates and macros, including code organization, common definitions, fast input-output tricks, debugging templates, and test-case handling to boost efficiency.

Learn how to implement factorial using recursion, identify base and recursive cases, explore call stack dynamics, and analyze time and space complexity O(N).

Learn to determine if an array is sorted using recursion, with base cases and two implementation approaches: pointer arithmetic with n-1 and index-based checks in C++.

Explore recursion by printing numbers from 1 to n in increasing and decreasing order with two simple methods. See how base case and call stack shape output.

Master exponentiation by squaring to compute a^n in log(n) steps by solving subproblems of size n/2, squaring results, and multiplying by a when n is odd, with base cases.

Learn to derive recurrences for tiling a 4x n board with 4x1 tiles using recursion, considering vertical and horizontal placements and the F(n)=F(n-1)+F(n-4) base cases.

Count binary strings of length n with no consecutive ones using a Fibonacci-like recurrence f(n)=f(n-1)+f(n-2), exploring recursion, memoization, and DP approaches.

Count the ways n friends go solo or pair up using f(n)=f(n-1)+(n-1)f(n-2) with base cases, and see how dynamic programming and memorization reduce time from exponential to linear.

Master the Tower of Hanoi using its rules and recursion to move discs from source to destination via a helper rod, following the no smaller on larger rule.

Demonstrates a recursive Tower of Hanoi solution with three rods, breaking the problem into subproblems and applying a base case to print moves from A to C via helper rod.

Explore implementing subset generation with recursion, using include or exclude decisions for each character, storing results in a shared output array and printing at the base case, illustrated with abc.

Implement backtracking to solve the n-queen problem by placing one queen per row, checking column and diagonal safety, printing the board on a solution, and backtracking when needed.

Explore counting all n-queen configurations by extending backtracking to accumulate every valid arrangement, using base cases that return one and summing results across rows and columns.

Generate balanced brackets with a recursive backtracking approach that tracks open and close counts and builds the output string. Compare in-place modification with copying and use backtracking to ensure correctness.

Learn to implement a sudoku solver using backtracking and brute-force search, filling empty cells with 1–9 while upholding row, column, and 3x3 subgrid rules.

Implement a sudoku solver with backtracking: define base and recursive cases, check safety for row, column, and 3x3 subgrids, and backtrack until a valid solution prints.

Explore hamiltonian paths in directed or undirected graphs, by using backtracking and DFS, marking vertices as visited and backtracking to unvisit, and analyzing brute force versus backtracking approaches.

Code a backtracking solution for Hamiltonian paths on a graph using an adjacency list, a visited array, and a count to visit every vertex exactly once.

Explore dynamic programming fundamentals by forming states, deriving recursive relations, and solving 26 problems using bottom-up (tabulation) and top-down (memorization) approaches, with optimal substructure and overlapping subproblems.

Master dynamic programming by comparing tabulation and memorization through a Fibonacci example. See how memorization reduces calls and how bottom-up tabulation builds solutions, guiding you to start top-down.

Learn how recursion underpins dynamic programming and how to turn exponential recursions into efficient solutions with memorization or tabulation. See a classic no-consecutive-ones binary string problem linked to Fibonacci.

Explore the fundamentals of one dimensional dynamic programming (1D DP) by examining recursive states, memoization, and examples such as Fibonacci, factorial, and triangular numbers, then tackle optimization and combinatorial problems.

Explore how dynamic programming solves a Zonal Computing Olympiad scheduling problem, weighing greedy ideas, and building DP states, base cases, and transitions for optimal substructure and overlapping subproblems.

Present a bottom-up dynamic programming solution for SUPW, using f(i) = min(DP[i-1], DP[i-2], DP[i-3]) + a[i], with base cases for the first three days and min of the last three.

Use dynamic programming to maximize earnings in an IPL schedule by selecting matches with no three consecutive plays, leveraging the complement of the SUPW problem.

Learn how to minimize steps to reach one using dynamic programming rather than greedy, evaluating n-1, n/2 (if divisible), and n/3 (if divisible) transitions, with memoization to store results.

Decode a numeric string into valid letters by partitioning into 1- or 2-digit numbers 1-26. Use dynamic programming to count all possible encodings.

Explore the rod cutting problem via dynamic programming, treating it as a partitioning task and using a recurrence to maximize price by cutting the rod into subpieces.

Explore rod cutting with dynamic programming, using a recursive relation and memoization to maximize revenue from given prices. Consider base cases and one-dimensional structure to analyze DP time complexity.

Explore the house robber problem and solve it with dynamic programming, presenting two-state and one-dimensional approaches, with recurrence relations and space optimization.

Explore palindromic partitioning with a dynamic programming inspired backtracking approach that builds all palindromic substrings, using memoization to optimize partition construction.

Learn dynamic programming for subset sum by building a boolean prefix state and choosing include or exclude, tracing back a solution and optimizing memory with a tabular bottom-up approach.

Explore subset sum with repeating numbers through a dynamic programming recurrence that decides to include or exclude values, enabling multiple uses and uncovering the optimal substructure.

Code the subset sum with repeating numbers, enabling multiple uses of elements, and relate it to the coin change problem with infinite supply, previewing a tabular approach for memory optimization.

Learn subset sum with tabulation in dynamic programming by building a table that shows sums achievable with or without each element, then optimize memory.

Learn to solve the subset sum problem with bottom-up tabulation, trace back the solution in a dp table, and optimize memory while counting possibilities.

Explore memory optimization in the subset sum dynamic programming solution by using two-row and one-row techniques to reduce space complexity while maintaining time efficiency.

Master memory optimization for subset sum by using a single dp array updated backwards to preserve previous results, with base case zero and true values.

Trace back approaches in dynamic programming to reconstruct a subset by choosing include or exclude decisions, using an index-based base case and a print-subset routine to follow the solution path.

Explore solving a Codeforces modulo sum problem with dynamic programming on residues, using prefix sums and the pigeonhole principle to determine achievable divisibility.

Explore the knapsack problem through zero-one and unbounded variants, compare greedy approaches with dynamic programming insights, and learn why greedy can fail for optimal value.

Explore the 0/1 knapsack problem and demonstrate how to use recursion and memoization in dynamic programming to choose include or exclude items for maximum value.

Master the knapsack problem by implementing a pure recursive solution, then translate to a tabulation dynamic programming approach with memory optimization and memoization.

Explore the zero in knapsack problem where items can be used multiple times to maximize value within capacity. Include and exclude choices use the recurrence f(x, y) and forward DP updates.

Use a dynamic programming approach to the colorful knapsack, selecting exactly one stone from each color within capacity, and maximize the total weight via a dp table.

Compute the minimum painting cost for adjacent houses by iterating colors, initializing base cases, and updating dynamic programming arrays to track costs, ensuring no two adjacent houses share a color.

Present a codeforces problem make fence great again, where increasing board heights costs rubles and adjacent heights must differ; solve via dynamic programming with 0–2 increments per board.

Apply dynamic programming to the plates problem, using two stacks and a dp state to pick exactly p top plates for maximum beauty.

Explore a dynamic programming solution for the plates problem, constructing a bottom-up approach with prefix optimization on vectors to maximize plates under constraints, while analyzing complexity.

Learn a dynamic programming approach to the best time to buy and sell stock, with at most k transactions, non-overlapping, using a buy-sell state and continuous partitions.

Explore dynamic programming for the best time to buy and sell stock, implementing a memoized DP with buy/sell states, price vector, and transaction limits.

Learn to minimize the largest sum when partitioning an array of non-negative integers into m nonempty contiguous subarrays using dynamic programming.

Solve palindromic partitioning 2 by computing the minimum cuts needed to partition s into palindromic substrings, using dynamic programming and printing the optimal partition.

Learn a dynamic programming approach to palindromic partitioning, using memoization to compute the minimum number of palindromic partitions in a string, with palindrome checks and dynamic programming states.