feature: dp pattern 1 fibonacci, tribonacci added

include/0005_DynamicProgramming/0001_FibonacciNumber.h

@@ -0,0 +1,23 @@
+#pragma once
+#include<vector>
+using namespace std;
+
+/*
+Pattern 1
+Linear Recurrence
+
+Description
+Print the n'th Fibonacci number.
+
+*/
+
+namespace FibonacciNumber
+{
+	class DynamicProgramming
+	{
+	private:
+	public:
+		int RecursiveNthFibonacci(int n);
+		int DpNthFibonacci(int n);
+	};
+}

include/0005_DynamicProgramming/0002_TribonacciNumber.h

@@ -0,0 +1,23 @@
+#pragma once
+#include<vector>
+using namespace std;
+
+/*
+Pattern 1
+Linear Recurrence
+
+Description
+Print the n'th Tribonacci number.
+
+*/
+
+namespace TribonacciNumber
+{
+	class DynamicProgramming
+	{
+	private:
+	public:
+		int RecursiveNthTribonacci(int n);
+		int DpNthTribonacci(int n);
+	};
+}

include/0005_DynamicProgramming/0003_ClimbingStairs.h

@@ -0,0 +1,24 @@
+#pragma once
+#include<vector>
+using namespace std;
+
+/*
+Pattern 1
+Linear Recurrence
+
+Description
+There are n stairs, and a person standing at the bottom wants to climb stairs to reach the top.
+The person can climb either 1 stair or 2 stairs at a time, the task is to count the number of ways that a person can reach at the top.
+
+*/
+
+namespace ClimbingStairs
+{
+	class DynamicProgramming
+	{
+	private:
+	public:
+		int RecursiveCountWays(int n);
+		int DpCountWays(int n);
+	};
+}

include/0005_DynamicProgramming/0004_MinimumCostClimbingStairs.h

@@ -0,0 +1,25 @@
+#pragma once
+#include<vector>
+using namespace std;
+
+/*
+Pattern 1
+Linear Recurrence
+
+Description
+Given an array of integers cost[] of length n, where cost[i] is the cost of the ith step on a staircase. Once the cost is paid, we can either climb 1 or 2 steps.
+We can either start from the step with index 0, or the step with index 1. The task is to find the minimum cost to reach the top.
+
+*/
+
+namespace MinimumCostClimbingStairs
+{
+	class DynamicProgramming
+	{
+	private:
+		int MinCostRecursive(int step, vector<int>& cost);
+	public:
+		int RecursiveMinimumCostClimbingStairs(vector<int>& cost);
+		int DpMinimumCostClimbingStairs(vector<int>& cost);
+	};
+}

source/0005_DynamicProgramming/0001_FibonacciNumber.cc

@@ -0,0 +1,28 @@
+#include "../../include/0005_DynamicProgramming/0001_FibonacciNumber.h"
+
+namespace FibonacciNumber
+{
+	int DynamicProgramming::RecursiveNthFibonacci(int n)
+	{
+		if (n <= 1)
+		{
+			return n;
+		}
+
+		return this->RecursiveNthFibonacci(n - 1) + this->RecursiveNthFibonacci(n - 2);
+	}
+
+	int DynamicProgramming::DpNthFibonacci(int n)
+	{
+		vector<int> dp(n + 1, 0);
+		dp[0] = 0;
+		dp[1] = 1;
+
+		for (int i = 2; i <= n; i++)
+		{
+			dp[i] = dp[i - 1] + dp[i - 2];
+		}
+
+		return dp[n];
+	}
+}

source/0005_DynamicProgramming/0002_TribonacciNumber.cc

@@ -0,0 +1,33 @@
+#include "../../include/0005_DynamicProgramming/0002_TribonacciNumber.h"
+
+namespace TribonacciNumber
+{
+	int DynamicProgramming::RecursiveNthTribonacci(int n)
+	{
+		if (n == 0 || n == 1 || n == 2)
+		{
+			return 0;
+		}
+
+		if (n == 3)
+		{
+			return 1;
+		}
+
+		return this->RecursiveNthTribonacci(n - 1) + this->RecursiveNthTribonacci(n - 2) + this->RecursiveNthTribonacci(n - 3);
+	}
+
+	int DynamicProgramming::DpNthTribonacci(int n)
+	{
+		vector<int> dp(n, 0);
+		dp[0] = dp[1] = 0;
+		dp[2] = 1;
+
+		for (int i = 3; i < n; i++)
+		{
+			dp[i] = dp[i - 1] + dp[i - 2] + dp[i - 3];
+		}
+
+		return dp[n - 1];
+	}
+}

source/0005_DynamicProgramming/0003_ClimbingStairs.cc

@@ -0,0 +1,29 @@
+#include "../../include/0005_DynamicProgramming/0003_ClimbingStairs.h"
+using namespace std;
+
+namespace ClimbingStairs
+{
+	int DynamicProgramming::RecursiveCountWays(int n)
+	{
+		if (n == 0 || n == 1)
+		{
+			return 1;
+		}
+
+		return this->RecursiveCountWays(n - 1) + this->RecursiveCountWays(n - 2);
+	}
+
+	int DynamicProgramming::DpCountWays(int n)
+	{
+		vector<int> dp(n + 1, 0);
+		dp[0] = 1;
+		dp[1] = 1;
+
+		for (int i = 2; i <= n; i++)
+		{
+			dp[i] = dp[i - 1] + dp[i - 2];
+		}
+
+		return dp[n];
+	}
+}

