Skip to content
Related Articles

Related Articles

Table of Contents

Improve Article
Save Article
Like Article

Minimize cost to reach end of an array by two forward jumps or one backward jump in each move

  • Difficulty Level : Hard
  • Last Updated : 24 Feb, 2022

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 ith index.

Examples:

Input: arr[] = {5, 1, 2, 10, 100}
Output: 18
Explanation:
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: 20
Explanation:
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)th index or jump from (i – 1)th to (i + 1)th index, i.e. (2 jumps forward), followed by 1 backward jump, i.e. from (i + 1)th index to ith index.
  • 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(2N)
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 ith index.
  • Initialize dp[0] = arr[0] as the cost to reach the 0th index, which is equal to the value at the 0th index itself. Update dp[1] = arr[0] + arr[1] + arr[2], as to reach the 1st index, jump from the 0th index to 2nd index indexn to the 1st 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
Javascript



<script>
 
// Javascript program for the above approach
 
    // Function to find the minimum cost
    // to reach the end of an array
    function minCost(arr, n)
    {
        
        // Base Case: When N < 3
        if (n < 3) {
            document.write(arr[0]);
            return;
        }
  
        // Store the results in table
        let dp = [];
  
        // 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 (let 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
        document.write(dp[n - 1]);
    }
 
// Driver Code
 
        let arr = [ 9, 4, 6, 8, 5 ];
        let N = arr.length;
        minCost(arr, N);
 
</script>
Output: 
20
 
Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes
arrow_drop_up
Next

Minimum sum of two integers whose product is strictly greater than N
Recommended Articles
Page :
Check if end of a sorted Array can be reached by repeated jumps of one more, one less or same number of indices as previous jump
24, Nov 20
Minimize cost to reach the end of given Binary Array using jump of K length after performing given operations
27, Oct 21
Minimize cost to reach bottom right from top left corner of Matrix with given separate cost for each move
11, Jan 22
Maximum jumps to reach end of Array with condition that index i can make arr[i] jumps
10, Jul 21
Minimum cost to reach end of array array when a maximum jump of K index is allowed
15, Mar 19
Minimum cost to reach the end of the array with maximum jumps of length K
26, Jan 22
Find the minimum of maximum length of a jump required to reach the last island in exactly k jumps
23, Apr 19
Newton Forward And Backward Interpolation
17, Oct 17
Count unique stairs that can be reached by moving given number of steps forward or backward
18, Mar 21
Find position after K jumps from start of given Array where each jump is from i to arr[i]
19, Jan 22
Count ways to reach end from start stone with at most K jumps at each step
30, Mar 20
Minimize cost of choosing and skipping array elements to reach end of the given array
25, Oct 20
Count number of ways to jump to reach end
20, May 17
Count minimum factor jumps required to reach the end of an Array
05, May 20
Paths requiring minimum number of jumps to reach end of array
22, Sep 20
Count of jumps to reach the end of Array by jumping from arr[i] to arr[arr[i]]
11, Oct 21
Minimize cost to reach end of an N-length straight path
02, Mar 21
Minimum number of jumps to reach end
24, Jan 12
Minimum number of jumps to reach end | Set 2 (O(n) solution)
09, Jun 17
Minimum number of Fibonacci jumps to reach end
21, Aug 19
Minimize cost to split an array into K subsets such that the cost of each element is its product with its position in the subset
03, Jan 21
Minimize cost by splitting given Array into subsets of size K and adding highest K/2 elements of each subset into cost
26, Jan 22
Minimum jumps to traverse all integers in range [1, N] such that integer i can jump i steps
28, Jul 21
Minimize the number of steps required to reach the end of the array
14, May 19
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
ramandeep8421
@ramandeep8421
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox

Start Your Coding Journey Now!