Given an array **arr[] **consisting of **N** positive integers, the task is to find the minimum cost required to either cross the array or reach the end of the array by only moving to indices **(i + 2)** and **(i – 1)** from the **i**^{th} index.

**Examples:**

Input:arr[] = {5, 1, 2, 10, 100}Output:18Explanation:

Optimal cost path (0 based indexing): 0 → 2 → 1 → 3 → 5

Therefore, the minimum cost = 5 + 2 + 1 + 10 = 18.

Input:arr[] = {9, 4, 6, 8, 5}Output:20Explanation:

Optimal cost path (0 based indexing): 0 → 2 → 4

Therefore, the minimum cost = 9 + 6 + 5 = 20

**Naive Approach:** The given problem can be solved based on the following observations:

- Since all costs are positive, it will never be an optimal option to move more than one step backward, hence to reach a particular index
**i**of the array, either jump directly from the**(i – 2)**index or jump from^{th}**(i – 1)**to^{th}**(i + 1)**(2 jumps forward), followed by 1 backward jump, i.e. from^{th}index, i.e.**(i + 1)**index to^{th}**i**index.^{th} - Now, traverse from the end of the array recursively and for the elements at indices
**(i – 2)**and**(i – 1)**, calculate the minimum cost of the two. Therefore, the minimum cost to cross the array can be calculated using the following recurrence relation:

minCost(index) = minimum(minCost(index – 2) + arr[i], minCost(index – 1) + arr[i] + arr[i + 1])

**Time Complexity:** O(2^{N})**Auxiliary Space:** O(1)

**Efficient Approach:** The approach discussed above has both Optimal Substructure and Overlapping Subproblems. Therefore it can be optimized by either using Memoization or Tabulation. Follow the steps below to solve the problem:

- Initialize an array
**dp[]**, where**dp[i]**stores the minimum cost to reach the**i**index.^{th} - Initialize
**dp[0] = arr[0]**as the cost to reach the**0**, which is equal to the value at the^{th}index**0**itself. Update^{th}index**dp[1] = arr[0] + arr[1] + arr[2]**, as to reach the**1**, jump from the^{st}index**0**index to^{th}**2**indexn to the^{nd}index**1**.^{st}index - Iterate over the range
**[2, N – 2]**using a variable**i**and update**dp[i]**as the minimum of**(dp[i – 2] + arr[i])**and**(dp[i – 1] + arr[i] + arr[i + 1])**. - For the last index
**(N – 1)**, update**dp[N – 1]**as minimum of**(dp[N – 3] + arr[N – 1])**and**(dp[N – 2])**. - After completing the above steps, print the value of
**dp[N – 1]**as the result.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the minimum cost` `// to reach the end of an array` `void` `minCost(` `int` `arr[], ` `int` `n)` `{` ` ` `// Base Case: When N < 3` ` ` `if` `(n < 3) {` ` ` `cout << arr[0];` ` ` `return` `;` ` ` `}` ` ` `// Store the results in table` ` ` `int` `* dp = ` `new` `int` `[n];` ` ` `// Initialize base cases` ` ` `dp[0] = arr[0];` ` ` `dp[1] = dp[0] + arr[1] + arr[2];` ` ` `// Iterate over the range[2, N - 2]` ` ` `// to construct the dp array` ` ` `for` `(` `int` `i = 2; i < n - 1; i++)` ` ` `dp[i] = min(dp[i - 2] + arr[i],` ` ` `dp[i - 1] + arr[i]` ` ` `+ arr[i + 1]);` ` ` `// Handle case for the last index, i.e. N - 1` ` ` `dp[n - 1] = min(dp[n - 2],` ` ` `dp[n - 3] + arr[n - 1]);` ` ` `// Print the answer` ` ` `cout << dp[n - 1];` `}` `// Driver Code` `int` `main()` `{` ` ` `int` `arr[] = { 9, 4, 6, 8, 5 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `minCost(arr, N);` ` ` `return` `0;` `}` |

## Java

