# Minimize cost to convert all array elements to 0

• Difficulty Level : Hard
• Last Updated : 24 May, 2021

Given two integers X and Y and a binary array arr[] of length N whose first and last element is 1, the task is to minimize the cost to convert all array elements to 0, where X and Y represent the cost of converting a subarray of all 1s to 0s and the cost of converting any element to 0 respectively.

Examples:

Input: arr[] = {1, 1, 1, 0, 1, 1}, X = 10, Y = 4
Output: 14
Explanation: To minimize the cost to convert all elements to 0, perform the following operations:

1. Change element at index 3 to 1. Now the array modifies to {1, 1, 1, 1, 1, 1}. The cost of this operation is 4.
2. Change all element of the array to 0. The cost of this operation is 10.
Therefore, the total cost is 4 + 10 + 14.

Input: arr[] = {1, 0, 0, 1, 1, 0, 1}, X = 2, Y = 3
Output: 6
Explanation: To minimize the cost of changing all array elements to 0, perform the following operations:

1. Change all element of the subarray over the range [3, 4] to 0. Now the array modifies to {1, 0, 0, 0, 0, 0, 1}. The cost of this operation is 2.
2. Change all element of the subarray over the range [0, 0] to 0. Now the array modifies to {0, 0, 0, 0, 0, 0, 1}. The cost of this operation is 2.
3. Change all element of the subarray over the range [6, 6] to 0. Now the array modifies to {0, 0, 0, 0, 0, 0, 0}. The cost of this operation is 2.

Therefore, the total cost is 2 + 2 + 2 = 3.

Approach: Follow the steps:

