# Minimize cost to reach the end of given Binary Array using jump of K length after performing given operations

• Difficulty Level : Hard
• Last Updated : 11 Nov, 2021

Given a binary array arr[] of N integers and an integer P, the task is to find the minimum cost to reach the end of the array from Pth index using jumps of length K. A jump to index i is valid if arr[i] = 1. The array can be modified using the following operations:

• Replace an index having a value 0 to 1. The cost of this operation is X.
• Delete the integer at index P. The cost of this operation is Y.

Example:

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.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

Input: arr[] = {0, 0, 0, 1, 1, 0, 0, 1, 1, 1}, P = 6, K = 2, X = 1, Y = 2
Output: 1
Explanation: In 1st operation, replace the value at index 6 to 1. Hence, arr[] = {0, 0, 0, 1, 1, 1, 0, 1, 1, 1}. Initially, the current index = P = 6. Jump from P to P + K => from 6 => 8. Again jump to the next possible index i.e, 8 => 10, which is the end of the array.

Input: arr[] = {0, 1, 0, 0, 0, 1, 0}, P = 4, K = 1, X = 2, Y = 1
Output: 4

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

• For a given P, check if indices P, P+K, P+2K… have their value as 1. If not, then replace them with 1 and maintain their count. Hence, the final cost = count * X.
• Upon applying the second operation i times, the starting index will become P+i. Hence the final cost = (i * Y) + (count * X).