`// Java Program to implement` `// the above approach` `import` `java.io.*;` `import` `java.util.*;` `class` `GFG` `{` ` ` `// Function to find the minimum cost` ` ` `// to reach the end of an array` ` ` `static` `void` `minCost(` `int` `arr[], ` `int` `n)` ` ` `{` ` ` ` ` `// Base Case: When N < 3` ` ` `if` `(n < ` `3` `) {` ` ` `System.out.println(arr[` `0` `]);` ` ` `return` `;` ` ` `}` ` ` `// Store the results in table` ` ` `int` `dp[] = ` `new` `int` `[n];` ` ` `// Initialize base cases` ` ` `dp[` `0` `] = arr[` `0` `];` ` ` `dp[` `1` `] = dp[` `0` `] + arr[` `1` `] + arr[` `2` `];` ` ` `// Iterate over the range[2, N - 2]` ` ` `// to construct the dp array` ` ` `for` `(` `int` `i = ` `2` `; i < n - ` `1` `; i++)` ` ` `dp[i] = Math.min(dp[i - ` `2` `] + arr[i],` ` ` `dp[i - ` `1` `] + arr[i] + arr[i + ` `1` `]);` ` ` `// Handle case for the last index, i.e. N - 1` ` ` `dp[n - ` `1` `] = Math.min(dp[n - ` `2` `], dp[n - ` `3` `] + arr[n - ` `1` `]);` ` ` `// Print the answer` ` ` `System.out.println(dp[n - ` `1` `]);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `main(String[] args)` ` ` `{` ` ` `int` `arr[] = { ` `9` `, ` `4` `, ` `6` `, ` `8` `, ` `5` `};` ` ` `int` `N = arr.length;` ` ` `minCost(arr, N);` ` ` `}` `}` `// This code is contributed by Kingash.` |

## Python3

`# Python 3 program for the above approach` `# Function to find the minimum cost` `# to reach the end of an array` `def` `minCost(arr, n):` ` ` `# Base Case: When N < 3` ` ` `if` `(n < ` `3` `):` ` ` `print` `(arr[` `0` `])` ` ` `return` ` ` `# Store the results in table` ` ` `dp ` `=` `[` `0` `] ` `*` `n` ` ` `# Initialize base cases` ` ` `dp[` `0` `] ` `=` `arr[` `0` `]` ` ` `dp[` `1` `] ` `=` `dp[` `0` `] ` `+` `arr[` `1` `] ` `+` `arr[` `2` `]` ` ` `# Iterate over the range[2, N - 2]` ` ` `# to construct the dp array` ` ` `for` `i ` `in` `range` `(` `2` `, n ` `-` `1` `):` ` ` `dp[i] ` `=` `min` `(dp[i ` `-` `2` `] ` `+` `arr[i],` ` ` `dp[i ` `-` `1` `] ` `+` `arr[i]` ` ` `+` `arr[i ` `+` `1` `])` ` ` `# Handle case for the last index, i.e. N - 1` ` ` `dp[n ` `-` `1` `] ` `=` `min` `(dp[n ` `-` `2` `],` ` ` `dp[n ` `-` `3` `] ` `+` `arr[n ` `-` `1` `])` ` ` `# Print the answer` ` ` `print` `(dp[n ` `-` `1` `])` `# Driver Code` `if` `__name__ ` `=` `=` `"__main__"` `:` ` ` `arr ` `=` `[` `9` `, ` `4` `, ` `6` `, ` `8` `, ` `5` `]` ` ` `N ` `=` `len` `(arr)` ` ` `minCost(arr, N)` ` ` `# This code is contributed by ukasp.` |

## C#

`// C# Program to implement` `// the above approach` `using` `System;` `public` `class` `GFG` `{` ` ` `// Function to find the minimum cost` ` ` `// to reach the end of an array` ` ` `static` `void` `minCost(` `int` `[]arr, ` `int` `n)` ` ` `{` ` ` `// Base Case: When N < 3` ` ` `if` `(n < 3) {` ` ` `Console.WriteLine(arr[0]);` ` ` `return` `;` ` ` `}` ` ` `// Store the results in table` ` ` `int` `[]dp = ` `new` `int` `[n];` ` ` `// Initialize base cases` ` ` `dp[0] = arr[0];` ` ` `dp[1] = dp[0] + arr[1] + arr[2];` ` ` `// Iterate over the range[2, N - 2]` ` ` `// to construct the dp array` ` ` `for` `(` `int` `i = 2; i < n - 1; i++)` ` ` `dp[i] = Math.Min(dp[i - 2] + arr[i],` ` ` `dp[i - 1] + arr[i] + arr[i + 1]);` ` ` `// Handle case for the last index, i.e. N - 1` ` ` `dp[n - 1] = Math.Min(dp[n - 2], dp[n - 3] + arr[n - 1]);` ` ` `// Print the answer` ` ` `Console.WriteLine(dp[n - 1]);` ` ` `}` ` ` `// Driver Code` ` ` `public` `static` `void` `Main(` `string` `[] args)` ` ` `{` ` ` `int` `[]arr = { 9, 4, 6, 8, 5 };` ` ` `int` `N = arr.Length;` ` ` `minCost(arr, N);` ` ` `}` `}` `// This code is contributed by AnkThon` |

**Output:**

20

**Time Complexity:** O(N)**Auxiliary Space:** O(N)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the **DSA Self Paced Course** at a student-friendly price and become industry ready.