• Initialize a variable, say ans, to store the minimum cost of converting all array elements to 0.
• Calculate and store the lengths of all subarrays consisting of 0s only and store it in a vector and sort the vector in increasing order.
• Now, count the number of subarrays consisting of 1s only.
• Traverse the given array using the variable i, where i represents number of Y cost operations, and perform the following:
• For every possible number of operations of cost Y, find the cost by performing X operations.
• Since, on setting bits in between two groups of 1s, the total number of groups gets decreased, first merge the two groups of consecutive 1s to reduce the minimum number of operations.
• Find the minimum cost of completing the above step for each index as currCost and update ans to store the minimum of ans and currCost.
• After completing the above steps, print the value of ans as the minimum cost.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to calculate the minimum cost``// of converting all array elements to 0s``void` `minimumCost(``int``* binary, ``int` `n,``                 ``int` `a, ``int` `b)``{``    ``// Stores subarrays of 0s only``    ``vector<``int``> groupOfZeros;` `    ``int` `len = 0, i = 0;``    ``bool` `increment_need = ``true``;` `    ``// Traverse the array``    ``while` `(i < n) {``        ``increment_need = ``true``;` `        ``// If consecutive 0s occur``        ``while` `(i < n && binary[i] == 0) {``            ``len++;``            ``i++;``            ``increment_need = ``false``;``        ``}` `        ``// Increment if needed``        ``if` `(increment_need == ``true``) {``            ``i++;``        ``}` `        ``// Push the current length of``        ``// consecutive 0s in a vector``        ``if` `(len != 0) {``            ``groupOfZeros.push_back(len);``        ``}` `        ``// Update lengths as 0``        ``len = 0;``    ``}` `    ``// Sorting vector``    ``sort(groupOfZeros.begin(),``         ``groupOfZeros.end());` `    ``i = 0;``    ``bool` `found_ones = ``false``;` `    ``// Stores the number of``    ``// subarrays consisting of 1s``    ``int` `NumOfOnes = 0;` `    ``// Traverse the array``    ``while` `(i < n) {``        ``found_ones = ``false``;` `        ``// If current element is 1``        ``while` `(i < n && binary[i] == 1) {``            ``i++;``            ``found_ones = ``true``;``        ``}``        ``if` `(found_ones == ``false``)``            ``i++;` `        ``// Otherwise``        ``else` `            ``// Increment count of``            ``// consecutive ones``            ``NumOfOnes++;``    ``}` `    ``// Stores the minimum cost``    ``int` `ans = INT_MAX;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < n; i++) {` `        ``int` `curr = 0, totalOnes = NumOfOnes;` `        ``// First element``        ``if` `(i == 0) {``            ``curr = totalOnes * a;``        ``}``        ``else` `{` `            ``int` `mark = i, num_of_changes = 0;` `            ``// Traverse the subarray sizes``            ``for` `(``int` `x : groupOfZeros) {` `                ``if` `(mark >= x) {``                    ``totalOnes--;``                    ``mark -= x;` `                    ``// Update cost``                    ``num_of_changes += x;``                ``}``                ``else` `{``                    ``break``;``                ``}``            ``}` `            ``// Cost of performing X``            ``// and Y operations``            ``curr = (num_of_changes * b)``                   ``+ (totalOnes * a);``        ``}` `        ``// Find the minimum cost``        ``ans = min(ans, curr);``    ``}` `    ``// Print the minimum cost``    ``cout << ans;``}` `// Driver Code``int` `main()``{``    ``int` `arr[] = { 1, 1, 1, 0, 1, 1 };``    ``int` `N = ``sizeof``(arr) / ``sizeof``(arr[0]);``    ``int` `X = 10, Y = 4;` `    ``// Function Call``    ``minimumCost(arr, N, X, Y);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.io.*;``import` `java.util.*;` `class` `GFG{` `// Function to calculate the minimum cost``// of converting all array elements to 0s``public` `static` `void` `minimumCost(``int``[] binary, ``int` `n,``                               ``int` `a, ``int` `b)``{``    ` `    ``// Stores subarrays of 0s only``    ``List groupOfZeros = ``new` `ArrayList();` `    ``int` `len = ``0``, i = ``0``;``    ``boolean` `increment_need = ``true``;` `    ``// Traverse the array``    ``while` `(i < n)``    ``{``        ``increment_need = ``true``;` `        ``// If consecutive 0s occur``        ``while` `(i < n && binary[i] == ``0``)``        ``{``            ``len++;``            ``i++;``            ``increment_need = ``false``;``        ``}` `        ``// Increment if needed``        ``if` `(increment_need == ``true``)``        ``{``            ``i++;``        ``}` `        ``// Push the current length of``        ``// consecutive 0s in a vector``        ``if` `(len != ``0``)``        ``{``            ``groupOfZeros.add(len);``        ``}` `        ``// Update lengths as 0``        ``len = ``0``;``    ``}` `    ``// Sorting List``    ``Collections.sort(groupOfZeros);` `    ``i = ``0``;``    ``boolean` `found_ones = ``false``;` `    ``// Stores the number of``    ``// subarrays consisting of 1s``    ``int` `NumOfOnes = ``0``;` `    ``// Traverse the array``    ``while` `(i < n)``    ``{``        ``found_ones = ``false``;` `        ``// If current element is 1``        ``while` `(i < n && binary[i] == ``1``)``        ``{``            ``i++;``            ``found_ones = ``true``;``        ``}``        ``if` `(found_ones == ``false``)``            ``i++;` `        ``// Otherwise``        ``else` `            ``// Increment count of``            ``// consecutive ones``            ``NumOfOnes++;``    ``}` `    ``// Stores the minimum cost``    ``int` `ans = Integer.MAX_VALUE;` `    ``// Traverse the array``    ``for``(``int` `i1 = ``0``; i1 < n; i1++)``    ``{``        ``int` `curr = ``0``, totalOnes = NumOfOnes;` `        ``// First element``        ``if` `(i1 == ``0``)``        ``{``            ``curr = totalOnes * a;``        ``}``        ``else``        ``{``            ``int` `mark = i1, num_of_changes = ``0``;` `            ``// Traverse the subarray sizes``            ``for``(``int` `x : groupOfZeros)``            ``{``                ``if` `(mark >= x)``                ``{``                    ``totalOnes--;``                    ``mark -= x;``                    ` `                    ``// Update cost``                    ``num_of_changes += x;``                ``}``                ``else``                ``{``                    ``break``;``                ``}``            ``}` `            ``// Cost of performing X``            ``// and Y operations``            ``curr = (num_of_changes * b) +``                        ``(totalOnes * a);``        ``}` `        ``// Find the minimum cost``        ``ans = Math.min(ans, curr);``    ``}` `    ``// Print the minimum cost``    ``System.out.println(ans);``}` `// Driver code``public` `static` `void` `main(String[] args)``{``    ``int` `arr[] = { ``1``, ``1``, ``1``, ``0``, ``1``, ``1` `};``    ``int` `N = ``6``;``    ``int` `X = ``10``, Y = ``4``;``    ` `    ``// Function Call``    ``minimumCost(arr, N, X, Y);``}``}` `// This code is contributed by RohitOberoi`

