Algorithms

  1. Algorithmic Design Paradigms
    1. Brute-Force Approach
      1. Exhaustive Search
        1. Generating All Possibilities
          1. Systematic Enumeration
            1. Time Complexity Considerations
              1. Space Complexity
              2. When to Use Brute-Force
                1. Small Problem Sizes
                  1. Correctness Verification
                    1. Baseline Solutions
                    2. Applications and Examples
                      1. Linear Search
                        1. Selection Sort
                          1. Traveling Salesperson Problem
                          2. Limitations
                            1. Exponential Time Complexity
                              1. Scalability Issues
                            2. Divide and Conquer
                              1. The Divide-and-Conquer Strategy
                                1. Problem Decomposition
                                  1. Dividing the Problem
                                    1. Balanced Division
                                      1. Unbalanced Division
                                      2. Conquering Subproblems
                                        1. Base Cases
                                          1. Recursive Solutions
                                          2. Combining Solutions
                                            1. Merge Operations
                                              1. Result Aggregation
                                            2. Design Steps
                                              1. Problem Analysis
                                                1. Division Strategy
                                                  1. Base Case Identification
                                                    1. Combination Method
                                                    2. Analysis of Divide-and-Conquer Algorithms
                                                      1. Recurrence Relations
                                                        1. Master Theorem Application
                                                          1. Time Complexity Analysis
                                                            1. Space Complexity Analysis
                                                            2. Classic Examples
                                                              1. Merge Sort
                                                                1. Division Process
                                                                  1. Merging Process
                                                                    1. Analysis
                                                                    2. Quick Sort
                                                                      1. Partitioning
                                                                        1. Pivot Selection
                                                                          1. Analysis
                                                                          2. Binary Search
                                                                            1. Maximum Subarray Problem
                                                                              1. Closest Pair of Points
                                                                                1. Strassen's Matrix Multiplication
                                                                                2. Advantages and Disadvantages
                                                                                  1. Parallelization Potential
                                                                                    1. Memory Usage
                                                                                      1. Implementation Complexity
                                                                                    2. Greedy Algorithms
                                                                                      1. Greedy Strategy
                                                                                        1. Local Optimal Choices
                                                                                          1. Irrevocable Decisions
                                                                                            1. Hope for Global Optimum
                                                                                            2. Key Properties
                                                                                              1. Greedy-Choice Property
                                                                                                1. Verification Methods
                                                                                                2. Optimal Substructure
                                                                                                  1. Relationship to Dynamic Programming
                                                                                                3. Greedy Algorithm Design Steps
                                                                                                  1. Problem Analysis
                                                                                                    1. Greedy Choice Identification
                                                                                                      1. Subproblem Reduction
                                                                                                        1. Correctness Proof
                                                                                                        2. Proof Techniques
                                                                                                          1. Exchange Arguments
                                                                                                            1. Staying Ahead Arguments
                                                                                                              1. Cut-and-Paste Arguments
                                                                                                              2. Classic Problems
                                                                                                                1. Activity Selection Problem
                                                                                                                  1. Problem Statement
                                                                                                                    1. Greedy Strategy
                                                                                                                      1. Correctness Proof
                                                                                                                      2. Fractional Knapsack Problem
                                                                                                                        1. Huffman Coding
                                                                                                                          1. Optimal Prefix Codes
                                                                                                                            1. Tree Construction
                                                                                                                              1. Encoding and Decoding
                                                                                                                              2. Minimum Spanning Tree
                                                                                                                                1. Kruskal's Algorithm
                                                                                                                                  1. Prim's Algorithm
                                                                                                                                  2. Single-Source Shortest Paths
                                                                                                                                    1. Dijkstra's Algorithm
                                                                                                                                  3. When Greedy Fails
                                                                                                                                    1. Counterexamples
                                                                                                                                      1. 0/1 Knapsack Problem
                                                                                                                                        1. Coin Change Problem
                                                                                                                                        2. Approximation Algorithms
                                                                                                                                          1. Performance Ratios
                                                                                                                                            1. Greedy Approximations
                                                                                                                                          2. Dynamic Programming
                                                                                                                                            1. Core Concepts
                                                                                                                                              1. Overlapping Subproblems
                                                                                                                                                1. Identification
                                                                                                                                                  1. Subproblem Graphs
                                                                                                                                                  2. Optimal Substructure
                                                                                                                                                    1. Verification
                                                                                                                                                      1. Relationship to Greedy Algorithms
                                                                                                                                                    2. Implementation Approaches
                                                                                                                                                      1. Memoization
                                                                                                                                                        1. Top-Down Approach
                                                                                                                                                          1. Recursive Implementation
                                                                                                                                                            1. Cache Management
                                                                                                                                                              1. Space Complexity
                                                                                                                                                              2. Tabulation
                                                                                                                                                                1. Bottom-Up Approach
                                                                                                                                                                  1. Table Construction
                                                                                                                                                                    1. Iterative Solutions
                                                                                                                                                                      1. Space Optimization
                                                                                                                                                                    2. Design Process
                                                                                                                                                                      1. Problem Characterization
                                                                                                                                                                        1. Recursive Solution
                                                                                                                                                                          1. Subproblem Identification
                                                                                                                                                                            1. Recurrence Relation
                                                                                                                                                                              1. Base Cases
                                                                                                                                                                                1. Implementation Choice
                                                                                                                                                                                2. Classic Problems
                                                                                                                                                                                  1. Fibonacci Numbers
                                                                                                                                                                                    1. Naive Recursion
                                                                                                                                                                                      1. Memoized Version
                                                                                                                                                                                        1. Tabulated Version
                                                                                                                                                                                          1. Space-Optimized Version
                                                                                                                                                                                          2. Longest Common Subsequence
                                                                                                                                                                                            1. Problem Definition
                                                                                                                                                                                              1. Recurrence Relation
                                                                                                                                                                                                1. Table Construction
                                                                                                                                                                                                  1. Solution Reconstruction
                                                                                                                                                                                                  2. 0/1 Knapsack Problem
                                                                                                                                                                                                    1. Problem Statement
                                                                                                                                                                                                      1. Recurrence Relation
                                                                                                                                                                                                        1. Implementation
                                                                                                                                                                                                          1. Space Optimization
                                                                                                                                                                                                          2. Edit Distance
                                                                                                                                                                                                            1. Problem Definition
                                                                                                                                                                                                              1. Operations
                                                                                                                                                                                                                1. Recurrence Relation
                                                                                                                                                                                                                2. Coin Change Problem
                                                                                                                                                                                                                  1. Minimum Coins
                                                                                                                                                                                                                    1. Number of Ways
                                                                                                                                                                                                                    2. Longest Increasing Subsequence
                                                                                                                                                                                                                      1. Matrix Chain Multiplication
                                                                                                                                                                                                                        1. Parenthesization Problem
                                                                                                                                                                                                                          1. Optimal Substructure
                                                                                                                                                                                                                            1. Implementation
                                                                                                                                                                                                                          2. Advanced Topics
                                                                                                                                                                                                                            1. Space Optimization Techniques
                                                                                                                                                                                                                              1. Printing Solutions
                                                                                                                                                                                                                                1. Multi-dimensional DP
                                                                                                                                                                                                                                  1. DP on Trees
                                                                                                                                                                                                                                    1. DP with Bitmasks
                                                                                                                                                                                                                                  2. Backtracking
                                                                                                                                                                                                                                    1. Backtracking Concept
                                                                                                                                                                                                                                      1. State-Space Tree
                                                                                                                                                                                                                                        1. Pruning Unsuccessful Paths
                                                                                                                                                                                                                                        2. Algorithm Structure
                                                                                                                                                                                                                                          1. Recursive Framework
                                                                                                                                                                                                                                            1. Choice Making
                                                                                                                                                                                                                                              1. Constraint Checking
                                                                                                                                                                                                                                                1. Backtrack Operation
                                                                                                                                                                                                                                                2. Implementation Techniques
                                                                                                                                                                                                                                                  1. Explicit State Representation
                                                                                                                                                                                                                                                    1. Implicit State Representation
                                                                                                                                                                                                                                                      1. Pruning Strategies
                                                                                                                                                                                                                                                        1. Constraint Pruning
                                                                                                                                                                                                                                                          1. Bound Pruning
                                                                                                                                                                                                                                                        2. Classic Problems
                                                                                                                                                                                                                                                          1. N-Queens Problem
                                                                                                                                                                                                                                                            1. Problem Statement
                                                                                                                                                                                                                                                              1. State Representation
                                                                                                                                                                                                                                                                1. Constraint Checking
                                                                                                                                                                                                                                                                  1. Solution Counting
                                                                                                                                                                                                                                                                  2. Subset Sum Problem
                                                                                                                                                                                                                                                                    1. Problem Definition
                                                                                                                                                                                                                                                                      1. Backtracking Solution
                                                                                                                                                                                                                                                                        1. Pruning Optimizations
                                                                                                                                                                                                                                                                        2. Graph Coloring
                                                                                                                                                                                                                                                                          1. Problem Statement
                                                                                                                                                                                                                                                                            1. Backtracking Approach
                                                                                                                                                                                                                                                                            2. Sudoku Solver
                                                                                                                                                                                                                                                                              1. Hamiltonian Path Problem
                                                                                                                                                                                                                                                                                1. Knight's Tour Problem
                                                                                                                                                                                                                                                                                2. Optimization Techniques
                                                                                                                                                                                                                                                                                  1. Constraint Propagation
                                                                                                                                                                                                                                                                                    1. Variable Ordering
                                                                                                                                                                                                                                                                                      1. Value Ordering
                                                                                                                                                                                                                                                                                        1. Symmetry Breaking
                                                                                                                                                                                                                                                                                        2. Analysis
                                                                                                                                                                                                                                                                                          1. Worst-Case Complexity
                                                                                                                                                                                                                                                                                            1. Average-Case Analysis
                                                                                                                                                                                                                                                                                              1. Pruning Effectiveness
                                                                                                                                                                                                                                                                                            2. Branch and Bound
                                                                                                                                                                                                                                                                                              1. Core Concepts
                                                                                                                                                                                                                                                                                                1. State-Space Tree
                                                                                                                                                                                                                                                                                                  1. Bounding Functions
                                                                                                                                                                                                                                                                                                    1. Lower Bounds
                                                                                                                                                                                                                                                                                                      1. Upper Bounds
                                                                                                                                                                                                                                                                                                      2. Pruning Strategies
                                                                                                                                                                                                                                                                                                        1. Bound-Based Pruning
                                                                                                                                                                                                                                                                                                          1. Dominance Pruning
                                                                                                                                                                                                                                                                                                        2. Algorithm Framework
                                                                                                                                                                                                                                                                                                          1. Node Selection Strategies
                                                                                                                                                                                                                                                                                                            1. Depth-First Search
                                                                                                                                                                                                                                                                                                              1. Breadth-First Search
                                                                                                                                                                                                                                                                                                              2. Bound Calculation
                                                                                                                                                                                                                                                                                                                1. Pruning Decisions
                                                                                                                                                                                                                                                                                                                2. Implementation Details
                                                                                                                                                                                                                                                                                                                  1. Priority Queues
                                                                                                                                                                                                                                                                                                                    1. State Representation
                                                                                                                                                                                                                                                                                                                      1. Memory Management
                                                                                                                                                                                                                                                                                                                      2. Classic Problems
                                                                                                                                                                                                                                                                                                                        1. Traveling Salesperson Problem
                                                                                                                                                                                                                                                                                                                          1. Problem Statement
                                                                                                                                                                                                                                                                                                                            1. Bounding Functions
                                                                                                                                                                                                                                                                                                                              1. Implementation
                                                                                                                                                                                                                                                                                                                              2. 0/1 Knapsack Problem
                                                                                                                                                                                                                                                                                                                                1. Fractional Relaxation
                                                                                                                                                                                                                                                                                                                                  1. Bound Calculation
                                                                                                                                                                                                                                                                                                                                  2. Job Assignment Problem
                                                                                                                                                                                                                                                                                                                                    1. Integer Linear Programming
                                                                                                                                                                                                                                                                                                                                    2. Comparison with Other Paradigms
                                                                                                                                                                                                                                                                                                                                      1. vs Backtracking
                                                                                                                                                                                                                                                                                                                                        1. vs Dynamic Programming
                                                                                                                                                                                                                                                                                                                                          1. vs Greedy Algorithms

                                                                                                                                                                                                                                                                                                                                      Previous

                                                                                                                                                                                                                                                                                                                                      2. Data Structures

                                                                                                                                                                                                                                                                                                                                      Go to top

                                                                                                                                                                                                                                                                                                                                      Next

                                                                                                                                                                                                                                                                                                                                      4. Sorting and Searching Algorithms