Hence, the given problem can be solved by iterating over all possible values of i in the range [1, N-P) and calculating the cost at each step. It can be done by maintaining an array zeroes[], where zeroes[i] stores the frequency of 0’s at indices i, i+K, i+2K…

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to find the minimum cost to``// reach the end of the given array``int` `minimumCost(``int` `arr[], ``int` `N,``                ``int` `P, ``int` `K, ``int` `X,``                ``int` `Y)``{``    ``// Convert P to 0-based indexing``    ``P = P - 1;` `    ``// Vector to store the count of zeros``    ``// till the current index``    ``vector<``int``> zeros(N, 0);` `    ``// Traverse the array and store the``    ``// count of zeros in vector``    ``for` `(``int` `i = 0; i < N; i++) {` `        ``// If element is 0``        ``if` `(arr[i] == 0) {``            ``zeros[i]++;``        ``}``    ``}``    ``// Iterate in the range [N-K-1, 0]``    ``// and increment zeros[i] by zeros[i+K]``    ``for` `(``int` `i = N - K - 1; i >= 0; i--) {``        ``zeros[i] += zeros[i + K];``    ``}` `    ``// Variable to store the min cost``    ``int` `cost = INT_MAX;` `    ``// Loop to calculate the cost for all``    ``// values of i in range [P, N]``    ``for` `(``int` `i = P; i < N; i++) {``        ``cost = min(cost,``                   ``((i - P) * Y)``                       ``+ (zeros[i] * X));``    ``}` `    ``// Return Answer``    ``return` `cost;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 0, 1, 0, 0, 0, 1, 0 };``    ``int` `P = 4;``    ``int` `K = 1;``    ``int` `X = 2;``    ``int` `Y = 1;``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr);` `    ``cout << minimumCost(arr, N, P, K, X, Y);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach` `public` `class` `GFG {``    `  `// Function to find the minimum cost to``// reach the end of the given array``static` `int` `minimumCost(``int` `arr[], ``int` `N,``                ``int` `P, ``int` `K, ``int` `X,``                ``int` `Y)``{``    ``// Convert P to 0-based indexing``    ``P = P - ``1``;` `    ``// Vector to store the count of zeros``    ``// till the current index``    ``int` `zeros[] = ``new` `int``[N] ;` `    ``// Traverse the array and store the``    ``// count of zeros in vector``    ``for` `(``int` `i = ``0``; i < N; i++) {` `        ``// If element is 0``        ``if` `(arr[i] == ``0``) {``            ``zeros[i]++;``        ``}``    ``}``    ``// Iterate in the range [N-K-1, 0]``    ``// and increment zeros[i] by zeros[i+K]``    ``for` `(``int` `i = N - K - ``1``; i >= ``0``; i--) {``        ``zeros[i] += zeros[i + K];``    ``}` `    ``// Variable to store the min cost``    ``int` `cost = Integer.MAX_VALUE;` `    ``// Loop to calculate the cost for all``    ``// values of i in range [P, N]``    ``for` `(``int` `i = P; i < N; i++) {``        ``cost = Math.min(cost,``                   ``((i - P) * Y)``                       ``+ (zeros[i] * X));``    ``}` `    ``// Return Answer``    ``return` `cost;``}` `    ``// Driver Code``    ``public` `static` `void` `main (String[] args) {``        ` `    ``int` `arr[] = { ``0``, ``1``, ``0``, ``0``, ``0``, ``1``, ``0` `};``    ``int` `P = ``4``;``    ``int` `K = ``1``;``    ``int` `X = ``2``;``    ``int` `Y = ``1``;``    ``int` `N = arr.length;` `    ``System.out.println(minimumCost(arr, N, P, K, X, Y));``    ``}``}` `// This code is contributed by AnkThon`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to find the minimum cost to``# reach the end of the given array``def` `minimumCost(arr, N, P, K,  X, Y) :` `    ``# Convert P to 0-based indexing``    ``P ``=` `P ``-` `1``;` `    ``# Vector to store the count of zeros``    ``# till the current index``    ``zeros ``=` `[``0``] ``*` `N ;` `    ``# Traverse the array and store the``    ``# count of zeros in vector``    ``for` `i ``in` `range``(N) :` `        ``# If element is 0``        ``if` `(arr[i] ``=``=` `0``) :``            ``zeros[i] ``+``=` `1``;` `    ``# Iterate in the range [N-K-1, 0]``    ``# and increment zeros[i] by zeros[i+K]``    ``for` `i ``in` `range``( N ``-` `K ``-` `1``, ``-``1``, ``-``1``) :``        ``zeros[i] ``+``=` `zeros[i ``+` `K];` `    ``# Variable to store the min cost``    ``cost ``=` `sys.maxsize;` `    ``# Loop to calculate the cost for all``    ``# values of i in range [P, N]``    ``for` `i ``in` `range``(P, N) :``        ``cost ``=` `min``(cost,((i ``-` `P) ``*` `Y) ``+` `(zeros[i] ``*` `X));` `    ``# Return Answer``    ``return` `cost;` `# Driver Code``if` `__name__ ``=``=` `"__main__"` `:` `    ``arr ``=` `[ ``0``, ``1``, ``0``, ``0``, ``0``, ``1``, ``0` `];``    ``P ``=` `4``;``    ``K ``=` `1``;``    ``X ``=` `2``;``    ``Y ``=` `1``;``    ``N ``=` `len``(arr);` `    ``print``(minimumCost(arr, N, P, K, X, Y));` `   ``# This code is contributed by AnkThon`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG``{` `    ``// Function to find the minimum cost to``    ``// reach the end of the given array``    ``static` `int` `minimumCost(``int``[] arr, ``int` `N, ``int` `P, ``int` `K, ``int` `X, ``int` `Y)``    ``{``      ` `        ``// Convert P to 0-based indexing``        ``P = P - 1;` `        ``// Vector to store the count of zeros``        ``// till the current index``        ``int``[] zeros = ``new` `int``[N];` `        ``// Traverse the array and store the``        ``// count of zeros in vector``        ``for` `(``int` `i = 0; i < N; i++)``        ``{` `            ``// If element is 0``            ``if` `(arr[i] == 0)``            ``{``                ``zeros[i]++;``            ``}``        ``}``        ``// Iterate in the range [N-K-1, 0]``        ``// and increment zeros[i] by zeros[i+K]``        ``for` `(``int` `i = N - K - 1; i >= 0; i--)``        ``{``            ``zeros[i] += zeros[i + K];``        ``}` `        ``// Variable to store the min cost``        ``int` `cost = ``int``.MaxValue;` `        ``// Loop to calculate the cost for all``        ``// values of i in range [P, N]``        ``for` `(``int` `i = P; i < N; i++)``        ``{``            ``cost = Math.Min(cost,``                       ``((i - P) * Y)``                           ``+ (zeros[i] * X));``        ``}` `        ``// Return Answer``        ``return` `cost;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{` `        ``int``[] arr = { 0, 1, 0, 0, 0, 1, 0 };``        ``int` `P = 4;``        ``int` `K = 1;``        ``int` `X = 2;``        ``int` `Y = 1;``        ``int` `N = arr.Length;` `        ``Console.WriteLine(minimumCost(arr, N, P, K, X, Y));``    ``}``}` `// This code is contributed by _Saurabh_Jaiswal`

## Javascript

 ``

Output
`4`

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

My Personal Notes arrow_drop_up