What are some examples of dynamic programming in C++?

What are some examples of dynamic programming in C++?

Dynamic programming is a method for solving complex problems by breaking them down into simpler subproblems. Here are a few examples in C++:

1. Fibonacci Sequence
2. Knapsack Problem
3. Longest Common Subsequence
4. Coin Change Problem
5. Matrix Chain Multiplication

Can you explain the Fibonacci sequence example?

Sure! The Fibonacci sequence can be calculated using dynamic programming by storing previously computed values to avoid redundant calculations. Here's a simple C++ implementation:

#include <iostream>
#include <vector>

int fibonacci(int n) {
    std::vector<int> fib(n + 1);
    fib[0] = 0;
    fib[1] = 1;
    for (int i = 2; i <= n; ++i) {
        fib[i] = fib[i - 1] + fib[i - 2];
    }
    return fib[n];
}

int main() {
    int n = 10;
    std::cout << "Fibonacci of " << n << " is " << fibonacci(n);
    return 0;
}

This code calculates the nth Fibonacci number efficiently.

What about the Knapsack problem?

The Knapsack problem is a classic example of dynamic programming. It involves selecting items with given weights and values to maximize the total value without exceeding a weight limit. Here's a C++ implementation:

#include <iostream>
#include <vector>

int knapsack(int W, std::vector<int> weights, std::vector<int> values, int n) {
    std::vector<std::vector<int>> dp(n + 1, std::vector<int>(W + 1));
    for (int i = 0; i <= n; ++i) {
        for (int w = 0; w <= W; ++w) {
            if (i == 0 || w == 0)
                dp[i][w] = 0;
            else if (weights[i - 1] <= w)
                dp[i][w] = std::max(values[i - 1] + dp[i - 1][w - weights[i - 1]], dp[i - 1][w]);
            else
                dp[i][w] = dp[i - 1][w];
        }
    }
    return dp[n][W];
}

int main() {
    std::vector<int> weights = {1, 2, 3};
    std::vector<int> values = {10, 15, 40};
    int W = 6;
    int n = values.size();
    std::cout << "Maximum value in Knapsack = " << knapsack(W, weights, values, n);
    return 0;
}

This code finds the maximum value that can be carried in the knapsack.