Sponsored
Sponsored
This approach involves breaking down the problem into overlapping subproblems, solving each subproblem only once, and storing their solutions - typically in a table. This can help reduce redundant calculations and improve efficiency.
Time Complexity: O(n), as each subproblem from 1 to n is solved once.
Space Complexity: O(n), due to the storage of results in the dp array.
1#include <iostream>
2#include <vector>
3
4int solveProblem(int n) {
5 std::vector<int> dp(n + 1, 1);
6 for (int i = 1; i <= n; ++i) {
7 dp[i] = dp[i - 1] * 2;
8 }
9 return dp[n];
10}
11
12int main() {
13 int n = 5;
14 std::cout << "Solution: " << solveProblem(n) << std::endl;
15 return 0;
16}This C++ solution mirrors the C code but makes use of the vector from the Standard Library to manage dynamic memory allocation automatically, ensuring efficiency and simplicity.
A recursive approach solves the problem by solving smaller instances of the same problem. While this is a straightforward approach, it may lead to inefficiencies without memoization or optimizations because it can repeatedly solve the same subproblems.
Time Complexity: O(2^n), due to many duplicate subproblem calculations without memoization.
Space Complexity: O(n), considering the call stack.
1
class Solution {
static int SolveProblem(int n) {
if (n == 0) return 1;
return 2 * SolveProblem(n - 1);
}
static void Main() {
int n = 5;
Console.WriteLine("Solution: " + SolveProblem(n));
}
}In this C# solution, the recursive function invokes itself with smaller arguments until a base case of n equals zero is met.