Algorithm Design and Analysis

  1. Dynamic Programming
    1. The Dynamic Programming Paradigm
      1. Overlapping Subproblems
        1. Optimal Substructure
          1. Comparison with Divide and Conquer
            1. When to Use Dynamic Programming
            2. Approaches to Dynamic Programming
              1. Memoization
                1. Top-Down Approach
                  1. Recursive Implementation
                    1. Caching Results
                      1. Implementation Techniques
                      2. Tabulation
                        1. Bottom-Up Approach
                          1. Iterative Table Filling
                            1. Space Optimization Techniques
                              1. Order of Computation
                            2. Classic Dynamic Programming Problems
                              1. Fibonacci Numbers
                                1. Naive Recursive Solution
                                  1. Memoized Solution
                                    1. Tabulated Solution
                                      1. Space-Optimized Solution
                                      2. 0/1 Knapsack Problem
                                        1. Problem Formulation
                                          1. Recursive Formulation
                                            1. Table Construction
                                              1. Backtracking Solution
                                                1. Space Optimization
                                                2. Longest Common Subsequence
                                                  1. Problem Statement
                                                    1. Recursive Formulation
                                                      1. Table Construction
                                                        1. Reconstructing the Solution
                                                          1. Space Optimization
                                                          2. Longest Increasing Subsequence
                                                            1. Problem Statement
                                                              1. Dynamic Programming Solution
                                                                1. Binary Search Optimization
                                                                2. Edit Distance
                                                                  1. Problem Statement
                                                                    1. Recursive Formulation
                                                                      1. Table Construction
                                                                      2. Matrix-Chain Multiplication
                                                                        1. Problem Statement
                                                                          1. Parenthesization
                                                                            1. Recursive Formulation
                                                                              1. Cost Table Construction
                                                                                1. Optimal Parenthesization
                                                                                2. Coin Change Problem
                                                                                  1. Minimum Coins
                                                                                    1. Number of Ways
                                                                                      1. Table Construction
                                                                                      2. All-Pairs Shortest Paths
                                                                                        1. Floyd-Warshall Algorithm
                                                                                          1. Algorithm Steps
                                                                                            1. Handling Negative Cycles
                                                                                              1. Path Reconstruction

                                                                                          Previous

                                                                                          5. Greedy Algorithms

                                                                                          Go to top

                                                                                          Next

                                                                                          7. Backtracking and Branch-and-Bound