source/0005_DynamicProgramming/0004_MinimumCostClimbingStairs.cc

@@ -0,0 +1,48 @@
+#include "../../include/0005_DynamicProgramming/0004_MinimumCostClimbingStairs.h"
+#include<algorithm>
+
+namespace MinimumCostClimbingStairs
+{
+	int DynamicProgramming::MinCostRecursive(int step, vector<int>& cost)
+	{
+		if (step == 0 || step == 1)
+		{
+			return cost[step];
+		}
+
+		return cost[step] + min(this->MinCostRecursive(step - 1, cost), this->MinCostRecursive(step - 2, cost));
+	}
+
+	int DynamicProgramming::RecursiveMinimumCostClimbingStairs(vector<int>& cost)
+	{
+		int totalSteps = cost.size();
+
+		if (totalSteps == 1)
+		{
+			return cost[0];
+		}
+
+		return min(this->MinCostRecursive(totalSteps - 1, cost), this->MinCostRecursive(totalSteps - 2, cost));
+	}
+
+	int DynamicProgramming::DpMinimumCostClimbingStairs(vector<int>& cost)
+	{
+		int totalSteps = cost.size();
+		vector<int> dp(totalSteps, 0);
+
+		if (totalSteps == 1)
+		{
+			return cost[0];
+		}
+
+		dp[0] = cost[0];
+		dp[1] = cost[1];
+
+		for (int i = 2; i < totalSteps; i++)
+		{
+			dp[i] = cost[i] + min(dp[i - 1], dp[i - 2]);
+		}
+
+		return min(dp[totalSteps - 1], dp[totalSteps - 2]);
+	}
+}

source/0005_DynamicProgramming/CMakeLists.txt

@@ -0,0 +1,11 @@
+# Specify the source files
+set(0005DYNAMICPROGRAMMING_SOURCES
+    0001_FibonacciNumber.cc
+    0002_TribonacciNumber.cc
+    0003_ClimbingStairs.cc
+    0004_MinimumCostClimbingStairs.cc
+
+)
+
+# Create a library target
+add_library(0005DYNAMICPROGRAMMING ${0005DYNAMICPROGRAMMING_SOURCES})

test/0005_DynamicProgramming/0001_FibonacciNumberTest.cc

@@ -0,0 +1,34 @@
+#include<gtest/gtest.h>
+#include "../../include/0005_DynamicProgramming/0001_FibonacciNumber.h"
+using namespace std;
+
+namespace FibonacciNumber
+{
+	TEST(FibonacciNumber, RecursiveTest)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 5;
+		int expectedFib = 5;
+
+		// Act
+		int actualFib = dp.RecursiveNthFibonacci(n);
+
+		// Assert
+		ASSERT_EQ(expectedFib, actualFib);
+	}
+
+	TEST(FibonacciNumber, DpTest)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 5;
+		int expectedFib = 5;
+
+		// Act
+		int actualFib = dp.DpNthFibonacci(n);
+
+		// Assert
+		ASSERT_EQ(expectedFib, actualFib);
+	}
+}

test/0005_DynamicProgramming/0002_TribonacciNumberTest.cc

@@ -0,0 +1,34 @@
+#include<gtest/gtest.h>
+#include "../../include/0005_DynamicProgramming/0002_TribonacciNumber.h"
+using namespace std;
+
+namespace TribonacciNumber
+{
+	TEST(TribonacciNumber, RecursiveTest)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 5;
+		int expectedFib = 2;
+
+		// Act
+		int actualFib = dp.RecursiveNthTribonacci(n);
+
+		// Assert
+		ASSERT_EQ(expectedFib, actualFib);
+	}
+
+	TEST(TribonacciNumber, DpTest)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 10;
+		int expectedFib = 44;
+
+		// Act
+		int actualFib = dp.DpNthTribonacci(n);
+
+		// Assert
+		ASSERT_EQ(expectedFib, actualFib);
+	}
+}

test/0005_DynamicProgramming/0003_ClimbingStairsTest.cc

@@ -0,0 +1,33 @@
+#include<gtest/gtest.h>
+#include "../../include/0005_DynamicProgramming/0003_ClimbingStairs.h"
+
+namespace ClimbingStairs
+{
+	TEST(ClimbingStairs, RecursiveTest)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 4;
+		int expectedCount = 5;
+
+		// Act
+		int actualCount = dp.RecursiveCountWays(n);
+
+		// Assert
+		ASSERT_EQ(expectedCount, actualCount);
+	}
+
+	TEST(ClimbingStairs, DpTest)
+	{
+		// Arrange
+		DynamicProgramming dp;
+		int n = 4;
+		int expectedCount = 5;
+
+		// Act
+		int actualCount = dp.DpCountWays(n);
+
+		// Assert
+		ASSERT_EQ(expectedCount, actualCount);
+	}
+}