## Python3

 `# Python3 program for the above approach``import` `sys` `# Function to calculate the minimum cost``# of converting all array elements to 0s``def` `minimumCost(binary, n,``                ``a,  b):` `    ``# Stores subarrays of 0s only``    ``groupOfZeros ``=` `[]` `    ``length ``=` `0``    ``i ``=` `0``    ``increment_need ``=` `True` `    ``# Traverse the array``    ``while` `(i < n):``        ``increment_need ``=` `True` `        ``# If consecutive 0s occur``        ``while` `(i < n ``and` `binary[i] ``=``=` `0``):``            ``length ``+``=` `1``            ``i ``+``=` `1``            ``increment_need ``=` `False` `        ``# Increment if needed``        ``if` `(increment_need ``=``=` `True``):``            ``i ``+``=` `1` `        ``# Push the current length of``        ``# consecutive 0s in a vector``        ``if` `(length !``=` `0``):``            ``groupOfZeros.append(length)` `        ``# Update lengths as 0``        ``length ``=` `0` `    ``# Sorting vector``    ``groupOfZeros.sort()` `    ``i ``=` `0``    ``found_ones ``=` `False` `    ``# Stores the number of``    ``# subarrays consisting of 1s``    ``NumOfOnes ``=` `0` `    ``# Traverse the array``    ``while` `(i < n):``        ``found_ones ``=` `False` `        ``# If current element is 1``        ``while` `(i < n ``and` `binary[i] ``=``=` `1``):``            ``i ``+``=` `1``            ``found_ones ``=` `True` `        ``if` `(found_ones ``=``=` `False``):``            ``i ``+``=` `1` `        ``# Otherwise``        ``else``:` `            ``# Increment count of``            ``# consecutive ones``            ``NumOfOnes ``+``=` `1` `    ``# Stores the minimum cost``    ``ans ``=` `sys.maxsize` `    ``# Traverse the array``    ``for` `i ``in` `range``(n):` `        ``curr ``=` `0``        ``totalOnes ``=` `NumOfOnes` `        ``# First element``        ``if` `(i ``=``=` `0``):``            ``curr ``=` `totalOnes ``*` `a` `        ``else``:` `            ``mark ``=` `i``            ``num_of_changes ``=` `0` `            ``# Traverse the subarray sizes``            ``for` `x ``in` `groupOfZeros:` `                ``if` `(mark >``=` `x):``                    ``totalOnes ``-``=` `1``                    ``mark ``-``=` `x` `                    ``# Update cost``                    ``num_of_changes ``+``=` `x` `                ``else``:``                    ``break` `            ``# Cost of performing X``            ``# and Y operations``            ``curr ``=` `((num_of_changes ``*` `b)``                    ``+` `(totalOnes ``*` `a))` `        ``# Find the minimum cost``        ``ans ``=` `min``(ans, curr)` `    ``# Print the minimum cost``    ``print``(ans)` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:``    ``arr ``=` `[``1``, ``1``, ``1``, ``0``, ``1``, ``1``]``    ``N ``=` `len``(arr)``    ``X ``=` `10``    ``Y ``=` `4` `    ``# Function Call``    ``minimumCost(arr, N, X, Y)` `    ``# This code is contributed by chitranayal`

## C#

 `// C# program for the above approach``using` `System;``using` `System.Collections.Generic;` `class` `GFG{` `// Function to calculate the minimum cost``// of converting all array elements to 0s``public` `static` `void` `minimumCost(``int``[] binary, ``int` `n,``                               ``int` `a, ``int` `b)``{``  ` `    ``// Stores subarrays of 0s only``    ``List<``int``> groupOfZeros = ``new` `List<``int``>();` `    ``int` `len = 0, i = 0;``    ``bool` `increment_need = ``true``;` `    ``// Traverse the array``    ``while` `(i < n)``    ``{``        ``increment_need = ``true``;` `        ``// If consecutive 0s occur``        ``while` `(i < n && binary[i] == 0)``        ``{``            ``len++;``            ``i++;``            ``increment_need = ``false``;``        ``}` `        ``// Increment if needed``        ``if` `(increment_need == ``true``)``        ``{``            ``i++;``        ``}` `        ``// Push the current length of``        ``// consecutive 0s in a vector``        ``if` `(len != 0)``        ``{``            ``groupOfZeros.Add(len);``        ``}` `        ``// Update lengths as 0``        ``len = 0;``    ``}` `    ``// Sorting List``    ``groupOfZeros.Sort();` `    ``i = 0;``    ``bool` `found_ones = ``false``;` `    ``// Stores the number of``    ``// subarrays consisting of 1s``    ``int` `NumOfOnes = 0;` `    ``// Traverse the array``    ``while` `(i < n)``    ``{``        ``found_ones = ``false``;` `        ``// If current element is 1``        ``while` `(i < n && binary[i] == 1)``        ``{``            ``i++;``            ``found_ones = ``true``;``        ``}``        ``if` `(found_ones == ``false``)``            ``i++;` `        ``// Otherwise``        ``else` `            ``// Increment count of``            ``// consecutive ones``            ``NumOfOnes++;``    ``}` `    ``// Stores the minimum cost``    ``int` `ans = ``int``.MaxValue;` `    ``// Traverse the array``    ``for``(``int` `i1 = 0; i1 < n; i1++)``    ``{``        ``int` `curr = 0, totalOnes = NumOfOnes;` `        ``// First element``        ``if` `(i1 == 0)``        ``{``            ``curr = totalOnes * a;``        ``}``        ``else``        ``{``            ``int` `mark = i1, num_of_changes = 0;` `            ``// Traverse the subarray sizes``            ``foreach``(``int` `x ``in` `groupOfZeros)``            ``{``                ``if` `(mark >= x)``                ``{``                    ``totalOnes--;``                    ``mark -= x;``                    ` `                    ``// Update cost``                    ``num_of_changes += x;``                ``}``                ``else``                ``{``                    ``break``;``                ``}``            ``}` `            ``// Cost of performing X``            ``// and Y operations``            ``curr = (num_of_changes * b) +``                        ``(totalOnes * a);``        ``}` `        ``// Find the minimum cost``        ``ans = Math.Min(ans, curr);``    ``}` `    ``// Print the minimum cost``    ``Console.WriteLine(ans);``}` `// Driver code``public` `static` `void` `Main(String[] args)``{``    ``int` `[]arr = { 1, 1, 1, 0, 1, 1 };``    ``int` `N = 6;``    ``int` `X = 10, Y = 4;``    ` `    ``// Function Call``    ``minimumCost(arr, N, X, Y);``}``}` `// This code is contributed by Amit Katiyar`

## Javascript

 ``

Output:

`14`

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

My Personal Notes arrow_drop_up